/** @file Edid.c
 * @brief Reads and parses the EDID, checks if a requested video mode is in the supplied EDID
 *
 * Copyright (c) 2018-2019, DisplayLink (UK) Ltd. All rights reserved.
 *
 * SPDX-License-Identifier: BSD-2-Clause-Patent
 *
**/

#include "UsbDisplayLink.h"
#include "Edid.h"

CONST UINT8 ExpectedEdidHeader[EDID_HEADER_SIZE] = { 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00 };

//
// Standard timing defined by VESA EDID
//
CONST EDID_TIMING EstablishedTimings[EDID_NUMBER_OF_ESTABLISHED_TIMINGS_BYTES][8] = {
  //
  // Established Timing I
  //
  {
    { 800, 600, 60 },
    { 800, 600, 56 },
    { 640, 480, 75 },
    { 640, 480, 72 },
    { 640, 480, 67 },
    { 640, 480, 60 },
    { 720, 400, 88 },
    { 720, 400, 70 },
  },
  {
    //
    // Established Timing II
    //
    { 1280, 1024, 75 },
    { 1024,  768, 75 },
    { 1024,  768, 70 },
    { 1024,  768, 60 },
    { 1024,  768, 87 },
    { 832,   624, 75 },
    { 800,   600, 75 },
    { 800,   600, 72 },
  },
  //
  // Established Timing III
  //
  {
    { 1152, 870, 75 },
    { 0, 0, 0 },
    { 0, 0, 0 },
    { 0, 0, 0 },
    { 0, 0, 0 },
    { 0, 0, 0 },
    { 0, 0, 0 },
    { 0, 0, 0 },
  }
};

/**
 * Requests the monitor EDID data from the connected DisplayLink device
 * @param UsbDisplayLinkDev
 * @param EdidDataBlock
 * @param EdidSize
 * @retval EFI_DEVICE_ERROR - No EDID received, or EDID is corrupted
 * @retval EFI_OUT_OF_RESOURCES - Cannot allocate memory
 * @retval EFI_SUCCESS
 *
 */
STATIC EFI_STATUS
ReadEdidData (
  IN USB_DISPLAYLINK_DEV      *UsbDisplayLinkDev,
  OUT UINT8                    **EdidDataBlock,
  OUT UINTN                    *EdidSize
)
{
  EFI_STATUS Status;

  UINT8 EdidDataRead[EDID_BLOCK_SIZE];
  UINT8 *EdidData = EdidDataRead;
  UINT8* ValidEdid;

  Status = DlUsbSendControlReadMessage (UsbDisplayLinkDev, GET_OUTPUT_EDID, 0, EdidDataRead, sizeof (EdidDataRead));

  if (EFI_ERROR (Status) || (EdidData[0] != 0)) {
    DEBUG ((DEBUG_ERROR, "No monitor EDID received from DisplayLink device - System error %r, EDID error %d. Monitor connected correctly?\n", Status, EdidData[0]));
    return EFI_DEVICE_ERROR;
  } else {
    //
    // Search for the EDID signature
    //
    ValidEdid = &EdidData[0];
    CONST UINT64 Signature = 0x00ffffffffffff00ull;
    if (CompareMem (ValidEdid, &Signature, 8) != 0) {
      //
      // No EDID signature found
      //
      DEBUG ((DEBUG_ERROR, "Monitor EDID received from DisplayLink device did not have a valid signature - corrupted?\n"));
      Status = EFI_DEVICE_ERROR;
      return Status;
    }
  }

  *EdidDataBlock = (UINT8*)AllocateCopyPool (
    EDID_BLOCK_SIZE,
    ValidEdid);

  if (*EdidDataBlock == NULL) {
    return EFI_OUT_OF_RESOURCES;
  }

  //
  // Currently only support EDID 1.x
  //
  *EdidSize = EDID_BLOCK_SIZE;

  return EFI_SUCCESS;
}


/**
Calculates the mod256 checksum of the EDID and compares it with the one supplied at the end of the EDID
@param  EDID        Pointer to the 128-byte EDID
@retval TRUE        The EDID checksum is correct
**/
BOOLEAN
IsEdidChecksumCorrect (
    CONST VOID *EDID
    )
{
  CONST UINT8 EdidChecksum = ((UINT8 *)EDID)[EDID_BLOCK_SIZE - 1];
  UINT8 CalculatedChecksum;

  CalculatedChecksum = 0;

  UINTN i;
  for (i = 0; i < EDID_BLOCK_SIZE - 1; i++) {
    CalculatedChecksum += ((UINT8 *)EDID)[i];
  }
  CalculatedChecksum = 0 - CalculatedChecksum;

  return (CalculatedChecksum == EdidChecksum);
}

/**
Check if a particular video mode is in the Established Timings section of the EDID.

@param  EDID        Pointer to the 128-byte EDID
@param  hRes        Horizontal resolution
@param  vRes        Vertical resolution
@param  refresh     Refresh rate
@retval TRUE        The requested mode is present in the Established Timings section

**/
STATIC BOOLEAN
IsModeInEstablishedTimings (
    IN CONST VOID *EDID,
    IN UINT16 HRes,
    IN UINT16 VRes,
    IN UINT16 Refresh
    )
{
  CONST struct Edid *pEDID = (CONST struct Edid *)EDID;
  BOOLEAN ModeSupported;

  ModeSupported = FALSE;

  int EstByteNum;
  int BitNum;
  for (EstByteNum = 0; EstByteNum < EDID_NUMBER_OF_ESTABLISHED_TIMINGS_BYTES; EstByteNum++) {
    for (BitNum = 0; BitNum < 8; BitNum++) {
      if (pEDID->EstablishedTimings[EstByteNum] & (1 << BitNum)) { // The bit is set in the established timings of the EDID

        if ((EstablishedTimings[EstByteNum][BitNum].HRes == HRes) && // The passed-in resolution matches the resolution represented by the set bit
          (EstablishedTimings[EstByteNum][BitNum].VRes == VRes) &&
          (EstablishedTimings[EstByteNum][BitNum].Refresh == Refresh)) {

          ModeSupported = TRUE;
          break;
        }
      }
    }
    if (ModeSupported == TRUE) {
      break;
    }
  }
  return ModeSupported;
}

/**
Extract the resolutions and refresh rate from one of the entries in the Standard Timings section of the EDID.

@param  EDID          Pointer to the 128-byte EDID
@param  timingNumber  The entry that we want to extract
@param  hRes          Output - Horizontal resolution
@param  vRes          Output - Vertical resolution
@param  refresh       Output - Refresh rate
@retval TRUE          The requested Standard Timings entry contains valid data

**/
STATIC BOOLEAN ReadStandardTiming (
  CONST VOID *EDID,
  IN UINT8 TimingNumber,
  OUT UINT16 *HRes,
  OUT UINT16 *VRes,
  OUT UINT8 *Refresh)
{
  CONST struct Edid *pEDID = (CONST struct Edid *)EDID;

  // See section 3.9.1 of the VESA EDID spec

  if (((pEDID->standardTimingIdentifications[TimingNumber].HorizontalActivePixels) == 0x01) &&
    (pEDID->standardTimingIdentifications[TimingNumber].ImageAspectRatioAndrefresh) == 0x01) {
    *HRes = 0;
    *VRes = 0;
    *Refresh = 0;
    return FALSE;
  }
  *HRes = (pEDID->standardTimingIdentifications[TimingNumber].HorizontalActivePixels + 31) * 8;

  UINT8 AspectRatio;
  AspectRatio = (pEDID->standardTimingIdentifications[TimingNumber].ImageAspectRatioAndrefresh >> 6) & 0x3;

  switch (AspectRatio) {
  case 0: *VRes = (*HRes * 10) / 16;
    break;
  case 1: *VRes = (*HRes * 3) / 4;
    break;
  case 2: *VRes = (*HRes * 4) / 5;
    break;
  case 3: *VRes = (*HRes * 9) / 16;
    break;
  default: break;
  }

  // WORKAROUND - 1360x768 is not a perfect aspect ratio
  if ((*HRes == 1360) && (*VRes == 765)) {
    *VRes = 768;
  }

  *Refresh = (pEDID->standardTimingIdentifications[TimingNumber].ImageAspectRatioAndrefresh & 0x1F) + 60;

  return TRUE;
}

/**
Extract the resolutions and refresh rate from one of the entries in the Detailed Timings section of the EDID.

@param  EDID          Pointer to the 128-byte EDID
@param  timingNumber  The entry that we want to extract
@param  videoMode     Output - Filled in with details from the detailed timing
@retval TRUE          The requested Detailed Timings entry contains valid data

**/
STATIC BOOLEAN
ReadDetailedTiming (
  IN CONST VOID *EDID,
  IN UINT8 TimingNumber,
  OUT struct VideoMode *VideoMode
  )
{
  if (TimingNumber >= EDID_NUMBER_OF_DETAILED_TIMINGS) {
    return FALSE;
  }

  UINT16 NumValidDetailedTimingsFound;
  NumValidDetailedTimingsFound = 0;

  // Spin through the detailed timings until we find a valid one - then check if this has the index that we want
  int BlockNumber;
  for (BlockNumber = 0; BlockNumber < EDID_NUMBER_OF_DETAILED_TIMINGS; BlockNumber++) {
    CONST struct Edid *pEDID = (CONST struct Edid *)EDID;
    CONST struct DetailedTimingIdentification *pTiming = &pEDID->detailedTimingDescriptions[BlockNumber];

    if (((BlockNumber == 0) && (pTiming->PixelClock == EDID_DETAILED_TIMING_INVALID_PIXEL_CLOCK)) ||
      (pTiming->PixelClock == 0)) {
      // This is not a valid detailed timing descriptor
      continue;
    }

    if ((pTiming->Features & EdidDetailedTimingsFeaturesSyncSchemeMask) != EdidDetailedTimingsFeaturesSyncSchemeMask) {
      DEBUG ((DEBUG_INFO, "EDID detailed timing with unsupported sync scheme found - not processing.\n"));
      continue;
    }

    if ((pTiming->Features & EdidDetailedTimingsFeaturesStereoModeMask) != 0) {
      DEBUG ((DEBUG_INFO, "EDID detailed timing with unsupported stereo mode found - not processing.\n"));
      continue;
    }

    // We've found a supported detailed timing - now see if this is the requested one
    if (TimingNumber != NumValidDetailedTimingsFound) {
      NumValidDetailedTimingsFound++;
      continue;
    }

    ZeroMem ((VOID *)VideoMode, sizeof (struct VideoMode));

    // Bit manipulations copied from host software class EDIDTimingDescriptor

    VideoMode->PixelClock = (UINT16)pTiming->PixelClock;
    VideoMode->HActive = pTiming->HActiveLo + ((pTiming->HActiveHiBlankingHi & 0xF0) << 4);
    VideoMode->VActive = pTiming->VActiveLo + ((pTiming->VActiveHiBlankingHi & 0xF0) << 4);

    VideoMode->HBlanking = pTiming->HBlankingLo + ((pTiming->HActiveHiBlankingHi & 0x0F) << 8);
    VideoMode->VBlanking = pTiming->VBlankingLo + ((pTiming->VActiveHiBlankingHi & 0x0F) << 8);

    VideoMode->HSyncOffset = pTiming->HSyncOffsetLo + ((pTiming->HSyncOffsetHiHSyncWidthHiVSyncOffsetHiSyncWidthHi & 0xC0) << 2);  // Horizontal Front Porch
    VideoMode->HSyncWidth = pTiming->HSyncWidthLo + ((pTiming->HSyncOffsetHiHSyncWidthHiVSyncOffsetHiSyncWidthHi & 0x30) << 4);

    VideoMode->VSyncOffset = ((pTiming->VSyncOffsetLoSyncWidthLo & 0xF0) >> 4) + ((pTiming->HSyncOffsetHiHSyncWidthHiVSyncOffsetHiSyncWidthHi & 0x0C) << 2); // Vertical Front Porch
    VideoMode->VSyncWidth = (pTiming->VSyncOffsetLoSyncWidthLo & 0x0F) + ((pTiming->HSyncOffsetHiHSyncWidthHiVSyncOffsetHiSyncWidthHi & 0x03) << 4);

    VideoMode->Reserved2 = 2;
    VideoMode->Accumulate = 1;

    // Horizontal and vertical sync inversions - positive if bit set in descriptor (EDID spec)
    // In the VideoMode, they are negative if the bit is set (NR-110497-TC 4.3.3 0x22 Set Video Mode)

    // Horizontal sync
    if ((pTiming->Features & EdidDetailedTimingsFeaturesHorizontalSyncPositive) == 0) {
      VideoMode->Flags |= VideoModeFlagsHorizontalSyncInverted;
    }
    // Vertical sync
    if ((pTiming->Features & EdidDetailedTimingsFeaturesVerticalSyncPositive) == 0) {
      VideoMode->Flags |= VideoModeFlagsVerticalSyncInverted;
    }
    // Interlace
    if ((pTiming->Features & EdidDetailedTimingsFeaturesInterlaced) == EdidDetailedTimingsFeaturesInterlaced) {
      VideoMode->Flags |= VideoModeFlagsInterlaced;
    }

    DEBUG ((DEBUG_INFO, "Read mode %dx%d from detailed timings\n", VideoMode->HActive, VideoMode->VActive));
    return TRUE;
  }
  return FALSE;
}

/**
Check if a particular video mode is in either the Established or Standard Timings section of the EDID.

@param  EDID        Pointer to the 128-byte EDID
@param  hRes        Horizontal resolution
@param  vRes        Vertical resolution
@param  refresh     Refresh rate
@retval TRUE        The requested mode is present in the EDID

**/
STATIC BOOLEAN
IsModeInEdid (
    IN CONST VOID *EDID,
    IN UINT16 HRes,
    IN UINT16 VRes,
    IN UINT16 Refresh
    )
{
  UINT16 EdidHRes;
  UINT16 EdidVRes;
  UINT8 EdidRefresh;
  BOOLEAN ModeSupported;

  ModeSupported = IsModeInEstablishedTimings (EDID, HRes, VRes, Refresh);

  if (ModeSupported == FALSE) {
    // Check if the mode is in the Standard Timings section of the EDID
    UINT8 i;
    for (i = 0; i < EDID_NUMBER_OF_STANDARD_TIMINGS; i++) {
      if (TRUE == ReadStandardTiming (EDID, i, &EdidHRes, &EdidVRes, &EdidRefresh)) {
        if ((HRes == EdidHRes) && (VRes == EdidVRes) && (Refresh == EdidRefresh)) {
          ModeSupported = TRUE;
          break;
        }
      }
    }
  }
  return ModeSupported;
}

/**
Returns the (index)'th entry from the list of pre-calculated video timings that is also present in the EDID,
or, video mode data corresponding to any detailed timings present in the EDID.

Like QueryVideoMode, finds the number (and contents) of video modes available by repeatedly calling this function
with an increasing index value, until it returns FALSE
@param  index       The caller wants the _index_'th video mode
@param  EDID        Pointer to the 128-byte EDID
@param  edidSize    Size in bytes of the EDID
@param  videoMode   Video timings extracted from the modeData structure
@retval EFI_SUCCESS The requested mode is present in the EDID
@retval EFI_INVALID_PARAMETER The requested mode is not present in the EDID
**/
EFI_STATUS
DlEdidGetSupportedVideoMode (
    IN UINT32 Index,
    IN CONST VOID *EDID,
    IN UINT32 EdidSize,
    OUT CONST struct VideoMode **VideoMode
    )
{
  UINTN SupportedVideoModesFoundInEdid;
  EFI_STATUS Status;

  SupportedVideoModesFoundInEdid = 0;
  Status = EFI_INVALID_PARAMETER;

  // If we didn't manage to find an EDID earlier, just use one of the hard-coded video modes
  if ((EDID == NULL) || (EdidSize != EDID_BLOCK_SIZE)) {
    if (Index >= DlVideoModeGetNumSupportedVideoModes ()) {
      return EFI_INVALID_PARAMETER;
    }
    else {
      *VideoMode = DlVideoModeGetSupportedVideoMode (Index);
      DEBUG ((DEBUG_WARN, "No monitor EDID loaded - returning mode from default list (%dx%d)\n", (*VideoMode)->HActive, (*VideoMode)->VActive));
      return EFI_SUCCESS;
    }
  }

  UINT16 ModeNumber;
  for (ModeNumber = 0; ModeNumber < DlVideoModeGetNumSupportedVideoModes (); ModeNumber++) {

    CONST struct VideoMode *SupportedVideoMode = DlVideoModeGetSupportedVideoMode (ModeNumber);
    ASSERT (SupportedVideoMode);

    if (IsModeInEdid (EDID, SupportedVideoMode->HActive, SupportedVideoMode->VActive, DISPLAYLINK_FIXED_VERTICAL_REFRESH_RATE)) {
      if (Index == SupportedVideoModesFoundInEdid) {
        *VideoMode = SupportedVideoMode;
        Status = EFI_SUCCESS;
        break;
      }
      SupportedVideoModesFoundInEdid++;
    }
  }

  if (EFI_ERROR (Status)) {
    // Have a look in the detailed timings
    UINTN DetailedTimingNumber;
    STATIC struct VideoMode TmpVideoMode;
    DetailedTimingNumber = Index - SupportedVideoModesFoundInEdid;

    if (DetailedTimingNumber < EDID_NUMBER_OF_DETAILED_TIMINGS) {
      if (ReadDetailedTiming (EDID, (UINT8)DetailedTimingNumber, &TmpVideoMode)) {
        *VideoMode = &TmpVideoMode;
        Status = EFI_SUCCESS;
      }
    }
  }

  return Status;
}

/**
 * Like GetSupportedEdidVideoMode, but will return a fallback fixed mode of 640x480@60Hz
 * for index 0 if no suitable modes found in EDID.
 * @param index
 * @param EDID
 * @param edidSize
 * @param videoMode
 * @return EFI_SUCCESS
 */
EFI_STATUS
DlEdidGetSupportedVideoModeWithFallback (
    IN UINT32 Index,
    IN CONST VOID *EDID,
    IN UINT32 EdidSize,
    OUT CONST struct VideoMode **VideoMode
    )
{
  EFI_STATUS Status;
  Status = DlEdidGetSupportedVideoMode (Index, EDID, EdidSize, VideoMode);

  if (EFI_ERROR (Status)) {
    // Special case - if we didn't find any matching video modes in the EDID, fall back to 640x480@60Hz
    if (Index == 0) {
      *VideoMode = DlVideoModeGetSupportedVideoMode (0);
      DEBUG ((DEBUG_WARN, "No video modes supported by driver found in monitor EDID received from DL device - falling back to %dx%d\n", (*VideoMode)->HActive, (*VideoMode)->VActive));
      Status = EFI_SUCCESS;
    }
  }

  return Status;
}

/**
Count the number of video modes that we have timing information for that are present in the EDID
@param  EDID        Pointer to the 128-byte EDID
@param  edidSize
@retval             The number of modes in the EDID

**/
UINT32
DlEdidGetNumSupportedModesInEdid (
    IN CONST VOID *EDID,
    IN UINT32 EdidSize
    )
{
  UINT32 MaxMode;

  if ((EDID == NULL) || (EdidSize != EDID_BLOCK_SIZE)) {
    return DlVideoModeGetNumSupportedVideoModes ();
  }

  for (MaxMode = 0; ; MaxMode++) {
    CONST struct VideoMode *videoMode;
    if (EFI_ERROR (DlEdidGetSupportedVideoMode (MaxMode, EDID, EdidSize, &videoMode))) {
      break;
    }
  }
  DEBUG ((DEBUG_INFO, "Found %d video modes supported by driver in monitor EDID.\n", MaxMode));
  return MaxMode;
}



/**
 * Read the EDID from the connected monitor, store it in the local data structure
 * @param UsbDisplayLinkDev
 * @retval EFI_OUT_OF_RESOURCES - Could not allocate memory
 * @retval EFI_SUCCESS
 */
EFI_STATUS
DlReadEdid (
    IN USB_DISPLAYLINK_DEV* UsbDisplayLinkDev
    )
{
  EFI_STATUS Status;
  BOOLEAN EdidFound;
  EFI_EDID_OVERRIDE_PROTOCOL* EdidOverride;

  //
  // setup EDID information
  //
  UsbDisplayLinkDev->EdidDiscovered.Edid = (UINT8 *)NULL;
  UsbDisplayLinkDev->EdidDiscovered.SizeOfEdid = 0;

  EdidFound = FALSE;

  //
  // Find EDID Override protocol firstly, this protocol is installed by platform if needed.
  //
  Status = gBS->LocateProtocol (&gEfiEdidOverrideProtocolGuid, NULL, (VOID**)&EdidOverride);

  if (!EFI_ERROR (Status)) {
    UINT32 EdidAttributes = 0xff;
    UINTN EdidDataSize = 0;
    UINT8* EdidDataBlock = (UINT8*)NULL;

    // Allocate double size of VESA_BIOS_EXTENSIONS_EDID_BLOCK_SIZE to avoid overflow
    EdidDataBlock = (UINT8*)AllocatePool (EDID_BLOCK_SIZE * 2);

    if (NULL == EdidDataBlock) {
      return EFI_OUT_OF_RESOURCES;
    }

    Status = EdidOverride->GetEdid (
      EdidOverride,
      &UsbDisplayLinkDev->Handle,
      &EdidAttributes,
      &EdidDataSize,
      &EdidDataBlock);

    if (!EFI_ERROR (Status) && EdidAttributes == 0 && EdidDataSize != 0) {
      UsbDisplayLinkDev->EdidDiscovered.SizeOfEdid = (UINT32)EdidDataSize;
      UsbDisplayLinkDev->EdidDiscovered.Edid = EdidDataBlock;
      EdidFound = TRUE;
    }
    else {
      FreePool (EdidDataBlock);
      EdidDataBlock = NULL;
    }
  }

  if (EdidFound != TRUE) {
    UINTN EdidDataSize = 0;
    UINT8* EdidDataBlock = (UINT8*)NULL;

    if (ReadEdidData (UsbDisplayLinkDev, &EdidDataBlock, &EdidDataSize) == EFI_SUCCESS) {

      if (IsEdidChecksumCorrect (EdidDataBlock)) {
        UsbDisplayLinkDev->EdidDiscovered.SizeOfEdid = (UINT32)EdidDataSize;
        UsbDisplayLinkDev->EdidDiscovered.Edid = EdidDataBlock;
        EdidFound = TRUE;
      } else {
        DEBUG ((DEBUG_WARN, "Monitor EDID received from DisplayLink device had an invalid checksum. Corrupted?\n"));
      }
    }
  }

  if (EdidFound == FALSE) {
    DEBUG ((DEBUG_WARN, "No valid monitor EDID received from DisplayLink device. Cannot detect resolutions supported by monitor.\n"));
  }

  // Set the EDID active.
  // In an error case this will be set 0/NULL, which flags to the parsing code that there is no EDID.
  UsbDisplayLinkDev->EdidActive.SizeOfEdid = UsbDisplayLinkDev->EdidDiscovered.SizeOfEdid;
  UsbDisplayLinkDev->EdidActive.Edid = UsbDisplayLinkDev->EdidDiscovered.Edid;

  return EFI_SUCCESS;
}