diff --git a/XilinxProcessorIPLib/drivers/video_common/data/video_common.mdd b/XilinxProcessorIPLib/drivers/video_common/data/video_common.mdd
new file mode 100644
index 00000000..58ee3cb7
--- /dev/null
+++ b/XilinxProcessorIPLib/drivers/video_common/data/video_common.mdd
@@ -0,0 +1,41 @@
+##******************************************************************************
+##
+## Copyright (C) 2014 Xilinx, Inc. All rights reserved.
+##
+## Permission is hereby granted, free of charge, to any person obtaining a copy
+## of this software and associated documentation files (the "Software"), to deal
+## in the Software without restriction, including without limitation the rights
+## to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+## copies of the Software, and to permit persons to whom the Software is
+## furnished to do so, subject to the following conditions:
+##
+## The above copyright notice and this permission notice shall be included in
+## all copies or substantial portions of the Software.
+##
+## Use of the Software is limited solely to applications:
+## (a) running on a Xilinx device, or
+## (b) that interact with a Xilinx device through a bus or interconnect.
+##
+## THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+## IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+## FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+## XILINX BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+## WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
+## OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+## SOFTWARE.
+##
+## Except as contained in this notice, the name of the Xilinx shall not be used
+## in advertising or otherwise to promote the sale, use or other dealings in
+## this Software without prior written authorization from Xilinx.
+##
+##*****************************************************************************/
+
+OPTION psf_version = 2.1;
+
+BEGIN driver video_common
+ OPTION supported_peripherals = ();
+ OPTION driver_state = ACTIVE;
+ OPTION copyfiles = all;
+ OPTION VERSION = 1.0;
+ OPTION NAME = video_common;
+END driver
diff --git a/XilinxProcessorIPLib/drivers/video_common/examples/xvidc_edid_print_example.c b/XilinxProcessorIPLib/drivers/video_common/examples/xvidc_edid_print_example.c
new file mode 100644
index 00000000..0ed75ab0
--- /dev/null
+++ b/XilinxProcessorIPLib/drivers/video_common/examples/xvidc_edid_print_example.c
@@ -0,0 +1,745 @@
+/*******************************************************************************
+ *
+ * Copyright (C) 2015 Xilinx, Inc. All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * Use of the Software is limited solely to applications:
+ * (a) running on a Xilinx device, or
+ * (b) that interact with a Xilinx device through a bus or interconnect.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * XILINX BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
+ * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * Except as contained in this notice, the name of the Xilinx shall not be used
+ * in advertising or otherwise to promote the sale, use or other dealings in
+ * this Software without prior written authorization from Xilinx.
+ *
+*******************************************************************************/
+/******************************************************************************/
+/**
+ *
+ * @file xvidc_edid_print_example.c
+ *
+ * Contains an example that, given a supplied base Extended Display
+ * Identification Data (EDID) structure, will parse, decode, and print its
+ * contents.
+ *
+ * @note None.
+ *
+ *
+ * MODIFICATION HISTORY:
+ *
+ * Ver Who Date Changes
+ * ----- ---- -------- -----------------------------------------------
+ * 1.0 als 11/09/14 Initial release.
+ *
+ *
+*******************************************************************************/
+
+/******************************* Include Files ********************************/
+
+#include "string.h"
+#include "xil_printf.h"
+#include "xstatus.h"
+#include "xvidc_edid_print_example.h"
+
+/******************* Macros (Inline Functions) Definitions ********************/
+
+#define FLOAT_FRAC_TO_U32(V, D) ((u32)(V * D) - (((u32)V) * D))
+
+/**************************** Function Prototypes *****************************/
+
+static void Edid_PrintBaseVPId(u8 *EdidRaw);
+static void Edid_PrintBaseVerRev(u8 *EdidRaw);
+static void Edid_PrintBaseBasicDisp(u8 *EdidRaw);
+static void Edid_PrintColorChar(u8 *EdidRaw);
+static void Edid_PrintEstTimings(u8 *EdidRaw);
+static void Edid_PrintStdTimings(u8 *EdidRaw);
+static void Edid_PrintPtm(u8 *EdidRaw);
+static u8 Edid_CalculateChecksum(u8 *Data, u8 Size);
+
+/*************************** Function Definitions *****************************/
+
+/******************************************************************************/
+/**
+ * This function decodes the supplied base Extended Display Identification Data
+ * (EDID) structure and prints its contents.
+ *
+ * @param EdidRaw is the base EDID structure to decode and print.
+ *
+ * @return
+ * - XST_SUCCESS if the supplied base EDID has a valid EDID header.
+ * - XST_FAILURE otherwise. The EDID wasn't decoded further.
+ *
+ * @note None.
+ *
+*******************************************************************************/
+u32 Edid_PrintDecodeBase(u8 *EdidRaw)
+{
+ /* Check valid header. */
+ if (XVidC_EdidIsHeaderValid(EdidRaw)) {
+ xil_printf("\nEDID header is: 00 FF FF FF FF FF FF 00\n");
+ }
+ else {
+ xil_printf("\nNot an EDID base block...\n");
+ return XST_FAILURE;
+ }
+
+ /* Obtain vendor and product identification information. */
+ Edid_PrintBaseVPId(EdidRaw);
+ Edid_PrintBaseVerRev(EdidRaw);
+ Edid_PrintBaseBasicDisp(EdidRaw);
+ Edid_PrintColorChar(EdidRaw);
+ Edid_PrintEstTimings(EdidRaw);
+ Edid_PrintStdTimings(EdidRaw);
+
+ xil_printf("Descriptors:\n");
+ xil_printf("\tFirst tag: 0x%02lx 0x%02lx\n", EdidRaw[0x36],
+ EdidRaw[0x38]);
+ xil_printf("\tSecond tag: 0x%02lx 0x%02lx\n", EdidRaw[0x48],
+ EdidRaw[0x4A]);
+ xil_printf("\tThird tag: 0x%02lx 0x%02lx\n", EdidRaw[0x5A],
+ EdidRaw[0x5C]);
+ xil_printf("\tFourth tag: 0x%02lx 0x%02lx\n", EdidRaw[0x6C],
+ EdidRaw[0x6E]);
+
+ Edid_PrintPtm(EdidRaw);
+
+ xil_printf("Number of extensions:\t%d\n",
+ XVidC_EdidGetExtBlkCount(EdidRaw));
+ xil_printf("Checksum:\t\t0x%02lx -> Calculated sum = 0x%02lx\n",
+ XVidC_EdidGetChecksum(EdidRaw),
+ Edid_CalculateChecksum(EdidRaw, 128));
+
+ return XST_SUCCESS;
+}
+
+/******************************************************************************/
+/**
+ * This function decodes the supplied base Extended Display Identification Data
+ * (EDID) structure for supported video timing modes and prints all video
+ * timing modes that are both supported in the EDID and listed in the
+ * XVidC_VideoTimingModes table.
+ *
+ * @param EdidRaw is the base EDID structure to decode.
+ *
+ * @return None.
+ *
+ * @note None.
+ *
+*******************************************************************************/
+void Edid_PrintSuppVmTable(u8 *EdidRaw)
+{
+ u8 Index;
+
+ xil_printf("Supported resolutions from video mode table:\n");
+ for (Index = 0; Index < XVIDC_VM_NUM_SUPPORTED; Index++) {
+ if (XVidC_EdidIsVideoTimingSupported(EdidRaw,
+ &XVidC_VideoTimingModes[Index]) ==
+ XST_SUCCESS) {
+ xil_printf("\t%s\n",
+ XVidC_VideoTimingModes[Index].Name);
+ }
+ }
+}
+
+/******************************************************************************/
+/**
+ * This function decodes the supplied base Extended Display Identification Data
+ * (EDID) structure for the vendor and product ID and prints this information.
+ *
+ * @param EdidRaw is the base EDID structure to decode.
+ *
+ * @return None.
+ *
+ * @note None.
+ *
+*******************************************************************************/
+static void Edid_PrintBaseVPId(u8 *EdidRaw)
+{
+ char ManName[4];
+ XVidC_EdidGetManName(EdidRaw, ManName);
+
+ /* Vendor and product identification. */
+ xil_printf("Vendor and product identification:\n");
+ xil_printf("\tID manufacturer name:\t%s\n", ManName);
+ xil_printf("\tID product code:\t0x%04lx\n",
+ XVidC_EdidGetIdProdCode(EdidRaw));
+ xil_printf("\tID serial number:\t0x%08lx\n",
+ XVidC_EdidGetIdSn(EdidRaw));
+ if (XVidC_EdidIsYearModel(EdidRaw)) {
+ xil_printf("\tModel year:\t\t%d\n",
+ XVidC_EdidGetModManYear(EdidRaw));
+ }
+ else if (XVidC_EdidGetManWeek(EdidRaw) == 0x00) {
+ xil_printf("\tManufactured:\t\tYear = %d ; Week N/A\n",
+ XVidC_EdidGetModManYear(EdidRaw));
+ }
+ else {
+ xil_printf("\tManufactured:\t\tYear = %d ; Week = %d\n",
+ XVidC_EdidGetModManYear(EdidRaw),
+ XVidC_EdidGetManWeek(EdidRaw));
+ }
+}
+
+/******************************************************************************/
+/**
+ * This function decodes the supplied base Extended Display Identification Data
+ * (EDID) structure for the EDID version and revision and prints this
+ * information.
+ *
+ * @param EdidRaw is the base EDID structure to decode.
+ *
+ * @return None.
+ *
+ * @note None.
+ *
+*******************************************************************************/
+static void Edid_PrintBaseVerRev(u8 *EdidRaw)
+{
+ /* EDID structure version and revision. */
+ xil_printf("EDID structure version and revision: %d.%d\n",
+ XVidC_EdidGetStructVer(EdidRaw),
+ XVidC_EdidGetStructRev(EdidRaw));
+}
+
+/******************************************************************************/
+/**
+ * This function decodes the supplied base Extended Display Identification Data
+ * (EDID) structure for basic display parameters and features and prints this
+ * information.
+ *
+ * @param EdidRaw is the base EDID structure to decode.
+ *
+ * @return None.
+ *
+ * @note None.
+ *
+*******************************************************************************/
+static void Edid_PrintBaseBasicDisp(u8 *EdidRaw)
+{
+ /* Basic display parameters and features. */
+ xil_printf("Basic display parameters and features:\n");
+ if (XVidC_EdidIsDigitalSig(EdidRaw)) {
+ /* Input is a digital video signal interface. */
+ xil_printf("\tVideo signal interface is digital.\n");
+
+ if (XVidC_EdidGetColorDepth(EdidRaw) != XVIDC_BPC_UNKNOWN) {
+ xil_printf("\tColor bit depth:\t%d\n",
+ XVidC_EdidGetColorDepth(EdidRaw));
+ }
+ else {
+ xil_printf("\tColor bit depth is undefined.\n");
+ }
+
+ switch (XVidC_EdidGetDigitalSigIfaceStd(EdidRaw)) {
+ case XVIDC_EDID_BDISP_VID_DIG_VIS_DVI:
+ xil_printf("\tDVI is supported.\n");
+ break;
+ case XVIDC_EDID_BDISP_VID_DIG_VIS_HDMIA:
+ xil_printf("\tHDMI-a is supported.\n");
+ break;
+ case XVIDC_EDID_BDISP_VID_DIG_VIS_HDMIB:
+ xil_printf("\tHDMI-b is supported.\n");
+ break;
+ case XVIDC_EDID_BDISP_VID_DIG_VIS_MDDI:
+ xil_printf("\tMDDI is supported.\n");
+ break;
+ case XVIDC_EDID_BDISP_VID_DIG_VIS_DP:
+ xil_printf("\tDisplayPort is supported.\n");
+ break;
+ default:
+ xil_printf("\tDigital interface undefined.\n");
+ break;
+ }
+ }
+ else {
+ /* Input is an analog video signal interface. */
+ xil_printf("\tVideo signal interface is analog.\n");
+
+ xil_printf("\tSignal level standard:\t");
+
+ switch (XVidC_EdidGetAnalogSigLvlStd(EdidRaw)) {
+ case XVIDC_EDID_BDISP_VID_ANA_SLS_0700_0300_1000:
+ xil_printf("0.700 : 0.300 : 1.000 Vp-p ");
+ break;
+ case XVIDC_EDID_BDISP_VID_ANA_SLS_0714_0286_1000:
+ xil_printf("0.714 : 0.286 : 1.000 Vp-p ");
+ break;
+ case XVIDC_EDID_BDISP_VID_ANA_SLS_1000_0400_1400:
+ xil_printf("1.000 : 0.400 : 1.400 Vp-p ");
+ break;
+ case XVIDC_EDID_BDISP_VID_ANA_SLS_0700_0000_0700:
+ default:
+ xil_printf("0.700 : 0.000 : 0.700 V p-p");
+ break;
+ }
+ xil_printf("(Video : Sync : Total)\n");
+
+ xil_printf("\tVideo setup:\t\t");
+ if (XVidC_EdidGetAnalogSigVidSetup(EdidRaw)) {
+ xil_printf("Blank-to-black setup or pedestal.\n");
+ }
+ else {
+ xil_printf("Blank level = black level.\n");
+ }
+
+ xil_printf("\tSynchronization types:\n");
+ xil_printf("\t\tSeparate sync H & V signals ");
+ if (XVidC_EdidSuppAnalogSigSepSyncHv(EdidRaw)) {
+ xil_printf("are supported.\n");
+ }
+ else {
+ xil_printf("are not supported.\n");
+ }
+ xil_printf("\t\tComposite sync signal on horizontal ");
+ if (XVidC_EdidSuppAnalogSigCompSyncH(EdidRaw)) {
+ xil_printf("is supported.\n");
+ }
+ else {
+ xil_printf("is not supported.\n");
+ }
+ xil_printf("\t\tComposite sync signal on green video ");
+ if (XVidC_EdidSuppAnalogSigCompSyncG(EdidRaw)) {
+ xil_printf("is supported.\n");
+ }
+ else {
+ xil_printf("is not supported.\n");
+ }
+
+ xil_printf("\tSerrations on the vertical sync ");
+ if (XVidC_EdidSuppAnalogSigSerrVsync(EdidRaw)) {
+ xil_printf("is supported.\n");
+ }
+ else {
+ xil_printf("is not supported.\n");
+ }
+ }
+
+ if (XVidC_EdidIsSsArSs(EdidRaw)) {
+ xil_printf("\tScreen size (HxV):\t%dx%d(cm)\n",
+ XVidC_EdidGetSsArH(EdidRaw),
+ XVidC_EdidGetSsArV(EdidRaw));
+ }
+ else if (XVidC_EdidIsSsArArL(EdidRaw)) {
+ xil_printf("\tAspect ratio (H:V):\t");
+ switch (XVidC_EdidGetSsArH(EdidRaw)) {
+ case 0x4F:
+ xil_printf("16:9 ");
+ break;
+ case 0x3D:
+ xil_printf("16:10 ");
+ break;
+ case 0x22:
+ xil_printf("4:3 ");
+ break;
+ case 0x1A:
+ xil_printf("5:4 ");
+ break;
+ default:
+ xil_printf("%d.%03d:1 ",
+ (u32)XVidC_EdidGetSsArArL(EdidRaw),
+ FLOAT_FRAC_TO_U32(
+ XVidC_EdidGetSsArArL(EdidRaw), 1000));
+ break;
+ }
+ xil_printf("(landscape)\n");
+ }
+ else if (XVidC_EdidIsSsArArP(EdidRaw)) {
+ xil_printf("\tAspect ratio (H:V):\t");
+ switch(XVidC_EdidGetSsArV(EdidRaw)) {
+ case 0x4F:
+ xil_printf("9:16 ");
+ break;
+ case 0x3D:
+ xil_printf("10:16 ");
+ break;
+ case 0x22:
+ xil_printf("3:4 ");
+ break;
+ case 0x1A:
+ xil_printf("4:5 ");
+ break;
+ default:
+ xil_printf("%d.%03d:1 ",
+ (u32)XVidC_EdidIsSsArArP(EdidRaw),
+ FLOAT_FRAC_TO_U32(
+ XVidC_EdidGetSsArArP(EdidRaw),
+ 1000));
+ break;
+ }
+ xil_printf("(portrait)\n");
+ }
+ else {
+ xil_printf("\tScreen size and aspect ratio are undefined.\n");
+ }
+
+ if (XVidC_EdidIsGammaInExt(EdidRaw)) {
+ xil_printf("\tGamma is defined in an extension block.\n");
+ }
+ else {
+ xil_printf("\tGamma:\t\t\t%d.%02d\n",
+ (u32)XVidC_EdidGetGamma(EdidRaw),
+ FLOAT_FRAC_TO_U32(XVidC_EdidGetGamma(EdidRaw),
+ 100));
+ }
+
+ xil_printf("\tDisplay power management:\n");
+ xil_printf("\t\t\t\tStandby mode ");
+ if (XVidC_EdidSuppFeaturePmStandby(EdidRaw)) {
+ xil_printf("is supported.\n");
+ }
+ else {
+ xil_printf("is not supported.\n");
+ }
+ xil_printf("\t\t\t\tSuspend mode ");
+ if (XVidC_EdidSuppFeaturePmSuspend(EdidRaw)) {
+ xil_printf("is supported.\n");
+ }
+ else {
+ xil_printf("is not supported.\n");
+ }
+ xil_printf("\t\t\t\tActive off = very low power ");
+ if (XVidC_EdidSuppFeaturePmOffVlp(EdidRaw)) {
+ xil_printf("is supported.\n");
+ }
+ else {
+ xil_printf("is not supported.\n");
+ }
+
+ if (XVidC_EdidIsDigitalSig(EdidRaw)) {
+ /* Input is a digital video signal interface. */
+ xil_printf("\tSupported color encoding format(s):\n");
+ xil_printf("\t\t\t\tRGB 4:4:4\n");
+ if (XVidC_EdidSuppFeatureDigColorEncYCrCb444(EdidRaw)) {
+ xil_printf("\t\t\t\tYCrCb 4:4:4\n");
+ }
+ if (XVidC_EdidSuppFeatureDigColorEncYCrCb422(EdidRaw)) {
+ xil_printf("\t\t\t\tYCrCb 4:2:2\n");
+ }
+ }
+ else {
+ /* Input is an analog video signal interface. */
+ xil_printf("\tDisplay color type:\t");
+ switch (XVidC_EdidGetFeatureAnaColorType(EdidRaw)) {
+ case XVIDC_EDID_BDISP_FEATURE_ANA_COLORTYPE_MCG:
+ xil_printf("Monochrome or grayscale display.\n");
+ break;
+ case XVIDC_EDID_BDISP_FEATURE_ANA_COLORTYPE_RGB:
+ xil_printf("RGB color display.\n");
+ break;
+ case XVIDC_EDID_BDISP_FEATURE_ANA_COLORTYPE_NRGB:
+ xil_printf("Non-RGB color display.\n");
+ break;
+ case XVIDC_EDID_BDISP_FEATURE_ANA_COLORTYPE_UNDEF:
+ default:
+ xil_printf("Display color type is undefined.\n");
+ break;
+ }
+ }
+
+ xil_printf("\tOther supported features:\n");
+ /* sRGB standard is the default color space. */
+ xil_printf("\t\tsRGB standard ");
+ if (XVidC_EdidIsFeaturePtmInc(EdidRaw)) {
+ xil_printf("is ");
+ }
+ else {
+ xil_printf("is not ");
+ }
+ xil_printf("the default color space.\n");
+ /* Preferred timing mode includes. */
+ xil_printf("\t\tPtm ");
+ if (XVidC_EdidIsFeaturePtmInc(EdidRaw)) {
+ xil_printf("includes ");
+ }
+ else {
+ xil_printf("does not include ");
+ }
+ xil_printf("the native pixel format and preferred refresh rate.\n");
+ /* Continuous frequency. */
+ xil_printf("\t\tDisplay ");
+ if (XVidC_EdidIsFeatureContFreq(EdidRaw)) {
+ xil_printf("is ");
+ }
+ else {
+ xil_printf("is non-");
+ }
+ xil_printf("continuous frequency.\n");
+}
+
+/******************************************************************************/
+/**
+ * This function decodes the supplied base Extended Display Identification Data
+ * (EDID) structure for color characteristics and prints this information.
+ *
+ * @param EdidRaw is the base EDID structure to decode.
+ *
+ * @return None.
+ *
+ * @note None.
+ *
+*******************************************************************************/
+static void Edid_PrintColorChar(u8 *EdidRaw)
+{
+ xil_printf("Color characterisitics:\n");
+ xil_printf("\tRed_x:\t\t\t%d.%09d +- 0.0005\n",
+ (u32)XVidC_EdidGetCcRedX(EdidRaw),
+ FLOAT_FRAC_TO_U32(XVidC_EdidGetCcRedX(EdidRaw), 1000000000));
+ xil_printf("\tRed_y:\t\t\t%d.%09d +- 0.0005\n",
+ (u32)XVidC_EdidGetCcRedY(EdidRaw),
+ FLOAT_FRAC_TO_U32(XVidC_EdidGetCcRedY(EdidRaw), 1000000000));
+ xil_printf("\tGreen_x:\t\t%d.%09d +- 0.0005\n",
+ (u32)XVidC_EdidGetCcGreenX(EdidRaw),
+ FLOAT_FRAC_TO_U32(XVidC_EdidGetCcGreenX(EdidRaw), 1000000000));
+ xil_printf("\tGreen_y:\t\t%d.%09d +- 0.0005\n",
+ (u32)XVidC_EdidGetCcGreenY(EdidRaw),
+ FLOAT_FRAC_TO_U32(XVidC_EdidGetCcGreenY(EdidRaw), 1000000000));
+ xil_printf("\tBlue_x:\t\t\t%d.%09d +- 0.0005\n",
+ (u32)XVidC_EdidGetCcBlueX(EdidRaw),
+ FLOAT_FRAC_TO_U32(XVidC_EdidGetCcBlueX(EdidRaw), 1000000000));
+ xil_printf("\tBlue_y:\t\t\t%d.%09d +- 0.0005\n",
+ (u32)XVidC_EdidGetCcBlueY(EdidRaw),
+ FLOAT_FRAC_TO_U32(XVidC_EdidGetCcBlueY(EdidRaw), 1000000000));
+ xil_printf("\tWhite_x:\t\t%d.%09d +- 0.0005\n",
+ (u32)XVidC_EdidGetCcWhiteX(EdidRaw),
+ FLOAT_FRAC_TO_U32(XVidC_EdidGetCcWhiteX(EdidRaw), 1000000000));
+ xil_printf("\tWhite_y:\t\t%d.%09d +- 0.0005\n",
+ (u32)XVidC_EdidGetCcWhiteY(EdidRaw),
+ FLOAT_FRAC_TO_U32(XVidC_EdidGetCcWhiteY(EdidRaw), 1000000000));
+}
+
+/******************************************************************************/
+/**
+ * This function decodes the supplied base Extended Display Identification Data
+ * (EDID) structure for supported established timings and prints this
+ * information.
+ *
+ * @param EdidRaw is the base EDID structure to decode.
+ *
+ * @return None.
+ *
+ * @note None.
+ *
+*******************************************************************************/
+static void Edid_PrintEstTimings(u8 *EdidRaw)
+{
+ xil_printf("Established timings:\n");
+ if (XVidC_EdidSuppEstTimings720x400_70(EdidRaw)) {
+ xil_printf("\t720x400 @ 70Hz supported.\n");
+ }
+ if (XVidC_EdidSuppEstTimings720x400_88(EdidRaw)) {
+ xil_printf("\t720x400 @ 88Hz supported.\n");
+ }
+ if (XVidC_EdidSuppEstTimings640x480_60(EdidRaw)) {
+ xil_printf("\t640x480 @ 60Hz supported.\n");
+ }
+ if (XVidC_EdidSuppEstTimings640x480_67(EdidRaw)) {
+ xil_printf("\t640x480 @ 67Hz supported.\n");
+ }
+ if (XVidC_EdidSuppEstTimings640x480_72(EdidRaw)) {
+ xil_printf("\t640x480 @ 72Hz supported.\n");
+ }
+ if (XVidC_EdidSuppEstTimings640x480_75(EdidRaw)) {
+ xil_printf("\t640x480 @ 75Hz supported.\n");
+ }
+ if (XVidC_EdidSuppEstTimings800x600_56(EdidRaw)) {
+ xil_printf("\t800x600 @ 56Hz supported.\n");
+ }
+ if (XVidC_EdidSuppEstTimings800x600_60(EdidRaw)) {
+ xil_printf("\t800x600 @ 60Hz supported.\n");
+ }
+ if (XVidC_EdidSuppEstTimings800x600_72(EdidRaw)) {
+ xil_printf("\t800x600 @ 72Hz supported.\n");
+ }
+ if (XVidC_EdidSuppEstTimings800x600_75(EdidRaw)) {
+ xil_printf("\t800x600 @ 75Hz supported.\n");
+ }
+ if (XVidC_EdidSuppEstTimings832x624_75(EdidRaw)) {
+ xil_printf("\t832x624 @ 75Hz supported.\n");
+ }
+ if (XVidC_EdidSuppEstTimings1024x768_87(EdidRaw)) {
+ xil_printf("\t1024x768 @ 87Hz supported.\n");
+ }
+ if (XVidC_EdidSuppEstTimings1024x768_60(EdidRaw)) {
+ xil_printf("\t1024x768 @ 60Hz supported.\n");
+ }
+ if (XVidC_EdidSuppEstTimings1024x768_70(EdidRaw)) {
+ xil_printf("\t1024x768 @ 70Hz supported.\n");
+ }
+ if (XVidC_EdidSuppEstTimings1024x768_75(EdidRaw)) {
+ xil_printf("\t1024x768 @ 75Hz supported.\n");
+ }
+ if (XVidC_EdidSuppEstTimings1280x1024_75(EdidRaw)) {
+ xil_printf("\t1280x1024 @ 75Hz supported.\n");
+ }
+ if (XVidC_EdidSuppEstTimings1152x870_75(EdidRaw)) {
+ xil_printf("\t1152x870 @ 75Hz supported.\n");
+ }
+ xil_printf("\tManufacturer specified timings field: 0x%02lx.\n",
+ XVidC_EdidGetTimingsMan(EdidRaw));
+}
+
+/******************************************************************************/
+/**
+ * This function decodes the supplied base Extended Display Identification Data
+ * (EDID) structure for supported standard timings and prints this information.
+ *
+ * @param EdidRaw is the base EDID structure to decode.
+ *
+ * @return None.
+ *
+ * @note None.
+ *
+*******************************************************************************/
+static void Edid_PrintStdTimings(u8 *EdidRaw)
+{
+ u8 Index;
+
+ xil_printf("Standard timings:\n");
+ for (Index = 0; Index < 8; Index++) {
+ if (EdidRaw[XVIDC_EDID_STD_TIMINGS_H(Index + 1)] <= 1) {
+ /* Not a valid standard timing. */
+ continue;
+ }
+
+ xil_printf("\t%dx%d @ %dHz supported.\n",
+ XVidC_EdidGetStdTimingsH(EdidRaw, Index + 1),
+ XVidC_EdidGetStdTimingsV(EdidRaw, Index + 1),
+ XVidC_EdidGetStdTimingsFrr(EdidRaw, Index + 1));
+ }
+}
+
+/******************************************************************************/
+/**
+ * This function decodes the supplied base Extended Display Identification Data
+ * (EDID) structure for the preferred timing mode (PTM) and prints its timing
+ * information.
+ *
+ * @param EdidRaw is the base EDID structure to decode.
+ *
+ * @return None.
+ *
+ * @note None.
+ *
+*******************************************************************************/
+static void Edid_PrintPtm(u8 *EdidRaw)
+{
+ u8 *Ptm;
+
+ Ptm = &EdidRaw[XVIDC_EDID_PTM];
+
+ u16 HBlank = ((Ptm[XVIDC_EDID_DTD_PTM_HRES_HBLANK_U4] &
+ XVIDC_EDID_DTD_PTM_XRES_XBLANK_U4_XBLANK_MASK) << 8) |
+ Ptm[XVIDC_EDID_DTD_PTM_HBLANK_LSB];
+
+ u16 VBlank = ((Ptm[XVIDC_EDID_DTD_PTM_VRES_VBLANK_U4] &
+ XVIDC_EDID_DTD_PTM_XRES_XBLANK_U4_XBLANK_MASK) << 8) |
+ Ptm[XVIDC_EDID_DTD_PTM_VBLANK_LSB];
+
+ u32 HActive = (((Ptm[XVIDC_EDID_DTD_PTM_HRES_HBLANK_U4] &
+ XVIDC_EDID_DTD_PTM_XRES_XBLANK_U4_XRES_MASK) >>
+ XVIDC_EDID_DTD_PTM_XRES_XBLANK_U4_XRES_SHIFT) << 8) |
+ Ptm[XVIDC_EDID_DTD_PTM_HRES_LSB];
+
+ u32 VActive = (((Ptm[XVIDC_EDID_DTD_PTM_VRES_VBLANK_U4] &
+ XVIDC_EDID_DTD_PTM_XRES_XBLANK_U4_XRES_MASK) >>
+ XVIDC_EDID_DTD_PTM_XRES_XBLANK_U4_XRES_SHIFT) << 8) |
+ Ptm[XVIDC_EDID_DTD_PTM_VRES_LSB];
+
+ u32 PixelClkKhz = ((Ptm[XVIDC_EDID_DTD_PTM_PIXEL_CLK_KHZ_MSB] <<
+ 8) | Ptm[XVIDC_EDID_DTD_PTM_PIXEL_CLK_KHZ_LSB]) * 10;
+
+ u32 HFrontPorch = (((Ptm[XVIDC_EDID_DTD_PTM_XFPORCH_XSPW_U2] &
+ XVIDC_EDID_DTD_PTM_XFPORCH_XSPW_U2_HFPORCH_MASK) >>
+ XVIDC_EDID_DTD_PTM_XFPORCH_XSPW_U2_HFPORCH_SHIFT) << 8)
+ | Ptm[XVIDC_EDID_DTD_PTM_HFPORCH_LSB];
+
+ u32 HSyncWidth = (((Ptm[XVIDC_EDID_DTD_PTM_XFPORCH_XSPW_U2] &
+ XVIDC_EDID_DTD_PTM_XFPORCH_XSPW_U2_HSPW_MASK) >>
+ XVIDC_EDID_DTD_PTM_XFPORCH_XSPW_U2_HSPW_SHIFT) << 8) |
+ Ptm[XVIDC_EDID_DTD_PTM_HSPW_LSB];
+
+ u32 VFrontPorch = (((Ptm[XVIDC_EDID_DTD_PTM_XFPORCH_XSPW_U2] &
+ XVIDC_EDID_DTD_PTM_XFPORCH_XSPW_U2_VFPORCH_MASK) >>
+ XVIDC_EDID_DTD_PTM_XFPORCH_XSPW_U2_VFPORCH_SHIFT) << 8)
+ | ((Ptm[XVIDC_EDID_DTD_PTM_VFPORCH_VSPW_L4] &
+ XVIDC_EDID_DTD_PTM_VFPORCH_VSPW_L4_VFPORCH_MASK) >>
+ XVIDC_EDID_DTD_PTM_VFPORCH_VSPW_L4_VFPORCH_SHIFT);
+
+ u32 VSyncWidth = ((Ptm[XVIDC_EDID_DTD_PTM_XFPORCH_XSPW_U2] &
+ XVIDC_EDID_DTD_PTM_XFPORCH_XSPW_U2_VSPW_MASK) << 8) |
+ (Ptm[XVIDC_EDID_DTD_PTM_VFPORCH_VSPW_L4] &
+ XVIDC_EDID_DTD_PTM_VFPORCH_VSPW_L4_VSPW_MASK);
+
+ u32 HBackPorch = HBlank - (HFrontPorch + HSyncWidth);
+
+ u32 VBackPorch = VBlank - (VFrontPorch + VSyncWidth);
+
+ u8 HPolarity = (Ptm[XVIDC_EDID_DTD_PTM_SIGNAL] &
+ XVIDC_EDID_DTD_PTM_SIGNAL_HPOLARITY_MASK) >>
+ XVIDC_EDID_DTD_PTM_SIGNAL_HPOLARITY_SHIFT;
+ u8 VPolarity = (Ptm[XVIDC_EDID_DTD_PTM_SIGNAL] &
+ XVIDC_EDID_DTD_PTM_SIGNAL_VPOLARITY_MASK) >>
+ XVIDC_EDID_DTD_PTM_SIGNAL_VPOLARITY_SHIFT;
+
+ xil_printf("Preferred timing mode:\n");
+ xil_printf("\tHorizontal resolution:\t%d px\n"
+ "\tVertical resolution:\t%d lines\n"
+ "\tPixel clock:\t\t%d KHz\n"
+ "\tHorizontal front porch:\t%d px\n"
+ "\tHorizontal sync width:\t%d px\n"
+ "\tHorizontal back porch:\t%d px\n"
+ "\tHorizontal blanking:\t%d px\n"
+ "\tHorizontal polarity:\t%d\n"
+ "\tVertical front porch:\t%d px\n"
+ "\tVertical sync width:\t%d px\n"
+ "\tVertical back porch:\t%d px\n"
+ "\tVertical blanking:\t%d px\n"
+ "\tVertical polarity:\t%d\n",
+ HActive, VActive, PixelClkKhz,
+ HFrontPorch, HSyncWidth, HBackPorch, HBlank, HPolarity,
+ VFrontPorch, VSyncWidth, VBackPorch, VBlank, VPolarity);
+
+ xil_printf("\tInterlaced:\t\t%s\n",
+ XVidC_EdidIsDtdPtmInterlaced(EdidRaw) ?
+ "Yes." : "No (progressive).");
+}
+
+/******************************************************************************/
+/**
+ * This function calculates a checksum.
+ *
+ * @param Data is a pointer to the data to calculate the checksum on.
+ * @param Size the number of bytes of Data to calculate the checksum on.
+ *
+ * @return The checksum value (truncated to a 8 bits).
+ *
+ * @note None.
+ *
+*******************************************************************************/
+static u8 Edid_CalculateChecksum(u8 *Data, u8 Size)
+{
+ u8 Index;
+ u8 Sum = 0;
+
+ for (Index = 0; Index < Size; Index++) {
+ Sum += Data[Index];
+ }
+
+ return Sum;
+}
diff --git a/XilinxProcessorIPLib/drivers/video_common/examples/xvidc_edid_print_example.h b/XilinxProcessorIPLib/drivers/video_common/examples/xvidc_edid_print_example.h
new file mode 100644
index 00000000..41c9928b
--- /dev/null
+++ b/XilinxProcessorIPLib/drivers/video_common/examples/xvidc_edid_print_example.h
@@ -0,0 +1,67 @@
+/*******************************************************************************
+ *
+ * Copyright (C) 2015 Xilinx, Inc. All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * Use of the Software is limited solely to applications:
+ * (a) running on a Xilinx device, or
+ * (b) that interact with a Xilinx device through a bus or interconnect.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * XILINX BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
+ * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * Except as contained in this notice, the name of the Xilinx shall not be used
+ * in advertising or otherwise to promote the sale, use or other dealings in
+ * this Software without prior written authorization from Xilinx.
+ *
+*******************************************************************************/
+/******************************************************************************/
+/**
+ *
+ * @file xvidc_edid_print_example.h
+ *
+ * Contains an example that, given a supplied base Extended Display
+ * Identification Data (EDID) structure, will parse, decode, and print its
+ * contents.
+ *
+ * @note None.
+ *
+ *
+ * MODIFICATION HISTORY:
+ *
+ * Ver Who Date Changes
+ * ----- ---- -------- -----------------------------------------------
+ * 1.0 als 11/09/14 Initial release.
+ *
+ *
+*******************************************************************************/
+
+#ifndef XVIDC_EDID_PRINT_H_
+/* Prevent circular inclusions by using protection macros. */
+#define XVIDC_EDID_PRINT_H_
+
+/******************************* Include Files ********************************/
+
+#include "xdp.h"
+#include "xvidc_edid.h"
+
+/**************************** Function Prototypes *****************************/
+
+u32 Edid_PrintDecodeBase(u8 *EdidRaw);
+void Edid_PrintSuppVmTable(u8 *EdidRaw);
+
+#endif /* XVIDC_EDID_PRINT_H_ */
diff --git a/XilinxProcessorIPLib/drivers/video_common/src/Makefile b/XilinxProcessorIPLib/drivers/video_common/src/Makefile
new file mode 100644
index 00000000..19b90c33
--- /dev/null
+++ b/XilinxProcessorIPLib/drivers/video_common/src/Makefile
@@ -0,0 +1,40 @@
+COMPILER=
+ARCHIVER=
+CP=cp
+COMPILER_FLAGS=
+EXTRA_COMPILER_FLAGS=
+LIB=libxil.a
+
+CC_FLAGS = $(COMPILER_FLAGS)
+ECC_FLAGS = $(EXTRA_COMPILER_FLAGS)
+
+RELEASEDIR=../../../lib
+INCLUDEDIR=../../../include
+INCLUDES=-I./. -I${INCLUDEDIR}
+
+OUTS = *.o
+
+LIBSOURCES:=*.c
+INCLUDEFILES:=*.h
+
+OBJECTS = $(addsuffix .o, $(basename $(wildcard *.c)))
+
+libs: banner video_common_libs clean
+
+%.o: %.c
+ ${COMPILER} $(CC_FLAGS) $(ECC_FLAGS) $(INCLUDES) -o $@ $<
+
+banner:
+ echo "Compiling video_common"
+
+video_common_libs: ${OBJECTS}
+ $(ARCHIVER) -r ${RELEASEDIR}/${LIB} ${OBJECTS}
+
+.PHONY: include
+include: video_common_includes
+
+video_common_includes:
+ ${CP} ${INCLUDEFILES} ${INCLUDEDIR}
+
+clean:
+ rm -rf ${OBJECTS}
diff --git a/XilinxProcessorIPLib/drivers/video_common/src/xvidc.c b/XilinxProcessorIPLib/drivers/video_common/src/xvidc.c
new file mode 100644
index 00000000..02675d0d
--- /dev/null
+++ b/XilinxProcessorIPLib/drivers/video_common/src/xvidc.c
@@ -0,0 +1,529 @@
+/*******************************************************************************
+ *
+ * Copyright (C) 2015 Xilinx, Inc. All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * Use of the Software is limited solely to applications:
+ * (a) running on a Xilinx device, or
+ * (b) that interact with a Xilinx device through a bus or interconnect.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * XILINX BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
+ * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * Except as contained in this notice, the name of the Xilinx shall not be used
+ * in advertising or otherwise to promote the sale, use or other dealings in
+ * this Software without prior written authorization from Xilinx.
+ *
+*******************************************************************************/
+/******************************************************************************/
+/**
+ *
+ * @file xvidc.c
+ *
+ * Contains common utility functions that are typically used by video-related
+ * drivers and applications.
+ *
+ * @note None.
+ *
+ *
+ * MODIFICATION HISTORY:
+ *
+ * Ver Who Date Changes
+ * ----- ---- -------- -----------------------------------------------
+ * 1.0 rc, 01/10/15 Initial release.
+ * als
+ *
+ *
+*******************************************************************************/
+
+/******************************* Include Files ********************************/
+
+#include "xil_printf.h"
+#include "xvidc.h"
+
+/*************************** Function Definitions *****************************/
+
+/******************************************************************************/
+/**
+ * This function calculates pixel clock based on the inputs.
+ *
+ * @param HTotal specifies horizontal total.
+ * @param VTotal specifies vertical total.
+ * @param FrameRate specifies rate at which frames are generated.
+ *
+ * @return Pixel clock in Hz.
+ *
+ * @note None.
+ *
+*******************************************************************************/
+u32 XVidC_GetPixelClockHzByHVFr(u32 HTotal, u32 VTotal, u8 FrameRate)
+{
+ return (HTotal * VTotal * FrameRate);
+}
+
+/******************************************************************************/
+/**
+ * This function calculates pixel clock from video mode.
+ *
+ * @param VmId specifies the resolution id.
+ *
+ * @return Pixel clock in Hz.
+ *
+ * @note None.
+ *
+*******************************************************************************/
+u32 XVidC_GetPixelClockHzByVmId(XVidC_VideoMode VmId)
+{
+ u32 ClkHz;
+ const XVidC_VideoTimingMode *VmPtr;
+
+ VmPtr = &XVidC_VideoTimingModes[VmId];
+
+ if (XVidC_IsInterlaced(VmId)) {
+ /* For interlaced mode, use both frame 0 and frame 1 vertical
+ * totals. */
+ ClkHz = VmPtr->Timing.F0PVTotal + VmPtr->Timing.F1VTotal;
+
+ /* Multiply the number of pixels by the frame rate of each
+ * individual frame (half of the total frame rate). */
+ ClkHz *= VmPtr->FrameRate / 2;
+ }
+ else {
+ /* For progressive mode, use only frame 0 vertical total. */
+ ClkHz = VmPtr->Timing.F0PVTotal;
+
+ /* Multiply the number of pixels by the frame rate. */
+ ClkHz *= VmPtr->FrameRate;
+ }
+
+ /* Multiply the vertical total by the horizontal total for number of
+ * pixels. */
+ ClkHz *= VmPtr->Timing.HTotal;
+
+ return ClkHz;
+}
+
+/******************************************************************************/
+/**
+ * This function checks if the input video mode is interlaced/progressive based
+ * on its ID from the video timings table.
+ *
+ * @param VmId specifies the resolution ID from the video timings table.
+ *
+ * @return Video format.
+ * - XVIDC_VF_PROGRESSIVE
+ * - XVIDC_VF_INTERLACED
+ *
+ * @note None.
+ *
+*******************************************************************************/
+XVidC_VideoFormat XVidC_GetVideoFormat(XVidC_VideoMode VmId)
+{
+ if (XVidC_VideoTimingModes[VmId].Timing.F1VTotal == 0) {
+ return (XVIDC_VF_PROGRESSIVE);
+ }
+
+ return (XVIDC_VF_INTERLACED);
+}
+
+/******************************************************************************/
+/**
+ * This function checks if the input video mode is interlaced based on its ID
+ * from the video timings table.
+ *
+ * @param VmId specifies the resolution ID from the video timings table.
+ *
+ * @return
+ * - 1 if the video timing with the supplied table ID is
+ * interlaced.
+ * - 0 if the video timing is progressive.
+ *
+ * @note None.
+ *
+*******************************************************************************/
+u8 XVidC_IsInterlaced(XVidC_VideoMode VmId)
+{
+ if (XVidC_GetVideoFormat(VmId) == XVIDC_VF_INTERLACED) {
+ return 1;
+ }
+
+ return 0;
+}
+
+/******************************************************************************/
+/**
+ * This function returns the Video Mode ID that matches the detected input
+ * width, height, frame rate and I/P flag
+ *
+ * @param Width specifies the number pixels per scanline.
+ * @param Height specifies the number of scanline's.
+ * @param FrameRate specifies refresh rate in HZ
+ * @param IsInterlaced is flag.
+ * - 0 = Progressive
+ * - 1 = Interlaced.
+ *
+ * @return Id of a supported video mode.
+ *
+ * @note None.
+ *
+*******************************************************************************/
+XVidC_VideoMode XVidC_GetVideoModeId(u32 Width, u32 Height, u32 FrameRate,
+ u8 IsInterlaced)
+{
+ u32 Low;
+ u32 High;
+ u32 Mid;
+ u32 HActive;
+ u32 VActive;
+ u32 Rate;
+ u32 ResFound = (FALSE);
+ XVidC_VideoMode Mode;
+
+ if (IsInterlaced) {
+ Low = (XVIDC_VM_INTL_START);
+ High = (XVIDC_VM_INTL_END);
+ }
+ else {
+ Low = (XVIDC_VM_PROG_START);
+ High = (XVIDC_VM_PROG_END);
+ }
+
+ HActive = VActive = Rate = 0;
+
+ /* Binary search finds item in sorted array.
+ * And returns index (zero based) of item
+ * If item is not found returns flag remains
+ * FALSE. Search key is "width or HActive"
+ */
+ while (Low <= High) {
+ Mid = (Low + High) / 2;
+ HActive = XVidC_VideoTimingModes[Mid].Timing.HActive;
+ if (Width == HActive) {
+ ResFound = (TRUE);
+ break;
+ }
+ else if (Width < HActive) {
+ High = Mid - 1;
+ }
+ else {
+ Low = Mid + 1;
+ }
+ }
+
+ /* HActive matched at middle */
+ if (ResFound) {
+ /* Rewind to start index of mode with matching width */
+ while ((Mid > 0) &&
+ (XVidC_VideoTimingModes[Mid - 1].Timing.HActive ==
+ Width)) {
+ --Mid;
+ }
+
+ ResFound = (FALSE);
+ VActive = XVidC_VideoTimingModes[Mid].Timing.VActive;
+ Rate = XVidC_VideoTimingModes[Mid].FrameRate;
+
+ /* Now do a linear search for matching VActive and Frame
+ * Rate
+ */
+ while (HActive == Width) {
+ /* check current entry */
+ if ((VActive == Height) && (Rate == FrameRate)) {
+ ResFound = (TRUE);
+ break;
+ }
+ /* Check next entry */
+ else {
+ Mid = Mid + 1;
+ HActive =
+ XVidC_VideoTimingModes[Mid].Timing.HActive;
+ VActive =
+ XVidC_VideoTimingModes[Mid].Timing.VActive;
+ Rate = XVidC_VideoTimingModes[Mid].FrameRate;
+ }
+ }
+ Mode =
+ (ResFound) ? (XVidC_VideoMode)Mid : (XVIDC_VM_NOT_SUPPORTED);
+ }
+ else {
+ Mode = (XVIDC_VM_NOT_SUPPORTED);
+ }
+
+ return (Mode);
+}
+
+/******************************************************************************/
+/**
+ * This function returns the pointer to video mode data at index provided.
+ *
+ * @param VmId specifies the resolution id.
+ *
+ * @return Pointer to XVidC_VideoTimingMode structure based on the given
+ * video mode.
+ *
+ * @note None.
+ *
+*******************************************************************************/
+const XVidC_VideoTimingMode *XVidC_GetVideoModeData(XVidC_VideoMode VmId)
+{
+ if (VmId < (XVIDC_VM_NUM_SUPPORTED)) {
+ return (&XVidC_VideoTimingModes[VmId]);
+ }
+ else {
+ return (NULL);
+ }
+}
+
+/******************************************************************************/
+/**
+ *
+ * This function returns the resolution name for index specified.
+ *
+ * @param VmId specifies the resolution id.
+ *
+ * @return Pointer to a resolution name string.
+ *
+ * @note None.
+ *
+*******************************************************************************/
+const char *XVidC_GetVideoModeStr(XVidC_VideoMode VmId)
+{
+ if (VmId < (XVIDC_VM_NUM_SUPPORTED)) {
+ return (XVidC_VideoTimingModes[VmId].Name);
+ }
+ else {
+ return ("Video mode not supported");
+ }
+}
+
+/******************************************************************************/
+/**
+ * This function returns the frame rate name for index specified.
+ *
+ * @param VmId specifies the resolution id.
+ *
+ * @return Pointer to a frame rate name string.
+ *
+ * @note None.
+ *
+*******************************************************************************/
+char *XVidC_GetFrameRateStr(XVidC_VideoMode VmId)
+{
+ if (VmId < (XVIDC_VM_NUM_SUPPORTED)) {
+ switch (XVidC_VideoTimingModes[VmId].FrameRate) {
+ case (XVIDC_FR_24HZ):
+ return ("24Hz");
+
+ case (XVIDC_FR_25HZ):
+ return ("25Hz");
+
+ case (XVIDC_FR_30HZ):
+ return ("30Hz");
+
+ case (XVIDC_FR_50HZ):
+ return ("50Hz");
+
+ case (XVIDC_FR_56HZ):
+ return ("56Hz");
+
+ case (XVIDC_FR_60HZ):
+ return ("60Hz");
+
+ case (XVIDC_FR_65HZ):
+ return ("65Hz");
+
+ case (XVIDC_FR_67HZ):
+ return ("67Hz");
+
+ case (XVIDC_FR_70HZ):
+ return("70Hz");
+
+ case (XVIDC_FR_72HZ):
+ return ("72Hz");
+
+ case (XVIDC_FR_75HZ):
+ return ("75Hz");
+
+ case (XVIDC_FR_85HZ):
+ return ("85Hz");
+
+ case (XVIDC_FR_87HZ):
+ return ("87Hz");
+
+ case (XVIDC_FR_88HZ):
+ return ("88Hz");
+
+ case (XVIDC_FR_100HZ):
+ return("100Hz");
+
+ case (XVIDC_FR_120HZ):
+ return ("120Hz");
+
+ default:
+ return ("Frame rate not supported");
+ }
+ }
+ else {
+ return ("Video mode not supported");
+ }
+}
+
+/******************************************************************************/
+/**
+ * This function returns the color format name for index specified.
+ *
+ * @param ColorFormatId specifies the index of color format space.
+ * 0 = XVIDC_CSF_RGB
+ * 1 = XVIDC_CSF_YCRCB_444,
+ * 2 = XVIDC_CSF_YCRCB_422,
+ * 3 = XVIDC_CSF_YCRCB_420,
+ *
+ * @return Pointer to a color space name string.
+ *
+ * @note None.
+ *
+*******************************************************************************/
+char *XVidC_GetColorFormatStr(XVidC_ColorFormat ColorFormatId)
+{
+ switch (ColorFormatId) {
+ case (XVIDC_CSF_RGB):
+ return ("RGB");
+
+ case (XVIDC_CSF_YCRCB_444):
+ return ("YUV_444");
+
+ case (XVIDC_CSF_YCRCB_422):
+ return ("YUV_422");
+
+ case (XVIDC_CSF_YCRCB_420):
+ return ("YUV_420");
+
+ default:
+ return ("Color space format not supported");
+ }
+}
+
+/******************************************************************************/
+/**
+ * This function returns the frame rate for index specified.
+ *
+ * @param VmId specifies the resolution id.
+ *
+ * @return Frame rate in Hz.
+ *
+ * @note None.
+ *
+*******************************************************************************/
+XVidC_FrameRate XVidC_GetFrameRate(XVidC_VideoMode VmId)
+{
+ if (VmId < (XVIDC_VM_NUM_SUPPORTED)) {
+ return (XVidC_VideoTimingModes[VmId].FrameRate);
+ }
+ else {
+ return (XVIDC_FR_NUM_SUPPORTED);
+ }
+}
+
+/******************************************************************************/
+/**
+ * This function returns the timing parameters for specified resolution.
+ *
+ * @param VmId specifies the resolution id.
+ *
+ * @return Pointer to a XVidC_VideoTiming structure.
+ *
+ * @note None.
+ *
+*******************************************************************************/
+const XVidC_VideoTiming *XVidC_GetTimingInfo(XVidC_VideoMode VmId)
+{
+ if (VmId < (XVIDC_VM_NUM_SUPPORTED)) {
+ return (&XVidC_VideoTimingModes[VmId].Timing);
+ }
+ else {
+ return (NULL);
+ }
+}
+
+/******************************************************************************/
+/**
+ * This function prints the stream information on STDIO/UART console.
+ *
+ * @param Stream is a pointer to video stream.
+ *
+ * @return None.
+ *
+ * @note None.
+ *
+*******************************************************************************/
+void XVidC_ReportStreamInfo(XVidC_VideoStream *Stream)
+{
+ xil_printf("\tColor Space Format:%s\r\n",
+ XVidC_GetColorFormatStr(Stream->ColorFormatId));
+ xil_printf("\tColor Depth:%d\r\n", Stream->ColorDepth);
+ xil_printf("\tPixels Per Clock:%d\r\n", Stream->PixPerClk);
+ xil_printf("\tFrame Rate:%s\r\n", XVidC_GetFrameRateStr(Stream->VmId));
+ xil_printf("\tMode:%s\r\n",
+ Stream->IsInterlaced ? "Interlaced" : "Progressive" );
+ xil_printf("\tResolution:%s\r\n", XVidC_GetVideoModeStr(Stream->VmId));
+ xil_printf("\tPixel Clock:%d\r\n",
+ XVidC_GetPixelClockHzByVmId(Stream->VmId));
+}
+
+/******************************************************************************/
+/**
+ * This function prints timing information on STDIO/Uart console.
+ *
+ * @param Timing is a pointer to Video Timing structure of the stream.
+ * @param IsInterlaced is a TRUE/FALSE flag that denotes the timing
+ * parameter is for interlaced/progressive stream.
+ *
+ * @return None.
+ *
+ * @note None.
+ *
+*******************************************************************************/
+void XVidC_ReportTiming(XVidC_VideoTiming *Timing, u8 IsInterlaced)
+{
+ xil_printf("\r\n\tHSYNC Timing: hav=%04d, hfp=%02d, hsw=%02d(hsp=%d), "
+ "hbp=%03d, htot=%04d \n\r", Timing->HActive,
+ Timing->HFrontPorch, Timing->HSyncWidth,
+ Timing->HSyncPolarity,
+ Timing->HBackPorch, Timing->HTotal);
+
+ /* Interlaced */
+ if (IsInterlaced) {
+ xil_printf("\tVSYNC Timing (Field 0): vav=%04d, vfp=%02d, "
+ "vsw=%02d(vsp=%d), vbp=%03d, vtot=%04d\n\r",
+ Timing->VActive, Timing->F0PVFrontPorch,
+ Timing->F0PVSyncWidth, Timing->VSyncPolarity,
+ Timing->F0PVBackPorch, Timing->F0PVTotal);
+ xil_printf("\tVSYNC Timing (Field 1): vav=%04d, vfp=%02d, "
+ "vsw=%02d(vsp=%d), vbp=%03d, vtot=%04d\n\r",
+ Timing->VActive, Timing->F1VFrontPorch,
+ Timing->F1VSyncWidth, Timing->VSyncPolarity,
+ Timing->F1VBackPorch, Timing->F1VTotal);
+ }
+ /* Progressive */
+ else {
+ xil_printf("\tVSYNC Timing: vav=%04d, vfp=%02d, "
+ "vsw=%02d(vsp=%d), vbp=%03d, vtot=%04d\n\r",
+ Timing->VActive, Timing->F0PVFrontPorch,
+ Timing->F0PVSyncWidth, Timing->VSyncPolarity,
+ Timing->F0PVBackPorch, Timing->F0PVTotal);
+ }
+}
diff --git a/XilinxProcessorIPLib/drivers/video_common/src/xvidc.h b/XilinxProcessorIPLib/drivers/video_common/src/xvidc.h
new file mode 100644
index 00000000..835108dd
--- /dev/null
+++ b/XilinxProcessorIPLib/drivers/video_common/src/xvidc.h
@@ -0,0 +1,389 @@
+/*******************************************************************************
+ *
+ * Copyright (C) 2015 Xilinx, Inc. All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * Use of the Software is limited solely to applications:
+ * (a) running on a Xilinx device, or
+ * (b) that interact with a Xilinx device through a bus or interconnect.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * XILINX BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
+ * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * Except as contained in this notice, the name of the Xilinx shall not be used
+ * in advertising or otherwise to promote the sale, use or other dealings in
+ * this Software without prior written authorization from Xilinx.
+ *
+*******************************************************************************/
+/******************************************************************************/
+/**
+ *
+ * @file xvidc.h
+ *
+ * Contains common structures, definitions, macros, and utility functions that
+ * are typically used by video-related drivers and applications.
+ *
+ * @note None.
+ *
+ *
+ * MODIFICATION HISTORY:
+ *
+ * Ver Who Date Changes
+ * ----- ---- -------- -----------------------------------------------
+ * 1.0 rc, 01/10/15 Initial release.
+ * als
+ *
+ *
+*******************************************************************************/
+
+#ifndef XVIDC_H_
+/* Prevent circular inclusions by using protection macros. */
+#define XVIDC_H_
+
+/******************************* Include Files ********************************/
+
+#include "xil_types.h"
+
+/************************** Constant Definitions ******************************/
+
+/**
+ * This typedef enumerates the list of available standard display monitor
+ * timings as specified in the xvidc_timings_table.c file. The naming format is:
+ *
+ * XVIDC_VM___(_RB)
+ *
+ * Where RB stands for reduced blanking.
+ */
+typedef enum {
+ /* Interlaced modes. */
+ XVIDC_VM_480_60_I = 0,
+ XVIDC_VM_576_50_I,
+ XVIDC_VM_1080_50_I,
+ XVIDC_VM_1080_60_I,
+
+ /* Progressive modes. */
+ XVIDC_VM_640x350_85_P,
+ XVIDC_VM_640x480_60_P,
+ XVIDC_VM_640x480_72_P,
+ XVIDC_VM_640x480_75_P,
+ XVIDC_VM_640x480_85_P,
+ XVIDC_VM_720x400_85_P,
+ XVIDC_VM_720x480_60_P,
+ XVIDC_VM_720x576_50_P,
+ XVIDC_VM_800x600_56_P,
+ XVIDC_VM_800x600_60_P,
+ XVIDC_VM_800x600_72_P,
+ XVIDC_VM_800x600_75_P,
+ XVIDC_VM_800x600_85_P,
+ XVIDC_VM_800x600_120_P_RB,
+ XVIDC_VM_848x480_60_P,
+ XVIDC_VM_1024x768_60_P,
+ XVIDC_VM_1024x768_70_P,
+ XVIDC_VM_1024x768_75_P,
+ XVIDC_VM_1024x768_85_P,
+ XVIDC_VM_1024x768_120_P_RB,
+ XVIDC_VM_1152x864_75_P,
+ XVIDC_VM_1280x720_50_P,
+ XVIDC_VM_1280x720_60_P,
+ XVIDC_VM_1280x768_60_P,
+ XVIDC_VM_1280x768_60_P_RB,
+ XVIDC_VM_1280x768_75_P,
+ XVIDC_VM_1280x768_85_P,
+ XVIDC_VM_1280x768_120_P_RB,
+ XVIDC_VM_1280x800_60_P,
+ XVIDC_VM_1280x800_60_P_RB,
+ XVIDC_VM_1280x800_75_P,
+ XVIDC_VM_1280x800_85_P,
+ XVIDC_VM_1280x800_120_P_RB,
+ XVIDC_VM_1280x960_60_P,
+ XVIDC_VM_1280x960_85_P,
+ XVIDC_VM_1280x960_120_P_RB,
+ XVIDC_VM_1280x1024_60_P,
+ XVIDC_VM_1280x1024_75_P,
+ XVIDC_VM_1280x1024_85_P,
+ XVIDC_VM_1280x1024_120_P_RB,
+ XVIDC_VM_1360x768_60_P,
+ XVIDC_VM_1360x768_120_P_RB,
+ XVIDC_VM_1366x768_60_P,
+ XVIDC_VM_1400x1050_60_P,
+ XVIDC_VM_1400x1050_60_P_RB,
+ XVIDC_VM_1400x1050_75_P,
+ XVIDC_VM_1400x1050_85_P,
+ XVIDC_VM_1400x1050_120_P_RB,
+ XVIDC_VM_1440x900_60_P,
+ XVIDC_VM_1440x900_60_P_RB,
+ XVIDC_VM_1440x900_75_P,
+ XVIDC_VM_1440x900_85_P,
+ XVIDC_VM_1440x900_120_P_RB,
+ XVIDC_VM_1600x1200_60_P,
+ XVIDC_VM_1600x1200_65_P,
+ XVIDC_VM_1600x1200_70_P,
+ XVIDC_VM_1600x1200_75_P,
+ XVIDC_VM_1600x1200_85_P,
+ XVIDC_VM_1600x1200_120_P_RB,
+ XVIDC_VM_1680x1050_60_P,
+ XVIDC_VM_1680x1050_60_P_RB,
+ XVIDC_VM_1680x1050_75_P,
+ XVIDC_VM_1680x1050_85_P,
+ XVIDC_VM_1680x1050_120_P_RB,
+ XVIDC_VM_1792x1344_60_P,
+ XVIDC_VM_1792x1344_75_P,
+ XVIDC_VM_1792x1344_120_P_RB,
+ XVIDC_VM_1856x1392_60_P,
+ XVIDC_VM_1856x1392_75_P,
+ XVIDC_VM_1856x1392_120_P_RB,
+ XVIDC_VM_1920x1080_24_P,
+ XVIDC_VM_1920x1080_25_P,
+ XVIDC_VM_1920x1080_30_P,
+ XVIDC_VM_1920x1080_50_P,
+ XVIDC_VM_1920x1080_60_P,
+ XVIDC_VM_1920x1200_60_P,
+ XVIDC_VM_1920x1200_60_P_RB,
+ XVIDC_VM_1920x1200_75_P,
+ XVIDC_VM_1920x1200_85_P,
+ XVIDC_VM_1920x1200_120_P_RB,
+ XVIDC_VM_1920x1440_60_P,
+ XVIDC_VM_1920x1440_75_P,
+ XVIDC_VM_1920x1440_120_P_RB,
+ XVIDC_VM_1920x2160_60_P,
+ XVIDC_VM_2560x1600_60_P,
+ XVIDC_VM_2560x1600_60_P_RB,
+ XVIDC_VM_2560x1600_75_P,
+ XVIDC_VM_2560x1600_85_P,
+ XVIDC_VM_2560x1600_120_P_RB,
+ XVIDC_VM_3840x2160_24_P,
+ XVIDC_VM_3840x2160_25_P,
+ XVIDC_VM_3840x2160_30_P,
+ XVIDC_VM_3840x2160_60_P,
+
+ XVIDC_VM_NUM_SUPPORTED,
+ XVIDC_VM_USE_EDID_PREFERRED,
+ XVIDC_VM_NO_INPUT,
+ XVIDC_VM_NOT_SUPPORTED,
+
+ /* Marks beginning/end of interlaced/progressive modes in the table. */
+ XVIDC_VM_INTL_START = XVIDC_VM_480_60_I,
+ XVIDC_VM_PROG_START = XVIDC_VM_640x350_85_P,
+ XVIDC_VM_INTL_END = (XVIDC_VM_PROG_START - 1),
+ XVIDC_VM_PROG_END = (XVIDC_VM_NUM_SUPPORTED - 1),
+
+ /* Common naming. */
+ XVIDC_VM_VGA_60_P = XVIDC_VM_640x480_60_P,
+ XVIDC_VM_480_60_P = XVIDC_VM_720x480_60_P,
+ XVIDC_VM_SVGA_60_P = XVIDC_VM_800x600_60_P,
+ XVIDC_VM_XGA_60_P = XVIDC_VM_1024x768_60_P,
+ XVIDC_VM_720_50_P = XVIDC_VM_1280x720_50_P,
+ XVIDC_VM_720_60_P = XVIDC_VM_1280x720_60_P,
+ XVIDC_VM_WXGA_60_P = XVIDC_VM_1366x768_60_P,
+ XVIDC_VM_UXGA_60_P = XVIDC_VM_1600x1200_60_P,
+ XVIDC_VM_WSXGA_60_P = XVIDC_VM_1680x1050_60_P,
+ XVIDC_VM_1080_24_P = XVIDC_VM_1920x1080_24_P,
+ XVIDC_VM_1080_25_P = XVIDC_VM_1920x1080_25_P,
+ XVIDC_VM_1080_30_P = XVIDC_VM_1920x1080_30_P,
+ XVIDC_VM_1080_50_P = XVIDC_VM_1920x1080_50_P,
+ XVIDC_VM_1080_60_P = XVIDC_VM_1920x1080_60_P,
+ XVIDC_VM_WUXGA_60_P = XVIDC_VM_1920x1200_60_P,
+ XVIDC_VM_UHD2_60_P = XVIDC_VM_1920x2160_60_P,
+ XVIDC_VM_UHD_24_P = XVIDC_VM_3840x2160_24_P,
+ XVIDC_VM_UHD_25_P = XVIDC_VM_3840x2160_25_P,
+ XVIDC_VM_UHD_30_P = XVIDC_VM_3840x2160_30_P,
+ XVIDC_VM_UHD_60_P = XVIDC_VM_3840x2160_60_P
+} XVidC_VideoMode;
+
+/**
+ * Progressive/interlaced video format.
+ */
+typedef enum {
+ XVIDC_VF_PROGRESSIVE = 0,
+ XVIDC_VF_INTERLACED
+} XVidC_VideoFormat;
+
+/**
+ * Frame rate.
+ */
+typedef enum {
+ XVIDC_FR_24HZ = 24,
+ XVIDC_FR_25HZ = 25,
+ XVIDC_FR_30HZ = 30,
+ XVIDC_FR_50HZ = 50,
+ XVIDC_FR_56HZ = 56,
+ XVIDC_FR_60HZ = 60,
+ XVIDC_FR_65HZ = 65,
+ XVIDC_FR_67HZ = 67,
+ XVIDC_FR_70HZ = 70,
+ XVIDC_FR_72HZ = 72,
+ XVIDC_FR_75HZ = 75,
+ XVIDC_FR_85HZ = 85,
+ XVIDC_FR_87HZ = 87,
+ XVIDC_FR_88HZ = 88,
+ XVIDC_FR_100HZ = 100,
+ XVIDC_FR_120HZ = 120,
+ XVIDC_FR_NUM_SUPPORTED = 16,
+ XVIDC_FR_UNKNOWN
+} XVidC_FrameRate;
+
+/**
+ * Color depth - bits per color component.
+ */
+typedef enum {
+ XVIDC_BPC_6 = 6,
+ XVIDC_BPC_8 = 8,
+ XVIDC_BPC_10 = 10,
+ XVIDC_BPC_12 = 12,
+ XVIDC_BPC_14 = 14,
+ XVIDC_BPC_16 = 16,
+ XVIDC_BPC_NUM_SUPPORTED = 6,
+ XVIDC_BPC_UNKNOWN
+} XVidC_ColorDepth;
+
+/**
+ * Pixels per clock.
+ */
+typedef enum {
+ XVIDC_PPC_1 = 1,
+ XVIDC_PPC_2 = 2,
+ XVIDC_PPC_4 = 4,
+ XVIDC_PPC_NUM_SUPPORTED = 3,
+} XVidC_PixelsPerClock;
+
+/**
+ * Color space format.
+ */
+typedef enum {
+ XVIDC_CSF_RGB = 0,
+ XVIDC_CSF_YCRCB_444,
+ XVIDC_CSF_YCRCB_422,
+ XVIDC_CSF_YCRCB_420,
+ XVIDC_CSF_NUM_SUPPORTED,
+ XVIDC_CSF_UNKNOWN
+} XVidC_ColorFormat;
+
+/**
+ * Color space conversion standard.
+ */
+typedef enum {
+ XVIDC_BT_2020 = 0,
+ XVIDC_BT_709,
+ XVIDC_BT_601,
+ XVIDC_BT_NUM_SUPPORTED,
+ XVIDC_BT_UNKNOWN
+} XVidC_ColorStd;
+
+/**
+ * Color conversion output range.
+ */
+typedef enum {
+ XVIDC_CR_16_235 = 0,
+ XVIDC_CR_16_240,
+ XVIDC_CR_0_255,
+ XVIDC_CR_NUM_SUPPORTED,
+ XVIDC_CR_UNKNOWN_RANGE
+} XVidC_ColorRange;
+
+/****************************** Type Definitions ******************************/
+
+/**
+ * Video timing structure.
+ */
+typedef struct {
+ u16 HActive;
+ u16 HFrontPorch;
+ u16 HSyncWidth;
+ u16 HBackPorch;
+ u16 HTotal;
+ u8 HSyncPolarity;
+ u16 VActive;
+ u16 F0PVFrontPorch;
+ u16 F0PVSyncWidth;
+ u16 F0PVBackPorch;
+ u16 F0PVTotal;
+ u16 F1VFrontPorch;
+ u16 F1VSyncWidth;
+ u16 F1VBackPorch;
+ u16 F1VTotal;
+ u8 VSyncPolarity;
+} XVidC_VideoTiming;
+
+/**
+ * Video stream structure.
+ */
+typedef struct {
+ XVidC_ColorFormat ColorFormatId;
+ XVidC_ColorDepth ColorDepth;
+ XVidC_PixelsPerClock PixPerClk;
+ XVidC_FrameRate FrameRate;
+ u8 IsInterlaced;
+ XVidC_VideoMode VmId;
+ XVidC_VideoTiming Timing;
+} XVidC_VideoStream;
+
+/**
+ * Video window structure.
+ */
+typedef struct {
+ u32 StartX;
+ u32 StartY;
+ u32 Width;
+ u32 Height;
+} XVidC_VideoWindow;
+
+/**
+ * Video timing mode from the video timing table.
+ */
+typedef struct {
+ XVidC_VideoMode VmId;
+ const char Name[21];
+ XVidC_FrameRate FrameRate;
+ XVidC_VideoTiming Timing;
+} XVidC_VideoTimingMode;
+
+/**
+ * Callback type which represents a custom timer wait handler. This is only
+ * used for Microblaze since it doesn't have a native sleep function. To avoid
+ * dependency on a hardware timer, the default wait functionality is implemented
+ * using loop iterations; this isn't too accurate. Therefore a custom timer
+ * handler is used, the user may implement their own wait implementation.
+ *
+ * @param TimerPtr is a pointer to the timer instance.
+ * @param Delay is the duration (msec/usec) to be passed to the timer
+ * function.
+ *
+*******************************************************************************/
+typedef void (*XVidC_DelayHandler)(void *TimerPtr, u32 Delay);
+
+/**************************** Function Prototypes *****************************/
+
+u32 XVidC_GetPixelClockHzByHVFr(u32 HTotal, u32 VTotal, u8 FrameRate);
+u32 XVidC_GetPixelClockHzByVmId(XVidC_VideoMode VmId);
+XVidC_VideoFormat XVidC_GetVideoFormat(XVidC_VideoMode VmId);
+u8 XVidC_IsInterlaced(XVidC_VideoMode VmId);
+XVidC_VideoMode XVidC_GetVideoModeId(u32 Width, u32 Height, u32 FrameRate,
+ u8 IsInterlaced);
+const XVidC_VideoTimingMode* XVidC_GetVideoModeData(XVidC_VideoMode VmId);
+const char* XVidC_GetVideoModeStr(XVidC_VideoMode VmId);
+char* XVidC_GetFrameRateStr(XVidC_VideoMode VmId);
+char* XVidC_GetColorFormatStr(XVidC_ColorFormat ColorFormatId);
+XVidC_FrameRate XVidC_GetFrameRate(XVidC_VideoMode VmId);
+const XVidC_VideoTiming* XVidC_GetTimingInfo(XVidC_VideoMode VmId);
+void XVidC_ReportStreamInfo(XVidC_VideoStream *Stream);
+void XVidC_ReportTiming(XVidC_VideoTiming *Timing, u8 IsInterlaced);
+
+/*************************** Variable Declarations ****************************/
+
+const XVidC_VideoTimingMode XVidC_VideoTimingModes[XVIDC_VM_NUM_SUPPORTED];
+
+#endif /* XVIDC_H_ */
diff --git a/XilinxProcessorIPLib/drivers/video_common/src/xvidc_edid.c b/XilinxProcessorIPLib/drivers/video_common/src/xvidc_edid.c
new file mode 100644
index 00000000..9a35e7be
--- /dev/null
+++ b/XilinxProcessorIPLib/drivers/video_common/src/xvidc_edid.c
@@ -0,0 +1,686 @@
+/*******************************************************************************
+ *
+ * Copyright (C) 2015 Xilinx, Inc. All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * Use of the Software is limited solely to applications:
+ * (a) running on a Xilinx device, or
+ * (b) that interact with a Xilinx device through a bus or interconnect.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * XILINX BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
+ * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * Except as contained in this notice, the name of the Xilinx shall not be used
+ * in advertising or otherwise to promote the sale, use or other dealings in
+ * this Software without prior written authorization from Xilinx.
+ *
+*******************************************************************************/
+/******************************************************************************/
+/**
+ *
+ * @file xvidc_edid.c
+ *
+ * Contains function definitions related to the Extended Display Identification
+ * Data (EDID) structure which is present in all monitors. All content in this
+ * file is agnostic of communication interface protocol.
+ *
+ * @note None.
+ *
+ *
+ * MODIFICATION HISTORY:
+ *
+ * Ver Who Date Changes
+ * ----- ---- -------- -----------------------------------------------
+ * 1.0 als 11/09/14 Initial release.
+ *
+ *
+*******************************************************************************/
+
+/******************************* Include Files ********************************/
+
+#include "xvidc_edid.h"
+
+/**************************** Function Prototypes *****************************/
+
+static u32 XVidC_EdidIsVideoTimingSupportedPreferredTiming(u8 *EdidRaw,
+ XVidC_VideoTimingMode *VtMode);
+static u32 XVidC_EdidIsVideoTimingSupportedEstablishedTimings(u8 *EdidRaw,
+ XVidC_VideoTimingMode *VtMode);
+static u32 XVidC_EdidIsVideoTimingSupportedStandardTimings(u8 *EdidRaw,
+ XVidC_VideoTimingMode *VtMode);
+static float XVidC_CalculatePower(float Base, u8 Power);
+static float XVidC_CalculateBinaryFraction(u16 Val, u8 DecPtIndex);
+
+/**************************** Function Definitions ****************************/
+
+/******************************************************************************/
+/**
+ * Get the manufacturer name as specified in the vendor and product ID field of
+ * the supplied base Extended Display Identification Data (EDID).
+ *
+ * @param EdidRaw is the supplied base EDID to retrieve the manufacturer
+ * name from.
+ * @param ManName is the string that will be modified to hold the
+ * retrieved manufacturer name.
+ *
+ * @return None.
+ *
+ * @note The ManName argument is modified with the manufacturer name.
+ *
+*******************************************************************************/
+void XVidC_EdidGetManName(u8 *EdidRaw, char ManName[4])
+{
+ ManName[0] = 0x40 + ((EdidRaw[XVIDC_EDID_VPI_ID_MAN_NAME0] &
+ XVIDC_EDID_VPI_ID_MAN_NAME0_CHAR0_MASK) >>
+ XVIDC_EDID_VPI_ID_MAN_NAME0_CHAR0_SHIFT);
+ ManName[1] = 0x40 + (((EdidRaw[XVIDC_EDID_VPI_ID_MAN_NAME0] &
+ XVIDC_EDID_VPI_ID_MAN_NAME0_CHAR1_MASK) <<
+ XVIDC_EDID_VPI_ID_MAN_NAME0_CHAR1_POS) |
+ (EdidRaw[XVIDC_EDID_VPI_ID_MAN_NAME1] >>
+ XVIDC_EDID_VPI_ID_MAN_NAME1_CHAR1_SHIFT));
+ ManName[2] = 0x40 + (EdidRaw[XVIDC_EDID_VPI_ID_MAN_NAME1] &
+ XVIDC_EDID_VPI_ID_MAN_NAME1_CHAR2_MASK);
+ ManName[3] = '\0';
+}
+
+/******************************************************************************/
+/**
+ * Get the color bit depth (bits per primary color) as specified in the basic
+ * display parameters and features, video input definition field of the supplied
+ * base Extended Display Identification Data (EDID).
+ *
+ * @param EdidRaw is the supplied base EDID to retrieve color depth
+ * information from.
+ *
+ * @return The number of bits per primary color as specified by the
+ * supplied base EDID.
+ *
+ * @note None.
+ *
+*******************************************************************************/
+XVidC_ColorDepth XVidC_EdidGetColorDepth(u8 *EdidRaw)
+{
+ u8 Bpc;
+
+ switch (((EdidRaw[XVIDC_EDID_BDISP_VID] &
+ XVIDC_EDID_BDISP_VID_DIG_BPC_MASK) >>
+ XVIDC_EDID_BDISP_VID_DIG_BPC_SHIFT)) {
+ case XVIDC_EDID_BDISP_VID_DIG_BPC_6:
+ Bpc = XVIDC_BPC_6;
+ break;
+
+ case XVIDC_EDID_BDISP_VID_DIG_BPC_8:
+ Bpc = XVIDC_BPC_8;
+ break;
+
+ case XVIDC_EDID_BDISP_VID_DIG_BPC_10:
+ Bpc = XVIDC_BPC_10;
+ break;
+
+ case XVIDC_EDID_BDISP_VID_DIG_BPC_12:
+ Bpc = XVIDC_BPC_12;
+ break;
+
+ case XVIDC_EDID_BDISP_VID_DIG_BPC_14:
+ Bpc = XVIDC_BPC_14;
+ break;
+
+ case XVIDC_EDID_BDISP_VID_DIG_BPC_16:
+ Bpc = XVIDC_BPC_16;
+ break;
+
+ default:
+ Bpc = XVIDC_BPC_UNKNOWN;
+ break;
+ }
+
+ return Bpc;
+}
+
+/******************************************************************************/
+/**
+ * Calculates the x chromaticity coordinate for red by converting a 10 bit
+ * binary fraction representation from the supplied base Extended Display
+ * Identification Data (EDID) to a float.
+ *
+ * @param EdidRaw is the supplied base EDID to retrieve chromaticity
+ * information from.
+ *
+ * @return The x chromatacity coordinate for red.
+ *
+ * @note All values will be accurate to +/-0.0005.
+ *
+*******************************************************************************/
+float XVidC_EdidGetCcRedX(u8 *EdidRaw)
+{
+ return XVidC_CalculateBinaryFraction(
+ (EdidRaw[XVIDC_EDID_CC_REDX_HIGH] <<
+ XVIDC_EDID_CC_HIGH_SHIFT) | (EdidRaw[XVIDC_EDID_CC_RG_LOW] >>
+ XVIDC_EDID_CC_RBX_LOW_SHIFT), 9);
+}
+
+/******************************************************************************/
+/**
+ * Calculates the y chromaticity coordinate for red by converting a 10 bit
+ * binary fraction representation from the supplied base Extended Display
+ * Identification Data (EDID) to a float.
+ *
+ * @param EdidRaw is the supplied base EDID to retrieve chromaticity
+ * information from.
+ *
+ * @return The y chromatacity coordinate for red.
+ *
+ * @note All values will be accurate to +/-0.0005.
+ *
+*******************************************************************************/
+float XVidC_EdidGetCcRedY(u8 *EdidRaw)
+{
+ return XVidC_CalculateBinaryFraction(
+ (EdidRaw[XVIDC_EDID_CC_REDY_HIGH] <<
+ XVIDC_EDID_CC_HIGH_SHIFT) | ((EdidRaw[XVIDC_EDID_CC_RG_LOW] &
+ XVIDC_EDID_CC_RBY_LOW_MASK) >>
+ XVIDC_EDID_CC_RBY_LOW_SHIFT), 9);
+}
+
+/******************************************************************************/
+/**
+ * Calculates the x chromaticity coordinate for green by converting a 10 bit
+ * binary fraction representation from the supplied base Extended Display
+ * Identification Data (EDID) to a float.
+ *
+ * @param EdidRaw is the supplied base EDID to retrieve chromaticity
+ * information from.
+ *
+ * @return The x chromatacity coordinate for green.
+ *
+ * @note All values will be accurate to +/-0.0005.
+ *
+*******************************************************************************/
+float XVidC_EdidGetCcGreenX(u8 *EdidRaw)
+{
+ return XVidC_CalculateBinaryFraction(
+ (EdidRaw[XVIDC_EDID_CC_GREENX_HIGH] <<
+ XVIDC_EDID_CC_HIGH_SHIFT) | ((EdidRaw[XVIDC_EDID_CC_RG_LOW] &
+ XVIDC_EDID_CC_GWX_LOW_MASK) >>
+ XVIDC_EDID_CC_GWX_LOW_SHIFT), 9);
+}
+
+/******************************************************************************/
+/**
+ * Calculates the y chromaticity coordinate for green by converting a 10 bit
+ * binary fraction representation from the supplied base Extended Display
+ * Identification Data (EDID) to a float.
+ *
+ * @param EdidRaw is the supplied base EDID to retrieve chromaticity
+ * information from.
+ *
+ * @return The y chromatacity coordinate for green.
+ *
+ * @note All values will be accurate to +/-0.0005.
+ *
+*******************************************************************************/
+float XVidC_EdidGetCcGreenY(u8 *EdidRaw)
+{
+ return XVidC_CalculateBinaryFraction(
+ (EdidRaw[XVIDC_EDID_CC_GREENY_HIGH] <<
+ XVIDC_EDID_CC_HIGH_SHIFT) | (EdidRaw[XVIDC_EDID_CC_RG_LOW] &
+ XVIDC_EDID_CC_GWY_LOW_MASK), 9);
+}
+
+/******************************************************************************/
+/**
+ * Calculates the x chromaticity coordinate for blue by converting a 10 bit
+ * binary fraction representation from the supplied base Extended Display
+ * Identification Data (EDID) to a float.
+ *
+ * @param EdidRaw is the supplied base EDID to retrieve chromaticity
+ * information from.
+ *
+ * @return The x chromatacity coordinate for blue.
+ *
+ * @note All values will be accurate to +/-0.0005.
+ *
+*******************************************************************************/
+float XVidC_EdidGetCcBlueX(u8 *EdidRaw)
+{
+ return XVidC_CalculateBinaryFraction(
+ (EdidRaw[XVIDC_EDID_CC_BLUEX_HIGH] <<
+ XVIDC_EDID_CC_HIGH_SHIFT) | (EdidRaw[XVIDC_EDID_CC_BW_LOW] >>
+ XVIDC_EDID_CC_RBX_LOW_SHIFT), 9);
+}
+
+/******************************************************************************/
+/**
+ * Calculates the y chromaticity coordinate for blue by converting a 10 bit
+ * binary fraction representation from the supplied base Extended Display
+ * Identification Data (EDID) to a float.
+ *
+ * @param EdidRaw is the supplied base EDID to retrieve chromaticity
+ * information from.
+ *
+ * @return The y chromatacity coordinate for blue.
+ *
+ * @note All values will be accurate to +/-0.0005.
+ *
+*******************************************************************************/
+float XVidC_EdidGetCcBlueY(u8 *EdidRaw)
+{
+ return XVidC_CalculateBinaryFraction(
+ (EdidRaw[XVIDC_EDID_CC_BLUEY_HIGH] <<
+ XVIDC_EDID_CC_HIGH_SHIFT) | ((EdidRaw[XVIDC_EDID_CC_BW_LOW] &
+ XVIDC_EDID_CC_RBY_LOW_MASK) >> XVIDC_EDID_CC_RBY_LOW_SHIFT), 9);
+}
+
+/******************************************************************************/
+/**
+ * Calculates the x chromaticity coordinate for white by converting a 10 bit
+ * binary fraction representation from the supplied base Extended Display
+ * Identification Data (EDID) to a float.
+ *
+ * @param EdidRaw is the supplied base EDID to retrieve chromaticity
+ * information from.
+ *
+ * @return The x chromatacity coordinate for white.
+ *
+ * @note All values will be accurate to +/-0.0005.
+ *
+*******************************************************************************/
+float XVidC_EdidGetCcWhiteX(u8 *EdidRaw)
+{
+ return XVidC_CalculateBinaryFraction(
+ (EdidRaw[XVIDC_EDID_CC_WHITEX_HIGH] <<
+ XVIDC_EDID_CC_HIGH_SHIFT) | ((EdidRaw[XVIDC_EDID_CC_BW_LOW] &
+ XVIDC_EDID_CC_GWX_LOW_MASK) >> XVIDC_EDID_CC_GWX_LOW_SHIFT), 9);
+}
+
+/******************************************************************************/
+/**
+ * Calculates the y chromaticity coordinate for white by converting a 10 bit
+ * binary fraction representation from the supplied base Extended Display
+ * Identification Data (EDID) to a float.
+ *
+ * @param EdidRaw is the supplied base EDID to retrieve chromaticity
+ * information from.
+ *
+ * @return The y chromatacity coordinate for white.
+ *
+ * @note All values will be accurate to +/-0.0005.
+ *
+*******************************************************************************/
+float XVidC_EdidGetCcWhiteY(u8 *EdidRaw)
+{
+ return XVidC_CalculateBinaryFraction(
+ (EdidRaw[XVIDC_EDID_CC_WHITEY_HIGH] <<
+ XVIDC_EDID_CC_HIGH_SHIFT) | (EdidRaw[XVIDC_EDID_CC_BW_LOW] &
+ XVIDC_EDID_CC_GWY_LOW_MASK), 9);
+}
+
+/******************************************************************************/
+/**
+ * Retrieves the active vertical resolution from the standard timings field of
+ * the supplied base Extended Display Identification Data (EDID).
+ *
+ * @param EdidRaw is the supplied base EDID to check the timing against.
+ * @param StdTimingsNum specifies which one of the standard timings to
+ * retrieve from the standard timings field.
+ *
+ * @return The vertical active resolution of the specified standard timing
+ * from the supplied base EDID.
+ *
+ * @note StdTimingsNum is an index 1-8.
+ *
+*******************************************************************************/
+u16 XVidC_EdidGetStdTimingsV(u8 *EdidRaw, u8 StdTimingsNum)
+{
+ u16 V;
+
+ switch (XVidC_EdidGetStdTimingsAr(EdidRaw, StdTimingsNum)) {
+ case XVIDC_EDID_STD_TIMINGS_AR_16_10:
+ V = (10 * XVidC_EdidGetStdTimingsH(EdidRaw,
+ StdTimingsNum)) / 16;
+ break;
+
+ case XVIDC_EDID_STD_TIMINGS_AR_4_3:
+ V = (3 * XVidC_EdidGetStdTimingsH(EdidRaw,
+ StdTimingsNum)) / 4;
+ break;
+
+ case XVIDC_EDID_STD_TIMINGS_AR_5_4:
+ V = (4 * XVidC_EdidGetStdTimingsH(EdidRaw,
+ StdTimingsNum)) / 5;
+ break;
+
+ case XVIDC_EDID_STD_TIMINGS_AR_16_9:
+ V = (9 * XVidC_EdidGetStdTimingsH(EdidRaw,
+ StdTimingsNum)) / 16;
+ break;
+ default:
+ V = 0;
+ break;
+ }
+
+ return V;
+}
+
+/******************************************************************************/
+/**
+ * Checks whether or not a specified video timing mode is supported as specified
+ * in the supplied base Extended Display Identification Data (EDID). The
+ * preferred timing, established timings (I, II, II), and the standard timings
+ * fields are checked for support.
+ *
+ * @param EdidRaw is the supplied base EDID to check the timing against.
+ * @param VtMode is the video timing mode to check for support.
+ *
+ * @return
+ * - XST_SUCCESS if the video timing mode is supported as specified
+ * in the supplied base EDID.
+ * - XST_FAILURE otherwise.
+ *
+ * @note None.
+ *
+*******************************************************************************/
+u32 XVidC_EdidIsVideoTimingSupported(u8 *EdidRaw, XVidC_VideoTimingMode *VtMode)
+{
+ u32 Status;
+
+ /* Check if the video mode is the preferred timing. */
+ Status = XVidC_EdidIsVideoTimingSupportedPreferredTiming(EdidRaw,
+ VtMode);
+ if (Status == XST_SUCCESS) {
+ return Status;
+ }
+
+ /* Check established timings I, II, and III. */
+ Status = XVidC_EdidIsVideoTimingSupportedEstablishedTimings(EdidRaw,
+ VtMode);
+ if (Status == XST_SUCCESS) {
+ return Status;
+ }
+
+ /* Check in standard timings support. */
+ Status = XVidC_EdidIsVideoTimingSupportedStandardTimings(EdidRaw,
+ VtMode);
+
+ return Status;
+}
+
+/******************************************************************************/
+/**
+ * Checks whether or not a specified video timing mode is the preferred timing
+ * of the supplied base Extended Display Identification Data (EDID).
+ *
+ * @param EdidRaw is the supplied base EDID to check the timing against.
+ * @param VtMode is the video timing mode to check for support.
+ *
+ * @return
+ * - XST_SUCCESS if the video timing mode is the preferred timing
+ * as specified in the base EDID.
+ * - XST_FAILURE otherwise.
+ *
+ * @note None.
+ *
+*******************************************************************************/
+static u32 XVidC_EdidIsVideoTimingSupportedPreferredTiming(u8 *EdidRaw,
+ XVidC_VideoTimingMode *VtMode)
+{
+ u8 *Ptm;
+
+ Ptm = &EdidRaw[XVIDC_EDID_PTM];
+
+ u32 HActive =
+ (((Ptm[XVIDC_EDID_DTD_PTM_HRES_HBLANK_U4] &
+ XVIDC_EDID_DTD_PTM_XRES_XBLANK_U4_XRES_MASK) >>
+ XVIDC_EDID_DTD_PTM_XRES_XBLANK_U4_XRES_SHIFT) << 8) |
+ Ptm[XVIDC_EDID_DTD_PTM_HRES_LSB];
+
+ u32 VActive =
+ (((Ptm[XVIDC_EDID_DTD_PTM_VRES_VBLANK_U4] &
+ XVIDC_EDID_DTD_PTM_XRES_XBLANK_U4_XRES_MASK) >>
+ XVIDC_EDID_DTD_PTM_XRES_XBLANK_U4_XRES_SHIFT) << 8) |
+ Ptm[XVIDC_EDID_DTD_PTM_VRES_LSB];
+
+ if (VtMode->Timing.F1VTotal != XVidC_EdidIsDtdPtmInterlaced(EdidRaw)) {
+ return (XST_FAILURE);
+ }
+ else if ((VtMode->Timing.HActive == HActive) &&
+ (VtMode->Timing.VActive == VActive)) {
+ return (XST_SUCCESS);
+ }
+
+ return XST_FAILURE;
+}
+
+/******************************************************************************/
+/**
+ * Checks whether or not a specified video timing mode is supported in the
+ * established timings field of the supplied base Extended Display
+ * Identification Data (EDID).
+ *
+ * @param EdidRaw is the supplied base EDID to check the timing against.
+ * @param VtMode is the video timing mode to check for support.
+ *
+ * @return
+ * - XST_SUCCESS if the video timing mode is supported in the
+ * base EDID's established timings field.
+ * - XST_FAILURE otherwise.
+ *
+ * @note None.
+ *
+*******************************************************************************/
+static u32 XVidC_EdidIsVideoTimingSupportedEstablishedTimings(u8 *EdidRaw,
+ XVidC_VideoTimingMode *VtMode)
+{
+ u32 Status = XST_FAILURE;
+
+ /* Check established timings I, II, and III. */
+ if ((VtMode->Timing.HActive == 800) &&
+ (VtMode->Timing.VActive == 640) &&
+ (VtMode->FrameRate == XVIDC_FR_56HZ) &&
+ XVidC_EdidSuppEstTimings800x600_56(EdidRaw)) {
+ Status = XST_SUCCESS;
+ }
+ else if ((VtMode->Timing.HActive == 640) &&
+ (VtMode->Timing.VActive == 480) &&
+ (VtMode->FrameRate == XVIDC_FR_60HZ) &&
+ XVidC_EdidSuppEstTimings640x480_60(EdidRaw)) {
+ Status = XST_SUCCESS;
+ }
+ else if ((VtMode->Timing.HActive == 800) &&
+ (VtMode->Timing.VActive == 600) &&
+ (VtMode->FrameRate == XVIDC_FR_60HZ) &&
+ XVidC_EdidSuppEstTimings800x600_60(EdidRaw)) {
+ Status = XST_SUCCESS;
+ }
+ else if ((VtMode->Timing.HActive == 1024) &&
+ (VtMode->Timing.VActive == 768) &&
+ (VtMode->FrameRate == XVIDC_FR_60HZ) &&
+ XVidC_EdidSuppEstTimings1024x768_60(EdidRaw)) {
+ Status = XST_SUCCESS;
+ }
+ else if ((VtMode->Timing.HActive == 640) &&
+ (VtMode->Timing.VActive == 480) &&
+ (VtMode->FrameRate == XVIDC_FR_67HZ) &&
+ XVidC_EdidSuppEstTimings640x480_67(EdidRaw)) {
+ Status = XST_SUCCESS;
+ }
+ else if ((VtMode->Timing.HActive == 720) &&
+ (VtMode->Timing.VActive == 400) &&
+ (VtMode->FrameRate == XVIDC_FR_70HZ) &&
+ XVidC_EdidSuppEstTimings720x400_70(EdidRaw)) {
+ Status = XST_SUCCESS;
+ }
+ else if ((VtMode->Timing.HActive == 1024) &&
+ (VtMode->Timing.VActive == 768) &&
+ (VtMode->FrameRate == XVIDC_FR_70HZ) &&
+ XVidC_EdidSuppEstTimings1024x768_70(EdidRaw)) {
+ Status = XST_SUCCESS;
+ }
+ else if ((VtMode->Timing.HActive == 640) &&
+ (VtMode->Timing.VActive == 480) &&
+ (VtMode->FrameRate == XVIDC_FR_72HZ) &&
+ XVidC_EdidSuppEstTimings640x480_72(EdidRaw)) {
+ Status = XST_SUCCESS;
+ }
+ else if ((VtMode->Timing.HActive == 800) &&
+ (VtMode->Timing.VActive == 600) &&
+ (VtMode->FrameRate == XVIDC_FR_72HZ) &&
+ XVidC_EdidSuppEstTimings800x600_72(EdidRaw)) {
+ Status = XST_SUCCESS;
+ }
+ else if ((VtMode->Timing.HActive == 640) &&
+ (VtMode->Timing.VActive == 480) &&
+ (VtMode->FrameRate == XVIDC_FR_75HZ) &&
+ XVidC_EdidSuppEstTimings640x480_75(EdidRaw)) {
+ Status = XST_SUCCESS;
+ }
+ else if ((VtMode->Timing.HActive == 800) &&
+ (VtMode->Timing.VActive == 600) &&
+ (VtMode->FrameRate == XVIDC_FR_75HZ) &&
+ XVidC_EdidSuppEstTimings800x600_75(EdidRaw)) {
+ Status = XST_SUCCESS;
+ }
+ else if ((VtMode->Timing.HActive == 832) &&
+ (VtMode->Timing.VActive == 624) &&
+ (VtMode->FrameRate == XVIDC_FR_75HZ) &&
+ XVidC_EdidSuppEstTimings832x624_75(EdidRaw)) {
+ Status = XST_SUCCESS;
+ }
+ else if ((VtMode->Timing.HActive == 1024) &&
+ (VtMode->Timing.VActive == 768) &&
+ (VtMode->FrameRate == XVIDC_FR_75HZ) &&
+ XVidC_EdidSuppEstTimings1024x768_75(EdidRaw)) {
+ Status = XST_SUCCESS;
+ }
+ else if ((VtMode->Timing.HActive == 1152) &&
+ (VtMode->Timing.VActive == 870) &&
+ (VtMode->FrameRate == XVIDC_FR_75HZ) &&
+ XVidC_EdidSuppEstTimings1152x870_75(EdidRaw)) {
+ Status = XST_SUCCESS;
+ }
+ else if ((VtMode->Timing.HActive == 1280) &&
+ (VtMode->Timing.VActive == 1024) &&
+ (VtMode->FrameRate == XVIDC_FR_75HZ) &&
+ XVidC_EdidSuppEstTimings1280x1024_75(EdidRaw)) {
+ Status = XST_SUCCESS;
+ }
+ else if ((VtMode->Timing.HActive == 1024) &&
+ (VtMode->Timing.VActive == 768) &&
+ (VtMode->FrameRate == XVIDC_FR_87HZ) &&
+ XVidC_EdidSuppEstTimings1024x768_87(EdidRaw)) {
+ Status = XST_SUCCESS;
+ }
+ else if ((VtMode->Timing.HActive == 720) &&
+ (VtMode->Timing.VActive == 400) &&
+ (VtMode->FrameRate == XVIDC_FR_88HZ) &&
+ XVidC_EdidSuppEstTimings720x400_88(EdidRaw)) {
+ Status = XST_SUCCESS;
+ }
+
+ return Status;
+}
+
+/******************************************************************************/
+/**
+ * Checks whether or not a specified video timing mode is supported in the
+ * standard timings field of the supplied base Extended Display Identification
+ * Data (EDID).
+ *
+ * @param EdidRaw is the supplied base EDID to check the timing against.
+ * @param VtMode is the video timing mode to check for support.
+ *
+ * @return
+ * - XST_SUCCESS if the video timing mode is supported in the
+ * base EDID's standard timings fields.
+ * - XST_FAILURE otherwise.
+ *
+ * @note None.
+ *
+*******************************************************************************/
+static u32 XVidC_EdidIsVideoTimingSupportedStandardTimings(u8 *EdidRaw,
+ XVidC_VideoTimingMode *VtMode)
+{
+ u8 Index;
+
+ for (Index = 0; Index < 8; Index++) {
+ if ((VtMode->Timing.HActive ==
+ XVidC_EdidGetStdTimingsH(EdidRaw, Index + 1)) &&
+ (VtMode->Timing.VActive ==
+ XVidC_EdidGetStdTimingsV(EdidRaw, Index + 1)) &&
+ (VtMode->FrameRate == (u8)XVidC_EdidGetStdTimingsFrr(
+ EdidRaw, Index + 1))) {
+ return XST_SUCCESS;
+ }
+ }
+
+ return XST_FAILURE;
+}
+
+/******************************************************************************/
+/**
+ * Perform a power operation.
+ *
+ * @param Base is b in the power operation, b^n.
+ * @param Power is n in the power operation, b^n.
+ *
+ * @return Base^Power (Base to the power of Power).
+ *
+ * @note None.
+ *
+*******************************************************************************/
+static float XVidC_CalculatePower(float Base, u8 Power)
+{
+ u8 Index;
+ float Res = 1.0;
+
+ for (Index = 0; Index < Power; Index++) {
+ Res *= Base;
+ }
+
+ return Res;
+}
+
+/******************************************************************************/
+/**
+ * Convert a fractional binary number into a decimal number. Binary digits to
+ * the right of the decimal point represent 2^-1 to 2^-(DecPtIndex+1). Binary
+ * digits to the left of the decimal point represent 2^0, 2^1, etc.
+ *
+ * @param Val is the binary representation of the fraction.
+ * @param DecPtIndex is the index of the decimal point in the binary
+ * number. The decimal point is between the binary digits at Val's
+ * indices (DecPtIndex) and (DecPtIndex + 1).
+ *
+ * @return Base^Power (Base to the power of Power).
+ *
+ * @note None.
+ *
+*******************************************************************************/
+static float XVidC_CalculateBinaryFraction(u16 Val, u8 DecPtIndex)
+{
+ int Index;
+ float Res;
+
+ for (Index = DecPtIndex, Res = 0; Index >= 0; Index--) {
+ if (((Val >> Index) & 0x1) == 1) {
+ Res += XVidC_CalculatePower(
+ 0.5, DecPtIndex - Index + 1);
+ }
+ }
+
+ return (Val >> (DecPtIndex + 1)) + Res;
+}
diff --git a/XilinxProcessorIPLib/drivers/video_common/src/xvidc_edid.h b/XilinxProcessorIPLib/drivers/video_common/src/xvidc_edid.h
new file mode 100644
index 00000000..862b33cf
--- /dev/null
+++ b/XilinxProcessorIPLib/drivers/video_common/src/xvidc_edid.h
@@ -0,0 +1,481 @@
+/*******************************************************************************
+ *
+ * Copyright (C) 2015 Xilinx, Inc. All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * Use of the Software is limited solely to applications:
+ * (a) running on a Xilinx device, or
+ * (b) that interact with a Xilinx device through a bus or interconnect.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * XILINX BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
+ * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * Except as contained in this notice, the name of the Xilinx shall not be used
+ * in advertising or otherwise to promote the sale, use or other dealings in
+ * this Software without prior written authorization from Xilinx.
+ *
+*******************************************************************************/
+/******************************************************************************/
+/**
+ *
+ * @file xvidc_edid.h
+ *
+ * Contains macros, definitions, and function declarations related to the
+ * Extended Display Identification Data (EDID) structure which is present in all
+ * monitors. All content in this file is agnostic of communication interface
+ * protocol.
+ *
+ * @note None.
+ *
+ *
+ * MODIFICATION HISTORY:
+ *
+ * Ver Who Date Changes
+ * ----- ---- -------- -----------------------------------------------
+ * 1.0 als 11/09/14 Initial release.
+ *
+ *
+*******************************************************************************/
+
+#ifndef XVIDC_EDID_H_
+/* Prevent circular inclusions by using protection macros. */
+#define XVIDC_EDID_H_
+
+/******************************* Include Files ********************************/
+
+#include "xstatus.h"
+#include "xvidc.h"
+
+/************************** Constant Definitions ******************************/
+
+/** @name Address mapping for the base EDID block.
+ * @{
+ */
+#define XVIDC_EDID_HEADER 0x00
+/* Vendor and product identification. */
+#define XVIDC_EDID_VPI_ID_MAN_NAME0 0x08
+#define XVIDC_EDID_VPI_ID_MAN_NAME1 0x09
+#define XVIDC_EDID_VPI_ID_PROD_CODE_LSB 0x0A
+#define XVIDC_EDID_VPI_ID_PROD_CODE_MSB 0x0B
+#define XVIDC_EDID_VPI_ID_SN0 0x0C
+#define XVIDC_EDID_VPI_ID_SN1 0x0D
+#define XVIDC_EDID_VPI_ID_SN2 0x0E
+#define XVIDC_EDID_VPI_ID_SN3 0x0F
+#define XVIDC_EDID_VPI_WEEK_MAN 0x10
+#define XVIDC_EDID_VPI_YEAR 0x11
+/* EDID structure version and revision. */
+#define XVIDC_EDID_STRUCT_VER 0x12
+#define XVIDC_EDID_STRUCT_REV 0x13
+/* Basic display parameters and features. */
+#define XVIDC_EDID_BDISP_VID 0x14
+#define XVIDC_EDID_BDISP_H_SSAR 0x15
+#define XVIDC_EDID_BDISP_V_SSAR 0x16
+#define XVIDC_EDID_BDISP_GAMMA 0x17
+#define XVIDC_EDID_BDISP_FEATURE 0x18
+/* Color characteristics (display x,y chromaticity coordinates). */
+#define XVIDC_EDID_CC_RG_LOW 0x19
+#define XVIDC_EDID_CC_BW_LOW 0x1A
+#define XVIDC_EDID_CC_REDX_HIGH 0x1B
+#define XVIDC_EDID_CC_REDY_HIGH 0x1C
+#define XVIDC_EDID_CC_GREENX_HIGH 0x1D
+#define XVIDC_EDID_CC_GREENY_HIGH 0x1E
+#define XVIDC_EDID_CC_BLUEX_HIGH 0x1F
+#define XVIDC_EDID_CC_BLUEY_HIGH 0x20
+#define XVIDC_EDID_CC_WHITEX_HIGH 0x21
+#define XVIDC_EDID_CC_WHITEY_HIGH 0x22
+/* Established timings. */
+#define XVIDC_EDID_EST_TIMINGS_I 0x23
+#define XVIDC_EDID_EST_TIMINGS_II 0x24
+#define XVIDC_EDID_EST_TIMINGS_MAN 0x25
+/* Standard timings. */
+#define XVIDC_EDID_STD_TIMINGS_H(N) (0x26 + 2 * (N - 1))
+#define XVIDC_EDID_STD_TIMINGS_AR_FRR(N) (0x27 + 2 * (N - 1))
+/* 18 byte descriptors. */
+#define XVIDC_EDID_18BYTE_DESCRIPTOR(N) (0x36 + 18 * (N - 1))
+#define XVIDC_EDID_PTM (XVIDC_EDID_18BYTE_DESCRIPTOR(1))
+/* - Detailed timing descriptor (DTD) / Preferred timing mode (PTM). */
+#define XVIDC_EDID_DTD_PTM_PIXEL_CLK_KHZ_LSB 0x00
+#define XVIDC_EDID_DTD_PTM_PIXEL_CLK_KHZ_MSB 0x01
+#define XVIDC_EDID_DTD_PTM_HRES_LSB 0x02
+#define XVIDC_EDID_DTD_PTM_HBLANK_LSB 0x03
+#define XVIDC_EDID_DTD_PTM_HRES_HBLANK_U4 0x04
+#define XVIDC_EDID_DTD_PTM_VRES_LSB 0x05
+#define XVIDC_EDID_DTD_PTM_VBLANK_LSB 0x06
+#define XVIDC_EDID_DTD_PTM_VRES_VBLANK_U4 0x07
+#define XVIDC_EDID_DTD_PTM_HFPORCH_LSB 0x08
+#define XVIDC_EDID_DTD_PTM_HSPW_LSB 0x09
+#define XVIDC_EDID_DTD_PTM_VFPORCH_VSPW_L4 0x0A
+#define XVIDC_EDID_DTD_PTM_XFPORCH_XSPW_U2 0x0B
+#define XVIDC_EDID_DTD_PTM_HIMGSIZE_MM_LSB 0x0C
+#define XVIDC_EDID_DTD_PTM_VIMGSIZE_MM_LSB 0x0D
+#define XVIDC_EDID_DTD_PTM_XIMGSIZE_MM_U4 0x0E
+#define XVIDC_EDID_DTD_PTM_HBORDER 0x0F
+#define XVIDC_EDID_DTD_PTM_VBORDER 0x10
+#define XVIDC_EDID_DTD_PTM_SIGNAL 0x11
+
+/* Extension block count. */
+#define XVIDC_EDID_EXT_BLK_COUNT 0x7E
+/* Checksum. */
+#define XVIDC_EDID_CHECKSUM 0x7F
+/* @} */
+
+/******************************************************************************/
+
+/** @name Extended Display Identification Data: Masks, shifts, and values.
+ * @{
+ */
+#define XVIDC_EDID_VPI_ID_MAN_NAME0_CHAR0_SHIFT 2
+#define XVIDC_EDID_VPI_ID_MAN_NAME0_CHAR0_MASK (0x1F << 2)
+#define XVIDC_EDID_VPI_ID_MAN_NAME0_CHAR1_MASK 0x03
+#define XVIDC_EDID_VPI_ID_MAN_NAME0_CHAR1_POS 3
+#define XVIDC_EDID_VPI_ID_MAN_NAME1_CHAR1_SHIFT 5
+#define XVIDC_EDID_VPI_ID_MAN_NAME1_CHAR2_MASK 0x1F
+
+/* Basic display parameters and features: Video input definition. */
+#define XVIDC_EDID_BDISP_VID_VSI_SHIFT 7
+#define XVIDC_EDID_BDISP_VID_VSI_MASK (0x01 << 7)
+#define XVIDC_EDID_BDISP_VID_ANA_SLS_SHIFT 5
+#define XVIDC_EDID_BDISP_VID_ANA_SLS_MASK (0x03 << 5)
+#define XVIDC_EDID_BDISP_VID_ANA_SLS_0700_0300_1000 0x0
+#define XVIDC_EDID_BDISP_VID_ANA_SLS_0714_0286_1000 0x1
+#define XVIDC_EDID_BDISP_VID_ANA_SLS_1000_0400_1400 0x2
+#define XVIDC_EDID_BDISP_VID_ANA_SLS_0700_0000_0700 0x3
+#define XVIDC_EDID_BDISP_VID_ANA_VID_SETUP_MASK (0x01 << 4)
+#define XVIDC_EDID_BDISP_VID_ANA_SEP_SYNC_HV_MASK (0x01 << 3)
+#define XVIDC_EDID_BDISP_VID_ANA_COMP_SYNC_H_MASK (0x01 << 2)
+#define XVIDC_EDID_BDISP_VID_ANA_COMP_SYNC_G_MASK (0x01 << 1)
+#define XVIDC_EDID_BDISP_VID_ANA_SERR_V_SYNC_MASK (0x01)
+#define XVIDC_EDID_BDISP_VID_DIG_BPC_SHIFT 4
+#define XVIDC_EDID_BDISP_VID_DIG_BPC_MASK (0x7 << 4)
+#define XVIDC_EDID_BDISP_VID_DIG_BPC_UNDEF 0x0
+#define XVIDC_EDID_BDISP_VID_DIG_BPC_6 0x1
+#define XVIDC_EDID_BDISP_VID_DIG_BPC_8 0x2
+#define XVIDC_EDID_BDISP_VID_DIG_BPC_10 0x3
+#define XVIDC_EDID_BDISP_VID_DIG_BPC_12 0x4
+#define XVIDC_EDID_BDISP_VID_DIG_BPC_14 0x5
+#define XVIDC_EDID_BDISP_VID_DIG_BPC_16 0x6
+#define XVIDC_EDID_BDISP_VID_DIG_VIS_MASK 0xF
+#define XVIDC_EDID_BDISP_VID_DIG_VIS_UNDEF 0x0
+#define XVIDC_EDID_BDISP_VID_DIG_VIS_DVI 0x1
+#define XVIDC_EDID_BDISP_VID_DIG_VIS_HDMIA 0x2
+#define XVIDC_EDID_BDISP_VID_DIG_VIS_HDMIB 0x3
+#define XVIDC_EDID_BDISP_VID_DIG_VIS_MDDI 0x4
+#define XVIDC_EDID_BDISP_VID_DIG_VIS_DP 0x5
+
+/* Basic display parameters and features: Feature support. */
+#define XVIDC_EDID_BDISP_FEATURE_PM_STANDBY_MASK (0x1 << 7)
+#define XVIDC_EDID_BDISP_FEATURE_PM_SUSPEND_MASK (0x1 << 6)
+#define XVIDC_EDID_BDISP_FEATURE_PM_OFF_VLP_MASK (0x1 << 5)
+#define XVIDC_EDID_BDISP_FEATURE_ANA_COLORTYPE_SHIFT 3
+#define XVIDC_EDID_BDISP_FEATURE_ANA_COLORTYPE_MASK (0x3 << 3)
+#define XVIDC_EDID_BDISP_FEATURE_ANA_COLORTYPE_MCG 0x0
+#define XVIDC_EDID_BDISP_FEATURE_ANA_COLORTYPE_RGB 0x1
+#define XVIDC_EDID_BDISP_FEATURE_ANA_COLORTYPE_NRGB 0x2
+#define XVIDC_EDID_BDISP_FEATURE_ANA_COLORTYPE_UNDEF 0x3
+#define XVIDC_EDID_BDISP_FEATURE_DIG_COLORENC_YCRCB444_MASK (0x1 << 3)
+#define XVIDC_EDID_BDISP_FEATURE_DIG_COLORENC_YCRCB422_MASK (0x1 << 4)
+#define XVIDC_EDID_BDISP_FEATURE_SRGB_DEF_MASK (0x1 << 2)
+#define XVIDC_EDID_BDISP_FEATURE_PTM_INC_MASK (0x1 << 1)
+#define XVIDC_EDID_BDISP_FEATURE_CONTFREQ_MASK (0x1)
+
+/* Color characteristics (display x,y chromaticity coordinates). */
+#define XVIDC_EDID_CC_HIGH_SHIFT 2
+#define XVIDC_EDID_CC_RBX_LOW_SHIFT 6
+#define XVIDC_EDID_CC_RBY_LOW_SHIFT 4
+#define XVIDC_EDID_CC_RBY_LOW_MASK (0x3 << 4)
+#define XVIDC_EDID_CC_GWX_LOW_SHIFT 2
+#define XVIDC_EDID_CC_GWX_LOW_MASK (0x3 << 2)
+#define XVIDC_EDID_CC_GWY_LOW_MASK (0x3)
+#define XVIDC_EDID_CC_GREENY_HIGH 0x1E
+#define XVIDC_EDID_CC_BLUEX_HIGH 0x1F
+#define XVIDC_EDID_CC_BLUEY_HIGH 0x20
+#define XVIDC_EDID_CC_WHITEX_HIGH 0x21
+#define XVIDC_EDID_CC_WHITEY_HIGH 0x22
+
+/* Established timings. */
+#define XVIDC_EDID_EST_TIMINGS_I_720x400_70_MASK (0x1 << 7)
+#define XVIDC_EDID_EST_TIMINGS_I_720x400_88_MASK (0x1 << 6)
+#define XVIDC_EDID_EST_TIMINGS_I_640x480_60_MASK (0x1 << 5)
+#define XVIDC_EDID_EST_TIMINGS_I_640x480_67_MASK (0x1 << 4)
+#define XVIDC_EDID_EST_TIMINGS_I_640x480_72_MASK (0x1 << 3)
+#define XVIDC_EDID_EST_TIMINGS_I_640x480_75_MASK (0x1 << 2)
+#define XVIDC_EDID_EST_TIMINGS_I_800x600_56_MASK (0x1 << 1)
+#define XVIDC_EDID_EST_TIMINGS_I_800x600_60_MASK (0x1)
+#define XVIDC_EDID_EST_TIMINGS_II_800x600_72_MASK (0x1 << 7)
+#define XVIDC_EDID_EST_TIMINGS_II_800x600_75_MASK (0x1 << 6)
+#define XVIDC_EDID_EST_TIMINGS_II_832x624_75_MASK (0x1 << 5)
+#define XVIDC_EDID_EST_TIMINGS_II_1024x768_87_MASK (0x1 << 4)
+#define XVIDC_EDID_EST_TIMINGS_II_1024x768_60_MASK (0x1 << 3)
+#define XVIDC_EDID_EST_TIMINGS_II_1024x768_70_MASK (0x1 << 2)
+#define XVIDC_EDID_EST_TIMINGS_II_1024x768_75_MASK (0x1 << 1)
+#define XVIDC_EDID_EST_TIMINGS_II_1280x1024_75_MASK (0x1)
+#define XVIDC_EDID_EST_TIMINGS_MAN_1152x870_75_MASK (0x1 << 7)
+#define XVIDC_EDID_EST_TIMINGS_MAN_MASK (0x7F)
+
+/* Standard timings. */
+#define XVIDC_EDID_STD_TIMINGS_AR_SHIFT 6
+#define XVIDC_EDID_STD_TIMINGS_AR_16_10 0x0
+#define XVIDC_EDID_STD_TIMINGS_AR_4_3 0x1
+#define XVIDC_EDID_STD_TIMINGS_AR_5_4 0x2
+#define XVIDC_EDID_STD_TIMINGS_AR_16_9 0x3
+#define XVIDC_EDID_STD_TIMINGS_FRR_MASK (0x3F)
+
+/* Detailed timing descriptor (DTD) / Preferred timing mode (PTM). */
+#define XVIDC_EDID_DTD_PTM_XRES_XBLANK_U4_XBLANK_MASK 0x0F
+#define XVIDC_EDID_DTD_PTM_XRES_XBLANK_U4_XRES_MASK 0xF0
+#define XVIDC_EDID_DTD_PTM_XRES_XBLANK_U4_XRES_SHIFT 4
+#define XVIDC_EDID_DTD_PTM_VFPORCH_VSPW_L4_VSPW_MASK 0x0F
+#define XVIDC_EDID_DTD_PTM_VFPORCH_VSPW_L4_VFPORCH_MASK 0xF0
+#define XVIDC_EDID_DTD_PTM_VFPORCH_VSPW_L4_VFPORCH_SHIFT 4
+#define XVIDC_EDID_DTD_PTM_XFPORCH_XSPW_U2_HFPORCH_MASK 0xC0
+#define XVIDC_EDID_DTD_PTM_XFPORCH_XSPW_U2_HSPW_MASK 0x30
+#define XVIDC_EDID_DTD_PTM_XFPORCH_XSPW_U2_VFPORCH_MASK 0x0C
+#define XVIDC_EDID_DTD_PTM_XFPORCH_XSPW_U2_VSPW_MASK 0x03
+#define XVIDC_EDID_DTD_PTM_XFPORCH_XSPW_U2_HFPORCH_SHIFT 6
+#define XVIDC_EDID_DTD_PTM_XFPORCH_XSPW_U2_HSPW_SHIFT 4
+#define XVIDC_EDID_DTD_PTM_XFPORCH_XSPW_U2_VFPORCH_SHIFT 2
+#define XVIDC_EDID_DTD_PTM_XIMGSIZE_MM_U4_VIMGSIZE_MM_MASK 0x0F
+#define XVIDC_EDID_DTD_PTM_XIMGSIZE_MM_U4_HIMGSIZE_MM_MASK 0xF0
+#define XVIDC_EDID_DTD_PTM_XIMGSIZE_MM_U4_HIMGSIZE_MM_SHIFT 4
+#define XVIDC_EDID_DTD_PTM_SIGNAL_INTERLACED_MASK 0x80
+#define XVIDC_EDID_DTD_PTM_SIGNAL_INTERLACED_SHIFT 7
+#define XVIDC_EDID_DTD_PTM_SIGNAL_HPOLARITY_MASK 0x02
+#define XVIDC_EDID_DTD_PTM_SIGNAL_VPOLARITY_MASK 0x04
+#define XVIDC_EDID_DTD_PTM_SIGNAL_HPOLARITY_SHIFT 1
+#define XVIDC_EDID_DTD_PTM_SIGNAL_VPOLARITY_SHIFT 2
+/* @} */
+
+/******************* Macros (Inline Functions) Definitions ********************/
+
+#define XVidC_EdidIsHeaderValid(E) \
+ !memcmp(E, "\x00\xFF\xFF\xFF\xFF\xFF\xFF\x00", 8)
+
+/* Vendor and product identification: ID manufacturer name. */
+/* void XVidC_EdidGetManName(u8 *EdidRaw, char ManName[4]); */
+
+/* Vendor and product identification: ID product code. */
+#define XVidC_EdidGetIdProdCode(E) \
+ ((u16)((E[XVIDC_EDID_VPI_ID_PROD_CODE_MSB] << 8) | \
+ E[XVIDC_EDID_VPI_ID_PROD_CODE_LSB]))
+
+/* Vendor and product identification: ID serial number. */
+#define XVidC_EdidGetIdSn(E) \
+ ((u32)((E[XVIDC_EDID_VPI_ID_SN3] << 24) | \
+ (E[XVIDC_EDID_VPI_ID_SN2] << 16) | (E[XVIDC_EDID_VPI_ID_SN1] << 8) | \
+ E[XVIDC_EDID_VPI_ID_SN0]))
+
+/* Vendor and product identification: Week and year of manufacture or model
+ * year. */
+#define XVidC_EdidGetManWeek(E) (E[XVIDC_EDID_VPI_WEEK_MAN])
+#define XVidC_EdidGetModManYear(E) (E[XVIDC_EDID_VPI_YEAR] + 1990)
+#define XVidC_EdidIsYearModel(E) (XVidC_EdidGetManWeek(E) == 0xFF)
+#define XVidC_EdidIsYearMan(E) (XVidC_EdidGetManWeek(E) != 0xFF)
+
+/* EDID structure version and revision. */
+#define XVidC_EdidGetStructVer(E) (E[XVIDC_EDID_STRUCT_VER])
+#define XVidC_EdidGetStructRev(E) (E[XVIDC_EDID_STRUCT_REV])
+
+/* Basic display parameters and features: Video input definition. */
+#define XVidC_EdidIsDigitalSig(E) \
+ ((E[XVIDC_EDID_BDISP_VID] & XVIDC_EDID_BDISP_VID_VSI_MASK) != 0)
+#define XVidC_EdidIsAnalogSig(E) \
+ ((E[XVIDC_EDID_BDISP_VID] & XVIDC_EDID_BDISP_VID_VSI_MASK) == 0)
+#define XVidC_EdidGetAnalogSigLvlStd(E) \
+ ((E[XVIDC_EDID_BDISP_VID] & XVIDC_EDID_BDISP_VID_ANA_SLS_MASK) >> \
+ XVIDC_EDID_BDISP_VID_ANA_SLS_SHIFT)
+#define XVidC_EdidGetAnalogSigVidSetup(E) \
+ ((E[XVIDC_EDID_BDISP_VID] & \
+ XVIDC_EDID_BDISP_VID_ANA_VID_SETUP_MASK) != 0)
+#define XVidC_EdidSuppAnalogSigSepSyncHv(E) \
+ ((E[XVIDC_EDID_BDISP_VID] & \
+ XVIDC_EDID_BDISP_VID_ANA_SEP_SYNC_HV_MASK) != 0)
+#define XVidC_EdidSuppAnalogSigCompSyncH(E) \
+ ((E[XVIDC_EDID_BDISP_VID] & \
+ XVIDC_EDID_BDISP_VID_ANA_COMP_SYNC_H_MASK) != 0)
+#define XVidC_EdidSuppAnalogSigCompSyncG(E) \
+ ((E[XVIDC_EDID_BDISP_VID] & \
+ XVIDC_EDID_BDISP_VID_ANA_COMP_SYNC_G_MASK) != 0)
+#define XVidC_EdidSuppAnalogSigSerrVsync(E) \
+ ((E[XVIDC_EDID_BDISP_VID] & \
+ XVIDC_EDID_BDISP_VID_ANA_SERR_V_SYNC_MASK) != 0)
+/* XVidC_ColorDepth XVidC_EdidGetColorDepth(u8 *EdidRaw); */
+#define XVidC_EdidGetDigitalSigIfaceStd(E) \
+ (E[XVIDC_EDID_BDISP_VID] & XVIDC_EDID_BDISP_VID_DIG_VIS_MASK)
+
+/* Basic display parameters and features: Horizontal and vertical screen size or
+ * aspect ratio. */
+#define XVidC_EdidIsSsArDefined(E) \
+ ((E[XVIDC_EDID_BDISP_H_SSAR] | E[XVIDC_EDID_BDISP_V_SSAR]) != 0)
+#define XVidC_EdidGetSsArH(E) E[XVIDC_EDID_BDISP_H_SSAR]
+#define XVidC_EdidGetSsArV(E) E[XVIDC_EDID_BDISP_V_SSAR]
+#define XVidC_EdidIsSsArSs(E) \
+ ((XVidC_EdidGetSsArH(E) != 0) && (XVidC_EdidGetSsArV(E) != 0))
+#define XVidC_EdidIsSsArArL(E) \
+ ((XVidC_EdidGetSsArH(E) != 0) && (XVidC_EdidGetSsArV(E) == 0))
+#define XVidC_EdidIsSsArArP(E) \
+ ((XVidC_EdidGetSsArH(E) == 0) && (XVidC_EdidGetSsArV(E) != 0))
+#define XVidC_EdidGetSsArArL(E) \
+ ((float)((XVidC_EdidGetSsArH(E) + 99.0) / 100.0))
+#define XVidC_EdidGetSsArArP(E) \
+ ((float)(100.0 / (XVidC_EdidGetSsArV(E) + 99.0)))
+
+/* Basic display parameters and features: Gamma. */
+#define XVidC_EdidIsGammaInExt(E) (E[XVIDC_EDID_BDISP_GAMMA] == 0xFF)
+#define XVidC_EdidGetGamma(E) \
+ ((float)((E[XVIDC_EDID_BDISP_GAMMA] + 100.0) / 100.0))
+
+/* Basic display parameters and features: Feature support. */
+#define XVidC_EdidSuppFeaturePmStandby(E) \
+ ((E[XVIDC_EDID_BDISP_FEATURE] & \
+ XVIDC_EDID_BDISP_FEATURE_PM_STANDBY_MASK) != 0)
+#define XVidC_EdidSuppFeaturePmSuspend(E) \
+ ((E[XVIDC_EDID_BDISP_FEATURE] & \
+ XVIDC_EDID_BDISP_FEATURE_PM_SUSPEND_MASK) != 0)
+#define XVidC_EdidSuppFeaturePmOffVlp(E) \
+ ((E[XVIDC_EDID_BDISP_FEATURE] & \
+ XVIDC_EDID_BDISP_FEATURE_PM_OFF_VLP_MASK) != 0)
+#define XVidC_EdidGetFeatureAnaColorType(E) \
+ ((E[XVIDC_EDID_BDISP_FEATURE] & \
+ XVIDC_EDID_BDISP_FEATURE_ANA_COLORTYPE_MASK) >> \
+ XVIDC_EDID_BDISP_FEATURE_ANA_COLORTYPE_SHIFT)
+#define XVidC_EdidSuppFeatureDigColorEncYCrCb444(E) \
+ ((E[XVIDC_EDID_BDISP_FEATURE] & \
+ XVIDC_EDID_BDISP_FEATURE_DIG_COLORENC_YCRCB444_MASK) != 0)
+#define XVidC_EdidSuppFeatureDigColorEncYCrCb422(E) \
+ ((E[XVIDC_EDID_BDISP_FEATURE] & \
+ XVIDC_EDID_BDISP_FEATURE_DIG_COLORENC_YCRCB422_MASK) != 0)
+#define XVidC_EdidIsFeatureSrgbDef(E) \
+ ((E[XVIDC_EDID_BDISP_FEATURE] & \
+ XVIDC_EDID_BDISP_FEATURE_SRGB_DEF_MASK) != 0)
+#define XVidC_EdidIsFeaturePtmInc(E) \
+ ((E[XVIDC_EDID_BDISP_FEATURE] & \
+ XVIDC_EDID_BDISP_FEATURE_PTM_INC_MASK) != 0)
+#define XVidC_EdidIsFeatureContFreq(E) \
+ ((E[XVIDC_EDID_BDISP_FEATURE] & \
+ XVIDC_EDID_BDISP_FEATURE_CONTFREQ_MASK) != 0)
+
+/* Color characterisitics (display x,y chromaticity coordinates). */
+/* float XVidC_EdidGetCcRedX(u8 *EdidRaw); */
+/* float XVidC_EdidGetCcRedY(u8 *EdidRaw); */
+/* float XVidC_EdidGetCcGreenX(u8 *EdidRaw); */
+/* float XVidC_EdidGetCcGreenY(u8 *EdidRaw); */
+/* float XVidC_EdidGetCcBlueX(u8 *EdidRaw); */
+/* float XVidC_EdidGetCcBlueY(u8 *EdidRaw); */
+/* float XVidC_EdidGetCcWhiteX(u8 *EdidRaw); */
+/* float XVidC_EdidGetCcWhiteY(u8 *EdidRaw); */
+
+/* Established timings. */
+#define XVidC_EdidSuppEstTimings720x400_70(E) \
+ ((E[XVIDC_EDID_EST_TIMINGS_I] & \
+ XVIDC_EDID_EST_TIMINGS_I_720x400_70_MASK) != 0)
+#define XVidC_EdidSuppEstTimings720x400_88(E) \
+ ((E[XVIDC_EDID_EST_TIMINGS_I] & \
+ XVIDC_EDID_EST_TIMINGS_I_720x400_88_MASK) != 0)
+#define XVidC_EdidSuppEstTimings640x480_60(E) \
+ ((E[XVIDC_EDID_EST_TIMINGS_I] & \
+ XVIDC_EDID_EST_TIMINGS_I_640x480_60_MASK) != 0)
+#define XVidC_EdidSuppEstTimings640x480_67(E) \
+ ((E[XVIDC_EDID_EST_TIMINGS_I] & \
+ XVIDC_EDID_EST_TIMINGS_I_640x480_67_MASK) != 0)
+#define XVidC_EdidSuppEstTimings640x480_72(E) \
+ ((E[XVIDC_EDID_EST_TIMINGS_I] & \
+ XVIDC_EDID_EST_TIMINGS_I_640x480_72_MASK) != 0)
+#define XVidC_EdidSuppEstTimings640x480_75(E) \
+ ((E[XVIDC_EDID_EST_TIMINGS_I] & \
+ XVIDC_EDID_EST_TIMINGS_I_640x480_75_MASK) != 0)
+#define XVidC_EdidSuppEstTimings800x600_56(E) \
+ ((E[XVIDC_EDID_EST_TIMINGS_I] & \
+ XVIDC_EDID_EST_TIMINGS_I_800x600_56_MASK) != 0)
+#define XVidC_EdidSuppEstTimings800x600_60(E) \
+ ((E[XVIDC_EDID_EST_TIMINGS_I] & \
+ XVIDC_EDID_EST_TIMINGS_I_800x600_60_MASK) != 0)
+#define XVidC_EdidSuppEstTimings800x600_72(E) \
+ ((E[XVIDC_EDID_EST_TIMINGS_II] & \
+ XVIDC_EDID_EST_TIMINGS_II_800x600_72_MASK) != 0)
+#define XVidC_EdidSuppEstTimings800x600_75(E) \
+ ((E[XVIDC_EDID_EST_TIMINGS_II] & \
+ XVIDC_EDID_EST_TIMINGS_II_800x600_75_MASK) != 0)
+#define XVidC_EdidSuppEstTimings832x624_75(E) \
+ ((E[XVIDC_EDID_EST_TIMINGS_II] & \
+ XVIDC_EDID_EST_TIMINGS_II_832x624_75_MASK) != 0)
+#define XVidC_EdidSuppEstTimings1024x768_87(E) \
+ ((E[XVIDC_EDID_EST_TIMINGS_II] & \
+ XVIDC_EDID_EST_TIMINGS_II_1024x768_87_MASK) != 0)
+#define XVidC_EdidSuppEstTimings1024x768_60(E) \
+ ((E[XVIDC_EDID_EST_TIMINGS_II] & \
+ XVIDC_EDID_EST_TIMINGS_II_1024x768_60_MASK) != 0)
+#define XVidC_EdidSuppEstTimings1024x768_70(E) \
+ ((E[XVIDC_EDID_EST_TIMINGS_II] & \
+ XVIDC_EDID_EST_TIMINGS_II_1024x768_70_MASK) != 0)
+#define XVidC_EdidSuppEstTimings1024x768_75(E) \
+ ((E[XVIDC_EDID_EST_TIMINGS_II] & \
+ XVIDC_EDID_EST_TIMINGS_II_1024x768_75_MASK) != 0)
+#define XVidC_EdidSuppEstTimings1280x1024_75(E) \
+ ((E[XVIDC_EDID_EST_TIMINGS_II] & \
+ XVIDC_EDID_EST_TIMINGS_II_1280x1024_75_MASK) != 0)
+#define XVidC_EdidSuppEstTimings1152x870_75(E) \
+ ((E[XVIDC_EDID_EST_TIMINGS_MAN] & \
+ XVIDC_EDID_EST_TIMINGS_MAN_1152x870_75_MASK) != 0)
+#define XVidC_EdidGetTimingsMan(E) \
+ (E[XVIDC_EDID_EST_TIMINGS_MAN] & XVIDC_EDID_EST_TIMINGS_MAN_MASK)
+
+/* Standard timings. */
+#define XVidC_EdidGetStdTimingsH(E, N) \
+ ((E[XVIDC_EDID_STD_TIMINGS_H(N)] + 31) * 8)
+#define XVidC_EdidGetStdTimingsAr(E, N) \
+ (E[XVIDC_EDID_STD_TIMINGS_AR_FRR(N)] >> XVIDC_EDID_STD_TIMINGS_AR_SHIFT)
+#define XVidC_EdidGetStdTimingsFrr(E, N) \
+ ((E[XVIDC_EDID_STD_TIMINGS_AR_FRR(N)] & \
+ XVIDC_EDID_STD_TIMINGS_FRR_MASK) + 60)
+/* u16 XVidC_EdidGetStdTimingsV(u8 *EdidRaw, u8 StdTimingsNum); */
+#define XVidC_EdidIsDtdPtmInterlaced(E) \
+ ((E[XVIDC_EDID_PTM + XVIDC_EDID_DTD_PTM_SIGNAL] & \
+ XVIDC_EDID_DTD_PTM_SIGNAL_INTERLACED_MASK) >> \
+ XVIDC_EDID_DTD_PTM_SIGNAL_INTERLACED_SHIFT)
+
+/* Extension block count. */
+#define XVidC_EdidGetExtBlkCount(E) (E[XVIDC_EDID_EXT_BLK_COUNT])
+
+/* Checksum. */
+#define XVidC_EdidGetChecksum(E) (E[XVIDC_EDID_CHECKSUM])
+
+/**************************** Function Prototypes *****************************/
+
+/* Vendor and product identification: ID manufacturer name. */
+void XVidC_EdidGetManName(u8 *EdidRaw, char ManName[4]);
+
+/* Basic display parameters and features: Video input definition. */
+XVidC_ColorDepth XVidC_EdidGetColorDepth(u8 *EdidRaw);
+
+/* Color characteristics (display x,y chromaticity coordinates). */
+float XVidC_EdidGetCcRedX(u8 *EdidRaw);
+float XVidC_EdidGetCcRedY(u8 *EdidRaw);
+float XVidC_EdidGetCcGreenX(u8 *EdidRaw);
+float XVidC_EdidGetCcGreenY(u8 *EdidRaw);
+float XVidC_EdidGetCcBlueX(u8 *EdidRaw);
+float XVidC_EdidGetCcBlueY(u8 *EdidRaw);
+float XVidC_EdidGetCcWhiteX(u8 *EdidRaw);
+float XVidC_EdidGetCcWhiteY(u8 *EdidRaw);
+
+/* Standard timings. */
+u16 XVidC_EdidGetStdTimingsV(u8 *EdidRaw, u8 StdTimingsNum);
+
+/* Utility functions. */
+u32 XVidC_EdidIsVideoTimingSupported(u8 *EdidRaw,
+ XVidC_VideoTimingMode *VtMode);
+
+#endif /* XVIDC_EDID_H_ */
diff --git a/XilinxProcessorIPLib/drivers/video_common/src/xvidc_timings_table.c b/XilinxProcessorIPLib/drivers/video_common/src/xvidc_timings_table.c
new file mode 100644
index 00000000..5fd641f9
--- /dev/null
+++ b/XilinxProcessorIPLib/drivers/video_common/src/xvidc_timings_table.c
@@ -0,0 +1,378 @@
+/*******************************************************************************
+ *
+ * Copyright (C) 2015 Xilinx, Inc. All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * Use of the Software is limited solely to applications:
+ * (a) running on a Xilinx device, or
+ * (b) that interact with a Xilinx device through a bus or interconnect.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * XILINX BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
+ * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * Except as contained in this notice, the name of the Xilinx shall not be used
+ * in advertising or otherwise to promote the sale, use or other dealings in
+ * this Software without prior written authorization from Xilinx.
+ *
+*******************************************************************************/
+/******************************************************************************/
+/**
+ *
+ * @file xvidc_timings_table.c
+ *
+ * Contains video timings for various standard resolutions.
+ *
+ * @note None.
+ *
+ *
+ * MODIFICATION HISTORY:
+ *
+ * Ver Who Date Changes
+ * ----- ---- -------- -----------------------------------------------
+ * 1.0 als, 01/10/15 Initial release.
+ * rc
+ *
+ *
+*******************************************************************************/
+
+/******************************* Include Files ********************************/
+
+#include "xvidc.h"
+
+/**************************** Variable Definitions ****************************/
+
+/**
+ * This table contains the main stream attributes for various standard
+ * resolutions. Each entry is of the format:
+ * 1) ID: XVIDC_VM_x__(_RB = Reduced Blanking)
+ * 2) Resolution naming: "x@"
+ * 3) Frame rate: XVIDC_FR_
+ * 4) Video timing structure:
+ * 1) Horizontal active resolution (pixels)
+ * 2) Horizontal front porch (pixels)
+ * 3) Horizontal sync width (pixels)
+ * 4) Horizontal back porch (pixels)
+ * 5) Horizontal total (pixels)
+ * 6) Horizontal sync polarity (0=negative|1=positive)
+ * 7) Vertical active resolution (lines)
+ * 8) Frame 0: Vertical front porch (lines)
+ * 9) Frame 0: Vertical sync width (lines)
+ * 10) Frame 0: Vertical back porch (lines)
+ * 11) Frame 0: Vertical total (lines)
+ * 12) Frame 1: Vertical front porch (lines)
+ * 13) Frame 1: Vertical sync width (lines)
+ * 14) Frame 1: Vertical back porch (lines)
+ * 15) Frame 1: Vertical total (lines)
+ * 16) Vertical sync polarity (0=negative|1=positive)
+ */
+const XVidC_VideoTimingMode XVidC_VideoTimingModes[XVIDC_VM_NUM_SUPPORTED] =
+{
+ /* Interlaced modes. */
+ { XVIDC_VM_480_60_I, "720x480@60Hz (I)", XVIDC_FR_60HZ,
+ {720, 19, 62, 57, 858, 0,
+ 240, 4, 3, 15, 262, 4, 3, 16, 263, 0} },
+ { XVIDC_VM_576_50_I, "720x576@50Hz (I)", XVIDC_FR_50HZ,
+ {720, 12, 63, 69, 864, 0,
+ 288, 2, 3, 19, 312, 2, 3, 20, 313, 0} },
+ { XVIDC_VM_1080_50_I, "1920x1080@50Hz (I)", XVIDC_FR_50HZ,
+ {1920, 88, 44, 148, 2200, 1,
+ 540, 2, 5, 15, 562, 2, 5, 16, 563, 1}, },
+ { XVIDC_VM_1080_60_I, "1920x1080@60Hz (I)", XVIDC_FR_60HZ,
+ {1920, 88, 44, 148, 2200, 1,
+ 540, 2, 5, 15, 562, 2, 5, 16, 563, 1}, },
+
+ /* Progressive modes. */
+ { XVIDC_VM_640x350_85_P, "640x350@85Hz", XVIDC_FR_85HZ,
+ {640, 32, 64, 96, 832, 1,
+ 350, 32, 3, 60, 445, 0, 0, 0, 0, 0} },
+ { XVIDC_VM_640x480_60_P, "640x480@60Hz", XVIDC_FR_60HZ,
+ {640, 8+8, 96, 40+8, 800, 0,
+ 480, 2+8, 2, 25+8, 525, 0, 0, 0, 0, 0} },
+ { XVIDC_VM_640x480_72_P, "640x480@72Hz", XVIDC_FR_72HZ,
+ {640, 8+16, 40, 120+8, 832, 0,
+ 480, 8+1, 3, 20+8, 520, 0, 0, 0, 0, 0} },
+ { XVIDC_VM_640x480_75_P, "640x480@75Hz", XVIDC_FR_75HZ,
+ {640, 16, 64, 120, 840, 0,
+ 480, 1, 3, 16, 500, 0, 0, 0, 0, 0} },
+ { XVIDC_VM_640x480_85_P, "640x480@85Hz", XVIDC_FR_85HZ,
+ {640, 56, 56, 80, 832, 0,
+ 480, 1, 3, 25, 509, 0, 0, 0, 0, 0} },
+ { XVIDC_VM_720x400_85_P, "720x400@85Hz", XVIDC_FR_85HZ,
+ {720, 36, 72, 108, 936, 0,
+ 400, 1, 3, 42, 446, 0, 0, 0, 0, 1} },
+ { XVIDC_VM_720x480_60_P, "720x480@60Hz", XVIDC_FR_60HZ,
+ {720, 16, 62, 60, 858, 0,
+ 480, 9, 6, 30, 525, 0, 0, 0, 0, 0} },
+ { XVIDC_VM_720x576_50_P, "720x576@50Hz", XVIDC_FR_50HZ,
+ {720, 16, 64, 68, 864, 1,
+ 576, 5, 5, 39, 625, 0, 0, 0, 0, 1}, },
+ { XVIDC_VM_800x600_56_P, "800x600@56Hz", XVIDC_FR_56HZ,
+ {800, 24, 72, 128, 1024, 1,
+ 600, 1, 2, 22, 625, 0, 0, 0, 0, 1} },
+ { XVIDC_VM_800x600_60_P, "800x600@60Hz", XVIDC_FR_60HZ,
+ {800, 40, 128, 88, 1056, 1,
+ 600, 1, 4, 23, 628, 0, 0, 0, 0, 1} },
+ { XVIDC_VM_800x600_72_P, "800x600@72Hz", XVIDC_FR_72HZ,
+ {800, 56, 120, 64, 1040, 1,
+ 600, 37, 6, 23, 666, 0, 0, 0, 0, 1} },
+ { XVIDC_VM_800x600_75_P, "800x600@75Hz", XVIDC_FR_75HZ,
+ {800, 16, 80, 160, 1056, 1,
+ 600, 1, 3, 21, 625, 0, 0, 0, 0, 1} },
+ { XVIDC_VM_800x600_85_P, "800x600@85Hz", XVIDC_FR_85HZ,
+ {800, 32, 64, 152, 1048, 1,
+ 600, 1, 3, 27, 631, 0, 0, 0, 0, 1} },
+ { XVIDC_VM_800x600_120_P_RB, "800x700@120Hz (RB)", XVIDC_FR_120HZ,
+ {800, 48, 32, 80, 960, 1,
+ 600, 3, 4, 29, 636, 0, 0, 0, 0, 0} },
+ { XVIDC_VM_848x480_60_P, "848x480@60Hz", XVIDC_FR_60HZ,
+ {848, 16, 112, 112, 1088, 1,
+ 480, 6, 8, 23, 517, 0, 0, 0, 0, 1} },
+ { XVIDC_VM_1024x768_60_P, "1024x768@60Hz", XVIDC_FR_60HZ,
+ {1024, 24, 136, 160, 1344, 0,
+ 768, 3, 6, 29, 806, 0, 0, 0, 0, 0} },
+ { XVIDC_VM_1024x768_70_P, "1024x768@70Hz", XVIDC_FR_70HZ,
+ {1024, 24, 136, 144, 1328, 0,
+ 768, 3, 6, 29, 806, 0, 0, 0, 0, 0} },
+ { XVIDC_VM_1024x768_75_P, "1024x768@75Hz", XVIDC_FR_75HZ,
+ {1024, 16, 96, 176, 1312, 1,
+ 768, 1, 3, 28, 800, 0, 0, 0, 0, 1} },
+ { XVIDC_VM_1024x768_85_P, "1024x768@85Hz", XVIDC_FR_85HZ,
+ {1024, 48, 96, 208, 1376, 1,
+ 768, 1, 3, 36, 808, 0, 0, 0, 0, 1} },
+ { XVIDC_VM_1024x768_120_P_RB, "1024x768@120Hz (RB)", XVIDC_FR_120HZ,
+ {1024, 48, 32, 80, 1184, 1,
+ 768, 3, 4, 38, 813, 0, 0, 0, 0, 0} },
+ { XVIDC_VM_1152x864_75_P, "1152x864@75Hz", XVIDC_FR_75HZ,
+ {1152, 64, 128, 256, 1600, 1,
+ 864, 1, 3, 32, 900, 0, 0, 0, 0, 1} },
+ { XVIDC_VM_1280x720_50_P, "1280x720@50Hz", XVIDC_FR_50HZ,
+ {1280, 440, 40, 220, 1980, 0,
+ 720, 5, 5, 20, 750, 0, 0, 0, 0, 0} },
+ { XVIDC_VM_1280x720_60_P, "720p@60Hz", XVIDC_FR_60HZ,
+ {1280, 110, 40, 220, 1650, 0,
+ 720, 5, 5, 20, 750, 0, 0, 0, 0, 0} },
+ { XVIDC_VM_1280x768_60_P, "1280x768@60Hz", XVIDC_FR_60HZ,
+ {1280, 64, 128, 192, 1664, 0,
+ 768, 3, 7, 20, 798, 0, 0, 0, 0, 1} },
+ { XVIDC_VM_1280x768_60_P_RB, "1280x768@60Hz (RB)", XVIDC_FR_60HZ,
+ {1280, 48, 32, 80, 1440, 1,
+ 768, 3, 7, 12, 790, 0, 0, 0, 0, 0} },
+ { XVIDC_VM_1280x768_75_P, "1280x768@75Hz", XVIDC_FR_75HZ,
+ {1280, 80, 128, 208, 1696, 0,
+ 768, 3, 7, 27, 805, 0, 0, 0, 0, 1} },
+ { XVIDC_VM_1280x768_85_P, "1280x768@85Hz", XVIDC_FR_85HZ,
+ {1280, 80, 136, 216, 1712, 0,
+ 768, 3, 7, 31, 809, 0, 0, 0, 0, 1} },
+ { XVIDC_VM_1280x768_120_P_RB, "1280x768@120Hz (RB)", XVIDC_FR_120HZ,
+ {1280, 48, 32, 80, 1440, 1,
+ 768, 3, 7, 35, 813, 0, 0, 0, 0, 0} },
+ { XVIDC_VM_1280x800_60_P, "1280x800@60Hz", XVIDC_FR_60HZ,
+ {1280, 72, 128, 200, 1680, 0,
+ 800, 3, 6, 22, 831, 0, 0, 0, 0, 1} },
+ { XVIDC_VM_1280x800_60_P_RB, "1280x800@60Hz (RB)", XVIDC_FR_60HZ,
+ {1280, 48, 32, 80, 1440, 1,
+ 800, 3, 6, 14, 823, 0, 0, 0, 0, 0} },
+ { XVIDC_VM_1280x800_75_P, "1280x800@75Hz", XVIDC_FR_75HZ,
+ {1280, 80, 128, 208, 1696, 0,
+ 800, 3, 6, 29, 838, 0, 0, 0, 0, 1} },
+ { XVIDC_VM_1280x800_85_P, "1280x800@85Hz", XVIDC_FR_85HZ,
+ {1280, 80, 136, 216, 1712, 0,
+ 800, 3, 6, 34, 843, 0, 0, 0, 0, 1} },
+ { XVIDC_VM_1280x800_120_P_RB, "1280x800@120Hz (RB)", XVIDC_FR_120HZ,
+ {1280, 48, 32, 80, 1440, 1,
+ 800, 3, 6, 38, 847, 0, 0, 0, 0, 0} },
+ { XVIDC_VM_1280x960_60_P, "1280x960@60Hz", XVIDC_FR_60HZ,
+ {1280, 96, 112, 312, 1800, 1,
+ 960, 1, 3, 36, 1000, 0, 0, 0, 0, 1} },
+ { XVIDC_VM_1280x960_85_P, "1280x960@85Hz", XVIDC_FR_85HZ,
+ {1280, 64, 160, 224, 1728, 1,
+ 960, 1, 3, 47, 1011, 0, 0, 0, 0, 1} },
+ { XVIDC_VM_1280x960_120_P_RB, "1280x960@120Hz (RB)", XVIDC_FR_120HZ,
+ {1280, 48, 32, 80, 1440, 1,
+ 960, 3, 4, 50, 1017, 0, 0, 0, 0, 0} },
+ { XVIDC_VM_1280x1024_60_P, "1280x1024@60Hz", XVIDC_FR_60HZ,
+ {1280, 48, 112, 248, 1688, 1,
+ 1024, 1, 3, 38, 1066, 0, 0, 0, 0, 1} },
+ { XVIDC_VM_1280x1024_75_P, "1280x1024@75Hz", XVIDC_FR_75HZ,
+ {1280, 16, 144, 248, 1688, 1,
+ 1024, 1, 3, 38, 1066, 0, 0, 0, 0, 1} },
+ { XVIDC_VM_1280x1024_85_P, "1280x1024@85Hz", XVIDC_FR_85HZ,
+ {1280, 64, 160, 224, 1728, 1,
+ 1024, 1, 3, 44, 1072, 0, 0, 0, 0, 1} },
+ { XVIDC_VM_1280x1024_120_P_RB, "1280x1024@120Hz (RB)", XVIDC_FR_120HZ,
+ {1280, 48, 32, 80, 1440, 1,
+ 1024, 3, 7, 50, 1084, 0, 0, 0, 0, 0} },
+ { XVIDC_VM_1360x768_60_P, "1360x768@60Hz", XVIDC_FR_60HZ,
+ {1360, 64, 112, 256, 1792, 1,
+ 768, 3, 6, 18, 795, 0, 0, 0, 0, 1} },
+ { XVIDC_VM_1360x768_120_P_RB, "1360x768@120Hz (RB)", XVIDC_FR_120HZ,
+ {1360, 48, 32, 80, 1520, 1,
+ 768, 3, 5, 37, 813, 0, 0, 0, 0, 0} },
+ { XVIDC_VM_1366x768_60_P, "1366x768@60Hz", XVIDC_FR_60HZ,
+ {1366, 14, 56, 64, 1500, 1,
+ 768, 1, 3, 28, 800, 0, 0, 0, 0, 1} },
+ { XVIDC_VM_1400x1050_60_P, "1400x1050@60Hz", XVIDC_FR_60HZ,
+ {1400, 88, 144, 232, 1864, 0,
+ 1050, 3, 4, 32, 1089, 0, 0, 0, 0, 1} },
+ { XVIDC_VM_1400x1050_60_P_RB, "1400x1050@60Hz (RB)", XVIDC_FR_60HZ,
+ {1400, 48, 32, 80, 1560, 1,
+ 1050, 3, 4, 23, 1080, 0, 0, 0, 0, 0} },
+ { XVIDC_VM_1400x1050_75_P, "1400x1050@75Hz", XVIDC_FR_75HZ,
+ {1400, 104, 144, 248, 1896, 0,
+ 1050, 3, 4, 42, 1099, 0, 0, 0, 0, 1} },
+ { XVIDC_VM_1400x1050_85_P, "1400x1050@85Hz", XVIDC_FR_85HZ,
+ {1400, 104, 152, 256, 1912, 0,
+ 1050, 3, 4, 48, 1105, 0, 0, 0, 0, 1} },
+ { XVIDC_VM_1400x1050_120_P_RB, "1400x1050@120Hz (RB)", XVIDC_FR_120HZ,
+ {1400, 48, 32, 80, 1560, 1,
+ 1050, 3, 4, 55, 1112, 0, 0, 0, 0, 0} },
+ { XVIDC_VM_1440x900_60_P, "1440x900@60Hz", XVIDC_FR_60HZ,
+ {1440, 80, 152, 232, 1904, 0,
+ 900, 3, 6, 25, 934, 0, 0, 0, 0, 1} },
+ { XVIDC_VM_1440x900_60_P_RB, "1440x900@60Hz (RB)", XVIDC_FR_60HZ,
+ {1440, 48, 32, 80, 1600, 1,
+ 900, 3, 6, 17, 926, 0, 0, 0, 0, 0} },
+ { XVIDC_VM_1440x900_75_P, "1440x900@75Hz", XVIDC_FR_75HZ,
+ {1440, 96, 152, 248, 1936, 0,
+ 900, 3, 6, 33, 942, 0, 0, 0, 0, 1} },
+ { XVIDC_VM_1440x900_85_P, "1440x900@85Hz", XVIDC_FR_85HZ,
+ {1440, 104, 152, 256, 1952, 0,
+ 900, 3, 6, 39, 948, 0, 0, 0, 0, 1} },
+ { XVIDC_VM_1440x900_120_P_RB, "1440x900@120Hz (RB)", XVIDC_FR_120HZ,
+ {1440, 48, 32, 80, 1600, 1,
+ 900, 3, 6, 44, 953, 0, 0, 0, 0, 0} },
+ { XVIDC_VM_1600x1200_60_P, "1600x1200@60Hz", XVIDC_FR_60HZ,
+ {1600, 64, 192, 304, 2160, 1,
+ 1200, 1, 3, 46, 1250, 0, 0, 0, 0, 1} },
+ { XVIDC_VM_1600x1200_65_P, "1600x1200@65Hz", XVIDC_FR_65HZ,
+ {1600, 64, 192, 304, 2160, 1,
+ 1200, 1, 3, 46, 1250, 0, 0, 0, 0, 1} },
+ { XVIDC_VM_1600x1200_70_P, "1600x1200@70Hz", XVIDC_FR_70HZ,
+ {1600, 64, 192, 304, 2160, 1,
+ 1200, 1, 3, 46, 1250, 0, 0, 0, 0, 1} },
+ { XVIDC_VM_1600x1200_75_P, "1600x1200@75Hz", XVIDC_FR_75HZ,
+ {1600, 64, 192, 304, 2160, 1,
+ 1200, 1, 3, 46, 1250, 0, 0, 0, 0, 1} },
+ { XVIDC_VM_1600x1200_85_P, "1600x1200@85Hz", XVIDC_FR_85HZ,
+ {1600, 64, 192, 304, 2160, 1,
+ 1200, 1, 3, 46, 1250, 0, 0, 0, 0, 1} },
+ { XVIDC_VM_1600x1200_120_P_RB, "1600x1200@120Hz (RB)", XVIDC_FR_120HZ,
+ {1600, 48, 32, 80, 1760, 1,
+ 1200, 3, 4, 64, 1271, 0, 0, 0, 0, 0} },
+ { XVIDC_VM_1680x1050_60_P, "1680x1050@60Hz", XVIDC_FR_60HZ,
+ {1680, 104, 176, 280, 2240, 0,
+ 1050, 3, 6, 30, 1089, 0, 0, 0, 0, 1} },
+ { XVIDC_VM_1680x1050_60_P_RB, "1680x1050@60Hz (RB)", XVIDC_FR_60HZ,
+ {1680, 48, 32, 80, 1840, 1,
+ 1050, 3, 6, 21, 1080, 0, 0, 0, 0, 0} },
+ { XVIDC_VM_1680x1050_75_P, "1680x1050@75Hz", XVIDC_FR_75HZ,
+ {1680, 120, 176, 296, 2272, 0,
+ 1050, 3, 6, 40, 1099, 0, 0, 0, 0, 1} },
+ { XVIDC_VM_1680x1050_85_P, "1680x1050@85Hz", XVIDC_FR_85HZ,
+ {1680, 128, 176, 304, 2288, 0,
+ 1050, 3, 6, 46, 1105, 0, 0, 0, 0, 1} },
+ { XVIDC_VM_1680x1050_120_P_RB, "1680x1050@120Hz (RB)", XVIDC_FR_120HZ,
+ {1680, 48, 32, 80, 1840, 1,
+ 1050, 3, 6, 53, 1112, 0, 0, 0, 0, 0} },
+ { XVIDC_VM_1792x1344_60_P, "1792x1344@60Hz", XVIDC_FR_60HZ,
+ {1792, 128, 200, 328, 2448, 0,
+ 1344, 1, 3, 46, 1394, 0, 0, 0, 0, 1} },
+ { XVIDC_VM_1792x1344_75_P, "1792x1344@75Hz", XVIDC_FR_75HZ,
+ {1792, 96, 216, 352, 2456, 0,
+ 1344, 1, 3, 69, 1417, 0, 0, 0, 0, 1} },
+ { XVIDC_VM_1792x1344_120_P_RB, "1792x1344@120Hz (RB)", XVIDC_FR_120HZ,
+ {1792, 48, 32, 80, 1952, 1,
+ 1344, 3, 4, 72, 1423, 0, 0, 0, 0, 0} },
+ { XVIDC_VM_1856x1392_60_P, "1856x1392@60Hz", XVIDC_FR_60HZ,
+ {1856, 96, 224, 352, 2528, 0,
+ 1392, 1, 3, 43, 1439, 0, 0, 0, 0, 1} },
+ { XVIDC_VM_1856x1392_75_P, "1856x1392@75Hz", XVIDC_FR_75HZ,
+ {1856, 128, 224, 352, 2560, 0,
+ 1392, 1, 3, 104, 1500, 0, 0, 0, 0, 1} },
+ { XVIDC_VM_1856x1392_120_P_RB, "1856x1392@120Hz (RB)", XVIDC_FR_120HZ,
+ {1856, 48, 32, 80, 2016, 1,
+ 1392, 3, 4, 75, 1474, 0, 0, 0, 0, 0} },
+ { XVIDC_VM_1920x1080_24_P, "1920x1080@24Hz", XVIDC_FR_24HZ,
+ {1920, 638, 44, 148, 2750, 0,
+ 1080, 4, 5, 36, 1125, 0, 0, 0, 0, 0} },
+ { XVIDC_VM_1920x1080_25_P, "1920x1080@25Hz", XVIDC_FR_25HZ,
+ {1920, 528, 44, 148, 2640, 0,
+ 1080, 4, 5, 36, 1125, 0, 0, 0, 0, 0} },
+ { XVIDC_VM_1920x1080_30_P, "1920x1080@30Hz", XVIDC_FR_30HZ,
+ {1920, 88, 44, 148, 2200, 0,
+ 1080, 4, 5, 36, 1125, 0, 0, 0, 0, 0} },
+ { XVIDC_VM_1920x1080_50_P, "1920x1080@50Hz", XVIDC_FR_50HZ,
+ {1920, 528, 44, 148, 2640, 0,
+ 1080, 4, 5, 36, 1125, 0, 0, 0, 0, 0} },
+ { XVIDC_VM_1920x1080_60_P, "1920x1080@60Hz", XVIDC_FR_60HZ,
+ {1920, 88, 44, 148, 2200, 0,
+ 1080, 4, 5, 36, 1125, 0, 0, 0, 0, 0} },
+ { XVIDC_VM_1920x1200_60_P, "1920x1200@60Hz", XVIDC_FR_60HZ,
+ {1920, 136, 200, 336, 2592, 0,
+ 1200, 3, 6, 36, 1245, 0, 0, 0, 0, 1} },
+ { XVIDC_VM_1920x1200_60_P_RB, "1920x1200@60Hz (RB)", XVIDC_FR_60HZ,
+ {1920, 48, 32, 80, 2080, 1,
+ 1200, 3, 6, 26, 1235, 0, 0, 0, 0, 0} },
+ { XVIDC_VM_1920x1200_75_P, "1920x1200@75Hz", XVIDC_FR_75HZ,
+ {1920, 136, 208, 344, 2608, 0,
+ 1200, 3, 6, 46, 1255, 0, 0, 0, 0, 1} },
+ { XVIDC_VM_1920x1200_85_P, "1920x1200@85Hz", XVIDC_FR_85HZ,
+ {1920, 144, 208, 352, 2624, 0,
+ 1200, 3, 6, 53, 1262, 0, 0, 0, 0, 1} },
+ { XVIDC_VM_1920x1200_120_P_RB, "1920x1200@120Hz (RB)", XVIDC_FR_120HZ,
+ {1920, 48, 32, 80, 2080, 1,
+ 1200, 3, 6, 62, 1271, 0, 0, 0, 0, 0} },
+ { XVIDC_VM_1920x1440_60_P, "1920x1440@60Hz", XVIDC_FR_60HZ,
+ {1920, 128, 208, 344, 2600, 0,
+ 1440, 1, 3, 56, 1500, 0, 0, 0, 0, 1} },
+ { XVIDC_VM_1920x1440_75_P, "1920x1440@75Hz", XVIDC_FR_75HZ,
+ {1920, 144, 224, 352, 2640, 0,
+ 1440, 1, 3, 56, 1500, 0, 0, 0, 0, 1} },
+ { XVIDC_VM_1920x1440_120_P_RB, "1920x1440@120Hz (RB)", XVIDC_FR_120HZ,
+ {1920, 48, 32, 80, 2080, 1,
+ 1440, 3, 4, 78, 1525, 0, 0, 0, 0, 0} },
+ { XVIDC_VM_1920x2160_60_P, "1920x2160@60Hz", XVIDC_FR_60HZ,
+ {1920, 88, 44, 148, 2200, 1,
+ 2160, 20, 10, 60, 2250, 0, 0, 0, 0, 0} },
+ { XVIDC_VM_2560x1600_60_P, "2560x1600@60Hz", XVIDC_FR_60HZ,
+ {2560, 192, 280, 472, 3504, 0,
+ 1600, 3, 6, 49, 1658, 0, 0, 0, 0, 1} },
+ { XVIDC_VM_2560x1600_60_P_RB, "2560x1600@60Hz (RB)", XVIDC_FR_60HZ,
+ {2560, 48, 32, 80, 2720, 1,
+ 1600, 3, 6, 37, 1646, 0, 0, 0, 0, 0} },
+ { XVIDC_VM_2560x1600_75_P, "2560x1600@75Hz", XVIDC_FR_75HZ,
+ {2560, 208, 280, 488, 3536, 0,
+ 1600, 3, 6, 63, 1672, 0, 0, 0, 0, 1} },
+ { XVIDC_VM_2560x1600_85_P, "2560x1600@85Hz", XVIDC_FR_85HZ,
+ {2560, 208, 280, 488, 3536, 0,
+ 1600, 3, 6, 73, 1682, 0, 0, 0, 0, 1} },
+ { XVIDC_VM_2560x1600_120_P_RB, "2560x1600@120Hz (RB)", XVIDC_FR_120HZ,
+ {2560, 48, 32, 80, 2720, 1,
+ 1600, 3, 6, 85, 1694, 0, 0, 0, 0, 0} },
+ { XVIDC_VM_3840x2160_24_P, "3840x2160@24Hz", XVIDC_FR_24HZ,
+ {3840, 1276, 88, 296, 5500, 0,
+ 2160, 8, 10, 72, 2250, 0, 0, 0, 0, 0} },
+ { XVIDC_VM_3840x2160_25_P, "3840x2160@25Hz", XVIDC_FR_25HZ,
+ {3840, 1056, 88, 296, 5280, 0,
+ 2160, 8, 10, 72, 2250, 0, 0, 0, 0, 0} },
+ { XVIDC_VM_3840x2160_30_P, "3840x2160@30Hz", XVIDC_FR_30HZ,
+ {3840, 176, 88, 296, 4400, 1,
+ 2160, 20, 10, 60, 2250, 0, 0, 0, 0, 0} },
+ { XVIDC_VM_3840x2160_60_P, "3840x2160@60Hz", XVIDC_FR_60HZ,
+ {3840, 176, 88, 296, 4400, 1,
+ 2160, 20, 10, 60, 2250, 0, 0, 0, 0, 0} }
+};