/** @file
  CmosAccessLib implementation.

Copyright (c) 2019, Intel Corporation. All rights reserved.<BR>
SPDX-License-Identifier: BSD-2-Clause-Patent

**/

#include "CmosAccessLibInternal.h"

/**
  Return the entry for the specified address in entries returned
  from platform.

  @param [in] Address  The CMOS address to find.

  @return A pointer to CMOS_ENTRY for the specified address,
          or NULL if not found.
**/
CMOS_ENTRY *
CmosAccessLibLocateEntry (
  IN UINT8      Address
  )
{
  UINTN              Index;
  UINTN              Count;
  CMOS_ENTRY         *Entries;

  Entries = PlatformCmosGetEntry (&Count);
  for (Index = 0; Index < Count; Index++) {
    if (Entries[Index].Address == Address) {
      return &Entries[Index];
    }
  }

  return NULL;
}

/**
  Test the attributes of the Entry and return ValueIfSet if test passes
  or !ValueIfSet if test fails. It returns DefaultValue if the Entry is
  NULL.

  @param [in] Address      The CMOS address.
  @param [in] Attributes   The attributes to test.
  @param [in] ValueIfSet   The value to return if test passes.
  @param [in] DefaultValue The value to return if Entry is NULL.
  @param [in] Entry        Pointer to entry.

  @retval ValueIfSet   If test passes.
  @retval !ValueIfSet  If test fails.
  @retval DefaultValue If the Entry is NULL.
**/
BOOLEAN
CmosAccessLibCheckAttribute (
  IN UINT8      Address,
  IN UINT8      Attributes,
  IN BOOLEAN    ValueIfSet,
  IN BOOLEAN    DefaultValue,
  IN CMOS_ENTRY *Entry        OPTIONAL
  )
{
  if (Entry != NULL) {
    ASSERT (Entry->Address == Address);
    if ((Entry->Attributes & Attributes) == Attributes) {
      return ValueIfSet;
    } else {
      return !ValueIfSet;
    }
  }

  return DefaultValue;
}

/**
  Check if the CMOS address needs Checksum calculation.

  @param [in] Address CMOS address to be checked
  @param [in] Entry   Pointer to entry.

  @retval TRUE       CMOS address needs Checksum calculation.
  @retval FALSE      CMOS address doesn't need Checksum calculation.
**/
BOOLEAN
CmosAccessLibNeedChecksum (
  IN UINT8       Address,
  IN CMOS_ENTRY  *Entry OPTIONAL
  )
{
  return CmosAccessLibCheckAttribute (Address, CMOS_EXCLUDE_FROM_CHECKSUM, FALSE, FALSE, Entry);
}


/**
  Check if the CMOS address needs to fill default data.

  @param [in] Address CMOS address to be checked
  @param [in] Entry   Pointer to entry.

  @retval TRUE       CMOS address need to fill default data.
  @retval FALSE      CMOS address doesn't need to fill default data.
**/
BOOLEAN
CmosAccessLibNeedFillDefault (
  IN UINT8       Address,
  IN CMOS_ENTRY  *Entry OPTIONAL
  )
{
  return CmosAccessLibCheckAttribute (Address, CMOS_EXCLUDE_FROM_INIT_DATA, FALSE, TRUE, Entry);
}

/**
  Check if the CMOS address is accessible.

  @param [in] Address CMOS address to be checked.
  @param [in] Entry   Pointer to entry.

  @retval TRUE       CMOS address is accessible.
  @retval FALSE      CMOS address isn't accessible.
**/
BOOLEAN
CmosAccessLibIsAccessible (
  IN UINT8       Address,
  IN CMOS_ENTRY  *Entry OPTIONAL
  )
{
  //
  // CMOS 0-9, A, B, C, D are for RTC.
  //
  if (Address <= 0xD) {
    return FALSE;
  }
  return CmosAccessLibCheckAttribute (Address, CMOS_EXCLUDE_FROM_ACCESS, FALSE, TRUE, Entry);
}

/**
  Return the CMOS location to store checksum.

  @param [out] Location Return the CMOS location to store the checksum.
**/
VOID
CmosAccessLibGetChecksumLocation (
  OUT CMOS_CHECKSUM_LOCATION_INFO *Location
  )
{
  UINTN                       Index;
  UINTN                       Count;
  CMOS_ENTRY                  *Entries;

  Location->Length = 0;

  Entries = PlatformCmosGetEntry (&Count);
  for (Index = 0; Index < Count; Index++) {
    if ((Entries[Index].Attributes & CMOS_CHECKSUM_LOCATION) == CMOS_CHECKSUM_LOCATION) {
      Location->Length++;
      if (Location->Length == 1) {
        Location->LowByteAddress = Entries[Index].Address;
      } else if (Location->Length == 2) {
        Location->HighByteAddress = Entries[Index].Address;
        break;
      }
    }
  }

  ASSERT (Location->Length <= 2);
}

/**
  Calculate the sum of CMOS values who need checksum calculation.

  @param [in] Location The CMOS location to store the checksum.

  @return The sum.
**/
UINT16
CmosAccessLibCalculateSum (
  IN CMOS_CHECKSUM_LOCATION_INFO *Location
  )
{
  UINT16                      Sum;
  UINTN                       Index;
  UINTN                       Count;
  CMOS_ENTRY                  *Entries;

  if (Location->Length == 0) {
    return 0;
  }

  Sum = 0;
  Entries = PlatformCmosGetEntry (&Count);
  for (Index = 0; Index < Count; Index++) {
    if (CmosAccessLibNeedChecksum (Entries[Index].Address, &Entries[Index])) {
      Sum += CmosRead8 (Entries[Index].Address);
    }
  }

  if (Location->Length == 1) {
    return (UINT8) Sum;
  } else {
    return Sum;
  }
}

/**
  Return the checksum value stored in CMOS.

  @param [in] Location The CMOS location to store the checksum.

  @return The checksum value.
**/
UINT16
CmosAccessLibReadChecksum (
  IN CMOS_CHECKSUM_LOCATION_INFO *Location
  )
{
  UINT16                      Checksum;

  Checksum = 0;

  switch (Location->Length) {
  case 2:
    Checksum = (CmosRead8 (Location->HighByteAddress) << 8);
    //
    // Fall to case 1 to get the low byte value
    //
  case 1:
    Checksum += CmosRead8 (Location->LowByteAddress);
    break;

  default:
    break;
  }
  return Checksum;
}


/**
  Write the Checksum to appropriate address.

  @param [in] Location The CMOS location to store the checksum.
  @param [in] Checksum The checksum value.
**/
VOID
CmosAccessLibWriteChecksum (
  CMOS_CHECKSUM_LOCATION_INFO *Location,
  IN UINT16                   Checksum
  )
{

  switch (Location->Length) {
  case 0:
    break;
  case 2:
    CmosWrite8 (Location->HighByteAddress, Checksum >> 8);
    //
    // Fall to case 1 to update low byte value
    //
  case 1:
    CmosWrite8 (Location->LowByteAddress, (UINT8) Checksum);
    break;
  }
}

/**
  Read a byte value from a CMOS address.

  @param [in] Address   Location to read from CMOS

  @return The byte value read from the CMOS address.
**/
UINT8
EFIAPI
CmosRead8 (
  IN  UINT8 Address
  )
{
  if (!CmosAccessLibIsAccessible (Address, CmosAccessLibLocateEntry (Address))) {
    return 0xFF;
  }

  if (Address <= CMOS_BANK0_LIMIT) {
    if (PlatformCmosGetNmiState ()) {
      Address |= BIT7;
    }
    IoWrite8 (PORT_70, Address);
    return IoRead8 (PORT_71);
  } else {
    IoWrite8 (PORT_72, Address);
    return IoRead8 (PORT_73);
  }
}

/**
  Write a byte value to a CMOS address.

  It's an internal function that doesn't update the checksum.

  @param [in] Address Location to write to CMOS.
  @param [in] Data    The byte value write to the CMOS address.
**/
VOID
CmosAccessLibICmosWrite8 (
  IN UINT8 Address,
  IN UINT8 Data
  )
{
  if (Address <= CMOS_BANK0_LIMIT) {
    if (PlatformCmosGetNmiState ()) {
      Address |= BIT7;
    }
    IoWrite8 (PORT_70, Address);
    IoWrite8 (PORT_71, Data);
  } else {
    IoWrite8 (PORT_72, Address);
    IoWrite8 (PORT_73, Data);
  }
}

/**
  Write a byte value to a CMOS address.

  @param [in] Address Location to write to CMOS.
  @param [in] Data    The byte value write to the CMOS address.
**/
VOID
EFIAPI
CmosWrite8 (
  IN UINT8 Address,
  IN UINT8 Data
  )
{
  UINT8                       OriginalData;
  CMOS_ENTRY                  *Entry;
  CMOS_CHECKSUM_LOCATION_INFO ChecksumLocation;

  Entry = CmosAccessLibLocateEntry (Address);

  if (!CmosAccessLibIsAccessible (Address, Entry)) {
    return;
  }

  OriginalData = CmosRead8 (Address);

  CmosAccessLibICmosWrite8 (Address, Data);

  if (CmosAccessLibNeedChecksum (Address, Entry)) {
    //
    // Sum of Data + Checksum = New Sum of Data + New Checksum = 0
    // New Sum of Data - Sum of Data = Checksum - New Checksum
    // New Checksum = Checksum - (New Sum of Data - Sum of Data)
    //
    CmosAccessLibGetChecksumLocation (&ChecksumLocation);
    CmosAccessLibWriteChecksum (
      &ChecksumLocation,
      CmosAccessLibReadChecksum (&ChecksumLocation) - (Data - OriginalData)
      );
  }
}

/**
  Read a word value from a CMOS address.

  @param [in] Address   Location to read from CMOS

  @return The word value read from the CMOS address.
**/
UINT16
EFIAPI
CmosRead16 (
  IN  UINT8  Address
  )
{
  return CmosRead8 (Address) + (CmosRead8 (Address + 1) << 8);
}

/**
  Write a word value to a CMOS address.

  @param [in] Address Location to write to CMOS.
  @param [in] Data    The word value write to the CMOS address.
**/
VOID
EFIAPI
CmosWrite16 (
  IN UINT8  Address,
  IN UINT16 Data
  )
{
  CmosWrite8 (Address, (UINT8) Data);
  CmosWrite8 (Address + 1, (UINT8) (Data >> 8));
}

/**
  Read a dword value from a CMOS address.

  @param [in] Address   Location to read from CMOS

  @return The dword value read from the CMOS address.
**/
UINT32
EFIAPI
CmosRead32 (
  IN  UINT8  Address
  )
{
  return CmosRead16 (Address) + (CmosRead16 (Address + 2) << 16);
}

/**
  Write a dword value to a CMOS address.

  @param [in] Address Location to write to CMOS.
  @param [in] Data    The dword value write to the CMOS address.
**/
VOID
EFIAPI
CmosWrite32 (
  IN UINT8  Address,
  IN UINT32 Data
  )
{
  CmosWrite16 (Address, (UINT16) Data);
  CmosWrite16 (Address + 2, (UINT16) (Data >> 16));
}


/**
  Initialize the CMOS.

  It initialize the CMOS area when Force is TRUE or the checksum is incorrect.

  @param[in]  Force  TRUE indicating initializing the CMOS area without checking the checksum.

  @retval TRUE  The CMOS is initialized to default value.
  @retval FALSE The CMOS isn't initialized to default value.
**/
BOOLEAN
EFIAPI
CmosInit (
  IN  BOOLEAN     Force
  )
{
  UINTN                       Address;
  CMOS_ENTRY                  *Entry;
  CMOS_CHECKSUM_LOCATION_INFO ChecksumLocation;
  UINT16                      Checksum;

  CmosAccessLibGetChecksumLocation (&ChecksumLocation);

  if (!Force) {
    //
    // Initialize the CMOS area when checksum is incorrect.
    //
    Checksum = CmosAccessLibCalculateSum (&ChecksumLocation) + CmosAccessLibReadChecksum (&ChecksumLocation);
    if (ChecksumLocation.Length == 1) {
      Checksum = (UINT8) Checksum;
    }

    if (Checksum != 0) {
      Force = TRUE;
    }
  }

  if (Force) {
    //
    // Traverse through entire CMOS location and fill it with zero
    //
    for (Address = 0; Address <= CMOS_BANK1_LIMIT; Address++) {
      Entry = CmosAccessLibLocateEntry ((UINT8) Address);
      if (CmosAccessLibNeedFillDefault ((UINT8) Address, Entry)) {
        CmosAccessLibICmosWrite8 ((UINT8) Address, (Entry == NULL) ? CMOS_DEFAULT_VALUE : Entry->DefaultValue);
      }
    }

    //
    // Write the New checksum to the Checksum field
    //
    CmosAccessLibWriteChecksum (
      &ChecksumLocation,
      (UINT16) (0x10000 - CmosAccessLibCalculateSum (&ChecksumLocation))
      );
    return TRUE;
  }

  return FALSE;
}