/**************************************************************************** * video/videomode/edid_parse.c * * Copyright (C) 2019 Gregory Nutt. All rights reserved. * Author: Gregory Nutt * * Derives from logic in FreeBSD which has an equivalent 3-clause BSD * license: * * Copyright (c) 2006 Itronix Inc. All rights reserved. * Written by Garrett D'Amore for Itronix Inc. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. The name of Itronix Inc. may not be used to endorse * or promote products derived from this software without specific * prior written permission. * * THIS SOFTWARE IS PROVIDED BY ITRONIX INC. ``AS IS'' AND ANY EXPRESS * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL ITRONIX INC. BE LIABLE FOR ANY * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ****************************************************************************/ /**************************************************************************** * Included Files ****************************************************************************/ #include #include #include #include #include #include #include #include #include /**************************************************************************** * Pre-processor Definitions ****************************************************************************/ #define DIVIDE(x,y) (((x) + ((y) / 2)) / (y)) /**************************************************************************** * Private Data ****************************************************************************/ /* These are reversed established timing order */ static FAR const char *g_edid_modes[] = { "1280x1024x75", "1024x768x75", "1024x768x70", "1024x768x60", "1024x768x87i", "832x624x74", /* Rounding error, 74.55 Hz aka "832x624x75" */ "800x600x75", "800x600x72", "800x600x60", "800x600x56", "640x480x75", "640x480x72", "640x480x67", "640x480x60", "720x400x87", /* Rounding error, 87.85 Hz aka "720x400x88" */ "720x400x70", }; /**************************************************************************** * Private Functions ****************************************************************************/ /**************************************************************************** * Name: edid_valid * * Description: * Return true if the EDID is valid * ****************************************************************************/ static bool edid_valid(FAR const uint8_t *data) { static const uint8_t magic[8] = EDID_MAGIC; int sum = 0; int i; /* Verify the EDID magic number */ if (memcmp(data, magic, 8) != 0) { return false; } /* Verify the EDID checksum */ for (i = 0; i < 128; i++) { sum += data[i]; } if ((sum & 0xff) != 0) { return false; } return true; } /**************************************************************************** * Name: edid_std_timing * * Description: * Parse STD timing entry * ****************************************************************************/ static bool edid_std_timing(FAR const uint8_t *stdtim, FAR struct videomode_s *mode) { FAR const struct videomode_s *lookup; char name[80]; unsigned x; unsigned y; unsigned f; if ((stdtim[0] == 1 && stdtim[1] == 1) || (stdtim[0] == 0 && stdtim[1] == 0) || (stdtim[0] == 0x20 && stdtim[1] == 0x20)) { return false; } x = stdtim[EDID_STDTIMING_XRES_OFFSET]; switch (x & EDID_STDTIMING_ASPECT_MASK) { case EDID_STDTIMING_ASPECT_16_10: y = x * 10 / 16; break; case EDID_STDTIMING_ASPECT_4_3: y = x * 3 / 4; break; case EDID_STDTIMING_ASPECT_5_4: y = x * 4 / 5; break; case EDID_STDTIMING_ASPECT_16_9: default: y = x * 9 / 16; break; } f = stdtim[EDID_STDTIMING_INFO_OFFSET]; /* First try to lookup the mode as a DMT timing */ snprintf(name, sizeof(name), "%dx%dx%d", x, y, f); if ((lookup = videomode_lookup_by_name(name)) != NULL) { *mode = *lookup; } else { /* Failing that, calculate it using gtf * * Hmm. I'm not using alternate GTF timings, which * could, in theory, be present. */ vesagtf_mode(x, y, f, mode); } return true; } /**************************************************************************** * Name: edid_search_mode * * Description: * Check if for duplicate video modes. * ****************************************************************************/ static struct videomode_s * edid_search_mode(FAR struct edid_info_s *edid, FAR const struct videomode_s *mode) { int refresh; int i; refresh = DIVIDE(DIVIDE(mode->dotclock * 1000, mode->htotal), mode->vtotal); for (i = 0; i < edid->edid_nmodes; i++) { if (mode->hdisplay == edid->edid_modes[i].hdisplay && mode->vdisplay == edid->edid_modes[i].vdisplay && refresh == DIVIDE(DIVIDE(edid->edid_modes[i].dotclock * 1000, edid->edid_modes[i].htotal), edid->edid_modes[i].vtotal)) { return &edid->edid_modes[i]; } } return NULL; } /**************************************************************************** * Name: edid_desc_timing * * Description: * ****************************************************************************/ static bool edid_desc_timing(FAR const uint8_t *desc, FAR struct videomode_s *mode) { uint16_t hactive; unsigned int hblank; unsigned int hsyncwid; unsigned int hsyncoff; unsigned int vactive; unsigned int vblank; unsigned int vsyncwid; unsigned int vsyncoff; uint8_t flags; flags = desc[EDID_DESC_FEATURES_OFFSET]; /* We don't support stereo modes (for now) */ if (flags & (EDID_DESC_STEREO_MASK | EDID_DESC_STEREO_INTERLEAVE)) { return false; } mode->dotclock = (uint16_t)desc[EDID_DESC_PIXCLOCK_OFFSET] | ((uint16_t)desc[EDID_DESC_PIXCLOCK_OFFSET + 1] << 8); hactive = EDID_DESC_HACTIVE(desc); hblank = EDID_DESC_HBLANK(desc); hsyncwid = EDID_DESC_HSYNC_WIDTH(desc); hsyncoff = EDID_DESC_HSYNC_OFFSET(desc); vactive = EDID_DESC_VACTIVE(desc); vblank = EDID_DESC_VBLANK(desc); vsyncwid = EDID_DESC_VSYNC_WIDTH(desc); vsyncoff = EDID_DESC_VSYNC_OFFSET(desc); /* Borders are contained within the blank areas. */ mode->hdisplay = hactive; mode->htotal = hactive + hblank; mode->hsync_start = hactive + hsyncoff; mode->hsync_end = mode->hsync_start + hsyncwid; mode->vdisplay = vactive; mode->vtotal = vactive + vblank; mode->vsync_start = vactive + vsyncoff; mode->vsync_end = mode->vsync_start + vsyncwid; mode->hskew = 0; mode->flags = 0; mode->name = NULL; if ((flags & EDID_DESC_INTERLACED) != 0) { mode->flags |= VID_INTERLACE; } if ((flags & EDID_DESC_DIGITAL_HPOLARITY) != 0) { mode->flags |= VID_PHSYNC; } else { mode->flags |= VID_NHSYNC; } if ((flags & EDID_DESC_DIGITAL_VSERRATION) != 0) { mode->flags |= VID_PVSYNC; } else { mode->flags |= VID_NVSYNC; } return true; } /**************************************************************************** * Name: edid_block * * Description: * Parse an EDID descriptor block. * ****************************************************************************/ static void edid_block(FAR struct edid_info_s *edid, FAR const uint8_t *desc) { struct videomode_s mode; FAR struct videomode_s *exist_mode; uint16_t pixclk; int i; /* A detailed timing descriptor with have a nonzero pixel clock */ pixclk = ((uint16_t)desc[EDID_DESC_PIXCLOCK_OFFSET] << 8) | (uint16_t)desc[EDID_DESC_PIXCLOCK_OFFSET + 1]; if (pixclk > 0) { if (!edid_desc_timing(desc, &mode)) { return; } /* Does this mode already exist? */ exist_mode = edid_search_mode(edid, &mode); if (exist_mode != NULL) { *exist_mode = mode; if (edid->edid_preferred_mode == NULL) { edid->edid_preferred_mode = exist_mode; } } else { edid->edid_modes[edid->edid_nmodes] = mode; if (edid->edid_preferred_mode == NULL) { edid->edid_preferred_mode = &edid->edid_modes[edid->edid_nmodes]; } edid->edid_nmodes++; } return; } /* Not a detailed timing descriptor */ switch (desc[EDID_DESC_DESCTYPE]) { case EDID_DESCTYPE_SERIALNO: #if 0 /* Not implemented */ memcpy(edid->edid_serstr, desc + EDID_DESC_ASCII_DATA_OFFSET, EDID_DESC_ASCII_DATA_LEN); edid->edid_serstr[sizeof(edid->edid_serial) - 1] = 0; #endif break; case EDID_DESCTYPE_TEXT: #if 0 /* Not implemented */ memcpy(edid->edid_comment, desc + EDID_DESC_ASCII_DATA_OFFSET, EDID_DESC_ASCII_DATA_LEN); edid->edid_comment[sizeof(edid->edid_comment) - 1] = 0; #endif break; case EDID_DESCTYPE_LIMITS: edid->edid_have_range = true; edid->edid_range.er_min_vfreq = EDID_DESC_RANGE_MIN_VFREQ(desc); edid->edid_range.er_max_vfreq = EDID_DESC_RANGE_MAX_VFREQ(desc); edid->edid_range.er_min_hfreq = EDID_DESC_RANGE_MIN_HFREQ(desc); edid->edid_range.er_max_hfreq = EDID_DESC_RANGE_MAX_HFREQ(desc); edid->edid_range.er_max_clock = EDID_DESC_RANGE_MAX_CLOCK(desc); if (!EDID_DESC_RANGE_HAVE_GTF2(desc)) { break; } edid->edid_range.er_have_gtf2 = true; edid->edid_range.er_gtf2_hfreq = EDID_DESC_RANGE_GTF2_HFREQ(desc); edid->edid_range.er_gtf2_c = EDID_DESC_RANGE_GTF2_C(desc); edid->edid_range.er_gtf2_m = EDID_DESC_RANGE_GTF2_M(desc); edid->edid_range.er_gtf2_j = EDID_DESC_RANGE_GTF2_J(desc); edid->edid_range.er_gtf2_k = EDID_DESC_RANGE_GTF2_K(desc); break; case EDID_DESCTYPE_NAME: #if 0 /* Not implemented */ /* Copy the product name into place */ memcpy(edid->edid_productname, desc + EDID_DESC_ASCII_DATA_OFFSET, EDID_DESC_ASCII_DATA_LEN); #endif break; case EDID_DESCTYPE_STDTIMING_ID: desc += EDID_DESC_STD_TIMING_START_OFFSET; for (i = 0; i < EDID_DESC_STD_TIMING_COUNT_OFFSET; i++) { if (edid_std_timing(desc, &mode)) { /* Does this mode already exist? */ exist_mode = edid_search_mode(edid, &mode); if (exist_mode == NULL) { edid->edid_modes[edid->edid_nmodes] = mode; edid->edid_nmodes++; } } desc += 2; } break; case EDID_DESCTYPE_WHITEPOINT: /* Not implemented yet */ break; } } /**************************************************************************** * Public Functions ****************************************************************************/ /**************************************************************************** * Name: edid_parse * * Description: * Given a block of raw EDID data, parse the data and convert it to the * 'digested' form of struct edid_info_s. * * Input Parameters: * data - A reference to the raw EDID data * edid - The location to return the digested EDID data. * * Returned Value: * Zero (OK) is returned on success; otherwise a negated errno value is * returned to indicate the nature of the failure. * ****************************************************************************/ int edid_parse(FAR const uint8_t *data, FAR struct edid_info_s *edid) { FAR const struct videomode_s *mode; uint16_t manufacturer; uint16_t estmodes; uint8_t gamma; int i; int max_dotclock = 0; int mhz; if (!edid_valid(&data[EDID_HEADER_MAGIC_OFFSET])) { return -EINVAL; } /* Get product identification */ manufacturer = (uint16_t)data[EDID_VENDOR_MANUFACTURER_OFFSET] | ((uint16_t)data[EDID_VENDOR_MANUFACTURER_OFFSET + 1] << 8); edid->edid_manufacturer[0] = EDID_VENDOR_MANUFACTURER_1(manufacturer); edid->edid_manufacturer[1] = EDID_VENDOR_MANUFACTURER_2(manufacturer); edid->edid_manufacturer[2] = EDID_VENDOR_MANUFACTURER_3(manufacturer); edid->edid_manufacturer[3] = 0; /* NUL terminate for convenience */ edid->edid_product = (uint16_t)data[EDID_VENDOR_PRODUCTCODE_OFFSET] | ((uint16_t)data[EDID_VENDOR_PRODUCTCODE_OFFSET + 1] << 8); edid->edid_serial = ((uint32_t)data[EDID_VENDOR_SERIALNO_OFFSET] << 24) | ((uint32_t)data[EDID_VENDOR_SERIALNO_OFFSET + 1] << 16) | ((uint32_t)data[EDID_VENDOR_SERIALNO_OFFSET + 2] << 8) | (uint32_t)data[EDID_VENDOR_SERIALNO_OFFSET + 3]; edid->edid_week = data[EDID_VENDOR_WEEK_OFFSET]; edid->edid_year = data[EDID_VENDOR_YEAR_OFFSET] + 1990; /* Get EDID revision */ edid->edid_version = data[EDID_VERSION_MAJOR_OFFSET]; edid->edid_revision = data[EDID_VERSION_MINOR_OFFSET]; edid->edid_video_input = data[EDID_DISPLAY_INPUT_OFFSET]; edid->edid_max_hsize = data[EDID_DISPLAY_HSIZE_OFFSET]; edid->edid_max_vsize = data[EDID_DISPLAY_VSIZE_OFFSET]; gamma = data[EDID_DISPLAY_GAMMA_OFFSET]; edid->edid_gamma = gamma == 0xff ? 100 : gamma + 100; edid->edid_features = data[EDID_DISPLAY_FEATURES_OFFSET]; edid->edid_chroma.ec_redx = EDID_CHROMA_RED_X(data); edid->edid_chroma.ec_redy = EDID_CHROMA_RED_X(data); edid->edid_chroma.ec_greenx = EDID_CHROMA_GREEN_X(data); edid->edid_chroma.ec_greeny = EDID_CHROMA_GREEN_Y(data); edid->edid_chroma.ec_bluex = EDID_CHROMA_BLUE_X(data); edid->edid_chroma.ec_bluey = EDID_CHROMA_BLUE_Y(data); edid->edid_chroma.ec_whitex = EDID_CHROMA_WHITE_X(data); edid->edid_chroma.ec_whitey = EDID_CHROMA_WHITE_Y(data); edid->edid_ext_block_count = data[EDID_TRAILER_NEXTENSIONS_OFFSET]; /* Lookup established modes */ edid->edid_nmodes = 0; edid->edid_preferred_mode = NULL; estmodes = ((uint16_t)data[EDID_TIMING_OFFSET_1] << 8) | (uint16_t)data[EDID_TIMING_OFFSET_2]; /* Iterate in established timing order */ for (i = 15; i >= 0; i--) { if (estmodes & (1 << i)) { mode = videomode_lookup_by_name(g_edid_modes[i]); if (mode != NULL) { edid->edid_modes[edid->edid_nmodes] = *mode; edid->edid_nmodes++; } else { lcdwarn("WARNING: No data for est. mode %s\n", g_edid_modes[i]); } } } /* Do standard timing section */ for (i = 0; i < EDID_STDTIMING_NUMBER; i++) { struct videomode_s stdmode; FAR struct videomode_s *exist_mode; if (edid_std_timing(data + EDID_STDTIMING_OFFSET + i * 2, &stdmode)) { /* Does this mode already exist? */ exist_mode = edid_search_mode(edid, &stdmode); if (exist_mode == NULL) { edid->edid_modes[edid->edid_nmodes] = stdmode; edid->edid_nmodes++; } } } /* Do detailed timings and descriptors */ for (i = 0; i < EDID_DESCRIPTOR_NUMBER; i++) { edid_block(edid, data + EDID_DESCRIPTOR_OFFSET + i * EDID_DESCRIPTOR_SIZE); } /* Some monitors lie about their maximum supported dot clock * by claiming to support modes which need a higher dot clock * than the stated maximum. * * For sanity's sake we bump it to the highest dot clock we find * in the list of supported modes */ for (i = 0; i < edid->edid_nmodes; i++) { if (edid->edid_modes[i].dotclock > max_dotclock) { max_dotclock = edid->edid_modes[i].dotclock; } } lcdinfo("max_dotclock according to supported modes: %d\n", max_dotclock); mhz = (max_dotclock + 999) / 1000; if (edid->edid_have_range) { if (mhz > edid->edid_range.er_max_clock) { edid->edid_range.er_max_clock = mhz; } } else { edid->edid_range.er_max_clock = mhz; } return OK; }