//*****************************************************************************
//
//  SPDX-FileCopyrightText: Copyright (c) 2021 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
//  SPDX-License-Identifier: MIT
//
//  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.
//
//  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
//  THE AUTHORS OR COPYRIGHT HOLDERS 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.
//
//  File:       nvt_edidext_displayid.c
//
//  Purpose:    the provide edid related services
//
//*****************************************************************************

#include "nvBinSegment.h"
#include "nvmisc.h"

#include "displayid.h"
#include "edid.h"

PUSH_SEGMENTS

static NVT_STATUS parseDisplayIdSection(DISPLAYID_SECTION * section,
                                        NvU32 max_length,
                                        NVT_EDID_INFO *pEdidInfo);
static NVT_STATUS parseDisplayIdBlock(NvU8 * block,
                                      NvU8 max_length,
                                      NvU8 * pLength,
                                      NVT_EDID_INFO *pEdidInfo);

// Specific blocks that can be parsed based on DisplayID
static NVT_STATUS parseDisplayIdProdIdentityBlock(NvU8 * block, NVT_DISPLAYID_INFO *pInfo);
static NVT_STATUS parseDisplayIdParam(NvU8 * block, NVT_DISPLAYID_INFO *pInfo);
static NVT_STATUS parseDisplayIdColorChar(NvU8 * block, NVT_DISPLAYID_INFO *pInfo);
static NVT_STATUS parseDisplayIdTiming1(NvU8 * block, NVT_EDID_INFO *pEdidInfo);
static NVT_STATUS parseDisplayIdTiming2(NvU8 * block, NVT_EDID_INFO *pEdidInfo);
static NVT_STATUS parseDisplayIdTiming3(NvU8 * block, NVT_EDID_INFO *pEdidInfo);
static NVT_STATUS parseDisplayIdTiming4(NvU8 * block, NVT_EDID_INFO *pEdidInfo);
static NVT_STATUS parseDisplayIdTiming5(NvU8 * block, NVT_EDID_INFO *pEdidInfo, NVT_DISPLAYID_INFO *pInfo);
static NVT_STATUS parseDisplayIdTimingVesa(NvU8 * block, NVT_EDID_INFO *pEdidInfo);
static NVT_STATUS parseDisplayIdTimingEIA(NvU8 * block, NVT_EDID_INFO *pEdidInfo);
static NVT_STATUS parseDisplayIdRangeLimits(NvU8 * block, NVT_DISPLAYID_INFO *pInfo);
static NVT_STATUS parseDisplayIdSerialNumber(NvU8 * block, NVT_DISPLAYID_INFO *pInfo);
static NVT_STATUS parseDisplayIdAsciiString(NvU8 * block, NVT_DISPLAYID_INFO *pInfo);
static NVT_STATUS parseDisplayIdDeviceData(NvU8 * block, NVT_DISPLAYID_INFO *pInfo);
static NVT_STATUS parseDisplayIdInterfacePower(NvU8 * block, NVT_DISPLAYID_INFO *pInfo);
static NVT_STATUS parseDisplayIdTransferChar(NvU8 * block, NVT_DISPLAYID_INFO *pInfo);
static NVT_STATUS parseDisplayIdDisplayInterface(NvU8 * block, NVT_DISPLAYID_INFO *pInfo);
static NVT_STATUS parseDisplayIdStereo(NvU8 * block, NVT_DISPLAYID_INFO *pInfo);
static NVT_STATUS parseDisplayIdTiledDisplay(NvU8 * block, NVT_DISPLAYID_INFO *pInfo);
static NVT_STATUS parseDisplayIdCtaData(NvU8 * block, NVT_EDID_INFO *pInfo, NVT_DISPLAYID_INFO *pDisplayIdInfo);
static NVT_STATUS parseDisplayIdDisplayInterfaceFeatures(NvU8 * block, NVT_DISPLAYID_INFO *pInfo);

static NVT_STATUS parseDisplayIdTiming1Descriptor(DISPLAYID_TIMING_1_DESCRIPTOR * desc, NVT_TIMING *pT);
static NVT_STATUS parseDisplayIdTiming2Descriptor(DISPLAYID_TIMING_2_DESCRIPTOR * desc, NVT_TIMING *pT);
static NVT_STATUS parseDisplayIdTiming3Descriptor(DISPLAYID_TIMING_3_DESCRIPTOR * desc, NVT_TIMING *pT);
static NVT_STATUS parseDisplayIdTiming5Descriptor(DISPLAYID_TIMING_5_DESCRIPTOR * desc, NVT_TIMING *pT);

/**
 * @brief Parses a displayID Extension block, with timings stored in pT and
 *        other info stored in pInfo
 * @param p The EDID Extension Block (With a DisplayID in it)
 * @param size Size of the displayID Extension Block
 * @param pEdidInfo EDID struct containing DisplayID information and
 *                  the timings
 */
CODE_SEGMENT(PAGE_DD_CODE)
NVT_STATUS getDisplayIdEDIDExtInfo(NvU8 *p, NvU32 size,
                                   NVT_EDID_INFO *pEdidInfo)
{
    DISPLAYID_SECTION * section;

    if (p == NULL || size < sizeof(EDIDV1STRUC))
        return NVT_STATUS_ERR;
    if (p[0] != NVT_EDID_EXTENSION_DISPLAYID)
        return NVT_STATUS_ERR;

    section = (DISPLAYID_SECTION *)(p + 1);
    pEdidInfo->ext_displayid.version = section->version;
    if (section->product_type > NVT_DISPLAYID_PROD_MAX_NUMBER)
        return NVT_STATUS_ERR;

    return parseDisplayIdSection(section, sizeof(EDIDV1STRUC) - 1, pEdidInfo);
}

/**
 * @brief updates the color format for each bpc for each timing
 * @param pInfo EDID struct containing DisplayID information and
 *              the timings
 * @param timingIdx Index of the first display ID timing in the
 *                              pInfo->timing[] timing array.
  */
CODE_SEGMENT(PAGE_DD_CODE)
void updateColorFormatForDisplayIdExtnTimings(NVT_EDID_INFO *pInfo,
                                              NvU32 timingIdx)
{
    // pDisplayIdInfo is the parsed display ID info
    NVT_DISPLAYID_INFO *pDisplayIdInfo = &pInfo->ext_displayid;
    NVT_TIMING *pT = &pInfo->timing[timingIdx];

    nvt_assert((timingIdx) <= COUNT(pInfo->timing));

    if ((pInfo->input.u.digital.video_interface == NVT_EDID_DIGITAL_VIDEO_INTERFACE_STANDARD_HDMI_A_SUPPORTED ||
         pInfo->input.u.digital.video_interface == NVT_EDID_DIGITAL_VIDEO_INTERFACE_STANDARD_HDMI_B_SUPPORTED || 
         pInfo->ext861.valid.H14B_VSDB || pInfo->ext861.valid.H20_HF_VSDB) && pInfo->ext861.revision >= NVT_CEA861_REV_A)
    {
         if (!pInfo->ext_displayid.supported_displayId2_0)
         {
             UPDATE_BPC_FOR_COLORFORMAT(pT->etc.rgb444, 0,
                                                        1,
                                                        pDisplayIdInfo->u4.display_interface.rgb_depth.support_10b,
                                                        pDisplayIdInfo->u4.display_interface.rgb_depth.support_12b,
                                                        pDisplayIdInfo->u4.display_interface.rgb_depth.support_14b,
                                                        pDisplayIdInfo->u4.display_interface.rgb_depth.support_16b);
         }
         else
         {
             // rgb444 (always support 6bpc and 8bpc as per DP spec 5.1.1.1.1 RGB Colorimetry)
             UPDATE_BPC_FOR_COLORFORMAT(pT->etc.rgb444, 0,
                                                        1,
                                                        pDisplayIdInfo->u4.display_interface_features.rgb_depth.support_10b,
                                                        pDisplayIdInfo->u4.display_interface_features.rgb_depth.support_12b,
                                                        pDisplayIdInfo->u4.display_interface_features.rgb_depth.support_14b,
                                                        pDisplayIdInfo->u4.display_interface_features.rgb_depth.support_16b);
         }
    }
    else // DP
    {
         if (!pInfo->ext_displayid.supported_displayId2_0)
         {
             UPDATE_BPC_FOR_COLORFORMAT(pT->etc.rgb444, 1,
                                                        1,
                                                        pDisplayIdInfo->u4.display_interface.rgb_depth.support_10b,
                                                        pDisplayIdInfo->u4.display_interface.rgb_depth.support_12b,
                                                        pDisplayIdInfo->u4.display_interface.rgb_depth.support_14b,
                                                        pDisplayIdInfo->u4.display_interface.rgb_depth.support_16b);
         }
         else
         {
            // rgb444 (always support 6bpc and 8bpc as per DP spec 5.1.1.1.1 RGB Colorimetry)
             UPDATE_BPC_FOR_COLORFORMAT(pT->etc.rgb444, 1,
                                                        1,
                                                        pDisplayIdInfo->u4.display_interface_features.rgb_depth.support_10b,
                                                        pDisplayIdInfo->u4.display_interface_features.rgb_depth.support_12b,
                                                        pDisplayIdInfo->u4.display_interface_features.rgb_depth.support_14b,
                                                        pDisplayIdInfo->u4.display_interface_features.rgb_depth.support_16b);         
         }
    }

    if (!pInfo->ext_displayid.supported_displayId2_0)
    {
        // yuv444
        UPDATE_BPC_FOR_COLORFORMAT(pT->etc.yuv444, 0, /* yuv444 does not support 6bpc */
                                                    pDisplayIdInfo->u4.display_interface.ycbcr444_depth.support_8b,
                                                    pDisplayIdInfo->u4.display_interface.ycbcr444_depth.support_10b,
                                                    pDisplayIdInfo->u4.display_interface.ycbcr444_depth.support_12b,
                                                    pDisplayIdInfo->u4.display_interface.ycbcr444_depth.support_14b,
                                                    pDisplayIdInfo->u4.display_interface.ycbcr444_depth.support_16b);
        // yuv422
        UPDATE_BPC_FOR_COLORFORMAT(pT->etc.yuv422, 0, /* yuv422 does not support 6bpc */
                                                    pDisplayIdInfo->u4.display_interface.ycbcr422_depth.support_8b,
                                                    pDisplayIdInfo->u4.display_interface.ycbcr422_depth.support_10b,
                                                    pDisplayIdInfo->u4.display_interface.ycbcr422_depth.support_12b,
                                                    pDisplayIdInfo->u4.display_interface.ycbcr422_depth.support_14b,
                                                    pDisplayIdInfo->u4.display_interface.ycbcr422_depth.support_16b);
    }
    else 
    {
        // yuv444
        UPDATE_BPC_FOR_COLORFORMAT(pT->etc.yuv444, 0, /* yuv444 does not support 6bpc */
                                                    pDisplayIdInfo->u4.display_interface_features.ycbcr444_depth.support_8b,
                                                    pDisplayIdInfo->u4.display_interface_features.ycbcr444_depth.support_10b,
                                                    pDisplayIdInfo->u4.display_interface_features.ycbcr444_depth.support_12b,
                                                    pDisplayIdInfo->u4.display_interface_features.ycbcr444_depth.support_14b,
                                                    pDisplayIdInfo->u4.display_interface_features.ycbcr444_depth.support_16b);
        // yuv422
        UPDATE_BPC_FOR_COLORFORMAT(pT->etc.yuv422, 0, /* yuv422 does not support 6bpc */
                                                    pDisplayIdInfo->u4.display_interface_features.ycbcr422_depth.support_8b,
                                                    pDisplayIdInfo->u4.display_interface_features.ycbcr422_depth.support_10b,
                                                    pDisplayIdInfo->u4.display_interface_features.ycbcr422_depth.support_12b,
                                                    pDisplayIdInfo->u4.display_interface_features.ycbcr422_depth.support_14b,
                                                    pDisplayIdInfo->u4.display_interface_features.ycbcr422_depth.support_16b);
        // yuv420
        UPDATE_BPC_FOR_COLORFORMAT(pT->etc.yuv420, 0, /* yuv420 does not support 6bpc */
                                                    pDisplayIdInfo->u4.display_interface_features.ycbcr420_depth.support_8b,
                                                    pDisplayIdInfo->u4.display_interface_features.ycbcr420_depth.support_10b,
                                                    pDisplayIdInfo->u4.display_interface_features.ycbcr420_depth.support_12b,
                                                    pDisplayIdInfo->u4.display_interface_features.ycbcr420_depth.support_14b,
                                                    pDisplayIdInfo->u4.display_interface_features.ycbcr420_depth.support_16b);
    }
}

/**
 * @brief Parses a displayID Section
 * @param section The DisplayID Section to parse
 * @param max_length The indicated total length of the displayID as given (or
 *                   sizeof(EDIDV1STRUCT) for an extension block)
 * @param pEdidInfo EDID struct containing DisplayID information and
 *                  the timings
 */
CODE_SEGMENT(PAGE_DD_CODE)
static NVT_STATUS parseDisplayIdSection(DISPLAYID_SECTION * section,
                                        NvU32 max_length,
                                        NVT_EDID_INFO *pEdidInfo)
{
    NvU8 block_location = 0;
    NvU8 section_length;
    NvU8 remaining_length;

    if (section == NULL || max_length <= NVT_DISPLAYID_SECTION_HEADER_LEN)
        return NVT_STATUS_ERR;
    if (section->section_bytes > max_length - NVT_DISPLAYID_SECTION_HEADER_LEN)
        return NVT_STATUS_ERR;

    remaining_length = section->section_bytes;

    while (block_location < section->section_bytes)
    {
        DISPLAYID_DATA_BLOCK_HEADER * hdr = (DISPLAYID_DATA_BLOCK_HEADER *) (section->data + block_location);
        NvU8 is_prod_id = remaining_length > 3 && block_location == 0 && hdr->type == 0 && hdr->data_bytes > 0;
        NvU8 i;

        // Check the padding.
        if (hdr->type == 0 && !is_prod_id)
        {
            for (i = 1 ; i < remaining_length; i++)
            {
                // All remaining bytes must all be 0.
                if (section->data[block_location + i] != 0)
                {
                    return NVT_STATUS_ERR;
                }
            }

            section_length = remaining_length;
        }
        else
        {
            if (parseDisplayIdBlock((NvU8 *)(section->data + block_location),
                                    section->section_bytes - block_location,
                                    &section_length,
                                    pEdidInfo) != NVT_STATUS_SUCCESS)
                return NVT_STATUS_ERR;
        }

        block_location += section_length;
        remaining_length -= section_length;
    }

    return NVT_STATUS_SUCCESS;
}

CODE_SEGMENT(PAGE_DD_CODE)
static NVT_STATUS parseDisplayIdBlock(NvU8 * block,
                                      NvU8 max_length,
                                      NvU8 * pLength,
                                      NVT_EDID_INFO *pEdidInfo)
{
    DISPLAYID_DATA_BLOCK_HEADER * hdr = (DISPLAYID_DATA_BLOCK_HEADER *) block;
    NVT_DISPLAYID_INFO *pInfo = &pEdidInfo->ext_displayid;

    if (block == NULL || max_length <= NVT_DISPLAYID_DATABLOCK_HEADER_LEN)
        return NVT_STATUS_ERR;
    if (hdr->data_bytes > max_length - NVT_DISPLAYID_DATABLOCK_HEADER_LEN)
        return NVT_STATUS_ERR;

    *pLength = hdr->data_bytes + NVT_DISPLAYID_DATABLOCK_HEADER_LEN;

    switch (hdr->type)
    {
        case NVT_DISPLAYID_BLOCK_TYPE_PRODUCT_IDENTITY:
            parseDisplayIdProdIdentityBlock(block, pInfo);
            break;
        case NVT_DISPLAYID_BLOCK_TYPE_DISPLAY_PARAM:
            parseDisplayIdParam(block, pInfo);
            break;
        case NVT_DISPLAYID_BLOCK_TYPE_COLOR_CHAR:
            parseDisplayIdColorChar(block, pInfo);
            break;
        case NVT_DISPLAYID_BLOCK_TYPE_TIMING_1:
            parseDisplayIdTiming1(block, pEdidInfo);
            break;
        case NVT_DISPLAYID_BLOCK_TYPE_TIMING_2:
            parseDisplayIdTiming2(block, pEdidInfo);
            break;
        case NVT_DISPLAYID_BLOCK_TYPE_TIMING_3:
            parseDisplayIdTiming3(block, pEdidInfo);
            break;
        case NVT_DISPLAYID_BLOCK_TYPE_TIMING_4:
            parseDisplayIdTiming4(block, pEdidInfo);
            break;
        case NVT_DISPLAYID_BLOCK_TYPE_TIMING_5:
            parseDisplayIdTiming5(block, pEdidInfo, pInfo);
            break;
        case NVT_DISPLAYID_BLOCK_TYPE_TIMING_VESA:
            parseDisplayIdTimingVesa(block, pEdidInfo);
            break;
        case NVT_DISPLAYID_BLOCK_TYPE_TIMING_CEA:
            parseDisplayIdTimingEIA(block, pEdidInfo);
            break;
        case NVT_DISPLAYID_BLOCK_TYPE_RANGE_LIMITS:
            parseDisplayIdRangeLimits(block, pInfo);
            break;
        case NVT_DISPLAYID_BLOCK_TYPE_SERIAL_NUMBER:
            parseDisplayIdSerialNumber(block, pInfo);
            break;
        case NVT_DISPLAYID_BLOCK_TYPE_ASCII_STRING:
            parseDisplayIdAsciiString(block, pInfo);
            break;
        case NVT_DISPLAYID_BLOCK_TYPE_DEVICE_DATA:
            parseDisplayIdDeviceData(block, pInfo);
            break;
        case NVT_DISPLAYID_BLOCK_TYPE_INTERFACE_POWER:
            parseDisplayIdInterfacePower(block, pInfo);
            break;
        case NVT_DISPLAYID_BLOCK_TYPE_TRANSFER_CHAR:
            parseDisplayIdTransferChar(block, pInfo);
            break;
        case NVT_DISPLAYID_BLOCK_TYPE_DISPLAY_INTERFACE:
            parseDisplayIdDisplayInterface(block, pInfo);
            break;
        case NVT_DISPLAYID_BLOCK_TYPE_STEREO:
            parseDisplayIdStereo(block, pInfo);
            break;
        case NVT_DISPLAYID_BLOCK_TYPE_TILEDDISPLAY:
            parseDisplayIdTiledDisplay(block, pInfo);
            break;
        case NVT_DISPLAYID_BLOCK_TYPE_CTA_DATA:
            parseDisplayIdCtaData(block, pEdidInfo, pInfo);
            break;
        case NVT_DISPLAYID_BLOCK_TYPE_DISPLAY_INTERFACE_FEATURES:
            parseDisplayIdDisplayInterfaceFeatures(block, pInfo);
            break;
        default:
            break;
    }
    return NVT_STATUS_SUCCESS;
}
CODE_SEGMENT(PAGE_DD_CODE)
static NVT_STATUS parseDisplayIdColorChar(NvU8 * block, NVT_DISPLAYID_INFO *pInfo)
{
    NvU32 i, j;
    NvU16 x_p, y_p;
    DISPLAYID_COLOR_CHAR_BLOCK * blk = (DISPLAYID_COLOR_CHAR_BLOCK *)block;

    /** unused flag - uncomment if you wish to use it in the future
    NvU8 isTemp = DRF_VAL(T_DISPLAYID, _COLOR, _TEMPORAL, blk->point_info);
    */
    NvU8 wp_num = DRF_VAL(T_DISPLAYID, _COLOR, _WHITE_POINTS, blk->point_info);
    NvU8 prim_num = DRF_VAL(T_DISPLAYID, _COLOR, _PRIMARIES, blk->point_info);

    if ((prim_num + wp_num) * sizeof(DISPLAYID_COLOR_POINT) + 1 != blk->header.data_bytes)
    {
        // Assert since this error is ignored
        nvt_assert(0);
        return NVT_STATUS_ERR;
    }

    for (i = 0; i < prim_num; i++)
    {
        x_p = (blk->points)[i].color_x_bits_low + 
            (DRF_VAL(T_DISPLAYID, _COLOR, _POINT_X, (blk->points)[i].color_bits_mid) << 8);
        y_p = DRF_VAL(T_DISPLAYID, _COLOR, _POINT_Y, (blk->points)[i].color_bits_mid) + 
            ((blk->points)[i].color_y_bits_high << 4);
        pInfo->primaries[i].x = x_p;
        pInfo->primaries[i].y = y_p;
    }

    for (j = 0; j < wp_num; j++)
    {
        x_p = (blk->points)[i].color_x_bits_low + 
            (DRF_VAL(T_DISPLAYID, _COLOR, _POINT_X, (blk->points)[i].color_bits_mid) << 8);
        y_p = DRF_VAL(T_DISPLAYID, _COLOR, _POINT_Y, (blk->points)[i].color_bits_mid) + 
            ((blk->points)[i].color_y_bits_high << 4);
        pInfo->white_points[pInfo->total_primaries + j].x = x_p;
        pInfo->white_points[pInfo->total_primaries + j].y = y_p;

        i++;
    }
    pInfo->total_primaries = prim_num;
    pInfo->total_white_points += wp_num;
    return NVT_STATUS_SUCCESS;
}

CODE_SEGMENT(PAGE_DD_CODE)
static NVT_STATUS parseDisplayIdProdIdentityBlock(NvU8 * block, NVT_DISPLAYID_INFO *pInfo)
{
    DISPLAYID_PROD_IDENTIFICATION_BLOCK * blk = (DISPLAYID_PROD_IDENTIFICATION_BLOCK *)block;
    if (blk->header.data_bytes - blk->productid_string_size != NVT_DISPLAYID_PRODUCT_IDENTITY_MIN_LEN)
    {
        // Assert since this error is ignored
        nvt_assert(0);
        return NVT_STATUS_ERR;
    }

    pInfo->vendor_id = (blk->vendor)[2] | ((blk->vendor)[1] << 8) | ((blk->vendor)[0] << 16);
    pInfo->product_id = blk->product_code;
    pInfo->serial_number = blk->serial_number;
    pInfo->week = blk->model_tag;
    pInfo->year = blk->model_year;

    if (blk->productid_string_size != 0)
        NVMISC_STRNCPY((char *)pInfo->product_string, (const char *)blk->productid_string, blk->productid_string_size);
    pInfo->product_string[blk->productid_string_size] = '\0';

    return NVT_STATUS_SUCCESS;
}

CODE_SEGMENT(PAGE_DD_CODE)
static NVT_STATUS parseDisplayIdParam(NvU8 * block, NVT_DISPLAYID_INFO *pInfo)
{
    DISPLAYID_DISPLAY_PARAM_BLOCK * blk = (DISPLAYID_DISPLAY_PARAM_BLOCK *)block;
    if (blk->header.data_bytes != NVT_DISPLAYID_DISPLAY_PARAM_BLOCK_LEN)
    {
        // Assert since this error is ignored
        nvt_assert(0);
        return NVT_STATUS_ERR;
    }

    pInfo->horiz_size         = blk->horizontal_image_size;
    pInfo->vert_size          = blk->vertical_image_size;
    pInfo->horiz_pixels       = blk->horizontal_pixel_count;
    pInfo->vert_pixels        = blk->vertical_pixel_count;

    pInfo->support_audio      = DRF_VAL(T_DISPLAYID, _DISPLAY_PARAM, _SUPPORT_AUDIO,        blk->feature);
    pInfo->separate_audio     = DRF_VAL(T_DISPLAYID, _DISPLAY_PARAM, _SEPARATE_AUDIO,       blk->feature);
    pInfo->audio_override     = DRF_VAL(T_DISPLAYID, _DISPLAY_PARAM, _AUDIO_INPUT_OVERRIDE, blk->feature);
    pInfo->power_management   = DRF_VAL(T_DISPLAYID, _DISPLAY_PARAM, _POWER_MANAGEMENT,     blk->feature);
    pInfo->fixed_timing       = DRF_VAL(T_DISPLAYID, _DISPLAY_PARAM, _FIXED_TIMING,         blk->feature);
    pInfo->fixed_pixel_format = DRF_VAL(T_DISPLAYID, _DISPLAY_PARAM, _FIXED_PIXEL_FORMAT,   blk->feature);
    pInfo->deinterlace        = DRF_VAL(T_DISPLAYID, _DISPLAY_PARAM, _DEINTERLACING,        blk->feature);

    pInfo->gamma              = (NvU16)(blk->transfer_char_gamma - 1) * 100;
    pInfo->aspect_ratio       = blk->aspect_ratio;

    pInfo->depth_overall      = DRF_VAL(T_DISPLAYID, _DISPLAY_PARAM, _DEPTH_OVERALL, blk->color_bit_depth);
    pInfo->depth_native       = DRF_VAL(T_DISPLAYID, _DISPLAY_PARAM, _DEPTH_NATIVE,  blk->color_bit_depth);

    return NVT_STATUS_SUCCESS;
}

CODE_SEGMENT(PAGE_DD_CODE)
static NVT_STATUS parseDisplayIdTiming1(NvU8 * block, NVT_EDID_INFO *pEdidInfo)
{
    NvU16 i;
    NVT_TIMING newTiming;
    DISPLAYID_TIMING_1_BLOCK * blk = (DISPLAYID_TIMING_1_BLOCK *)block;
    if (blk->header.data_bytes % sizeof(DISPLAYID_TIMING_1_DESCRIPTOR) != 0)
    {
        // Assert since this error is ignored
        nvt_assert(0);
        return NVT_STATUS_ERR;
    }

    for (i = 0; i * sizeof(DISPLAYID_TIMING_1_DESCRIPTOR) < blk->header.data_bytes; i++)
    {
        NVMISC_MEMSET(&newTiming, 0, sizeof(newTiming));

        if (parseDisplayIdTiming1Descriptor(blk->descriptors + i,
                                            &newTiming) == NVT_STATUS_SUCCESS)
        {
            if (!assignNextAvailableTiming(pEdidInfo, &newTiming))
            {
                break;
            }
        }
    }
    return NVT_STATUS_SUCCESS;
}
CODE_SEGMENT(PAGE_DD_CODE)
static NVT_STATUS parseDisplayIdTiming1Descriptor(DISPLAYID_TIMING_1_DESCRIPTOR * type1, NVT_TIMING *pT)
{
    NvU32 totalPixels_in_2_fields;
    if (type1 == NULL || pT == NULL)
        return NVT_STATUS_ERR;

    // the pixel clock
    pT->pclk = (NvU32)((type1->pixel_clock_high << 16) + (type1->pixel_clock_mid << 8) + type1->pixel_clock_low_minus_0_01MHz + 1);

    // the DisplayID spec does not support border
    pT->HBorder = pT->VBorder = 0;

    // get horizontal timing parameters
    pT->HVisible    = (NvU16)((type1->horizontal.active_image_pixels_high << 8) + type1->horizontal.active_image_pixels_low_minus_1 + 1);
    pT->HTotal      = (NvU16)((type1->horizontal.blank_pixels_high        << 8) + type1->horizontal.blank_pixels_low_minus_1        + 1) + pT->HVisible;
    pT->HFrontPorch = (NvU16)((type1->horizontal.front_porch_high         << 8) + type1->horizontal.front_porch_low_minus_1         + 1);
    pT->HSyncWidth  = (NvU16)((type1->horizontal.sync_width_high          << 8) + type1->horizontal.sync_width_low_minus_1          + 1);
    pT->HSyncPol    = type1->horizontal.sync_polarity ? NVT_H_SYNC_POSITIVE : NVT_H_SYNC_NEGATIVE;

    // get vertical timings
    pT->VVisible    = (NvU16)((type1->vertical.active_image_lines_high << 8) + type1->vertical.active_image_lines_low_minus_1 + 1);
    pT->VTotal      = (NvU16)((type1->vertical.blank_lines_high        << 8) + type1->vertical.blank_lines_low_minus_1        + 1) + pT->VVisible;
    pT->VFrontPorch = (NvU16)((type1->vertical.front_porch_lines_high  << 8) + type1->vertical.front_porch_lines_low_minus_1  + 1);
    pT->VSyncWidth  = (NvU16)((type1->vertical.sync_width_lines_high   << 8) + type1->vertical.sync_width_lines_low_minus_1   + 1);
    pT->VSyncPol    = type1->vertical.sync_polarity ? NVT_V_SYNC_POSITIVE : NVT_V_SYNC_NEGATIVE;

    // EDID used in DP1.4 Compliance test had incorrect HBlank listed, leading to wrong raster sizes being set by driver (bug 2714607)
    // Filter incorrect timings here. HTotal must cover sufficient blanking time
    if (pT->HTotal < (pT->HVisible + pT->HFrontPorch + pT->HSyncWidth))
    {
        return NVT_STATUS_ERR;
    }

    // the frame scanning type
    pT->interlaced = type1->options.interface_frame_scanning_type;

    // the aspect ratio
    switch (type1->options.aspect_ratio)
    {
        case NVT_DISPLAYID_TIMING_ASPECT_RATIO_1_1:
            pT->etc.aspect = (1 << 16) | 1;
            break;
        case NVT_DISPLAYID_TIMING_ASPECT_RATIO_5_4:
            pT->etc.aspect = (5 << 16) | 4;
            break;
        case NVT_DISPLAYID_TIMING_ASPECT_RATIO_4_3:
            pT->etc.aspect = (4 << 16) | 3;
            break;
        case NVT_DISPLAYID_TIMING_ASPECT_RATIO_15_9:
            pT->etc.aspect = (15 << 16) | 9;
            break;
        case NVT_DISPLAYID_TIMING_ASPECT_RATIO_16_9:
            pT->etc.aspect = (16 << 16) | 9;
            break;
        case NVT_DISPLAYID_TIMING_ASPECT_RATIO_16_10:
            pT->etc.aspect = (16 << 16) | 10;
            break;
        default:
            pT->etc.aspect = 0;
            break;
    }

    // the refresh rate
    if (pT->interlaced)
    {
        // in interlaced mode, adjust for one extra line in every other frame. pT->VTotal is field based here
        totalPixels_in_2_fields = (NvU32)pT->HTotal * ((NvU32)pT->VTotal * 2 + 1);
        // calculate the field rate in interlaced mode
        pT->etc.rr = (NvU16)axb_div_c(pT->pclk * 2, 10000, totalPixels_in_2_fields);
        pT->etc.rrx1k = axb_div_c(pT->pclk * 2, 10000000, totalPixels_in_2_fields);
    }
    else
    {
        // calculate frame rate in progressive mode
        // in progressive mode filed = frame
        pT->etc.rr = (NvU16)axb_div_c(pT->pclk, 10000, (NvU32)pT->HTotal * (NvU32)pT->VTotal);
        pT->etc.rrx1k = axb_div_c(pT->pclk, 10000000, (NvU32)pT->HTotal * (NvU32)pT->VTotal);
    }
    pT->etc.name[39] = '\0';
    pT->etc.rep = 0x1; // bit mask for no pixel repetition
    
    pT->etc.status = NVT_STATUS_DISPLAYID_1;
    // Unlike the PTM in EDID base block, DisplayID type I/II preferred timing does not have  dependency on sequence
    // so we'll just update the preferred flag, not sequence them
    //pT->etc.status = NVT_STATUS_DISPLAYID_1N(1);
    pT->etc.flag |= type1->options.is_preferred_detailed_timing ? NVT_FLAG_DISPLAYID_DTD_PREFERRED_TIMING : 0;
    
    /* Fields currently not used. Uncomment them for future use
    type1->options.stereo_support;
    */

    // the DisplayID spec covers the timing parameter(Visible/FrontPorch/SyncWidth/Total) range from 1~65536 while our NVT_TIMING structure which is mostly based on NvU16 only covers 0~65535
    nvt_assert(pT->HVisible != 0);
    nvt_assert(pT->HFrontPorch != 0);
    nvt_assert(pT->HSyncWidth != 0);
    nvt_assert(pT->VVisible != 0);
    nvt_assert(pT->VFrontPorch != 0);
    nvt_assert(pT->VSyncWidth != 0);

    // cover the possible overflow
    nvt_assert(pT->HTotal > pT->HVisible);
    nvt_assert(pT->VTotal > pT->VVisible);

    return NVT_STATUS_SUCCESS;
}

CODE_SEGMENT(PAGE_DD_CODE)
static NVT_STATUS parseDisplayIdTiming2(NvU8 * block, NVT_EDID_INFO *pEdidInfo)
{
    NvU16 i;
    DISPLAYID_TIMING_2_BLOCK * blk = (DISPLAYID_TIMING_2_BLOCK *)block;
    NVT_TIMING newTiming;

    if (blk->header.data_bytes % sizeof(DISPLAYID_TIMING_2_DESCRIPTOR) != 0)
    {
        // Assert since this error is ignored
        nvt_assert(0);
        return NVT_STATUS_ERR;
    }

    for (i = 0; i * sizeof(DISPLAYID_TIMING_2_DESCRIPTOR) < blk->header.data_bytes; i++)
    {
        NVMISC_MEMSET(&newTiming, 0, sizeof(newTiming));

        if (parseDisplayIdTiming2Descriptor(blk->descriptors + i,
                                            &newTiming) == NVT_STATUS_SUCCESS)
        {
            if (!assignNextAvailableTiming(pEdidInfo, &newTiming))
            {
                break;
            }
        }
    }
    return NVT_STATUS_SUCCESS;
}

CODE_SEGMENT(PAGE_DD_CODE)
static NVT_STATUS parseDisplayIdTiming2Descriptor(DISPLAYID_TIMING_2_DESCRIPTOR * type2, NVT_TIMING *pT)
{
    NvU32 totalPixels_in_2_fields;
    if (type2 == NULL || pT == NULL)
        return NVT_STATUS_ERR;

    // the pixel clock
    pT->pclk = (NvU32)((type2->pixel_clock_high << 16) + (type2->pixel_clock_mid << 8) + type2->pixel_clock_low_minus_0_01MHz + 1);

    // the DisplayID spec does not support border
    pT->HBorder = pT->VBorder = 0;

    // get horizontal timing parameters
    pT->HVisible    = (NvU16)((type2->horizontal.active_image_in_char_high << 8) + type2->horizontal.active_image_in_char_minus_1 + 1) * NVT_DISPLAYID_CHAR_WIDTH_IN_PIXELS;
    pT->HTotal      = (NvU16)(type2->horizontal.blank_in_char_minus_1 + 1) * NVT_DISPLAYID_CHAR_WIDTH_IN_PIXELS + pT->HVisible;
    pT->HFrontPorch = (NvU16)(type2->horizontal.front_porch_in_char_minus_1 + 1) * NVT_DISPLAYID_CHAR_WIDTH_IN_PIXELS;
    pT->HSyncWidth  = (NvU16)(type2->horizontal.sync_width_in_char_minus_1 + 1) * NVT_DISPLAYID_CHAR_WIDTH_IN_PIXELS;
    pT->HSyncPol    = type2->options.hsync_polarity ? NVT_H_SYNC_POSITIVE : NVT_H_SYNC_NEGATIVE;

    // get vertical timing parameters
    pT->VVisible    = (NvU16)((type2->vertical.active_image_lines_high << 8) + type2->vertical.active_image_lines_low_minus_1 + 1);
    pT->VTotal      = (NvU16)(type2->vertical.blank_lines_minus_1 + 1) + pT->VVisible;
    pT->VFrontPorch = (NvU16)(type2->vertical.front_porch_lines_minus_1 + 1);
    pT->VSyncWidth  = (NvU16)(type2->vertical.sync_width_lines_minus_1 + 1);
    pT->VSyncPol    = type2->options.vsync_polarity ? NVT_V_SYNC_POSITIVE : NVT_V_SYNC_NEGATIVE;

    // the frame scanning type
    pT->interlaced = type2->options.interface_frame_scanning_type;

    // the refresh rate
    if (pT->interlaced)
    {
        // in interlaced mode, adjust for one extra line in every other frame. pT->VTotal is field based here
        totalPixels_in_2_fields = (NvU32)pT->HTotal * ((NvU32)pT->VTotal * 2 + 1);
        // calculate the field rate in interlaced mode
        pT->etc.rr = (NvU16)axb_div_c(pT->pclk * 2, 10000, totalPixels_in_2_fields);
        pT->etc.rrx1k = axb_div_c(pT->pclk * 2, 10000000, totalPixels_in_2_fields);
    }
    else
    {
        // calculate frame rate in progressive mode
        // in progressive mode filed = frame
        pT->etc.rr = (NvU16)axb_div_c(pT->pclk, 10000, (NvU32)pT->HTotal * (NvU32)pT->VTotal);
        pT->etc.rrx1k = axb_div_c(pT->pclk, 10000000, (NvU32)pT->HTotal * (NvU32)pT->VTotal);
    }

    pT->etc.aspect = 0;
    pT->etc.name[39] = '\0';
    pT->etc.rep = 0x1; // Bit mask for no pixel repetition
    
    pT->etc.status = NVT_STATUS_DISPLAYID_2;
    // Unlike the PTM in EDID base block, DisplayID type I/II preferred timing does not have dependency on sequence
    // so we'll just update the preferred flag, not sequence them
    //pT->etc.status = NVT_STATUS_DISPLAYID_1N(1);
    pT->etc.flag |= type2->options.is_preferred_detailed_timing ? NVT_FLAG_DISPLAYID_DTD_PREFERRED_TIMING : 0;
    
    /* Fields currently not used. Uncomment them for future use
    type1->options.stereo_support;
    */

    // the DisplayID spec covers the timing parameter(Visible/FrontPorch/SyncWidth/Total) range from 1~65536 while our NVT_TIMING structure which is mostly based on NvU16 only covers 0~65535
    nvt_assert(pT->HVisible != 0);
    nvt_assert(pT->HFrontPorch != 0);
    nvt_assert(pT->HSyncWidth != 0);
    nvt_assert(pT->VVisible != 0);
    nvt_assert(pT->VFrontPorch != 0);
    nvt_assert(pT->VSyncWidth != 0);

    // cover the possible overflow
    nvt_assert(pT->HTotal > pT->HVisible);
    nvt_assert(pT->VTotal > pT->VVisible);

    return NVT_STATUS_SUCCESS;
}

CODE_SEGMENT(PAGE_DD_CODE)
static NVT_STATUS parseDisplayIdTiming3Descriptor(DISPLAYID_TIMING_3_DESCRIPTOR * desc,
                                                  NVT_TIMING *pT)
{
    NvU8 formula, aspect;
    NvU32 horiz, vert, rr;
    NvU32 interlace;
    if (desc == NULL || pT == NULL)
        return NVT_STATUS_ERR;

    formula = DRF_VAL(T_DISPLAYID, _TIMING_3, _FORMULA, desc->optns);
    /* Fields currently not used, uncomment for use
    preferred = DRF_VAL(T_DISPLAYID, _TIMING, _PREFERRED, desc->optns);
    */
    aspect = DRF_VAL(T_DISPLAYID, _TIMING_3, _ASPECT_RATIO, desc->optns);
    interlace = DRF_VAL(T_DISPLAYID, _TIMING_3, _INTERLACE, desc->transfer) ? NVT_INTERLACED : NVT_PROGRESSIVE;
    rr = (NvU32)(DRF_VAL(T_DISPLAYID, _TIMING_3, _REFRESH_RATE, desc->transfer) + 1);

    horiz = (NvU32)((desc->horizontal_active_pixels + 1) << 3);

    switch (aspect)
    {
        case NVT_DISPLAYID_TIMING_3_ASPECT_RATIO_1_1:
            vert = horiz;
            break;
        case NVT_DISPLAYID_TIMING_3_ASPECT_RATIO_5_4:
            vert = horiz * 4 / 5;
            break;
        case NVT_DISPLAYID_TIMING_3_ASPECT_RATIO_4_3:
            vert = horiz * 3 / 4;
            break;
        case NVT_DISPLAYID_TIMING_3_ASPECT_RATIO_15_9:
            vert = horiz * 9 / 15;
            break;
        case NVT_DISPLAYID_TIMING_3_ASPECT_RATIO_16_9:
            vert = horiz * 9 / 16;
            break;
        case NVT_DISPLAYID_TIMING_3_ASPECT_RATIO_16_10:
            vert = horiz * 10 / 16;
            break;
        default:
            return NVT_STATUS_ERR;
    }

    switch (formula)
    {
        case NVT_DISPLAYID_TIMING_3_FORMULA_STANDARD:
            if (NvTiming_CalcCVT(horiz, vert, rr, interlace, pT) != NVT_STATUS_SUCCESS)
                return NVT_STATUS_ERR;
            break;
        case NVT_DISPLAYID_TIMING_3_FORMULA_REDUCED_BLANKING:
            if (NvTiming_CalcCVT_RB(horiz, vert, rr, interlace, pT) != NVT_STATUS_SUCCESS)
                return NVT_STATUS_ERR;
            break;
        default:
            return NVT_STATUS_ERR;
    }

    return NVT_STATUS_SUCCESS;
}

CODE_SEGMENT(PAGE_DD_CODE)
static NVT_STATUS parseDisplayIdTiming3(NvU8 * block, NVT_EDID_INFO *pEdidInfo)
{
    NvU16 i;
    DISPLAYID_TIMING_3_BLOCK * blk = (DISPLAYID_TIMING_3_BLOCK *)block;
    NVT_TIMING newTiming;

    if (blk->header.data_bytes % sizeof(DISPLAYID_TIMING_3_DESCRIPTOR) != 0)
    {
        // Assert since this error is ignored
        nvt_assert(0);
        return NVT_STATUS_ERR;
    }

    for (i = 0; i * sizeof(DISPLAYID_TIMING_3_DESCRIPTOR) < blk->header.data_bytes; i++)
    {
        NVMISC_MEMSET(&newTiming, 0, sizeof(newTiming));

        if (parseDisplayIdTiming3Descriptor(blk->descriptors + i,
                                            &newTiming) == NVT_STATUS_SUCCESS)
        {
            if (!assignNextAvailableTiming(pEdidInfo, &newTiming))
            {
                break;
            }
        }
    }
    return NVT_STATUS_SUCCESS;
}

CODE_SEGMENT(PAGE_DD_CODE)
static NVT_STATUS parseDisplayIdTiming4(NvU8 * block, NVT_EDID_INFO *pEdidInfo)
{
    NvU16 i;
    NVT_TIMING newTiming;
    DISPLAYID_TIMING_4_BLOCK * blk = (DISPLAYID_TIMING_4_BLOCK *)block;
    if (blk->header.data_bytes < 1 || blk->header.data_bytes > NVT_DISPLAYID_DATABLOCK_MAX_PAYLOAD_LEN)
    {
        // Assert since this error is ignored
        nvt_assert(0);
        return NVT_STATUS_ERR;
    }

    for (i = 0; i < blk->header.data_bytes; i++)
    {
        NVMISC_MEMSET(&newTiming, 0, sizeof(newTiming));

        if (NvTiming_EnumDMT((NvU32)(blk->timing_codes[i]),
                             &newTiming) == NVT_STATUS_SUCCESS)
        {
            if (!assignNextAvailableTiming(pEdidInfo, &newTiming))
            {
                break;
            }
        }
    }
    return NVT_STATUS_SUCCESS;
}

CODE_SEGMENT(PAGE_DD_CODE)
static NVT_STATUS parseDisplayIdTiming5Descriptor(DISPLAYID_TIMING_5_DESCRIPTOR * desc, NVT_TIMING *pT)
{
    NvU32 width, height, rr;
    NvBool is1000div1001 = NV_FALSE;
    
    // we don't handle stereo type nor custom reduced blanking yet
    //NvU8 stereoType, formula;
    //stereoType = (desc->optns & NVT_DISPLAYID_TIMING_5_STEREO_SUPPORT_MASK);
    //formula = desc->optns & NVT_DISPLAYID_TIMING_5_FORMULA_SUPPORT_MASK;
    
    if (desc->optns & NVT_DISPLAYID_TIMING_5_FRACTIONAL_RR_SUPPORT_MASK)
    {
        is1000div1001 = NV_TRUE;
    }
    width = ((desc->horizontal_active_pixels_high << 8) | desc->horizontal_active_pixels_low) + 1;
    height = ((desc->vertical_active_pixels_high << 8) | desc->vertical_active_pixels_low) + 1;
    rr = desc->refresh_rate + 1;
    return NvTiming_CalcCVT_RB2(width, height, rr, is1000div1001, pT);
}

CODE_SEGMENT(PAGE_DD_CODE)
static NVT_STATUS parseDisplayIdTiming5(NvU8 * block, NVT_EDID_INFO *pEdidInfo, NVT_DISPLAYID_INFO *pInfo)
{
    NvU16 i;
    NVT_TIMING newTiming;
    DISPLAYID_TIMING_5_BLOCK * blk = (DISPLAYID_TIMING_5_BLOCK *)block;
    if (blk->header.data_bytes < 1 || blk->header.data_bytes > NVT_DISPLAYID_DATABLOCK_MAX_PAYLOAD_LEN)
    {
        // Assert since this error is ignored
        nvt_assert(0);
        return NVT_STATUS_ERR;
    }
    for (i = 0; i * sizeof(DISPLAYID_TIMING_5_DESCRIPTOR) < blk->header.data_bytes; i++)
    {
        NVMISC_MEMSET(&newTiming, 0, sizeof(newTiming));
        
        if (parseDisplayIdTiming5Descriptor(blk->descriptors + i, &newTiming) == NVT_STATUS_SUCCESS)
        {
            if (!assignNextAvailableTiming(pEdidInfo, &newTiming))
            {
                 break;
            }
        }
    }
    return NVT_STATUS_SUCCESS;
}

CODE_SEGMENT(PAGE_DD_CODE)
static NVT_STATUS parseDisplayIdTimingVesa(NvU8 * block, NVT_EDID_INFO *pEdidInfo)
{
    NvU8 i, j;
    NVT_TIMING newTiming;
    DISPLAYID_TIMING_MODE_BLOCK * blk = (DISPLAYID_TIMING_MODE_BLOCK *)block;
    if (blk->header.data_bytes != DISPLAYID_TIMING_VESA_BLOCK_SIZE)
    {
        // Assert since this error is ignored
        nvt_assert(0);
        return NVT_STATUS_ERR;
    }

    for (i = 0; i < DISPLAYID_TIMING_VESA_BLOCK_SIZE; i++)
    {
        for (j = 0; j < 8; j++)
        {
            if (blk->timing_modes[i] & (1 << j))
            {
                NVMISC_MEMSET(&newTiming, 0, sizeof(newTiming));

                if (NvTiming_EnumDMT((NvU32)(i * 8 + j + 1),
                                     &newTiming) == NVT_STATUS_SUCCESS)
                {
                    if (!assignNextAvailableTiming(pEdidInfo, &newTiming))
                    {
                        break;
                    }
                }
            }
        }
    }
    return NVT_STATUS_SUCCESS;
}

CODE_SEGMENT(PAGE_DD_CODE)
static NVT_STATUS parseDisplayIdTimingEIA(NvU8 * block, NVT_EDID_INFO *pEdidInfo)
{
    NvU8 i, j;
    NVT_TIMING newTiming;
    DISPLAYID_TIMING_MODE_BLOCK * blk = (DISPLAYID_TIMING_MODE_BLOCK *)block;
    if (blk->header.data_bytes != DISPLAYID_TIMING_CEA_BLOCK_SIZE)
    {
        // Assert since this error is ignored
        nvt_assert(0);
        return NVT_STATUS_ERR;
    }

    for (i = 0; i < DISPLAYID_TIMING_CEA_BLOCK_SIZE; i++)
    {
        for (j = 0; j < 8; j++)
        {
            if (blk->timing_modes[i] & (1 << j))
            {
                NVMISC_MEMSET(&newTiming, 0, sizeof(newTiming));

                if (NvTiming_EnumCEA861bTiming((NvU32)(i * 8 + j + 1),
                                               &newTiming) == NVT_STATUS_SUCCESS)
                {
                    if (!assignNextAvailableTiming(pEdidInfo, &newTiming))
                    {
                        break;
                    }
                }
            }
        }
    }
    return NVT_STATUS_SUCCESS;
}

CODE_SEGMENT(PAGE_DD_CODE)
static NVT_STATUS parseDisplayIdRangeLimits(NvU8 * block, NVT_DISPLAYID_INFO *pInfo)
{
    NVT_DISPLAYID_RANGE_LIMITS * rl;
    DISPLAYID_RANGE_LIMITS_BLOCK * blk = (DISPLAYID_RANGE_LIMITS_BLOCK *)block;
    if ((blk->header.data_bytes != DISPLAYID_RANGE_LIMITS_BLOCK_LEN) ||
        (pInfo->rl_num >= NVT_DISPLAYID_RANGE_LIMITS_MAX_COUNT))
    {
        // Assert since this error is ignored
        nvt_assert(0);
        return NVT_STATUS_ERR;
    }

    rl = pInfo->range_limits + pInfo->rl_num;
    (pInfo->rl_num)++;
    
    rl->pclk_min  = blk->pixel_clock_min[0] | (blk->pixel_clock_min[1] << 8) | (blk->pixel_clock_min[2] << 16);
    rl->pclk_max = blk->pixel_clock_max[0] | (blk->pixel_clock_max[1] << 8) | (blk->pixel_clock_max[2] << 16);

    rl->interlaced = DRF_VAL(T_DISPLAYID, _RANGE_LIMITS, _INTERLACE, blk->optns);
    rl->cvt = DRF_VAL(T_DISPLAYID, _RANGE_LIMITS, _CVT_STANDARD, blk->optns);
    rl->cvt_reduced = DRF_VAL(T_DISPLAYID, _RANGE_LIMITS, _CVT_REDUCED, blk->optns);
    rl->dfd = DRF_VAL(T_DISPLAYID, _RANGE_LIMITS, _DFD, blk->optns);

    rl->hfreq_min = blk->horizontal_frequency_min;
    rl->hfreq_max = blk->horizontal_frequency_max;
    rl->hblank_min = blk->horizontal_blanking_min;
    rl->vfreq_min = blk->vertical_refresh_rate_min;
    rl->vfreq_max = blk->vertical_refresh_rate_max;
    rl->vblank_min = blk->vertical_blanking_min;

    return NVT_STATUS_SUCCESS;
}

CODE_SEGMENT(PAGE_DD_CODE)
static NVT_STATUS parseDisplayIdSerialNumber(NvU8 * block, NVT_DISPLAYID_INFO *pInfo)
{
    DISPLAYID_ASCII_STRING_BLOCK * blk = (DISPLAYID_ASCII_STRING_BLOCK *)block;
    if (blk->header.data_bytes > NVT_DISPLAYID_DATABLOCK_MAX_PAYLOAD_LEN)
    {
        // Assert since this error is ignored
        nvt_assert(0);
        return NVT_STATUS_ERR;
    }

    // Nothing is currently done to store any ASCII Serial Number, if it is
    // required. Code here may need to be modified sometime in the future, along
    // with NVT_DISPLAYID_INFO struct
    return NVT_STATUS_SUCCESS;
}

CODE_SEGMENT(PAGE_DD_CODE)
static NVT_STATUS parseDisplayIdAsciiString(NvU8 * block, NVT_DISPLAYID_INFO *pInfo)
{
    DISPLAYID_ASCII_STRING_BLOCK * blk = (DISPLAYID_ASCII_STRING_BLOCK *)block;
    if (blk->header.data_bytes > NVT_DISPLAYID_DATABLOCK_MAX_PAYLOAD_LEN)
    {
        // Assert since this error is ignored
        nvt_assert(0);
        return NVT_STATUS_ERR;
    }

    // Nothing is currently done to store any ASCII String Data, if it is
    // required. Code here may need to be modified sometime in the future, along
    // with NVT_DISPLAYID_INFO struct
    return NVT_STATUS_SUCCESS;
}

CODE_SEGMENT(PAGE_DD_CODE)
static NVT_STATUS parseDisplayIdDeviceData(NvU8 * block, NVT_DISPLAYID_INFO *pInfo)
{
    DISPLAYID_DEVICE_DATA_BLOCK * blk = (DISPLAYID_DEVICE_DATA_BLOCK *)block;
    if (blk->header.data_bytes != DISPLAYID_DEVICE_DATA_BLOCK_LEN)
    {
        // Assert since this error is ignored
        nvt_assert(0);
        return NVT_STATUS_ERR;
    }

    pInfo->tech_type = blk->technology;

    pInfo->device_op_mode = DRF_VAL(T_DISPLAYID, _DEVICE, _OPERATING_MODE, blk->operating_mode);
    pInfo->support_backlight = DRF_VAL(T_DISPLAYID, _DEVICE, _BACKLIGHT, blk->operating_mode);
    pInfo->support_intensity = DRF_VAL(T_DISPLAYID, _DEVICE, _INTENSITY, blk->operating_mode);
    
    pInfo->horiz_pixel_count = blk->horizontal_pixel_count;
    pInfo->vert_pixel_count = blk->vertical_pixel_count;

    pInfo->orientation = DRF_VAL(T_DISPLAYID, _DEVICE, _ORIENTATION, blk->orientation);
    pInfo->rotation = DRF_VAL(T_DISPLAYID, _DEVICE, _ROTATION, blk->orientation);
    pInfo->zero_pixel = DRF_VAL(T_DISPLAYID, _DEVICE, _ZERO_PIXEL, blk->orientation);
    pInfo->scan_direction = DRF_VAL(T_DISPLAYID, _DEVICE, _SCAN, blk->orientation);

    pInfo->subpixel_info = blk->subpixel_info;
    pInfo->horiz_pitch = blk->horizontal_pitch;
    pInfo->vert_pitch = blk->vertical_pitch;

    pInfo->color_bit_depth = DRF_VAL(T_DISPLAYID, _DEVICE, _COLOR_DEPTH, blk->color_bit_depth);
    pInfo->white_to_black = DRF_VAL(T_DISPLAYID, _DEVICE, _WHITE_BLACK, blk->response_time);
    pInfo->response_time = DRF_VAL(T_DISPLAYID, _DEVICE, _RESPONSE_TIME, blk->response_time);

    return NVT_STATUS_SUCCESS;
}

CODE_SEGMENT(PAGE_DD_CODE)
static NVT_STATUS parseDisplayIdInterfacePower(NvU8 * block, NVT_DISPLAYID_INFO *pInfo)
{
    DISPLAYID_INTERFACE_POWER_BLOCK * blk = (DISPLAYID_INTERFACE_POWER_BLOCK *)block;
    if (blk->header.data_bytes != DISPLAYID_INTERFACE_POWER_BLOCK_LEN)
    {
        // Assert since this error is ignored
        nvt_assert(0);
        return NVT_STATUS_ERR;
    }

    // Note specifically that the data inside T1/T2 variables are the exact
    // interface power data. the millisecond increments are dependent on the
    // DisplayID specification.
    pInfo->t1_min = DRF_VAL(T_DISPLAYID, _POWER, _T1_MIN, blk->power_sequence_T1);
    pInfo->t1_max = DRF_VAL(T_DISPLAYID, _POWER, _T1_MAX, blk->power_sequence_T1);
    pInfo->t2_max = DRF_VAL(T_DISPLAYID, _POWER, _T2, blk->power_sequence_T2);
    pInfo->t3_max = DRF_VAL(T_DISPLAYID, _POWER, _T3, blk->power_sequence_T3);
    pInfo->t4_min = DRF_VAL(T_DISPLAYID, _POWER, _T4_MIN, blk->power_sequence_T4_min);
    pInfo->t5_min = DRF_VAL(T_DISPLAYID, _POWER, _T5_MIN, blk->power_sequence_T5_min);
    pInfo->t6_min = DRF_VAL(T_DISPLAYID, _POWER, _T6_MIN, blk->power_sequence_T6_min);

    return NVT_STATUS_SUCCESS;
}

CODE_SEGMENT(PAGE_DD_CODE)
static NVT_STATUS parseDisplayIdTransferChar(NvU8 * block, NVT_DISPLAYID_INFO *pInfo)
{
    // Transfer Characteristics are currently not supported, but parsing of the
    // block should be added in the future when more specifications on monitors
    // that require this information is located here.
    return NVT_STATUS_SUCCESS;
}

CODE_SEGMENT(PAGE_DD_CODE)
static NVT_STATUS parseDisplayIdDisplayInterface(NvU8 * block, NVT_DISPLAYID_INFO *pInfo)
{
    DISPLAYID_INTERFACE_DATA_BLOCK * blk = (DISPLAYID_INTERFACE_DATA_BLOCK *)block;
    if (blk->header.data_bytes != DISPLAYID_INTERFACE_DATA_BLOCK_LEN)
    {
        // Assert since this error is ignored
        nvt_assert(0);
        return NVT_STATUS_ERR;
    }
    pInfo->supported_displayId2_0 = 0;

    // Type/Link Info
    pInfo->u4.display_interface.interface_type = DRF_VAL(T_DISPLAYID, _INTERFACE, _TYPE, blk->info);
    pInfo->u4.display_interface.u1.digital_num_links = DRF_VAL(T_DISPLAYID, _INTERFACE, _NUMLINKS, blk->info);
    pInfo->u4.display_interface.interface_version = blk->version;

    // Color Depths
    pInfo->u4.display_interface.rgb_depth.support_16b = DRF_VAL(T_DISPLAYID, _INTERFACE, _RGB16, blk->color_depth_rgb);
    pInfo->u4.display_interface.rgb_depth.support_14b = DRF_VAL(T_DISPLAYID, _INTERFACE, _RGB14, blk->color_depth_rgb);
    pInfo->u4.display_interface.rgb_depth.support_12b = DRF_VAL(T_DISPLAYID, _INTERFACE, _RGB12, blk->color_depth_rgb);
    pInfo->u4.display_interface.rgb_depth.support_10b = DRF_VAL(T_DISPLAYID, _INTERFACE, _RGB10, blk->color_depth_rgb);
    pInfo->u4.display_interface.rgb_depth.support_8b = DRF_VAL(T_DISPLAYID, _INTERFACE, _RGB8, blk->color_depth_rgb);
    pInfo->u4.display_interface.rgb_depth.support_6b = DRF_VAL(T_DISPLAYID, _INTERFACE, _RGB6, blk->color_depth_rgb);
    pInfo->u4.display_interface.ycbcr444_depth.support_16b = DRF_VAL(T_DISPLAYID, _INTERFACE, _YCBCR444_16, blk->color_depth_ycbcr444);
    pInfo->u4.display_interface.ycbcr444_depth.support_14b = DRF_VAL(T_DISPLAYID, _INTERFACE, _YCBCR444_14, blk->color_depth_ycbcr444);
    pInfo->u4.display_interface.ycbcr444_depth.support_12b = DRF_VAL(T_DISPLAYID, _INTERFACE, _YCBCR444_12, blk->color_depth_ycbcr444);
    pInfo->u4.display_interface.ycbcr444_depth.support_10b = DRF_VAL(T_DISPLAYID, _INTERFACE, _YCBCR444_10, blk->color_depth_ycbcr444);
    pInfo->u4.display_interface.ycbcr444_depth.support_8b = DRF_VAL(T_DISPLAYID, _INTERFACE, _YCBCR444_8, blk->color_depth_ycbcr444);
    pInfo->u4.display_interface.ycbcr444_depth.support_6b = DRF_VAL(T_DISPLAYID, _INTERFACE, _YCBCR444_6, blk->color_depth_ycbcr444);
    pInfo->u4.display_interface.ycbcr422_depth.support_16b = DRF_VAL(T_DISPLAYID, _INTERFACE, _YCBCR422_16, blk->color_depth_ycbcr422);
    pInfo->u4.display_interface.ycbcr422_depth.support_14b = DRF_VAL(T_DISPLAYID, _INTERFACE, _YCBCR422_14, blk->color_depth_ycbcr422);
    pInfo->u4.display_interface.ycbcr422_depth.support_12b = DRF_VAL(T_DISPLAYID, _INTERFACE, _YCBCR422_12, blk->color_depth_ycbcr422);
    pInfo->u4.display_interface.ycbcr422_depth.support_10b = DRF_VAL(T_DISPLAYID, _INTERFACE, _YCBCR422_10, blk->color_depth_ycbcr422);
    pInfo->u4.display_interface.ycbcr422_depth.support_8b = DRF_VAL(T_DISPLAYID, _INTERFACE, _YCBCR422_8, blk->color_depth_ycbcr422);

    // Content Protection
    pInfo->u4.display_interface.content_protection = DRF_VAL(T_DISPLAYID, _INTERFACE, _CONTENT, blk->content_protection);
    pInfo->u4.display_interface.content_protection_version = blk->content_protection_version;
    
    // Spread
    pInfo->u4.display_interface.spread_spectrum = DRF_VAL(T_DISPLAYID, _INTERFACE, _SPREAD_TYPE, blk->spread);
    pInfo->u4.display_interface.spread_percent = DRF_VAL(T_DISPLAYID, _INTERFACE, _SPREAD_PER, blk->spread);

    // Proprietary Information
    switch (pInfo->u4.display_interface.interface_type)
    {
        case NVT_DISPLAYID_INTERFACE_TYPE_LVDS:
            pInfo->u2.lvds.color_map = DRF_VAL(T_DISPLAYID, _LVDS, _COLOR, blk->interface_attribute_1);
            pInfo->u2.lvds.support_2_8v = DRF_VAL(T_DISPLAYID, _LVDS, _2_8, blk->interface_attribute_1);
            pInfo->u2.lvds.support_12v = DRF_VAL(T_DISPLAYID, _LVDS, _12, blk->interface_attribute_1);
            pInfo->u2.lvds.support_5v = DRF_VAL(T_DISPLAYID, _LVDS, _5, blk->interface_attribute_1);
            pInfo->u2.lvds.support_3_3v = DRF_VAL(T_DISPLAYID, _LVDS, _3_3, blk->interface_attribute_1);
            pInfo->u2.lvds.DE_mode = DRF_VAL(T_DISPLAYID, _INTERFACE, _DE, blk->interface_attribute_2);
            pInfo->u2.lvds.polarity = DRF_VAL(T_DISPLAYID, _INTERFACE, _POLARITY, blk->interface_attribute_2);
            pInfo->u2.lvds.data_strobe = DRF_VAL(T_DISPLAYID, _INTERFACE, _STROBE, blk->interface_attribute_2);
            break;
        case NVT_DISPLAYID_INTERFACE_TYPE_PROPRIETARY:
            pInfo->u2.proprietary.DE_mode = DRF_VAL(T_DISPLAYID, _INTERFACE, _DE, blk->interface_attribute_1);
            pInfo->u2.proprietary.polarity = DRF_VAL(T_DISPLAYID, _INTERFACE, _POLARITY, blk->interface_attribute_1);
            pInfo->u2.proprietary.data_strobe = DRF_VAL(T_DISPLAYID, _INTERFACE, _STROBE, blk->interface_attribute_1);
            break;
        default:
            break;
    }
    return NVT_STATUS_SUCCESS;
}

CODE_SEGMENT(PAGE_DD_CODE)
static NVT_STATUS parseDisplayIdStereo(NvU8 * block, NVT_DISPLAYID_INFO *pInfo)
{
    NvU8 * sub;

    DISPLAYID_STEREO_INTERFACE_METHOD_BLOCK * blk = (DISPLAYID_STEREO_INTERFACE_METHOD_BLOCK *)block;
    if (blk->header.data_bytes > NVT_DISPLAYID_DATABLOCK_MAX_PAYLOAD_LEN)
    {
        // Assert since this error is ignored
        nvt_assert(0);
        return NVT_STATUS_ERR;
    }

    sub = blk->timing_sub_block;

    pInfo->stereo_code = blk->stereo_code;
    switch (blk->stereo_code)
    {
        case NVT_DISPLAYID_STEREO_FIELD_SEQUENTIAL:
            pInfo->u3.field_sequential.stereo_polarity = sub[0];
            break;
        case NVT_DISPLAYID_STEREO_SIDE_BY_SIDE:
            pInfo->u3.side_by_side.view_identity = sub[0];
            break;
        case NVT_DISPLAYID_STEREO_PIXEL_INTERLEAVED:
            NVMISC_MEMCPY(pInfo->u3.pixel_interleaved.interleave_pattern, sub, 8);
            break;
        case NVT_DISPLAYID_STEREO_DUAL_INTERFACE:
            pInfo->u3.left_right_separate.mirroring = DRF_VAL(T_DISPLAYID, _STEREO, _MIRRORING, sub[0]);
            pInfo->u3.left_right_separate.polarity = DRF_VAL(T_DISPLAYID, _STEREO, _POLARITY, sub[0]);
            break;
        case NVT_DISPLAYID_STEREO_MULTIVIEW:
            pInfo->u3.multiview.num_views = sub[0];
            pInfo->u3.multiview.code = sub[1];
            break;
        case NVT_DISPLAYID_STEREO_PROPRIETARY:
            break;
        default:
            // Assert since this error is ignored
            nvt_assert(0);
            return NVT_STATUS_ERR;
    }
    
    return NVT_STATUS_SUCCESS;
}

CODE_SEGMENT(PAGE_DD_CODE)
static NVT_STATUS parseDisplayIdTiledDisplay(NvU8 * block, NVT_DISPLAYID_INFO *pInfo)
{
    DISPLAYID_TILED_DISPLAY_BLOCK * blk = (DISPLAYID_TILED_DISPLAY_BLOCK *)block;
    if (blk->header.data_bytes > NVT_DISPLAYID_DATABLOCK_MAX_PAYLOAD_LEN)
    {
        // Assert since this error is ignored
        nvt_assert(0);
        return NVT_STATUS_ERR;
    }

    // For revision 0, we only allow one tiled display data block.
    if (!blk->header.revision && pInfo->tile_topology_id.vendor_id)
        return NVT_STATUS_SUCCESS;

    pInfo->tiled_display_revision           = blk->header.revision;

    pInfo->tile_capability.bSingleEnclosure     = blk->capability.single_enclosure;
    pInfo->tile_capability.bHasBezelInfo        = blk->capability.has_bezel_info;
    pInfo->tile_capability.multi_tile_behavior  = blk->capability.multi_tile_behavior;
    pInfo->tile_capability.single_tile_behavior = blk->capability.single_tile_behavior;

    pInfo->tile_topology.row                = ((blk->topo_loc_high.row << 5) | blk->topology_low.row) + 1;
    pInfo->tile_topology.col                = ((blk->topo_loc_high.col << 5) | blk->topology_low.col) + 1;

    pInfo->tile_location.x                  = (blk->topo_loc_high.x << 5) | blk->location_low.x;
    pInfo->tile_location.y                  = (blk->topo_loc_high.y << 5) | blk->location_low.y;

    pInfo->native_resolution.width          = ((blk->native_resolution.width_high<<8)|blk->native_resolution.width_low) + 1;
    pInfo->native_resolution.height         = ((blk->native_resolution.height_high<<8)|blk->native_resolution.height_low) + 1;

    pInfo->bezel_info.pixel_density         = blk->bezel_info.pixel_density;
    pInfo->bezel_info.top                   = (blk->bezel_info.top * blk->bezel_info.pixel_density) / 10;
    pInfo->bezel_info.bottom                = (blk->bezel_info.bottom * blk->bezel_info.pixel_density) / 10;
    pInfo->bezel_info.right                 = (blk->bezel_info.right * blk->bezel_info.pixel_density) / 10;
    pInfo->bezel_info.left                  = (blk->bezel_info.left * blk->bezel_info.pixel_density) / 10;

    pInfo->tile_topology_id.vendor_id       = (blk->topology_id.vendor_id[2] << 16) |
                                              (blk->topology_id.vendor_id[1] << 8 ) | 
                                              blk->topology_id.vendor_id[0];

    pInfo->tile_topology_id.product_id      = (blk->topology_id.product_id[1] << 8) | blk->topology_id.product_id[0];

    pInfo->tile_topology_id.serial_number   = (blk->topology_id.serial_number[3] << 24) |
                                              (blk->topology_id.serial_number[2] << 16) |
                                              (blk->topology_id.serial_number[1] << 8 ) |
                                              blk->topology_id.serial_number[0];

    return NVT_STATUS_SUCCESS;
}

CODE_SEGMENT(PAGE_DD_CODE)
static NVT_STATUS parseDisplayIdCtaData(NvU8 * block, NVT_EDID_INFO *pInfo, NVT_DISPLAYID_INFO *pDisplayIdInfo)
{
    DISPLAYID_DATA_BLOCK_HEADER * blk = (DISPLAYID_DATA_BLOCK_HEADER*)block;
    NVT_EDID_CEA861_INFO *p861info = &pInfo->ext861;
    if (blk->data_bytes > NVT_DISPLAYID_DATABLOCK_MAX_PAYLOAD_LEN)
    {
        // Assert since this error is ignored
        nvt_assert(0);
        return NVT_STATUS_ERR;
    }
    pDisplayIdInfo->cea_data_block_present = 1;
    p861info->revision = blk->revision;

    //parse CEA tags which starts at 3rd byte from block
    parseCta861DataBlockInfo(&block[3], blk->data_bytes, p861info);

    // update pInfo with basic hdmi info
    // assumes each edid will only have one such block across multiple cta861 blocks (otherwise may create declaration conflict)
    // in case of multiple such blocks, the last one takes precedence
    parseCta861VsdbBlocks(p861info, pInfo, FROM_DISPLAYID_13_DATA_BLOCK);

    parseCta861HfScdb(p861info, pInfo, FROM_DISPLAYID_13_DATA_BLOCK);

    //parse HDR related information from the HDR static metadata data block
    parseCea861HdrStaticMetadataDataBlock(p861info, pInfo, FROM_DISPLAYID_13_DATA_BLOCK);
    
    // base video
    parse861bShortTiming(p861info, pInfo, FROM_DISPLAYID_13_DATA_BLOCK);
    // yuv420-only video
    parse861bShortYuv420Timing(p861info, pInfo, FROM_DISPLAYID_13_DATA_BLOCK);
    // CEA861-F at 7.5.12 section about VFPDB block.
    if (p861info->total_vfpdb != 0)
    {
        parse861bShortPreferredTiming(p861info, pInfo, FROM_DISPLAYID_13_DATA_BLOCK);
    }

    return NVT_STATUS_SUCCESS;
}

CODE_SEGMENT(PAGE_DD_CODE)
static NVT_STATUS parseDisplayIdDisplayInterfaceFeatures(NvU8 * block, NVT_DISPLAYID_INFO *pInfo)
{
    NvU8 i;
    DISPLAYID_INTERFACE_FEATURES_DATA_BLOCK * blk = (DISPLAYID_INTERFACE_FEATURES_DATA_BLOCK *)block;
    if (blk->header.data_bytes > DISPLAYID_INTERFACE_FEATURES_DATA_BLOCK_MAX_LEN)
    {
        // Assert since this error is ignored
        nvt_assert(0);
        return NVT_STATUS_ERR;
    }
    pInfo->supported_displayId2_0 = 1;

    // Color Depths
    pInfo->u4.display_interface_features.rgb_depth.support_16b = DRF_VAL(T_DISPLAYID, _INTERFACE_FEATURES, _RGB16, blk->supported_color_depth_rgb);
    pInfo->u4.display_interface_features.rgb_depth.support_14b = DRF_VAL(T_DISPLAYID, _INTERFACE_FEATURES, _RGB14, blk->supported_color_depth_rgb);
    pInfo->u4.display_interface_features.rgb_depth.support_12b = DRF_VAL(T_DISPLAYID, _INTERFACE_FEATURES, _RGB12, blk->supported_color_depth_rgb);
    pInfo->u4.display_interface_features.rgb_depth.support_10b = DRF_VAL(T_DISPLAYID, _INTERFACE_FEATURES, _RGB10, blk->supported_color_depth_rgb);
    pInfo->u4.display_interface_features.rgb_depth.support_8b = DRF_VAL(T_DISPLAYID, _INTERFACE_FEATURES, _RGB8, blk->supported_color_depth_rgb);
    pInfo->u4.display_interface_features.rgb_depth.support_6b = DRF_VAL(T_DISPLAYID, _INTERFACE_FEATURES, _RGB6, blk->supported_color_depth_rgb);
    pInfo->u4.display_interface_features.ycbcr444_depth.support_16b = DRF_VAL(T_DISPLAYID, _INTERFACE_FEATURES, _YCBCR444_16, blk->supported_color_depth_ycbcr444);
    pInfo->u4.display_interface_features.ycbcr444_depth.support_14b = DRF_VAL(T_DISPLAYID, _INTERFACE_FEATURES, _YCBCR444_14, blk->supported_color_depth_ycbcr444);
    pInfo->u4.display_interface_features.ycbcr444_depth.support_12b = DRF_VAL(T_DISPLAYID, _INTERFACE_FEATURES, _YCBCR444_12, blk->supported_color_depth_ycbcr444);
    pInfo->u4.display_interface_features.ycbcr444_depth.support_10b = DRF_VAL(T_DISPLAYID, _INTERFACE_FEATURES, _YCBCR444_10, blk->supported_color_depth_ycbcr444);
    pInfo->u4.display_interface_features.ycbcr444_depth.support_8b = DRF_VAL(T_DISPLAYID, _INTERFACE_FEATURES, _YCBCR444_8, blk->supported_color_depth_ycbcr444);
    pInfo->u4.display_interface_features.ycbcr444_depth.support_6b = DRF_VAL(T_DISPLAYID, _INTERFACE_FEATURES, _YCBCR444_6, blk->supported_color_depth_ycbcr444);
    pInfo->u4.display_interface_features.ycbcr422_depth.support_16b = DRF_VAL(T_DISPLAYID, _INTERFACE_FEATURES, _YCBCR422_16, blk->supported_color_depth_ycbcr422);
    pInfo->u4.display_interface_features.ycbcr422_depth.support_14b = DRF_VAL(T_DISPLAYID, _INTERFACE_FEATURES, _YCBCR422_14, blk->supported_color_depth_ycbcr422);
    pInfo->u4.display_interface_features.ycbcr422_depth.support_12b = DRF_VAL(T_DISPLAYID, _INTERFACE_FEATURES, _YCBCR422_12, blk->supported_color_depth_ycbcr422);
    pInfo->u4.display_interface_features.ycbcr422_depth.support_10b = DRF_VAL(T_DISPLAYID, _INTERFACE_FEATURES, _YCBCR422_10, blk->supported_color_depth_ycbcr422);
    pInfo->u4.display_interface_features.ycbcr422_depth.support_8b = DRF_VAL(T_DISPLAYID, _INTERFACE_FEATURES, _YCBCR422_8, blk->supported_color_depth_ycbcr422);
    pInfo->u4.display_interface_features.ycbcr420_depth.support_16b = DRF_VAL(T_DISPLAYID, _INTERFACE_FEATURES, _YCBCR420_16, blk->supported_color_depth_ycbcr420);
    pInfo->u4.display_interface_features.ycbcr420_depth.support_14b = DRF_VAL(T_DISPLAYID, _INTERFACE_FEATURES, _YCBCR420_14, blk->supported_color_depth_ycbcr420);
    pInfo->u4.display_interface_features.ycbcr420_depth.support_12b = DRF_VAL(T_DISPLAYID, _INTERFACE_FEATURES, _YCBCR420_12, blk->supported_color_depth_ycbcr420);
    pInfo->u4.display_interface_features.ycbcr420_depth.support_10b = DRF_VAL(T_DISPLAYID, _INTERFACE_FEATURES, _YCBCR420_10, blk->supported_color_depth_ycbcr420);
    pInfo->u4.display_interface_features.ycbcr420_depth.support_8b = DRF_VAL(T_DISPLAYID, _INTERFACE_FEATURES, _YCBCR420_8, blk->supported_color_depth_ycbcr420);

    // Minimum Pixel Rate at Which YCbCr 4:2:0 Encoding Is Supported
    pInfo->u4.display_interface_features.minimum_pixel_rate_ycbcr420 = blk->minimum_pixel_rate_ycbcr420;
    
    // Audio capability
    pInfo->u4.display_interface_features.audio_capability.support_32khz = DRF_VAL(T_DISPLAYID, _INTERFACE_FEATURES, _AUDIO_SUPPORTED_32KHZ, blk->supported_audio_capability);
    pInfo->u4.display_interface_features.audio_capability.support_44_1khz = DRF_VAL(T_DISPLAYID, _INTERFACE_FEATURES, _AUDIO_SUPPORTED_44_1KHZ, blk->supported_audio_capability);
    pInfo->u4.display_interface_features.audio_capability.support_48khz = DRF_VAL(T_DISPLAYID, _INTERFACE_FEATURES, _AUDIO_SUPPORTED_48KHZ, blk->supported_audio_capability);

    // Colorspace and EOTF combination
    pInfo->u4.display_interface_features.colorspace_eotf_combination_1.support_colorspace_bt2020_eotf_smpte_st2084 = DRF_VAL(T_DISPLAYID, _INTERFACE_FEATURES, _COLORSPACE_BT2020_EOTF_SMPTE_ST2084, blk->supported_colorspace_eotf_combination_1);
    pInfo->u4.display_interface_features.colorspace_eotf_combination_1.support_colorspace_bt2020_eotf_bt2020 = DRF_VAL(T_DISPLAYID, _INTERFACE_FEATURES, _COLORSPACE_BT2020_EOTF_BT2020, blk->supported_colorspace_eotf_combination_1);
    pInfo->u4.display_interface_features.colorspace_eotf_combination_1.support_colorspace_dci_p3_eotf_dci_p3 = DRF_VAL(T_DISPLAYID, _INTERFACE_FEATURES, _COLORSPACE_DCI_P3_EOTF_DCI_P3, blk->supported_colorspace_eotf_combination_1);
    pInfo->u4.display_interface_features.colorspace_eotf_combination_1.support_colorspace_adobe_rgb_eotf_adobe_rgb = DRF_VAL(T_DISPLAYID, _INTERFACE_FEATURES, _COLORSPACE_ADOBE_RGB_EOTF_ADOBE_RGB, blk->supported_colorspace_eotf_combination_1);
    pInfo->u4.display_interface_features.colorspace_eotf_combination_1.support_colorspace_bt709_eotf_bt1886 = DRF_VAL(T_DISPLAYID, _INTERFACE_FEATURES, _COLORSPACE_BT709_EOTF_BT1886, blk->supported_colorspace_eotf_combination_1);
    pInfo->u4.display_interface_features.colorspace_eotf_combination_1.support_colorspace_bt601_eotf_bt601 = DRF_VAL(T_DISPLAYID, _INTERFACE_FEATURES, _COLORSPACE_BT601_EOTF_BT601, blk->supported_colorspace_eotf_combination_1);
    pInfo->u4.display_interface_features.colorspace_eotf_combination_1.support_colorspace_srgb_eotf_srgb = DRF_VAL(T_DISPLAYID, _INTERFACE_FEATURES, _COLORSPACE_SRGB_EOTF_SRGB, blk->supported_colorspace_eotf_combination_1);

    // Additional support Colorspace and EOTF
    pInfo->u4.display_interface_features.total_additional_colorspace_eotf.total = DRF_VAL(T_DISPLAYID, _INTERFACE_FEATURES, _ADDITIONAL_SUPPORTED_COLORSPACE_EOTF_TOTAL, blk->additional_supported_colorspace_eotf_total);

    for (i = 0; i < pInfo->u4.display_interface_features.total_additional_colorspace_eotf.total; i++)
    {
        pInfo->u4.display_interface_features.additional_colorspace_eotf[i].support_colorspace = DRF_VAL(T_DISPLAYID, _INTERFACE_FEATURES, _ADDITIONAL_SUPPORTED_COLORSPACE, blk->additional_supported_colorspace_eotf[i]);
        pInfo->u4.display_interface_features.additional_colorspace_eotf[i].support_eotf = DRF_VAL(T_DISPLAYID, _INTERFACE_FEATURES, _ADDITIONAL_SUPPORTED_EOTF, blk->additional_supported_colorspace_eotf[i]);

    }
    return NVT_STATUS_SUCCESS;
}


POP_SEGMENTS
