/** @file

  Copyright (c) 2020, Hisilicon Limited. All rights reserved.<BR>

  SPDX-License-Identifier: BSD-2-Clause-Patent

**/

#include <Uefi.h>
#include <PiDxe.h>
#include <Library/BaseLib.h>
#include <Library/BaseMemoryLib.h>
#include <Library/DebugLib.h>
#include <Library/I2CLib.h>
#include <Library/RtcHelperLib.h>
#include <Library/TimeBaseLib.h>
#include <Library/TimerLib.h>
#include <Library/UefiBootServicesTableLib.h>
#include <Library/UefiLib.h>
#include <Library/UefiRuntimeLib.h>
#include <Library/UefiRuntimeServicesTableLib.h>
#include <Protocol/RealTimeClock.h>
#include "RX8900RealTimeClock.h"

extern I2C_DEVICE gRtcDevice;

STATIC BOOLEAN       mRX8900Initialized = FALSE;
STATIC CONST CHAR16  mTimeZoneVariableName[] = L"RX8900RtcTimeZone";
STATIC CONST CHAR16  mDaylightVariableName[] = L"RX8900RtcDaylight";

EFI_STATUS
InitializeRX8900 (
  VOID
  )
{
  EFI_STATUS    Status;
  unsigned char writeTemp;

  Status = SwitchRtcI2cChannelAndLock ();
  if (EFI_ERROR (Status)) {
    goto EXIT;
  }

  Status = I2CInit (gRtcDevice.Socket, gRtcDevice.Port, Normal);
  if (EFI_ERROR (Status)) {
    goto EXIT;
  }

  writeTemp = RX8900_VDETOFF_SWOFF;
  Status = I2CWrite (&gRtcDevice, RX8900_REGADDR_BACKUP_FUN, 1, &writeTemp);
  if (EFI_ERROR (Status)) {
    goto EXIT;
  }
  writeTemp = TEMPERATURE_COMPENSATION_2S;
  Status = I2CWrite (&gRtcDevice, RX8900_REGADDR_CONTRLREG, 1, &writeTemp);
  if (EFI_ERROR (Status)) {
    goto EXIT;
  }
  writeTemp = OUTPUT_FREQUENCY_32768;
  Status = I2CWrite (&gRtcDevice, RX8900_REGADDR_EXTENSIONREG, 1, &writeTemp);
  if (EFI_ERROR (Status)) {
    goto EXIT;
  }

  writeTemp = FLAG_REG_DEFAULT;
  Status = I2CWrite (&gRtcDevice, RX8900_REGADDR_FLAGREG, 1, &writeTemp);
  if (EFI_ERROR (Status)) {
    goto EXIT;
  }
  writeTemp = RX8900_RAM_REG_DEFAULT;
  Status = I2CWrite (&gRtcDevice, RX8900_REGADDR_RAM, 1, &writeTemp);
  if (EFI_ERROR (Status)) {
    goto EXIT;
  }

  mRX8900Initialized = TRUE;

  EXIT:

  ReleaseOwnershipOfRtc ();
  return Status;
}

STATIC
INT16
GetTimeZone (
  VOID
  )
{
  EFI_STATUS  Status;
  INT16       TimeZone;
  UINTN       Size;

  TimeZone = EFI_UNSPECIFIED_TIMEZONE;
  Size = sizeof (TimeZone);
  Status = EfiGetVariable (
             (CHAR16 *)mTimeZoneVariableName,
             &gEfiCallerIdGuid,
             NULL,
             &Size,
             (VOID *)&TimeZone
             );

  if (EFI_ERROR (Status)) {
    TimeZone = EFI_UNSPECIFIED_TIMEZONE;
    // The time zone variable does not exist in non-volatile storage, so create it.
    Status = EfiSetVariable (
               (CHAR16 *)mTimeZoneVariableName,
               &gEfiCallerIdGuid,
               EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,
               Size,
               (VOID *)&TimeZone
               );

    if (EFI_ERROR (Status)) {
        DEBUG ((DEBUG_INFO, "Failed to save %s variable, Status = %r\n",
          mTimeZoneVariableName, Status));
    }
  } else {
    // Check TimeZone bounds:   -1440 to 1440 or 2047
    if ((TimeZone < -EFI_TIMEOFFSET_TIMEZONE) || (TimeZone > EFI_TIMEOFFSET_TIMEZONE)) {
      TimeZone = EFI_UNSPECIFIED_TIMEZONE;
    }
  }

  return TimeZone;
}

STATIC
UINT8
GetDayLight (
  VOID
  )
{
  EFI_STATUS  Status;
  UINT8       DayLight;
  UINTN       Size;

  DayLight = 0;
  // Get the current daylight information from non-volatile storage
  Size = sizeof (DayLight);
  Status = EfiGetVariable (
             (CHAR16 *)mDaylightVariableName,
             &gEfiCallerIdGuid,
             NULL,
             &Size,
             (VOID *)&DayLight
             );

  if (EFI_ERROR (Status)) {
    DayLight = 0;
    // The daylight variable does not exist in non-volatile storage, so create it.
    Status = EfiSetVariable (
               (CHAR16 *)mDaylightVariableName,
               &gEfiCallerIdGuid,
               EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,
               Size,
               (VOID *)&DayLight
               );
    if (EFI_ERROR (Status)) {
      DEBUG ((DEBUG_INFO, "Failed to save %s variable, Status = %r\n",
          mDaylightVariableName, Status));
    }
  }

  return DayLight;
}

EFI_STATUS
EFIAPI
LibGetTime (
  OUT EFI_TIME                *Time,
  OUT EFI_TIME_CAPABILITIES   *Capabilities
  )
{
  EFI_STATUS  Status;
  UINT8       Temp[7] = {0};
  UINT16      BaseYear = 2000;
  UINTN       EpochSeconds;
  UINT8       TryCount = 0;

  // Ensure Time is a valid pointer
  if (Time == NULL) {
    return EFI_INVALID_PARAMETER;
  }

  // Initialize the hardware if not already done
  if (!mRX8900Initialized) {
    Status = InitializeRX8900 ();
    if (EFI_ERROR (Status)) {
      return EFI_NOT_READY;
    }
  }

  Status = SwitchRtcI2cChannelAndLock ();
  if (EFI_ERROR (Status)) {
    ReleaseOwnershipOfRtc ();
    return Status;
  }

  do {
    Status = I2CRead (&gRtcDevice, RX8900_REGADDR_SECONDS, 7, Temp);
    if (EFI_ERROR (Status)) {
      Status = EFI_DEVICE_ERROR;
      goto Err;
    }

    Time->Second = BcdToDecimal8 (Temp[0]);
    Time->Minute = BcdToDecimal8 (Temp[1]);
    Time->Hour = BcdToDecimal8 (Temp[2]);
    Time->Day = BcdToDecimal8 (Temp[4]);
    Time->Month = BcdToDecimal8 (Temp[5]);
    Time->Year = BaseYear + BcdToDecimal8 (Temp[6]);
    Time->Nanosecond = 0;

    EpochSeconds = EfiTimeToEpoch (Time);

    Time->TimeZone = GetTimeZone ();
    // Adjust for the correct time zone
    if (Time->TimeZone != EFI_UNSPECIFIED_TIMEZONE) {
      EpochSeconds += Time->TimeZone * SEC_PER_MIN;
    }

    Time->Daylight = GetDayLight ();
    // Adjust for the correct period
    if ((Time->Daylight & EFI_TIME_IN_DAYLIGHT) == EFI_TIME_IN_DAYLIGHT) {
      // Convert to adjusted time, i.e. spring forwards one hour
      EpochSeconds += SEC_PER_HOUR;
    }

    // Convert from internal 32-bit time to UEFI time
    EpochToEfiTime (EpochSeconds, Time);
    if ((!IsTimeValid (Time)) || ((Time->Year - BaseYear) > 99) || (Time->Year < 2000)) {
      DEBUG ((DEBUG_INFO, "LibGetTime: %d-%d-%d %d-%d-%d EpochSeconds:%llx is invalid time!\n",
        Time->Second, Time->Minute, Time->Hour, Time->Day, Time->Month,
        Time->Year, EpochSeconds));
      Status = EFI_DEVICE_ERROR;
    }

Err:
    TryCount++;
  } while ((TryCount < 3) && (EFI_ERROR (Status)));

  ReleaseOwnershipOfRtc ();
  return Status;
}

STATIC
EFI_STATUS
SetTimeToRX8900 (
  IN  EFI_TIME                *Time
  )
{
  EFI_STATUS   Status;
  UINT8        Temp;

  (VOID)MicroSecondDelay (RTC_DELAY_1000_MICROSECOND);
  Temp = DecimalToBcd8 (Time->Second);
  Status = I2CWrite (&gRtcDevice, RX8900_REGADDR_SECONDS, 1, &Temp);
  if(EFI_ERROR (Status)) {
    Status = EFI_DEVICE_ERROR;
    return Status;
  }

  Temp = DecimalToBcd8 (Time->Minute);
  (VOID)MicroSecondDelay (RTC_DELAY_1000_MICROSECOND);
  Status = I2CWrite (&gRtcDevice, RX8900_REGADDR_MIUTES, 1, &Temp);
  if(EFI_ERROR (Status)) {
    Status = EFI_DEVICE_ERROR;
    return Status;
  }

  Temp = DecimalToBcd8 (Time->Hour);
  (VOID)MicroSecondDelay (RTC_DELAY_1000_MICROSECOND);
  Status = I2CWrite (&gRtcDevice, RX8900_REGADDR_HOURS, 1, &Temp);
  if(EFI_ERROR (Status)) {
    Status = EFI_DEVICE_ERROR;
    return Status;
  }

  Temp = DecimalToBcd8 (Time->Day);
  (VOID)MicroSecondDelay (RTC_DELAY_1000_MICROSECOND);
  Status = I2CWrite (&gRtcDevice, RX8900_REGADDR_DATE, 1, &Temp);
  if(EFI_ERROR (Status)) {
    Status = EFI_DEVICE_ERROR;
    return Status;
  }

  Temp = DecimalToBcd8 (Time->Month);
  (VOID)MicroSecondDelay (RTC_DELAY_1000_MICROSECOND);
  Status = I2CWrite (&gRtcDevice, RX8900_REGADDR_MONTH, 1, &Temp);
  if(EFI_ERROR (Status)) {
    Status = EFI_DEVICE_ERROR;
    return Status;
  }

  Time->Year= Time->Year % 100;
  Temp = Time->Year;
  Temp = DecimalToBcd8 (Temp);
  (VOID)MicroSecondDelay (RTC_DELAY_1000_MICROSECOND);
  Status = I2CWrite (&gRtcDevice, RX8900_REGADDR_YEAR, 1, &Temp);
  if(EFI_ERROR (Status)) {
    Status =  EFI_DEVICE_ERROR;
    return Status;
  }

  return Status;
}

EFI_STATUS
EFIAPI
LibSetTime (
  IN  EFI_TIME                *Time
  )
{
  EFI_STATUS  Status;
  UINTN EpochSeconds;

  // Initialize the hardware if not already done
  if (!mRX8900Initialized) {
    Status = InitializeRX8900 ();
    if (EFI_ERROR (Status)) {
      goto EXIT;
    }
  }

  Status = SwitchRtcI2cChannelAndLock ();
  if (EFI_ERROR (Status)) {
    goto EXIT;
  }

  if(!IsTimeValid(Time)){
    return EFI_INVALID_PARAMETER;
  }

  EpochSeconds = EfiTimeToEpoch (Time);

  // Adjust for the correct time zone, i.e. convert to UTC time zone
  if (Time->TimeZone != EFI_UNSPECIFIED_TIMEZONE) {
    EpochSeconds -= Time->TimeZone * SEC_PER_MIN;
  }

  // Adjust for the correct period
  if ((Time->Daylight & EFI_TIME_IN_DAYLIGHT) == EFI_TIME_IN_DAYLIGHT) {
    // Convert to un-adjusted time, i.e. fall back one hour
    EpochSeconds -= SEC_PER_HOUR;
  }

  EpochToEfiTime (EpochSeconds, Time);
  Status = SetTimeToRX8900 (Time);
  if (EFI_ERROR (Status)) {
    goto EXIT;
  }

  // Save the current time zone information into non-volatile storage
  Status = EfiSetVariable (
             (CHAR16 *)mTimeZoneVariableName,
             &gEfiCallerIdGuid,
             EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,
             sizeof (Time->TimeZone),
             (VOID *)&(Time->TimeZone)
             );
  if (EFI_ERROR (Status)) {
    DEBUG ((DEBUG_INFO, "LibSetTime: Failed to save %s variable, Status = %r\n",
      mTimeZoneVariableName, Status));
    goto EXIT;
  }

  // Save the current daylight information into non-volatile storage
  Status = EfiSetVariable (
             (CHAR16 *)mDaylightVariableName,
             &gEfiCallerIdGuid,
             EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,
             sizeof(Time->Daylight),
             (VOID *)&(Time->Daylight)
             );
  if (EFI_ERROR (Status)) {
    DEBUG ((DEBUG_INFO, "LibSetTime: Failed to save %s variable, Status = %r\n",
      mDaylightVariableName, Status));
    goto EXIT;
  }

  EXIT:
  ReleaseOwnershipOfRtc ();
  return Status;
}

EFI_STATUS
EFIAPI
LibGetWakeupTime (
  OUT BOOLEAN     *Enabled,
  OUT BOOLEAN     *Pending,
  OUT EFI_TIME    *Time
  )
{
  // Not a required feature
  return EFI_UNSUPPORTED;
}

EFI_STATUS
EFIAPI
LibSetWakeupTime (
  IN BOOLEAN      Enabled,
  OUT EFI_TIME    *Time
  )
{
  // Not a required feature
  return EFI_UNSUPPORTED;
}


EFI_STATUS
EFIAPI
LibRtcInitialize (
  IN EFI_HANDLE                            ImageHandle,
  IN EFI_SYSTEM_TABLE                      *SystemTable
  )
{
  EFI_STATUS    Status;
  EFI_HANDLE    Handle;
  EFI_TIME      EfiTime;

  // Setup the setters and getters
  gRT->GetTime = LibGetTime;
  gRT->SetTime = LibSetTime;
  gRT->GetWakeupTime = LibGetWakeupTime;
  gRT->SetWakeupTime = LibSetWakeupTime;

  Status = gRT->GetTime (&EfiTime, NULL);
  if (EFI_ERROR (Status) || (EfiTime.Year < 2000) || (EfiTime.Year > 2099) ||
      (!IsTimeValid (&EfiTime))) {
       EfiTime.Year = 2000;
       EfiTime.Month = 1;
       EfiTime.Day = 1;
       EfiTime.Hour = 0;
       EfiTime.Minute = 0;
       EfiTime.Second = 0;
       EfiTime.Nanosecond = 0;
       EfiTime.Daylight = 0;
       EfiTime.TimeZone = EFI_UNSPECIFIED_TIMEZONE;

      Status = gRT->SetTime (&EfiTime);
      if (EFI_ERROR (Status)) {
        DEBUG ((DEBUG_ERROR, "SetTime Status : %r\n", Status));
      }
  }

  Handle = NULL;
  Status = gBS->InstallMultipleProtocolInterfaces (
                  &Handle,
                  &gEfiRealTimeClockArchProtocolGuid,
                  NULL,
                  NULL
                 );

  return Status;
}


VOID
EFIAPI
LibRtcVirtualNotifyEvent (
  IN EFI_EVENT        Event,
  IN VOID             *Context
  )
{
  return;
}
