/*******************************************************************************
Copyright (C) 2018 Marvell International Ltd.

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

*******************************************************************************/

#include "XenonSdMmcOverride.h"

STATIC EFI_HANDLE              mXenonSdMmcOverrideHandle;
STATIC EDKII_SD_MMC_OVERRIDE  *mSdMmcOverride;

STATIC
EFI_STATUS
EFIAPI
XenonGetSdMmcDesc (
  IN      EFI_HANDLE              ControllerHandle,
  IN OUT  MV_BOARD_SDMMC_DESC     *SdMmcDesc
  )
{
  EFI_STATUS                      Status;
  MV_BOARD_SDMMC_DESC             *SdMmcDescs;
  NON_DISCOVERABLE_DEVICE         *Device;
  MARVELL_BOARD_DESC_PROTOCOL     *BoardDescProtocol;
  UINTN                           Index;

  Device = NULL;
  Status = gBS->OpenProtocol (ControllerHandle,
                  &gEdkiiNonDiscoverableDeviceProtocolGuid,
                  (VOID **) &Device,
                  mXenonSdMmcOverrideHandle,
                  ControllerHandle,
                  EFI_OPEN_PROTOCOL_GET_PROTOCOL);
  if (EFI_ERROR (Status)) {
    return Status;
  }

  BoardDescProtocol = NULL;
  Status = gBS->LocateProtocol (&gMarvellBoardDescProtocolGuid,
                  NULL,
                  (VOID **) &BoardDescProtocol);
  if (EFI_ERROR (Status)) {
    return Status;
  }

  Status = BoardDescProtocol->BoardDescSdMmcGet (BoardDescProtocol, &SdMmcDescs);
  if (EFI_ERROR (Status)) {
    return Status;
  }

  for (Index = 0; Index < SdMmcDescs->SdMmcDevCount; Index++) {
    if (SdMmcDescs[Index].SoC->SdMmcBaseAddress ==
        Device->Resources[0].AddrRangeMin) {
      *SdMmcDesc = SdMmcDescs[Index];
      break;
    }
  }

  if (Index == SdMmcDescs->SdMmcDevCount) {
    return EFI_INVALID_PARAMETER;
  }

  return EFI_SUCCESS;
}

STATIC
EFI_STATUS
XenonGetPciIo (
  IN      EFI_HANDLE              ControllerHandle,
  IN OUT  EFI_PCI_IO_PROTOCOL     **PciIo
  )
{
  EFI_STATUS Status;

  *PciIo  = NULL;
  Status = gBS->OpenProtocol (ControllerHandle,
                  &gEfiPciIoProtocolGuid,
                  (VOID **) PciIo,
                  mXenonSdMmcOverrideHandle,
                  ControllerHandle,
                  EFI_OPEN_PROTOCOL_GET_PROTOCOL);
  return Status;
}

/**
  Set SD Host Controller control 2 registry according to selected speed.

  @param[in] ControllerHandle The EFI_HANDLE of the controller.
  @param[in] Slot             The slot number of the SD card to send the command to.
  @param[in] Timing           The timing to select.

  @retval EFI_SUCCESS         The override function completed successfully.
  @retval EFI_NOT_FOUND       The specified controller or slot does not exist.
**/
STATIC
EFI_STATUS
XenonSdMmcHcUhsSignaling (
  IN EFI_HANDLE             ControllerHandle,
  IN UINT8                  Slot,
  IN SD_MMC_BUS_MODE        Timing
  )
{
  EFI_PCI_IO_PROTOCOL      *PciIo;
  EFI_STATUS                Status;
  UINT8                     HostCtrl2;
  UINT8                     XenonUhsSelect;

  if (Slot != 0) {
    return EFI_NOT_FOUND;
  }

  //
  // Update Host Control Register 2 only for HS200/HS400.
  //
  switch (Timing) {
    case SdMmcMmcHs200:
      XenonUhsSelect = XENON_SD_MMC_HC_CTRL_HS200;
      break;
    case SdMmcMmcHs400:
      XenonUhsSelect = XENON_SD_MMC_HC_CTRL_HS400;
      break;
    default:
      return EFI_SUCCESS;
  }

  Status = XenonGetPciIo (ControllerHandle, &PciIo);
  if (EFI_ERROR (Status)) {
    return Status;
  }

  HostCtrl2 = (UINT8)~UHS_MODE_SELECT_MASK;
  Status = XenonHcAndMmio (PciIo,
             Slot,
             SDHC_HOST_CTRL2,
             sizeof (HostCtrl2),
             &HostCtrl2);
  if (EFI_ERROR (Status)) {
    return Status;
  }

  Status = XenonHcOrMmio (PciIo,
             Slot,
             SDHC_HOST_CTRL2,
             sizeof (XenonUhsSelect),
             &XenonUhsSelect);

  return Status;
}

/**

  Additional operations specific for host controller

  @param[in]      ControllerHandle      The EFI_HANDLE of the controller.
  @param[in]      Slot                  The 0 based slot index.
  @param[in]      Timing                The timing which should be set by
                                        host controller.

  @retval EFI_SUCCESS           The override function completed successfully.
  @retval EFI_NOT_FOUND         The specified controller or slot does not exist.

**/
STATIC
EFI_STATUS
XenonSwitchClockFreqPost (
  IN      EFI_HANDLE                      ControllerHandle,
  IN      UINT8                           Slot,
  IN      SD_MMC_BUS_MODE                 Timing
  )
{
  EFI_STATUS                      Status;
  MV_BOARD_SDMMC_DESC             SdMmcDesc;
  EFI_PCI_IO_PROTOCOL             *PciIo;

  if (Slot != 0) {
    return EFI_NOT_FOUND;
  }

  Status = XenonGetPciIo (ControllerHandle, &PciIo);
  if (EFI_ERROR (Status)) {
    return Status;
  }
  Status = XenonGetSdMmcDesc (ControllerHandle, &SdMmcDesc);
  if (EFI_ERROR (Status)) {
    return Status;
  }

  Status = XenonSetPhy (PciIo,
             SdMmcDesc.XenonSlowModeEnabled,
             SdMmcDesc.XenonTuningStepDivisor,
             Timing);

  return Status;
}

/**

  Override function for SDHCI controller operations

  @param[in]      ControllerHandle      The EFI_HANDLE of the controller.
  @param[in]      Slot                  The 0 based slot index.
  @param[in]      PhaseType             The type of operation and whether the
                                        hook is invoked right before (pre) or
                                        right after (post)
  @param[in]      PhaseData             The pointer to a phase-specific data.

  @retval EFI_SUCCESS           The override function completed successfully.
  @retval EFI_NOT_FOUND         The specified controller or slot does not exist.
  @retval EFI_UNSUPPORTED       Nothing has been done in connection of PhaseType
  @retval EFI_INVALID_PARAMETER PhaseType is invalid

**/
STATIC
EFI_STATUS
EFIAPI
XenonSdMmcNotifyPhase (
  IN      EFI_HANDLE                      ControllerHandle,
  IN      UINT8                           Slot,
  IN      EDKII_SD_MMC_PHASE_TYPE         PhaseType,
  IN OUT  VOID                           *PhaseData
  )
{
  EFI_STATUS                      Status;
  MV_BOARD_SDMMC_DESC             SdMmcDesc;
  EFI_PCI_IO_PROTOCOL             *PciIo;
  SD_MMC_BUS_MODE                 *Timing;

  if (Slot != 0) {
    return EFI_NOT_FOUND;
  }

  switch (PhaseType) {
    case EdkiiSdMmcInitHostPre:
      Status = XenonGetPciIo (ControllerHandle, &PciIo);
      if (EFI_ERROR (Status)) {
        return Status;
      }

      Status = XenonGetSdMmcDesc (ControllerHandle, &SdMmcDesc);
      if (EFI_ERROR (Status)) {
        return Status;
      }

      Status = XenonInit (PciIo,
                 SdMmcDesc.Xenon1v8Enabled,
                 SdMmcDesc.XenonSlowModeEnabled,
                 SdMmcDesc.XenonTuningStepDivisor);
      return Status;
    case EdkiiSdMmcUhsSignaling:
      if (PhaseData == NULL) {
        return EFI_INVALID_PARAMETER;
      }

      Timing = (SD_MMC_BUS_MODE *)PhaseData;

      Status = XenonSdMmcHcUhsSignaling (ControllerHandle,
                 Slot,
                 *Timing);
      if (EFI_ERROR (Status)) {
        return Status;
      }
      break;
    case EdkiiSdMmcSwitchClockFreqPost:
      if (PhaseData == NULL) {
        return EFI_INVALID_PARAMETER;
      }

      Timing = (SD_MMC_BUS_MODE *)PhaseData;

      Status = XenonSwitchClockFreqPost (ControllerHandle,
                 Slot,
                 *Timing);
      if (EFI_ERROR (Status)) {
        return Status;
      }
      break;
    default:
      return EFI_SUCCESS;
  }

  return EFI_SUCCESS;
}

/**

  Override function for SDHCI capability bits

  @param[in]      ControllerHandle      The EFI_HANDLE of the controller.
  @param[in]      Slot                  The 0 based slot index.
  @param[in,out]  SdMmcHcSlotCapability The SDHCI capability structure.
  @param[in,out]  BaseClkFreq           The base clock frequency value that
                                        optionally can be updated.

  @retval EFI_SUCCESS           The override function completed successfully.
  @retval EFI_NOT_FOUND         The specified controller or slot does not exist.
  @retval EFI_INVALID_PARAMETER SdMmcHcSlotCapability is NULL

**/
STATIC
EFI_STATUS
EFIAPI
XenonSdMmcCapability (
  IN      EFI_HANDLE                      ControllerHandle,
  IN      UINT8                           Slot,
  IN OUT  VOID                            *SdMmcHcSlotCapability,
  IN OUT  UINT32                          *BaseClkFreq
  )
{
  EFI_STATUS           Status;
  MV_BOARD_SDMMC_DESC  SdMmcDesc;
  UINT64               Capability;

  if (SdMmcHcSlotCapability == NULL) {
    return EFI_INVALID_PARAMETER;
  }
  if (Slot != 0) {
    return EFI_NOT_FOUND;
  }
  Status = XenonGetSdMmcDesc (ControllerHandle, &SdMmcDesc);
  if (EFI_ERROR (Status)) {
    return Status;
  }

  Capability = ReadUnaligned64 (SdMmcHcSlotCapability);

  //
  // Override capabilities structure according to board configuration.
  //
  if (SdMmcDesc.Xenon1v8Enabled) {
    Capability &= ~(UINT64)(SDHC_CAP_VOLTAGE_33 | SDHC_CAP_VOLTAGE_30);
  } else {
    Capability &= ~(UINT64)(SDHC_CAP_SDR104 | SDHC_CAP_DDR50 |
                            SDHC_CAP_SDR50 | SDHC_CAP_HS400 |
                            SDHC_CAP_VOLTAGE_18);
  }

  if (!SdMmcDesc.Xenon8BitBusEnabled) {
    Capability &= ~(UINT64)(SDHC_CAP_BUS_WIDTH8);
  }

  if (SdMmcDesc.XenonSlowModeEnabled) {
    Capability &= ~(UINT64)(SDHC_CAP_SDR104 | SDHC_CAP_DDR50 | SDHC_CAP_HS400);
  }

  Capability &= ~(UINT64)(SDHC_CAP_SLOT_TYPE_MASK);
  Capability |= SdMmcDesc.SlotType << SDHC_CAP_SLOT_TYPE_OFFSET;

  WriteUnaligned64 (SdMmcHcSlotCapability, Capability);

  //
  // Override inappropriate base clock frequency from Capabilities Register 1.
  // Actual clock speed of Xenon controller is 400MHz.
  //
  *BaseClkFreq = XENON_MMC_MAX_CLK / 1000 / 1000;

  return EFI_SUCCESS;
}

/**
  The entry point for Xenon driver, used to install SdMMcOverrideProtocol
  on the ImageHandle.

  @param[in]  ImageHandle   The firmware allocated handle for this driver image.
  @param[in]  SystemTable   Pointer to the EFI system table.

  @retval EFI_SUCCESS   Driver loaded.
  @retval other         Driver not loaded.

**/
EFI_STATUS
EFIAPI
InitializeXenonDxe (
  IN EFI_HANDLE        ImageHandle,
  IN EFI_SYSTEM_TABLE  *SystemTable
  )
{
  EFI_STATUS Status;

  mSdMmcOverride = AllocateZeroPool (sizeof (EDKII_SD_MMC_OVERRIDE));
  if (mSdMmcOverride == NULL) {
    DEBUG ((DEBUG_ERROR, "%a: Cannot allocate memory\n", __FUNCTION__));
    return EFI_OUT_OF_RESOURCES;
  }

  mSdMmcOverride->Version = EDKII_SD_MMC_OVERRIDE_PROTOCOL_VERSION;
  mSdMmcOverride->Capability = XenonSdMmcCapability;
  mSdMmcOverride->NotifyPhase = XenonSdMmcNotifyPhase;

  Status = gBS->InstallProtocolInterface (&ImageHandle,
                  &gEdkiiSdMmcOverrideProtocolGuid,
                  EFI_NATIVE_INTERFACE,
                  mSdMmcOverride);
  if (EFI_ERROR (Status)) {
    DEBUG ((DEBUG_ERROR,
      "%a: Filed to install SdMmcOverride protocol\n",
      __FUNCTION__));
    return Status;
  }

  mXenonSdMmcOverrideHandle = ImageHandle;

  return Status;
}