/** @file

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

**/

#include "UsraAccessLib.h"

GET_ALLIGNED_ACCESS_ADDRESS mAccessAddrPtr[] =
{
  &GetPcieAccessAddress,     // AddrTypePCIE
  &GetPcieAccessAddress,     // AddrTypePCIEBLK
  &GetCsrAccessAddress,      // AddrTypeCSR
};

REGISTER_READ mRegisterReadPtr[] =
{
  &PcieRegisterRead,        // AddrTypePCIE
  &PcieBlkRegisterRead,     // AddrTypePCIEBLK
  &CsrRegisterRead,         // AddrTypeCSR
};

REGISTER_WRITE mRegisterWritePtr[] =
{
  &PcieRegisterWrite,       // AddrTypePCIE
  &PcieBlkRegisterWrite,    // AddrTypePCIEBLK
  &CsrRegisterWrite,        // AddrTypeCSR
};

REGISTER_MODIFY mRegisterModifyPtr[] =
{
  &PcieRegisterModify,      // AddrTypePCIE
  &PcieRegisterModify,      // AddrTypePCIEBLK
  &CsrRegisterModify,       // AddrTypeCSR
};

/**
  Perform MMIO read

  @param[in] AccessWidth          Access Width
  @param[in] AlignedAddress       An address to be read out
  @param[in] Buffer               A pointer of buffer contains the data to be read out

  @retval RETURN_SUCCESS          The function completed successfully.
**/
RETURN_STATUS
UsraRegAlignedRead (
  IN UINT32                   AccessWidth,
  IN UINTN                    AlignedAddress,
  OUT VOID                    *Buffer
  )
{
  switch (AccessWidth)
  {
  case  UsraWidth8:
    *((UINT8*)Buffer) = MmioRead8 (AlignedAddress);
    break;
  case  UsraWidth16:
    *((UINT16*)Buffer) = MmioRead16 (AlignedAddress);
    break;
  case  UsraWidth32:
    *((UINT32*)Buffer) = MmioRead32 (AlignedAddress);
    break;
  default:
    *((UINT64*)Buffer) = MmioRead64 (AlignedAddress);
    break;
  }

  return RETURN_SUCCESS;
};

/**
  Perform MMIO write

  @param[in] AccessWidth          Access Width
  @param[in] AlignedAddress       An address to be written
  @param[in] Buffer               A pointer of buffer contains the data to be written

  @retval RETURN_SUCCESS          The function completed successfully.
**/
RETURN_STATUS
UsraRegAlignedWrite (
  IN UINT32                   AccessWidth,
  IN UINTN                    AlignedAddress,
  OUT VOID                    *Buffer
  )
{
  switch (AccessWidth)
  {
  case  UsraWidth8:
    MmioWrite8 (AlignedAddress,*((UINT8*)Buffer));
    break;
  case  UsraWidth16:
    MmioWrite16 (AlignedAddress,*((UINT16*)Buffer));
    break;
  case  UsraWidth32:
    MmioWrite32 (AlignedAddress,*((UINT32*)Buffer));
    break;
  default:
    MmioWrite64 (AlignedAddress, *((UINT64*)Buffer));
    break;
  }
  return RETURN_SUCCESS;
}

/**
  Perform AND then OR operations for a input data

  @param[in out] Data             A pointer of the address of the register to be modified
  @param[in] AndBuffer            A pointer of buffer for the value used for AND operation
                                  A NULL pointer means no AND operation. RegisterModify() equivalents to RegisterOr()
  @param[in] OrBuffer             A pointer of buffer for the value used for OR operation
                                  A NULL pointer means no OR operation. RegisterModify() equivalents to RegisterAnd()
  @param[in] NumOfByte            NumOfByte Count of byte data to be performed

  @retval NONE
**/
VOID
DataAndOr (
  IN  UINT64                  *Data,
  IN  VOID                    *AndBuffer,
  IN  VOID                    *OrBuffer,
  IN  UINT8                   NumOfByte
)
{
  union{
    UINT64      QW;
    UINT8       Byte[8];
  } Buffer;
  UINT8                       AndData[8], OrData[8], i;

  Buffer.QW = *Data;
  for(i=0;i<NumOfByte;i++)
  {
    if (AndBuffer == NULL)
      ((UINT8*)AndData)[i] = 0xff;
    else
      AndData[i] = ((UINT8*)AndBuffer)[i];
    if (OrBuffer == NULL)
      ((UINT8*)OrData)[i] = 0;
    else
      OrData[i] = ((UINT8*)OrBuffer)[i];
    Buffer.Byte[i] = (Buffer.Byte[i] & AndData[i]) | OrData[i];
  }

  *Data = Buffer.QW;
}

//////////////////////////////////////////////////////////////////////////
//
// USRA Hardware Access Library
//
//////////////////////////////////////////////////////////////////////////

/**
  This API gets the flat address from the given USRA Address.

  @param[in] Address              A pointer of the address of the USRA Address Structure to be read out

  @retval                         The flat address
**/
INTN
EFIAPI
GetRegisterAddress (
  IN USRA_ADDRESS            *Address
  )
{
  UINTN                       AlignedAddress;

  mAccessAddrPtr[Address->Attribute.AddrType] (NULL, 0, Address, &AlignedAddress);

  return AlignedAddress;
};

/**
  This API performs 8-bit, 16-bit, 32-bit or 64-bit silicon register read operations.
  It transfers data from a register into a naturally aligned data buffer.

  @param[in] Address              A pointer of the address of the USRA Address Structure to be read out
  @param[in] Buffer               A pointer of buffer for the value read from the register

  @retval RETURN_SUCCESS          The function completed successfully.
**/
RETURN_STATUS
EFIAPI
RegisterRead (
  IN USRA_ADDRESS             *Address,
  IN VOID                     *Buffer
  )
{
  return mRegisterReadPtr[Address->Attribute.AddrType] (Address, Buffer);
};

/**
  This API performs 8-bit, 16-bit, 32-bit or 64-bit silicon register write operations.
  It transfers data from a naturally aligned data buffer into a silicon register.

  @param[in] Address              A pointer of the address of the USRA Address Structure to be written
  @param[in] Buffer               A pointer of buffer for the value write to the register

  @retval RETURN_SUCCESS          The function completed successfully.
**/
RETURN_STATUS
EFIAPI
RegisterWrite (
  IN USRA_ADDRESS             *Address,
  OUT VOID                    *Buffer
  )
{
  return mRegisterWritePtr[Address->Attribute.AddrType] (Address, Buffer);
};

/**
  This API performs 8-bit, 16-bit, 32-bit or 64-bit silicon register AND then OR operations. It read data from a
  register, And it with the AndBuffer, then Or it with the OrBuffer, and write the result back to the register

  @param[in] Address              A pointer of the address of the silicon register to be written
  @param[in] AndBuffer            A pointer of buffer for the value used for AND operation
                                  A NULL pointer means no AND operation. RegisterModify() equivalents to RegisterOr()
  @param[in] OrBuffer             A pointer of buffer for the value used for OR operation
                                  A NULL pointer means no OR operation. RegisterModify() equivalents to RegisterAnd()

  @retval RETURN_SUCCESS          The function completed successfully.
**/
RETURN_STATUS
EFIAPI
RegisterModify (
  IN USRA_ADDRESS             *Address,
  IN VOID                     *AndBuffer,
  IN VOID                     *OrBuffer
  )
{
  return mRegisterModifyPtr[Address->Attribute.AddrType] (Address, AndBuffer, OrBuffer);
};