/** @file

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

**/

#include "GpioLibrary.h"
#include <Uefi/UefiMultiPhase.h>
#include <Pi/PiMultiPhase.h>
#include <Library/HobLib.h>

//
// Possible registers to be accessed using GpioReadWriteReg() function
//
typedef enum {
  GpioHostOwnershipRegister = 0,
  GpioGpeEnableRegister,
  GpioSmiEnableRegister,
  GpioNmiEnableRegister,
  GpioPadConfigLockRegister,
  GpioPadLockOutputRegister
} GPIO_REG;

/**
  This procedure will write or read GPIO Pad Configuration register

  @param[in] GpioPad              GPIO pad
  @param[in] DwReg                Choose PADCFG register: 0:DW0, 1:DW1
  @param[in] Mask                 Mask
  @param[in] Write                Perform read(0) or write(1)
  @param[in,out] ReadWriteValue   Read/Write data

  @retval EFI_SUCCESS             The function completed successfully
  @retval EFI_INVALID_PARAMETER   Invalid group or pad number
  @retval EFI_UNSUPPORTED         Host cannot access this pad
**/
static
EFI_STATUS
GpioReadWritePadCfgReg (
  IN GPIO_PAD             GpioPad,
  IN UINT8                DwReg,
  IN UINT32               Mask,
  IN BOOLEAN              Write,
  IN OUT UINT32           *ReadWriteVal
  )
{
  UINT32               PadCfgReg;
  GPIO_GROUP_INFO      *GpioGroupInfo;
  UINTN                GpioGroupInfoLength;
  UINT32               GroupIndex;
  UINT32               PadNumber;


  GPIO_PAD_OWN         PadOwnVal;


  GroupIndex = GpioGetGroupIndexFromGpioPad (GpioPad);
  PadNumber = GpioGetPadNumberFromGpioPad (GpioPad);

DEBUG_CODE_BEGIN();
  if (!GpioIsCorrectPadForThisChipset (GpioPad)) {
    DEBUG ((DEBUG_ERROR, "GPIO ERROR: Incorrect GpioPad define used on this chipset (Group=%d, Pad=%d)!\n", GroupIndex, PadNumber));
    return EFI_UNSUPPORTED;
  }
DEBUG_CODE_END();

  GpioGroupInfo = GpioGetGroupInfoTable (&GpioGroupInfoLength);

  //
  // Check if group argument exceeds GPIO GROUP INFO array
  //
  if ((UINTN)GroupIndex >= GpioGroupInfoLength) {
    DEBUG ((DEBUG_ERROR, "GPIO ERROR: Group argument (%d) exceeds GPIO group range\n", GroupIndex));
    return EFI_INVALID_PARAMETER;
  }

  //
  // Check if legal pin number
  //
  if (PadNumber >= GpioGroupInfo[GroupIndex].PadPerGroup) {
    DEBUG ((DEBUG_ERROR, "GPIO ERROR: Pin number (%d) exceeds possible range for this group\n", PadNumber));
    return EFI_INVALID_PARAMETER;
  }

  if (Write && (DwReg == 1 || (Mask & ~B_PCH_GPIO_TX_STATE) != 0) && GpioIsPadLocked (GroupIndex, PadNumber)) {
    DEBUG ((DEBUG_ERROR, "GPIO ERROR: Pad is locked (Group=%d, Pad=%d)!\n", GroupIndex, PadNumber));
    return EFI_WRITE_PROTECTED;
  }

DEBUG_CODE_BEGIN();
  //
  // Check if selected GPIO Pad is not owned by CSME/ISH
  // If GPIO is not owned by Host all access to PadCfg will be dropped
  //
  GpioGetPadOwnership (GpioPad, &PadOwnVal);
  if (PadOwnVal != GpioPadOwnHost) {
    DEBUG ((DEBUG_ERROR, "GPIO ERROR: Accessing pad not owned by host (Group=%d, Pad=%d)!\n", GroupIndex, PadNumber));
    return EFI_UNSUPPORTED;
  }

  //
DEBUG_CODE_END();

  //
  // Create Pad Configuration register offset
  //
  PadCfgReg = 0x8 * PadNumber + GpioGroupInfo[GroupIndex].PadCfgOffset;
  if(DwReg == 1) {
    PadCfgReg += 0x4;
  }

  if (Write) {
    MmioAndThenOr32 (
      (UINTN)PCH_PCR_ADDRESS (GpioGroupInfo[GroupIndex].Community, PadCfgReg),
      (UINT32)(~Mask),
      (UINT32)(*ReadWriteVal & Mask)
    );
  } else {
    *ReadWriteVal = MmioRead32 (PCH_PCR_ADDRESS (GpioGroupInfo[GroupIndex].Community, PadCfgReg));
    *ReadWriteVal &= Mask;
  }

  return EFI_SUCCESS;
}

/**
  This procedure will write or read GPIO register

  @param[in] RegType              GPIO register type
  @param[in] Group                GPIO group
  @param[in] DwNum                Register number for current group (parameter applicable in accessing whole register).
                                  For group which has less then 32 pads per group DwNum must be 0.
  @param[in] GpioPad              GPIO pad
  @param[in] Write                Perform read(0) or write(1)
  @param[in] OnePad               Access whole register(0) or one pad(1)
  @param[in,out] ReadWriteValue   Read/Write data

  @retval EFI_SUCCESS             The function completed successfully
  @retval EFI_INVALID_PARAMETER   Invalid group, pad or DwNum parameter number
**/
static
EFI_STATUS
GpioReadWriteReg (
  IN GPIO_REG                  RegType,
  IN GPIO_GROUP                Group,
  IN UINT32                    DwNum,
  IN GPIO_PAD                  GpioPad,
  IN BOOLEAN                   Write,
  IN BOOLEAN                   OnePad,
  IN OUT UINT32                *ReadWriteVal
  )
{
  UINT32               Mask;
  UINT32               RegOffset;
  UINT32               GroupIndex;
  UINT32               PadNumber;
  GPIO_GROUP_INFO      *GpioGroupInfo;
  UINTN                GpioGroupInfoLength;

  RegOffset = 0;
  GpioGroupInfo = GpioGetGroupInfoTable (&GpioGroupInfoLength);

  if (OnePad) {
    GroupIndex = GpioGetGroupIndexFromGpioPad (GpioPad);
    PadNumber = GpioGetPadNumberFromGpioPad (GpioPad);
DEBUG_CODE_BEGIN();
    if (!GpioIsCorrectPadForThisChipset (GpioPad)) {
      DEBUG ((DEBUG_ERROR, "GPIO ERROR: Incorrect GpioPad define used on this chipset (Group=%d, Pad=%d)!\n", GroupIndex, PadNumber));
      return EFI_UNSUPPORTED;
    }
DEBUG_CODE_END();
  } else {
    GroupIndex = GpioGetGroupIndexFromGroup (Group);
    PadNumber = 0;
  }
  //
  // Check if group argument exceeds GPIO GROUP INFO array
  //
  if ((UINTN)GroupIndex >= GpioGroupInfoLength) {
    DEBUG ((DEBUG_ERROR, "GPIO ERROR: Group argument (%d) exceeds GPIO group range\n", GroupIndex));
    return EFI_INVALID_PARAMETER;
  }

  switch (RegType) {
    case GpioHostOwnershipRegister:
      RegOffset = GpioGroupInfo[GroupIndex].HostOwnOffset;
      break;
    case GpioGpeEnableRegister:
      RegOffset = GpioGroupInfo[GroupIndex].GpiGpeEnOffset;
      break;
    case GpioSmiEnableRegister:
      RegOffset = GpioGroupInfo[GroupIndex].SmiEnOffset;
      break;
    case GpioNmiEnableRegister:
      RegOffset = GpioGroupInfo[GroupIndex].NmiEnOffset;
      break;
    case GpioPadConfigLockRegister:
      RegOffset = GpioGroupInfo[GroupIndex].PadCfgLockOffset;
      break;
    case GpioPadLockOutputRegister:
      RegOffset = GpioGroupInfo[GroupIndex].PadCfgLockTxOffset;
      break;
    default:
      ASSERT (FALSE);
      break;
  }

  //
  // Check if selected register exists
  //
  if (RegOffset == NO_REGISTER_FOR_PROPERTY) {
    return EFI_INVALID_PARAMETER;
  }

  //
  // Access one GPIO Pad
  //
  if (OnePad) {
    //
    // Check if legal pin number
    //
    if (PadNumber >= GpioGroupInfo[GroupIndex].PadPerGroup){
      DEBUG ((DEBUG_ERROR, "GPIO ERROR: Pin number (%d) exceeds possible range for this group\n", PadNumber));
      return EFI_INVALID_PARAMETER;
    }
    //
    // For future use. If there are more then 32 pads per group then certain
    // group information would be split into more then one DWord register.
    //
    RegOffset += (PadNumber >> 5) * 0x4;
    //
    // Calculate pad bit position within DWord register
    //
    PadNumber %= 32;
    Mask = BIT0 << PadNumber;

    if (Write) {
      MmioAndThenOr32 (
        (UINTN)PCH_PCR_ADDRESS (GpioGroupInfo[GroupIndex].Community, RegOffset),
        (UINT32)(~Mask),
        (UINT32)((*ReadWriteVal << PadNumber) & Mask)
      );
    } else {
      *ReadWriteVal = MmioRead32 (PCH_PCR_ADDRESS (GpioGroupInfo[GroupIndex].Community, RegOffset));
      *ReadWriteVal = (*ReadWriteVal & Mask) >> PadNumber;
    }
  //
  // Access whole register
  //
  } else {
    //
    // Check if DwNum argument does not exceed number of DWord registers
    // resulting from available pads for certain group
    //
    if (DwNum > ((GpioGroupInfo[GroupIndex].PadPerGroup - 1) >> 5)){
      return EFI_INVALID_PARAMETER;
    }
    //
    // For future use. If there are more then 32 pads per group then certain
    // group information would be split into more then one DWord register.
    // For SKL PCH DwNum must be 0.
    //
    RegOffset += DwNum *0x4;

    if (Write) {
      MmioWrite32 (
        (UINTN)PCH_PCR_ADDRESS (GpioGroupInfo[GroupIndex].Community, RegOffset),
        (UINT32)(*ReadWriteVal)
      );
    } else {
      *ReadWriteVal = MmioRead32 (PCH_PCR_ADDRESS (GpioGroupInfo[GroupIndex].Community, RegOffset));
    }
  }

  return EFI_SUCCESS;
}

/**
  This procedure will write GPIO Lock/LockTx register using SBI.

  @param[in] RegType              GPIO register (Lock or LockTx)
  @param[in] Unlock               Lock pads(0) or unlock(1)
  @param[in] Group                GPIO group number
  @param[in] DwNum                Register number for current group (parameter applicable in accessing whole register).
                                  For group which has less then 32 pads per group DwNum must be 0.
  @param[in] PadsToModify         Bit mask for pads that are going to be modified
  @param[in] GpioPad              GPIO pad
  @param[in] OnePad               Access whole register(0) or one pad(1)

  @retval EFI_SUCCESS             The function completed successfully
  @retval EFI_INVALID_PARAMETER   Invalid group, pad or DwNum parameter number
**/
static
EFI_STATUS
GpioLockPadsUsingSbi (
  IN GPIO_REG                  RegType,
  IN BOOLEAN                   Unlock,
  IN GPIO_GROUP                Group,
  IN UINT32                    DwNum,
  IN UINT32                    PadsToModify,
  IN GPIO_PAD                  GpioPad,
  IN BOOLEAN                   OnePad
  )
{
  UINT8                Response;
  EFI_STATUS           Status;
  GPIO_GROUP_INFO      *GpioGroupInfo;
  UINTN                GpioGroupInfoLength;
  UINT32               RegOffset;
  UINT32               OldPadCfgLockRegVal;
  UINT32               NewPadCfgLockRegVal;
  UINT32               GroupIndex;
  UINT32               PadNumber;

  RegOffset = 0;
  OldPadCfgLockRegVal = 0;
  GpioGroupInfo = GpioGetGroupInfoTable (&GpioGroupInfoLength);

  if (OnePad) {
    GroupIndex = GpioGetGroupIndexFromGpioPad (GpioPad);
    PadNumber = GpioGetPadNumberFromGpioPad (GpioPad);
    Group = GpioGetGroupFromGpioPad (GpioPad);
DEBUG_CODE_BEGIN();
    if (!GpioIsCorrectPadForThisChipset (GpioPad)) {
      DEBUG ((DEBUG_ERROR, "GPIO ERROR: Incorrect GpioPad define used on this chipset (Group=%d, Pad=%d)!\n", GroupIndex, PadNumber));
      return EFI_UNSUPPORTED;
    }
DEBUG_CODE_END();
  } else {
    GroupIndex = GpioGetGroupIndexFromGroup (Group);
    PadNumber = 0;
  }

  //
  // Check if group argument exceeds GPIO GROUP INFO array
  //
  if ((UINTN)GroupIndex >= GpioGroupInfoLength) {
    DEBUG ((DEBUG_ERROR, "GPIO ERROR: Group argument (%d) exceeds GPIO group range\n", GroupIndex));
    return EFI_INVALID_PARAMETER;
  }

  switch (RegType) {
    case GpioPadConfigLockRegister:
      RegOffset = GpioGroupInfo[GroupIndex].PadCfgLockOffset;
      break;
    case GpioPadLockOutputRegister:
      RegOffset = GpioGroupInfo[GroupIndex].PadCfgLockTxOffset;
      break;
    default:
      ASSERT (FALSE);
      break;
  }

  //
  // Check if selected register exists
  //
  if (RegOffset == NO_REGISTER_FOR_PROPERTY) {
    return EFI_INVALID_PARAMETER;
  }

  //
  // Access one GPIO Pad
  //
  if (OnePad) {
    //
    // Check if legal pin number
    //
    if (PadNumber >= GpioGroupInfo[GroupIndex].PadPerGroup){
      DEBUG ((DEBUG_ERROR, "GPIO ERROR: Pin number (%d) exceeds possible range for this group\n", PadNumber));
      return EFI_INVALID_PARAMETER;
    }

    //
    // For future use. If there are more then 32 pads per group then certain
    // group information would be split into more then one DWord register.
    //
    DwNum = (PadNumber >> 5);
    RegOffset += DwNum * 0x4;
    //
    // Calculate pad bit position within DWord register
    //
    PadNumber %= 32;

    switch (RegType) {
      case GpioPadConfigLockRegister:
        GpioGetPadCfgLockForGroupDw (Group, DwNum, &OldPadCfgLockRegVal);
        break;
      case GpioPadLockOutputRegister:
        GpioGetPadCfgLockTxForGroupDw (Group, DwNum, &OldPadCfgLockRegVal);
        break;
    }
    if (Unlock) {
      NewPadCfgLockRegVal = OldPadCfgLockRegVal & (~(0x1 << PadNumber));
    } else {
      NewPadCfgLockRegVal = OldPadCfgLockRegVal | (0x1 << PadNumber);
    }

  } else {
    //
    // Access whole register
    //

    //
    // Check if DwNum argument does not exceed number of DWord registers
    // resulting from available pads for certain group
    //
    if (DwNum > ((GpioGroupInfo[GroupIndex].PadPerGroup - 1) >> 5)){
      return EFI_INVALID_PARAMETER;
    }
    //
    // For future use. If there are more then 32 pads per group then certain
    // group information would be split into more then one DWord register.
    // For SKL PCH DwNum must be 0.
    //
    RegOffset += DwNum *0x4;

    switch (RegType) {
      case GpioPadConfigLockRegister:
        GpioGetPadCfgLockForGroupDw (Group, DwNum, &OldPadCfgLockRegVal);
        break;
      case GpioPadLockOutputRegister:
        GpioGetPadCfgLockTxForGroupDw (Group, DwNum, &OldPadCfgLockRegVal);
        break;
    }
    if (Unlock) {
      NewPadCfgLockRegVal = OldPadCfgLockRegVal & (~PadsToModify);
    } else {
      NewPadCfgLockRegVal = OldPadCfgLockRegVal | PadsToModify;
    }
  }

  Status = PchSbiExecution (
             GpioGroupInfo[GroupIndex].Community,
             RegOffset,
             GpioLockUnlock,
             FALSE,
             &NewPadCfgLockRegVal,
             &Response
             );
  ASSERT_EFI_ERROR (Status);
  return Status;
}

/**
  This procedure will read multiple GPIO settings

  @param[in]  GpioPad                   GPIO Pad
  @param[out] GpioData                  GPIO data structure

  @retval EFI_SUCCESS                   The function completed successfully
  @retval EFI_INVALID_PARAMETER         Invalid group or pad number
**/
EFI_STATUS
GpioGetPadConfig (
  IN  GPIO_PAD               GpioPad,
  OUT GPIO_CONFIG            *GpioData
  )
{
  UINT32               Dw0Reg;
  UINT32               Dw1Reg;
  UINT32               PadCfgReg;
  UINT32               RegVal;
  GPIO_GROUP_INFO      *GpioGroupInfo;
  UINTN                GpioGroupInfoLength;
  GPIO_GROUP           Group;
  UINT32               GroupIndex;
  UINT32               PadNumber;

  GPIO_PAD_OWN         PadOwnVal;


  GpioGroupInfo = GpioGetGroupInfoTable (&GpioGroupInfoLength);

  Group = GpioGetGroupFromGpioPad (GpioPad);
  GroupIndex = GpioGetGroupIndexFromGpioPad (GpioPad);
  PadNumber = GpioGetPadNumberFromGpioPad (GpioPad);

DEBUG_CODE_BEGIN();
  if (!GpioIsCorrectPadForThisChipset (GpioPad)) {
    DEBUG ((DEBUG_ERROR, "GPIO ERROR: Incorrect GpioPad define used on this chipset (Group=%d, Pad=%d)!\n", GroupIndex, PadNumber));
    ASSERT (FALSE);
    return EFI_UNSUPPORTED;
  }

  GpioGetPadOwnership (GpioPad, &PadOwnVal);
  if (PadOwnVal != GpioPadOwnHost) {
    DEBUG ((DEBUG_ERROR, "GPIO ERROR: Accessing pad not owned by host (Group=%d, Pad=%d)!\n", GroupIndex, PadNumber));
    return EFI_UNSUPPORTED;
  }
DEBUG_CODE_END();

  //
  // Check if group argument exceeds GPIO group range
  //
  if ((Group < GpioGetLowestGroup ()) || (Group > GpioGetHighestGroup ())) {
    DEBUG ((DEBUG_ERROR, "GPIO ERROR: Group argument (%d) exceeds GPIO group range\n", GroupIndex));
    return EFI_INVALID_PARAMETER;
  }

  //
  // Check if legal pin number
  //
  if (PadNumber >= GpioGroupInfo[GroupIndex].PadPerGroup){
    DEBUG ((DEBUG_ERROR, "GPIO ERROR: Pin number (%d) exceeds possible range for this group\n", PadNumber));
    return EFI_INVALID_PARAMETER;
  }

  //
  // Create PADCFG register offset using group and pad number
  //
  PadCfgReg = 0x8 * PadNumber + GpioGroupInfo[GroupIndex].PadCfgOffset;

  //
  // Read PADCFG DW0 register
  //
  Dw0Reg = MmioRead32 ((UINTN)PCH_PCR_ADDRESS (GpioGroupInfo[GroupIndex].Community, PadCfgReg));

  //
  // Read PADCFG DW1 register
  //
  Dw1Reg = MmioRead32 ((UINTN)PCH_PCR_ADDRESS (GpioGroupInfo[GroupIndex].Community, PadCfgReg + 0x4));


  //
  // Get Reset Type (PadRstCfg)
  //
  GpioData->PowerConfig = ((Dw0Reg & B_PCH_GPIO_RST_CONF) >> (N_PCH_GPIO_RST_CONF - (GPIO_CONF_RESET_BIT_POS + 1))) | (0x1 << GPIO_CONF_RESET_BIT_POS);

  //
  // Get how interrupt is triggered (RxEvCfg)
  //
  GpioData->InterruptConfig = ((Dw0Reg & B_PCH_GPIO_RX_LVL_EDG) >> (N_PCH_GPIO_RX_LVL_EDG - (GPIO_CONF_INT_TRIG_BIT_POS + 1))) | (0x1 << GPIO_CONF_INT_TRIG_BIT_POS);

  //
  // Get interrupt generation (GPIRoutIOxAPIC/SCI/SMI/NMI)
  //
  GpioData->InterruptConfig |= ((Dw0Reg & (B_PCH_GPIO_RX_NMI_ROUTE | B_PCH_GPIO_RX_SCI_ROUTE | B_PCH_GPIO_RX_SMI_ROUTE | B_PCH_GPIO_RX_APIC_ROUTE)) >> (N_PCH_GPIO_RX_NMI_ROUTE - (GPIO_CONF_INT_ROUTE_BIT_POS + 1))) | (0x1 << GPIO_CONF_INT_ROUTE_BIT_POS);

  //
  // Get GPIO direction (GPIORxDis and GPIOTxDis)
  //
  GpioData->Direction = ((Dw0Reg & (B_PCH_GPIO_RXDIS | B_PCH_GPIO_TXDIS)) >> (N_PCH_GPIO_TXDIS - (GPIO_CONF_DIR_BIT_POS + 1))) | (0x1 << GPIO_CONF_DIR_BIT_POS);

  //
  // Get GPIO input inversion (RXINV)
  //
  GpioData->Direction |= ((Dw0Reg & B_PCH_GPIO_RXINV) >> (N_PCH_GPIO_RXINV - (GPIO_CONF_INV_BIT_POS + 1))) | (0x1 << GPIO_CONF_INV_BIT_POS);

  //
  // Get GPIO output state (GPIOTxState)
  //
  GpioData->OutputState = ((Dw0Reg & B_PCH_GPIO_TX_STATE) << (N_PCH_GPIO_TX_STATE + (GPIO_CONF_OUTPUT_BIT_POS + 1))) | (0x1 << GPIO_CONF_OUTPUT_BIT_POS) ;

  //
  // Configure GPIO RX raw override to '1' (RXRAW1)
  //
  GpioData->OtherSettings = ((Dw0Reg & B_PCH_GPIO_RX_RAW1) >> (N_PCH_GPIO_RX_RAW1 - (GPIO_CONF_RXRAW_BIT_POS + 1))) | (0x1 << GPIO_CONF_RXRAW_BIT_POS) ;

  //
  // Get GPIO Pad Mode (PMode)
  //
  GpioData->PadMode = ((Dw0Reg & B_PCH_GPIO_PAD_MODE) >> (N_PCH_GPIO_PAD_MODE - (GPIO_CONF_PAD_MODE_BIT_POS + 1))) | (0x1 << GPIO_CONF_PAD_MODE_BIT_POS);

  //
  // Get GPIO termination (Term)
  //
  GpioData->ElectricalConfig = ((Dw1Reg & B_PCH_GPIO_TERM) >> (N_PCH_GPIO_TERM - (GPIO_CONF_TERM_BIT_POS + 1))) | (0x1 << GPIO_CONF_TERM_BIT_POS) ;

  //
  // Get GPIO pad tolerance (padtol)
  //
  GpioData->ElectricalConfig |= ((Dw1Reg & B_PCH_GPIO_PADTOL) >> (N_PCH_GPIO_PADTOL - (GPIO_CONF_PADTOL_BIT_POS + 1))) | (0x1 << GPIO_CONF_PADTOL_BIT_POS) ;

  //
  // Read HOSTSW_OWN registers
  //
  RegVal = MmioRead32 ((UINTN)PCH_PCR_ADDRESS (GpioGroupInfo[GroupIndex].Community, GpioGroupInfo[GroupIndex].HostOwnOffset));

  //
  // Get Host Software Ownership
  //
  GpioData->HostSoftPadOwn = (((RegVal >> PadNumber) & 0x1) << (GPIO_CONF_HOST_OWN_BIT_POS + 1)) | (0x1 << GPIO_CONF_HOST_OWN_BIT_POS);

  //
  // Read PADCFGLOCK register
  //
  RegVal = MmioRead32 ((UINTN)PCH_PCR_ADDRESS (GpioGroupInfo[GroupIndex].Community, GpioGroupInfo[GroupIndex].PadCfgLockOffset));

  //
  // Get Pad Configuration Lock state
  //
  GpioData->LockConfig = (((RegVal >> PadNumber) & 0x1) << 1) | 0x1;

  //
  // Read PADCFGLOCKTX register
  //
  RegVal = MmioRead32 ((UINTN)PCH_PCR_ADDRESS (GpioGroupInfo[GroupIndex].Community, GpioGroupInfo[GroupIndex].PadCfgLockTxOffset));

  //
  // Get Pad Configuration Lock Tx state
  //
  GpioData->LockConfig |= (((RegVal >> PadNumber) & 0x1) << 2) | 0x1;

  return EFI_SUCCESS;
}

/**
  This procedure will configure multiple GPIO settings

  @param[in] GpioPad                    GPIO Pad
  @param[in] GpioData                   GPIO data structure

  @retval EFI_SUCCESS                   The function completed successfully
  @retval EFI_INVALID_PARAMETER         Invalid group or pad number
**/
EFI_STATUS
GpioSetPadConfig (
  IN GPIO_PAD                  GpioPad,
  IN GPIO_CONFIG               *GpioData
  )
{
  UINT32               Dw0Reg;
  UINT32               Dw0RegMask;
  UINT32               Dw1Reg;
  UINT32               Dw1RegMask;
  UINT32               PadCfgReg;
  UINT32               HostSoftOwnReg;
  UINT32               HostSoftOwnRegMask;
  UINT32               GpiGpeEnReg;
  UINT32               GpiGpeEnRegMask;
  GPIO_GROUP_INFO      *GpioGroupInfo;
  UINTN                GpioGroupInfoLength;
  GPIO_GROUP           Group;
  UINT32               GroupIndex;
  UINT32               PadNumber;

  GPIO_PAD_OWN         PadOwnVal;


  GpioGroupInfo = GpioGetGroupInfoTable (&GpioGroupInfoLength);

  Dw0RegMask = 0;
  Dw0Reg = 0;
  Dw1RegMask = 0;
  Dw1Reg = 0;

  Group = GpioGetGroupFromGpioPad (GpioPad);
  GroupIndex = GpioGetGroupIndexFromGpioPad (GpioPad);
  PadNumber = GpioGetPadNumberFromGpioPad (GpioPad);

DEBUG_CODE_BEGIN();
  if (!GpioIsCorrectPadForThisChipset (GpioPad)) {
    DEBUG ((DEBUG_ERROR, "GPIO ERROR: Incorrect GpioPad define used on this chipset (Group=%d, Pad=%d)!\n", GroupIndex, PadNumber));
    ASSERT (FALSE);
    return EFI_UNSUPPORTED;
  }

  GpioGetPadOwnership (GpioPad, &PadOwnVal);
  if (PadOwnVal != GpioPadOwnHost) {
    DEBUG ((DEBUG_ERROR, "GPIO ERROR: Accessing pad not owned by host (Group=%d, Pad=%d)!\n", GroupIndex, PadNumber));
    return EFI_UNSUPPORTED;
  }
DEBUG_CODE_END();
  //
  // Check if group argument exceeds GPIO group range
  //
  if ((Group < GpioGetLowestGroup ()) || (Group > GpioGetHighestGroup ())) {
    DEBUG ((DEBUG_ERROR, "GPIO ERROR: Group argument (%d) exceeds GPIO group range\n", GroupIndex));
    return EFI_INVALID_PARAMETER;
  }

  //
  // Check if legal pin number
  //
  if (PadNumber >= GpioGroupInfo[GroupIndex].PadPerGroup) {
    DEBUG ((DEBUG_ERROR, "GPIO ERROR: Pin number (%d) exceeds possible range for this group\n", PadNumber));
    return EFI_INVALID_PARAMETER;
  }

  if (GpioIsPadLocked (GroupIndex, PadNumber)) {
    DEBUG ((DEBUG_ERROR, "GPIO ERROR: Pad is locked (Group=%d, Pad=%d)!\n", GroupIndex, PadNumber));
    return EFI_WRITE_PROTECTED;
  }

  //
  // Configure Reset Type (PadRstCfg)
  //
  Dw0RegMask |= ((((GpioData->PowerConfig & GPIO_CONF_RESET_MASK) >> GPIO_CONF_RESET_BIT_POS) == GpioHardwareDefault) ? 0x0 : B_PCH_GPIO_RST_CONF);
  Dw0Reg |= (((GpioData->PowerConfig & GPIO_CONF_RESET_MASK) >> (GPIO_CONF_RESET_BIT_POS + 1)) << N_PCH_GPIO_RST_CONF);

  //
  // Configure how interrupt is triggered (RxEvCfg)
  //
  Dw0RegMask |= ((((GpioData->InterruptConfig & GPIO_CONF_INT_TRIG_MASK) >> GPIO_CONF_INT_TRIG_BIT_POS) == GpioHardwareDefault) ? 0x0 : B_PCH_GPIO_RX_LVL_EDG);
  Dw0Reg |= (((GpioData->InterruptConfig & GPIO_CONF_INT_TRIG_MASK) >> (GPIO_CONF_INT_TRIG_BIT_POS + 1)) << N_PCH_GPIO_RX_LVL_EDG);

  //
  // Configure interrupt generation (GPIRoutIOxAPIC/SCI/SMI/NMI)
  //
  Dw0RegMask |= ((((GpioData->InterruptConfig & GPIO_CONF_INT_ROUTE_MASK) >> GPIO_CONF_INT_ROUTE_BIT_POS) == GpioHardwareDefault)  ? 0x0 : (B_PCH_GPIO_RX_NMI_ROUTE | B_PCH_GPIO_RX_SCI_ROUTE | B_PCH_GPIO_RX_SMI_ROUTE | B_PCH_GPIO_RX_APIC_ROUTE));
  Dw0Reg |= (((GpioData->InterruptConfig & GPIO_CONF_INT_ROUTE_MASK) >> (GPIO_CONF_INT_ROUTE_BIT_POS + 1)) << N_PCH_GPIO_RX_NMI_ROUTE);

  //
  // Configure GPIO direction (GPIORxDis and GPIOTxDis)
  //
  Dw0RegMask |= ((((GpioData->Direction & GPIO_CONF_DIR_MASK) >> GPIO_CONF_DIR_BIT_POS) == GpioHardwareDefault) ? 0x0 : (B_PCH_GPIO_RXDIS | B_PCH_GPIO_TXDIS));
  Dw0Reg |= (((GpioData->Direction & GPIO_CONF_DIR_MASK) >> (GPIO_CONF_DIR_BIT_POS + 1)) << N_PCH_GPIO_TXDIS);

  //
  // Configure GPIO input inversion (RXINV)
  //
  Dw0RegMask |= ((((GpioData->Direction & GPIO_CONF_INV_MASK) >> GPIO_CONF_INV_BIT_POS) == GpioHardwareDefault) ?  0x0 : B_PCH_GPIO_RXINV);
  Dw0Reg |= (((GpioData->Direction & GPIO_CONF_INV_MASK) >> (GPIO_CONF_INV_BIT_POS + 1)) << N_PCH_GPIO_RXINV);

  //
  // Configure GPIO output state (GPIOTxState)
  //
  Dw0RegMask |= ((((GpioData->OutputState & GPIO_CONF_OUTPUT_MASK) >> GPIO_CONF_OUTPUT_BIT_POS) == GpioHardwareDefault) ? 0x0 : B_PCH_GPIO_TX_STATE);
  Dw0Reg |= (((GpioData->OutputState & GPIO_CONF_OUTPUT_MASK) >> (GPIO_CONF_OUTPUT_BIT_POS + 1)) << N_PCH_GPIO_TX_STATE);

  //
  // Configure GPIO RX raw override to '1' (RXRAW1)
  //
  Dw0RegMask |= ((((GpioData->OtherSettings & GPIO_CONF_RXRAW_MASK) >> GPIO_CONF_RXRAW_BIT_POS) == GpioHardwareDefault) ? 0x0 : B_PCH_GPIO_RX_RAW1);
  Dw0Reg |= (((GpioData->OtherSettings & GPIO_CONF_RXRAW_MASK) >> (GPIO_CONF_RXRAW_BIT_POS + 1)) << N_PCH_GPIO_RX_RAW1);

  //
  // Configure GPIO Pad Mode (PMode)
  //
  Dw0RegMask |= ((((GpioData->PadMode & GPIO_CONF_PAD_MODE_MASK) >> GPIO_CONF_PAD_MODE_BIT_POS) == GpioHardwareDefault) ? 0x0 : B_PCH_GPIO_PAD_MODE);
  Dw0Reg |= (((GpioData->PadMode & GPIO_CONF_PAD_MODE_MASK) >> (GPIO_CONF_PAD_MODE_BIT_POS + 1)) << N_PCH_GPIO_PAD_MODE);

  //
  // Configure GPIO termination (Term)
  //
  Dw1RegMask |= ((((GpioData->ElectricalConfig & GPIO_CONF_TERM_MASK) >> GPIO_CONF_TERM_BIT_POS) == GpioHardwareDefault) ? 0x0 : B_PCH_GPIO_TERM);
  Dw1Reg |= (((GpioData->ElectricalConfig & GPIO_CONF_TERM_MASK) >> (GPIO_CONF_TERM_BIT_POS + 1)) << N_PCH_GPIO_TERM);

  //
  // Configure GPIO pad tolerance (padtol)
  //
  Dw1RegMask |= ((((GpioData->ElectricalConfig & GPIO_CONF_PADTOL_MASK) >> GPIO_CONF_PADTOL_BIT_POS) == GpioHardwareDefault) ? 0x0 : B_PCH_GPIO_PADTOL);
  Dw1Reg |= (((GpioData->ElectricalConfig & GPIO_CONF_PADTOL_MASK) >> (GPIO_CONF_PADTOL_BIT_POS + 1)) << N_PCH_GPIO_PADTOL);

  //
  // Create PADCFG register offset using group and pad number
  //
  PadCfgReg = 0x8 * PadNumber + GpioGroupInfo[GroupIndex].PadCfgOffset;

  //
  // Write PADCFG DW0 register
  //
  MmioAndThenOr32 (
    (UINTN)PCH_PCR_ADDRESS (GpioGroupInfo[GroupIndex].Community, PadCfgReg),
    ~(UINT32)Dw0RegMask,
    (UINT32)Dw0Reg
  );

  //
  // Write PADCFG DW1 register
  //
  MmioAndThenOr32 (
    (UINTN)PCH_PCR_ADDRESS (GpioGroupInfo[GroupIndex].Community, PadCfgReg + 0x4),
    ~(UINT32)Dw1RegMask,
    (UINT32)Dw1Reg
  );

  //
  // Update value to be programmed in HOSTSW_OWN register
  //
  HostSoftOwnRegMask = (GpioData->HostSoftPadOwn & 0x1) << PadNumber;
  HostSoftOwnReg = (GpioData->HostSoftPadOwn >> 0x1) << PadNumber;

  //
  // Write HOSTSW_OWN registers
  //
  MmioAndThenOr32 (
    (UINTN)PCH_PCR_ADDRESS (GpioGroupInfo[GroupIndex].Community, GpioGroupInfo[GroupIndex].HostOwnOffset),
    ~(UINT32)HostSoftOwnRegMask,
    (UINT32)HostSoftOwnReg
    );

  //
  // Update value to be programmed in GPI_GPE_EN register
  //
  GpiGpeEnRegMask = (GpioData->InterruptConfig & 0x1) << PadNumber;
  GpiGpeEnReg = ((GpioData->InterruptConfig & GpioIntSci) >> 3) << PadNumber;

  //
  // Write GPI_GPE_EN registers
  //
  MmioAndThenOr32 (
    (UINTN)PCH_PCR_ADDRESS (GpioGroupInfo[GroupIndex].Community, GpioGroupInfo[GroupIndex].GpiGpeEnOffset),
    ~(UINT32)GpiGpeEnRegMask,
    (UINT32)GpiGpeEnReg
    );

  //
  // Program Pad Configuration Lock
  //
  if ((GpioData->LockConfig & GpioPadConfigLock) == GpioPadConfigLock) {
    GpioLockPadsUsingSbi (
                 GpioPadConfigLockRegister,
                 FALSE,
                 0,
                 0,
                 0,
                 GpioPad,
                 TRUE
                 );
  }

  //
  // Program Pad Configuration Lock Tx
  //
  if ((GpioData->LockConfig & GpioOutputStateLock) == GpioOutputStateLock) {
    GpioLockPadsUsingSbi (
                 GpioPadLockOutputRegister,
                 FALSE,
                 0,
                 0,
                 0,
                 GpioPad,
                 TRUE
                 );
  }
  return EFI_SUCCESS;
}

/**
  This procedure will set GPIO output level

  @param[in] GpioPad              GPIO pad
  @param[in] Value                Output value
                                  0: OutputLow, 1: OutputHigh

  @retval EFI_SUCCESS             The function completed successfully
  @retval EFI_INVALID_PARAMETER   Invalid group or pad number
**/
EFI_STATUS
GpioSetOutputValue (
  IN GPIO_PAD                  GpioPad,
  IN UINT32                    Value
  )
{
  EFI_STATUS Status;

  Status = GpioReadWritePadCfgReg (
            GpioPad,
            0,
            B_PCH_GPIO_TX_STATE,
            TRUE,
            &Value
            );
  ASSERT_EFI_ERROR (Status);
  return Status;
}

/**
  This procedure will get GPIO output level

  @param[in]  GpioPad             GPIO pad
  @param[out] OutputVal           GPIO Output value
                                  0: OutputLow, 1: OutputHigh

  @retval EFI_SUCCESS             The function completed successfully
  @retval EFI_INVALID_PARAMETER   Invalid group or pad number
**/
EFI_STATUS
GpioGetOutputValue (
  IN GPIO_PAD                  GpioPad,
  OUT UINT32                   *OutputVal
  )
{
  EFI_STATUS Status;

  Status = GpioReadWritePadCfgReg (
             GpioPad,
             0,
             B_PCH_GPIO_TX_STATE,
             FALSE,
             OutputVal
             );
  ASSERT_EFI_ERROR (Status);
  *OutputVal >>= N_PCH_GPIO_TX_STATE;

  return Status;
}

/**
  This procedure will get GPIO input level

  @param[in] GpioPad              GPIO pad
  @param[out] InputVal            GPIO Input value
                                  0: InputLow, 1: InpuHigh

  @retval EFI_SUCCESS             The function completed successfully
  @retval EFI_INVALID_PARAMETER   Invalid group or pad number
**/
EFI_STATUS
GpioGetInputValue (
  IN GPIO_PAD                  GpioPad,
  OUT UINT32                   *InputVal
  )
{
  EFI_STATUS Status;

  Status = GpioReadWritePadCfgReg (
             GpioPad,
             0,
             B_PCH_GPIO_RX_STATE,
             FALSE,
             InputVal
             );
  ASSERT_EFI_ERROR (Status);
  *InputVal >>= N_PCH_GPIO_RX_STATE;

  return Status;
}

/**
  This procedure will get GPIO IOxAPIC interrupt number

  @param[in]  GpioPad             GPIO pad
  @param[out] IrqNum              IRQ number

  @retval EFI_SUCCESS             The function completed successfully
  @retval EFI_INVALID_PARAMETER   Invalid group or pad number
**/
EFI_STATUS
GpioGetPadIoApicIrqNumber (
  IN GPIO_PAD                  GpioPad,
  OUT UINT32                   *IrqNum
  )
{
  EFI_STATUS Status;

  Status = GpioReadWritePadCfgReg (
             GpioPad,
             1,
             B_PCH_GPIO_INTSEL,
             FALSE,
             IrqNum
             );
  ASSERT_EFI_ERROR (Status);
  *IrqNum >>= N_PCH_GPIO_INTSEL;

  return Status;
}

/**
  This procedure will configure GPIO input inversion

  @param[in] GpioPad              GPIO pad
  @param[in] Value                Value for GPIO input inversion
                                  0: No input inversion, 1: Invert input

  @retval EFI_SUCCESS             The function completed successfully
  @retval EFI_INVALID_PARAMETER   Invalid group or pad number
**/
EFI_STATUS
GpioSetInputInversion (
  IN GPIO_PAD                  GpioPad,
  IN UINT32                    Value
  )
{
  EFI_STATUS Status;

  Value <<= N_PCH_GPIO_RXINV;
  Status = GpioReadWritePadCfgReg (
             GpioPad,
             0,
             B_PCH_GPIO_RXINV,
             TRUE,
             &Value
             );
  ASSERT_EFI_ERROR (Status);
  return Status;
}

/**
  This procedure will get GPIO pad input inversion value

  @param[in]  GpioPad             GPIO pad
  @param[out] InvertState         GPIO inversion state
                                  0: No input inversion, 1: Inverted input

  @retval EFI_SUCCESS             The function completed successfully
  @retval EFI_INVALID_PARAMETER   Invalid group or pad number
**/
EFI_STATUS
GpioGetInputInversion (
  IN  GPIO_PAD                 GpioPad,
  OUT UINT32                   *InvertState
  )
{
  EFI_STATUS Status;

  Status = GpioReadWritePadCfgReg (
             GpioPad,
             0,
             B_PCH_GPIO_RXINV,
             FALSE,
             InvertState
             );
  ASSERT_EFI_ERROR (Status);
  *InvertState >>= N_PCH_GPIO_RXINV;

  return Status;
}

/**
  This procedure will set GPIO interrupt settings

  @param[in] GpioPad              GPIO pad
  @param[in] Value                Value of Level/Edge
                                  use GPIO_INT_CONFIG as argument

  @retval EFI_SUCCESS             The function completed successfully
  @retval EFI_INVALID_PARAMETER   Invalid group or pad number
**/
EFI_STATUS
GpioSetPadInterruptConfig (
  IN GPIO_PAD                 GpioPad,
  IN GPIO_INT_CONFIG          Value
  )
{
  EFI_STATUS  Status;
  UINT32      RxLvlEdgeValue;
  UINT32      IntRouteValue;
  UINT32      GpeEnable;

  Status = EFI_SUCCESS;

  if (((Value & GPIO_CONF_INT_TRIG_MASK) >> GPIO_CONF_INT_TRIG_BIT_POS) != GpioHardwareDefault) {
    RxLvlEdgeValue = ((Value & GPIO_CONF_INT_TRIG_MASK) >> (GPIO_CONF_INT_TRIG_BIT_POS + 1)) << N_PCH_GPIO_RX_LVL_EDG;

    Status = GpioReadWritePadCfgReg (
               GpioPad,
               0,
               B_PCH_GPIO_RX_LVL_EDG,
               TRUE,
               &RxLvlEdgeValue
               );
    ASSERT_EFI_ERROR (Status);
  }

  if (((Value & GPIO_CONF_INT_ROUTE_MASK) >> GPIO_CONF_INT_ROUTE_BIT_POS) != GpioHardwareDefault) {

    IntRouteValue = ((Value & GPIO_CONF_INT_ROUTE_MASK) >> (GPIO_CONF_INT_ROUTE_BIT_POS + 1)) << N_PCH_GPIO_RX_NMI_ROUTE;

    Status = GpioReadWritePadCfgReg (
               GpioPad,
               0,
               (B_PCH_GPIO_RX_NMI_ROUTE | B_PCH_GPIO_RX_SCI_ROUTE | B_PCH_GPIO_RX_SMI_ROUTE | B_PCH_GPIO_RX_APIC_ROUTE),
               TRUE,
               &IntRouteValue
               );
    ASSERT_EFI_ERROR (Status);

    if ((Value & GpioIntSci) == GpioIntSci) {
      GpeEnable = 0x1;
    } else {
      GpeEnable = 0x0;
    }

    Status = GpioReadWriteReg (
               GpioGpeEnableRegister,
               0,
               0,
               GpioPad,
               TRUE,
               TRUE,
               &GpeEnable
               );
    ASSERT_EFI_ERROR (Status);
  }

  return Status;
}

/**
  This procedure will set GPIO electrical settings

  @param[in] GpioPad              GPIO pad
  @param[in] Value                Value of termination
                                  use GPIO_ELECTRICAL_CONFIG as argument

  @retval EFI_SUCCESS             The function completed successfully
  @retval EFI_INVALID_PARAMETER   Invalid group or pad number
**/
EFI_STATUS
GpioSetPadElectricalConfig (
  IN GPIO_PAD                  GpioPad,
  IN GPIO_ELECTRICAL_CONFIG    Value
  )
{
  EFI_STATUS  Status;
  UINT32      TermValue;
  UINT32      PadTolValue;

  Status = EFI_SUCCESS;

  if (((Value & GPIO_CONF_TERM_MASK) >> GPIO_CONF_TERM_BIT_POS) != GpioHardwareDefault) {
    TermValue = ((Value & GPIO_CONF_TERM_MASK) >> (GPIO_CONF_TERM_BIT_POS + 1)) << N_PCH_GPIO_TERM;

    Status = GpioReadWritePadCfgReg (
               GpioPad,
               1,
               B_PCH_GPIO_TERM,
               TRUE,
               &TermValue
               );
    ASSERT_EFI_ERROR (Status);
  }

  if (((Value & GPIO_CONF_PADTOL_MASK) >> GPIO_CONF_PADTOL_BIT_POS) != GpioHardwareDefault) {
    PadTolValue = ((Value & GPIO_CONF_PADTOL_MASK) >> (GPIO_CONF_PADTOL_BIT_POS + 1)) << N_PCH_GPIO_PADTOL;

    Status = GpioReadWritePadCfgReg (
               GpioPad,
               1,
               B_PCH_GPIO_PADTOL,
               TRUE,
               &PadTolValue
               );
    ASSERT_EFI_ERROR (Status);
  }
  return Status;
}

/**
  This procedure will set GPIO Reset settings

  @param[in] GpioPad              GPIO pad
  @param[in] Value                Value for Pad Reset Configuration
                                  use GPIO_RESET_CONFIG as argument

  @retval EFI_SUCCESS             The function completed successfully
  @retval EFI_INVALID_PARAMETER   Invalid group or pad number
**/
EFI_STATUS
GpioSetPadResetConfig (
  IN GPIO_PAD                  GpioPad,
  IN GPIO_RESET_CONFIG         Value
  )
{
  EFI_STATUS  Status;
  UINT32      ResetValue;

  Status = EFI_SUCCESS;

  if (((Value & GPIO_CONF_RESET_MASK) >> GPIO_CONF_RESET_BIT_POS) != GpioHardwareDefault) {
    ResetValue = ((Value & GPIO_CONF_RESET_MASK) >> (GPIO_CONF_RESET_BIT_POS + 1)) << N_PCH_GPIO_RST_CONF;

    Status = GpioReadWritePadCfgReg (
               GpioPad,
               0,
               B_PCH_GPIO_RST_CONF,
               TRUE,
               &ResetValue
               );
    ASSERT_EFI_ERROR (Status);
  }
  return Status;
}

/**
  This procedure will get GPIO Reset settings

  @param[in] GpioPad              GPIO pad
  @param[in] Value                Value of Pad Reset Configuration
                                  based on GPIO_RESET_CONFIG

  @retval EFI_SUCCESS             The function completed successfully
  @retval EFI_INVALID_PARAMETER   Invalid group or pad number
**/
EFI_STATUS
GpioGetPadResetConfig (
  IN GPIO_PAD                  GpioPad,
  IN GPIO_RESET_CONFIG         *Value
  )
{
  EFI_STATUS  Status;
  UINT32      ResetValue;

  Status = GpioReadWritePadCfgReg (
             GpioPad,
             0,
             B_PCH_GPIO_RST_CONF,
             FALSE,
             &ResetValue
             );
  ASSERT_EFI_ERROR (Status);

  //
  // Get Reset Type (PadRstCfg)
  //
  *Value = (ResetValue >> (N_PCH_GPIO_RST_CONF - (GPIO_CONF_RESET_BIT_POS + 1))) | (0x1 << GPIO_CONF_RESET_BIT_POS);

  return Status;
}

/**
  This procedure will get GPIO Host Software Pad Ownership for certain group

  @param[in]  Group               GPIO group
  @param[in]  DwNum               Host Ownership register number for current group.
                                  For group which has less then 32 pads per group DwNum must be 0.
  @param[out] HostSwRegVal        Value of Host Software Pad Ownership register
                                  Bit position - PadNumber
                                  Bit value - 0: ACPI Mode, 1: GPIO Driver mode

  @retval EFI_SUCCESS             The function completed successfully
  @retval EFI_INVALID_PARAMETER   Invalid group or DwNum parameter number
**/
EFI_STATUS
GpioGetHostSwOwnershipForGroupDw (
  IN  GPIO_GROUP                  Group,
  IN  UINT32                      DwNum,
  OUT UINT32                      *HostSwRegVal
  )
{
  EFI_STATUS  Status;

  Status = GpioReadWriteReg (
             GpioHostOwnershipRegister,
             Group,
             DwNum,
             0,
             FALSE,
             FALSE,
             HostSwRegVal
             );
  ASSERT_EFI_ERROR (Status);
  return Status;
}

/**
  This procedure will get GPIO Host Software Pad Ownership for certain group

  @param[in]  Group               GPIO group
  @param[in]  DwNum               Host Ownership register number for current group
                                  For group which has less then 32 pads per group DwNum must be 0.
  @param[in]  HostSwRegVal        Value of Host Software Pad Ownership register
                                  Bit position - PadNumber
                                  Bit value - 0: ACPI Mode, 1: GPIO Driver mode

  @retval EFI_SUCCESS             The function completed successfully
  @retval EFI_INVALID_PARAMETER   Invalid group or DwNum parameter number
**/
EFI_STATUS
GpioSetHostSwOwnershipForGroupDw (
  IN GPIO_GROUP                   Group,
  IN UINT32                       DwNum,
  IN UINT32                       HostSwRegVal
  )
{
  EFI_STATUS  Status;

  Status = GpioReadWriteReg (
             GpioHostOwnershipRegister,
             Group,
             DwNum,
             0,
             TRUE,
             FALSE,
             &HostSwRegVal
             );
  ASSERT_EFI_ERROR (Status);
  return Status;
}

/**
  This procedure will get Gpio Pad Host Software Ownership

  @param[in]  GpioPad             GPIO pad
  @param[out] PadHostSwOwn        Value of Host Software Pad Owner
                                  0: ACPI Mode, 1: GPIO Driver mode

  @retval EFI_SUCCESS             The function completed successfully
  @retval EFI_INVALID_PARAMETER   Invalid group or pad number
**/
EFI_STATUS
GpioGetHostSwOwnershipForPad (
  IN GPIO_PAD                 GpioPad,
  OUT UINT32                  *PadHostSwOwn
  )
{
  EFI_STATUS  Status;

  Status = GpioReadWriteReg (
             GpioHostOwnershipRegister,
             0,
             0,
             GpioPad,
             FALSE,
             TRUE,
             PadHostSwOwn
             );
  ASSERT_EFI_ERROR (Status);
  return Status;
}

/**
  This procedure will set Gpio Pad Host Software Ownership

  @param[in] GpioPad              GPIO pad
  @param[in] PadHostSwOwn         Pad Host Software Owner
                                  0: ACPI Mode, 1: GPIO Driver mode

  @retval EFI_SUCCESS             The function completed successfully
  @retval EFI_INVALID_PARAMETER   Invalid group or pad number
**/
EFI_STATUS
GpioSetHostSwOwnershipForPad (
  IN GPIO_PAD                  GpioPad,
  IN UINT32                    PadHostSwOwn
  )
{
  EFI_STATUS  Status;

  Status = GpioReadWriteReg (
             GpioHostOwnershipRegister,
             0,
             0,
             GpioPad,
             TRUE,
             TRUE,
             &PadHostSwOwn
             );
  ASSERT_EFI_ERROR (Status);
  return Status;
}

/**
  This procedure will get Gpio Pad Ownership

  @param[in] GpioPad              GPIO pad
  @param[out] PadOwnVal           Value of Pad Ownership

  @retval EFI_SUCCESS             The function completed successfully
  @retval EFI_INVALID_PARAMETER   Invalid group or pad number
**/
EFI_STATUS
GpioGetPadOwnership (
  IN  GPIO_PAD                GpioPad,
  OUT GPIO_PAD_OWN            *PadOwnVal
  )
{
  UINT32               Mask;
  UINT32               RegOffset;
  UINT32               GroupIndex;
  UINT32               PadNumber;
  GPIO_GROUP_INFO      *GpioGroupInfo;
  UINTN                GpioGroupInfoLength;
  UINT32               PadOwnRegValue;

  GroupIndex = GpioGetGroupIndexFromGpioPad (GpioPad);
  PadNumber = GpioGetPadNumberFromGpioPad (GpioPad);

  GpioGroupInfo = GpioGetGroupInfoTable (&GpioGroupInfoLength);

  //
  // Check if group argument exceeds GPIO GROUP INFO array
  //
  if ((UINTN)GroupIndex >= GpioGroupInfoLength) {
    DEBUG ((DEBUG_ERROR, "GPIO ERROR: Group argument (%d) exceeds GPIO group range\n", GroupIndex));
    ASSERT(FALSE);
    return EFI_INVALID_PARAMETER;
  }

  //
  // Check if legal pin number
  //
  if (PadNumber >= GpioGroupInfo[GroupIndex].PadPerGroup) {
    DEBUG ((DEBUG_ERROR, "GPIO ERROR: Pin number (%d) exceeds possible range for this group\n", PadNumber));
    ASSERT(FALSE);
    return EFI_INVALID_PARAMETER;
  }
  //
  // Calculate RegOffset using Pad Ownership offset and GPIO Pad number.
  // One DWord register contains information for 8 pads.
  //
  RegOffset = GpioGroupInfo[GroupIndex].PadOwnOffset + (PadNumber >> 3) * 0x4;

  //
  // Calculate pad bit position within DWord register
  //
  PadNumber %= 8;
  Mask = (BIT1 | BIT0) << (PadNumber * 4);

  PadOwnRegValue = MmioRead32 (PCH_PCR_ADDRESS (GpioGroupInfo[GroupIndex].Community, RegOffset));

  *PadOwnVal = (GPIO_PAD_OWN)((PadOwnRegValue & Mask) >> (PadNumber * 4));

  return EFI_SUCCESS;
}

/**
  This procedure will check state of Pad Config Lock for pads within one group

  @param[in]  Group               GPIO group
  @param[in]  DwNum               PadCfgLock register number for current group.
                                  For group which has less then 32 pads per group DwNum must be 0.
  @param[out] PadCfgLockRegVal    Value of PadCfgLock register
                                  Bit position - PadNumber
                                  Bit value - 0: NotLocked, 1: Locked

  @retval EFI_SUCCESS             The function completed successfully
  @retval EFI_INVALID_PARAMETER   Invalid group or DwNum parameter number
**/
EFI_STATUS
GpioGetPadCfgLockForGroupDw (
  IN  GPIO_GROUP                  Group,
  IN  UINT32                      DwNum,
  OUT UINT32                      *PadCfgLockRegVal
  )
{
  EFI_STATUS  Status;

  Status = GpioReadWriteReg (
             GpioPadConfigLockRegister,
             Group,
             DwNum,
             0,
             FALSE,
             FALSE,
             PadCfgLockRegVal
             );
  ASSERT_EFI_ERROR (Status);
  return Status;
}

/**
  This procedure will check state of Pad Config Lock for selected pad

  @param[in] GpioPad              GPIO pad
  @param[out] PadCfgLock          PadCfgLock for selected pad
                                  0: NotLocked, 1: Locked

  @retval EFI_SUCCESS             The function completed successfully
  @retval EFI_INVALID_PARAMETER   Invalid group or pad number
**/
EFI_STATUS
GpioGetPadCfgLock (
  IN GPIO_PAD                   GpioPad,
  OUT UINT32                    *PadCfgLock
  )
{
  EFI_STATUS  Status;

  Status = GpioReadWriteReg (
             GpioPadConfigLockRegister,
             0,
             0,
             GpioPad,
             FALSE,
             TRUE,
             PadCfgLock
             );
  ASSERT_EFI_ERROR (Status);
  return Status;
}

/**
  This procedure will check state of Pad Config Tx Lock for pads within one group

  @param[in]  Group               GPIO group
  @param[in]  DwNum               PadCfgLockTx register number for current group.
                                  For group which has less then 32 pads per group DwNum must be 0.
  @param[out] PadCfgLockTxRegVal  Value of PadCfgLockTx register
                                  Bit position - PadNumber
                                  Bit value - 0: NotLockedTx, 1: LockedTx

  @retval EFI_SUCCESS             The function completed successfully
  @retval EFI_INVALID_PARAMETER   Invalid group or DwNum parameter number
**/
EFI_STATUS
GpioGetPadCfgLockTxForGroupDw (
  IN  GPIO_GROUP                  Group,
  IN  UINT32                      DwNum,
  OUT UINT32                      *PadCfgLockTxRegVal
  )
{
  EFI_STATUS  Status;

  Status = GpioReadWriteReg (
             GpioPadLockOutputRegister,
             Group,
             DwNum,
             0,
             FALSE,
             FALSE,
             PadCfgLockTxRegVal
             );
  ASSERT_EFI_ERROR (Status);
  return Status;
}

/**
  This procedure will check state of Pad Config Tx Lock for selected pad

  @param[in] GpioPad              GPIO pad
  @param[out] PadCfgLock          PadCfgLockTx for selected pad
                                  0: NotLockedTx, 1: LockedTx

  @retval EFI_SUCCESS             The function completed successfully
  @retval EFI_INVALID_PARAMETER   Invalid group or pad number
**/
EFI_STATUS
GpioGetPadCfgLockTx (
  IN GPIO_PAD                   GpioPad,
  OUT UINT32                    *PadCfgLockTx
  )
{
  EFI_STATUS  Status;

  Status = GpioReadWriteReg (
             GpioPadLockOutputRegister,
             0,
             0,
             GpioPad,
             FALSE,
             TRUE,
             PadCfgLockTx
             );
  ASSERT_EFI_ERROR (Status);
  return Status;
}

/**
  This procedure will clear PadCfgLock for selected pads within one group.
  This function should be used only inside SMI.

  @param[in]  Group               GPIO group
  @param[in]  DwNum               PadCfgLock register number for current group.
                                  For group which has less then 32 pads per group DwNum must be 0.
  @param[in]  PadsToUnlock        Bitmask for pads which are going to be unlocked,
                                  Bit position - PadNumber
                                  Bit value - 0: DoNotUnlock, 1: Unlock

  @retval EFI_SUCCESS             The function completed successfully
  @retval EFI_INVALID_PARAMETER   Invalid group or pad number
**/
EFI_STATUS
GpioUnlockPadCfgForGroupDw (
  IN GPIO_GROUP                Group,
  IN UINT32                    DwNum,
  IN UINT32                    PadsToUnlock
  )
{
  EFI_STATUS           Status;

  Status = GpioLockPadsUsingSbi (
             GpioPadConfigLockRegister,
             TRUE,
             Group,
             DwNum,
             PadsToUnlock,
             0,
             FALSE
             );
  ASSERT_EFI_ERROR (Status);
  return Status;
}

/**
  This procedure will clear PadCfgLock for selected pad.
  This function should be used only inside SMI.

  @param[in] GpioPad              GPIO pad

  @retval EFI_SUCCESS             The function completed successfully
  @retval EFI_INVALID_PARAMETER   Invalid group or pad number
**/
EFI_STATUS
GpioUnlockPadCfg (
    IN GPIO_PAD                   GpioPad
  )
{
  EFI_STATUS           Status;

  Status = GpioLockPadsUsingSbi (
             GpioPadConfigLockRegister,
             TRUE,
             0,
             0,
             0,
             GpioPad,
             TRUE
             );
  ASSERT_EFI_ERROR (Status);
  return Status;
}

/**
  This procedure will set PadCfgLock for selected pads within one group

  @param[in]  Group               GPIO group
  @param[in]  DwNum               PadCfgLock register number for current group.
                                  For group which has less then 32 pads per group DwNum must be 0.
  @param[in]  PadsToLock          Bitmask for pads which are going to be locked
                                  Bit position - PadNumber
                                  Bit value - 0: DoNotLock, 1: Lock

  @retval EFI_SUCCESS             The function completed successfully
  @retval EFI_INVALID_PARAMETER   Invalid group or DwNum parameter number
**/
EFI_STATUS
GpioLockPadCfgForGroupDw (
  IN GPIO_GROUP                   Group,
  IN UINT32                       DwNum,
  IN UINT32                       PadsToLock
  )
{
  EFI_STATUS           Status;

  Status = GpioLockPadsUsingSbi (
             GpioPadConfigLockRegister,
             FALSE,
             Group,
             DwNum,
             PadsToLock,
             0,
             FALSE
             );
  ASSERT_EFI_ERROR (Status);
  return Status;
}

/**
  This procedure will set PadCfgLock for selected pad

  @param[in] GpioPad              GPIO pad

  @retval EFI_SUCCESS             The function completed successfully
  @retval EFI_INVALID_PARAMETER   Invalid group or pad number
**/
EFI_STATUS
GpioLockPadCfg (
  IN GPIO_PAD                   GpioPad
  )
{
  EFI_STATUS           Status;

  Status = GpioLockPadsUsingSbi (
             GpioPadConfigLockRegister,
             FALSE,
             0,
             0,
             0,
             GpioPad,
             TRUE
             );
  ASSERT_EFI_ERROR (Status);
  return Status;
}

/**
  This procedure will clear PadCfgLockTx for selected pads within one group.
  This function should be used only inside SMI.

  @param[in]  Group               GPIO group
  @param[in]  DwNum               PadCfgLockTx register number for current group.
                                  For group which has less then 32 pads per group DwNum must be 0.
  @param[in]  PadsToUnlockTx      Bitmask for pads which are going to be unlocked,
                                  Bit position - PadNumber
                                  Bit value - 0: DoNotUnLockTx, 1: LockTx

  @retval EFI_SUCCESS             The function completed successfully
  @retval EFI_INVALID_PARAMETER   Invalid group or pad number
**/
EFI_STATUS
GpioUnlockPadCfgTxForGroupDw (
  IN GPIO_GROUP                Group,
  IN UINT32                    DwNum,
  IN UINT32                    PadsToUnlockTx
  )
{
  EFI_STATUS           Status;

  Status = GpioLockPadsUsingSbi (
             GpioPadLockOutputRegister,
             TRUE,
             Group,
             DwNum,
             PadsToUnlockTx,
             0,
             FALSE
             );
  ASSERT_EFI_ERROR (Status);
  return Status;
}

/**
  This procedure will clear PadCfgLockTx for selected pad.
  This function should be used only inside SMI.

  @param[in] GpioPad              GPIO pad

  @retval EFI_SUCCESS             The function completed successfully
  @retval EFI_INVALID_PARAMETER   Invalid group or pad number
**/
EFI_STATUS
GpioUnlockPadCfgTx (
  IN GPIO_PAD                   GpioPad
  )
{
  EFI_STATUS           Status;

  Status = GpioLockPadsUsingSbi (
             GpioPadLockOutputRegister,
             TRUE,
             0,
             0,
             0,
             GpioPad,
             TRUE
             );
  ASSERT_EFI_ERROR (Status);
  return Status;
}

/**
  This procedure will set PadCfgLockTx for selected pads within one group

  @param[in]  Group               GPIO group
  @param[in]  DwNum               PadCfgLock register number for current group.
                                  For group which has less then 32 pads per group DwNum must be 0.
  @param[in]  PadsToLockTx        Bitmask for pads which are going to be locked,
                                  Bit position - PadNumber
                                  Bit value - 0: DoNotLockTx, 1: LockTx

  @retval EFI_SUCCESS             The function completed successfully
  @retval EFI_INVALID_PARAMETER   Invalid group or DwNum parameter number
**/
EFI_STATUS
GpioLockPadCfgTxForGroupDw (
  IN GPIO_GROUP                   Group,
  IN UINT32                       DwNum,
  IN UINT32                       PadsToLockTx
  )
{
  EFI_STATUS           Status;

  Status = GpioLockPadsUsingSbi (
             GpioPadLockOutputRegister,
             FALSE,
             Group,
             DwNum,
             PadsToLockTx,
             0,
             FALSE
             );
  ASSERT_EFI_ERROR (Status);
  return Status;
}

/**
  This procedure will set PadCfgLockTx for selected pad

  @param[in] GpioPad              GPIO pad

  @retval EFI_SUCCESS             The function completed successfully
  @retval EFI_INVALID_PARAMETER   Invalid group or pad number
**/
EFI_STATUS
GpioLockPadCfgTx (
  IN GPIO_PAD                   GpioPad
  )
{
  EFI_STATUS           Status;

  Status = GpioLockPadsUsingSbi (
             GpioPadLockOutputRegister,
             FALSE,
             0,
             0,
             0,
             GpioPad,
             TRUE
             );
  ASSERT_EFI_ERROR (Status);
  return Status;
}


/**
  This procedure will get Group to GPE mapping.

  @param[out] GroupToGpeDw0       GPIO group to be mapped to GPE_DW0
  @param[out] GroupToGpeDw1       GPIO group to be mapped to GPE_DW1
  @param[out] GroupToGpeDw2       GPIO group to be mapped to GPE_DW2

  @retval EFI_SUCCESS             The function completed successfully
  @retval EFI_INVALID_PARAMETER   Invalid group or pad number
**/
EFI_STATUS
GpioGetGroupToGpeDwX (
  IN GPIO_GROUP               *GroupToGpeDw0,
  IN GPIO_GROUP               *GroupToGpeDw1,
  IN GPIO_GROUP               *GroupToGpeDw2
  )
{
  UINT32               Data32;
  UINT32               PchPwrmBase;
  GPIO_GROUP           GpioGroupOffset;

  GpioGroupOffset = GpioGetLowestGroup ();


  PchPwrmBaseGet (&PchPwrmBase);

  Data32 = MmioRead32 ((UINTN) (PchPwrmBase + R_PCH_PWRM_GPIO_CFG));

  *GroupToGpeDw0 = ((Data32 & B_PCH_PWRM_GPIO_CFG_GPE0_DW0) >> N_PCH_PWRM_GPIO_CFG_GPE0_DW0) + GpioGroupOffset;
  *GroupToGpeDw1 = ((Data32 & B_PCH_PWRM_GPIO_CFG_GPE0_DW1) >> N_PCH_PWRM_GPIO_CFG_GPE0_DW1) + GpioGroupOffset;
  *GroupToGpeDw2 = ((Data32 & B_PCH_PWRM_GPIO_CFG_GPE0_DW2) >> N_PCH_PWRM_GPIO_CFG_GPE0_DW2) + GpioGroupOffset;

  return EFI_SUCCESS;
}

/**
  This procedure will set Group to GPE mapping.

  @param[in]  GroupToGpeDw0       GPIO group to be mapped to GPE_DW0
  @param[in]  GroupToGpeDw1       GPIO group to be mapped to GPE_DW1
  @param[in]  GroupToGpeDw2       GPIO group to be mapped to GPE_DW2

  @retval EFI_SUCCESS             The function completed successfully
  @retval EFI_INVALID_PARAMETER   Invalid group or pad number
**/
EFI_STATUS
GpioSetGroupToGpeDwX (
  IN GPIO_GROUP                GroupToGpeDw0,
  IN GPIO_GROUP                GroupToGpeDw1,
  IN GPIO_GROUP                GroupToGpeDw2
  )
{
  UINT32               Data32Or;
  UINT32               Data32And;
  UINT32               PchPwrmBase;
  GPIO_GROUP           GpioGroupLowest;
  GPIO_GROUP           GpioGroupHighest;

  GpioGroupLowest = GpioGetLowestGroup ();
  GpioGroupHighest = GpioGetHighestGroup ();

  //
  // Check if group argument exceeds GPIO group range
  //
  if (((UINT32)GroupToGpeDw0 < GpioGroupLowest) || ((UINT32)GroupToGpeDw0 > GpioGroupHighest) ||
    ((UINT32)GroupToGpeDw1 < GpioGroupLowest) || ((UINT32)GroupToGpeDw1 > GpioGroupHighest) ||
    ((UINT32)GroupToGpeDw2 < GpioGroupLowest) || ((UINT32)GroupToGpeDw2 > GpioGroupHighest)) {
    DEBUG ((DEBUG_ERROR, "GPIO ERROR: Group argument exceeds GPIO group range\n"));
    return EFI_INVALID_PARAMETER;
  }

  //
  // Check if each group number is unique
  //
  if ((GroupToGpeDw0 == GroupToGpeDw1) ||
    (GroupToGpeDw0 == GroupToGpeDw2) ||
    (GroupToGpeDw1 == GroupToGpeDw2)) {
    return EFI_INVALID_PARAMETER;
  }

  //
  // Values in GPE0_DWx registers are 0 based (GPP_A = 0h)
  //
  GroupToGpeDw0 = GpioGetGroupIndexFromGroup(GroupToGpeDw0);
  GroupToGpeDw1 = GpioGetGroupIndexFromGroup(GroupToGpeDw1);
  GroupToGpeDw2 = GpioGetGroupIndexFromGroup(GroupToGpeDw2);

  PchPwrmBaseGet (&PchPwrmBase);

  //
  // Program GPIO_CFG (PMRMBASE + 120h) register
  //
  Data32And = (UINT32) ~(B_PCH_PWRM_GPIO_CFG_GPE0_DW2 | B_PCH_PWRM_GPIO_CFG_GPE0_DW1 | B_PCH_PWRM_GPIO_CFG_GPE0_DW0);
  Data32Or  = (UINT32)((GroupToGpeDw2 << N_PCH_PWRM_GPIO_CFG_GPE0_DW2) |
              (GroupToGpeDw1 << N_PCH_PWRM_GPIO_CFG_GPE0_DW1) |
              (GroupToGpeDw0 << N_PCH_PWRM_GPIO_CFG_GPE0_DW0));

  MmioAndThenOr32 (
    (UINTN) (PchPwrmBase + R_PCH_PWRM_GPIO_CFG),
    Data32And,
    Data32Or
    );

  Data32And = (UINT32) ~(B_PCH_PCR_GPIO_MISCCFG_GPE0_DW2 | B_PCH_PCR_GPIO_MISCCFG_GPE0_DW1 | B_PCH_PCR_GPIO_MISCCFG_GPE0_DW0);
  Data32Or = (UINT32)((GroupToGpeDw2 << N_PCH_PCR_GPIO_MISCCFG_GPE0_DW2) |
             (GroupToGpeDw1 << N_PCH_PCR_GPIO_MISCCFG_GPE0_DW1) |
             (GroupToGpeDw0 << N_PCH_PCR_GPIO_MISCCFG_GPE0_DW0));
  //
  // Program MISCCFG register for Community 0
  //
  MmioAndThenOr32 (
    (UINTN)PCH_PCR_ADDRESS (PID_GPIOCOM0, R_PCH_PCR_GPIO_MISCCFG),
    Data32And,
    Data32Or
    );

  //
  // Program MISCCFG register for Community 1
  //
  MmioAndThenOr32 (
    (UINTN)PCH_PCR_ADDRESS (PID_GPIOCOM1, R_PCH_PCR_GPIO_MISCCFG),
    Data32And,
    Data32Or
    );

  //
  // Program MISCCFG register for Community 2
  //
  MmioAndThenOr32 (
    (UINTN)PCH_PCR_ADDRESS (PID_GPIOCOM2, R_PCH_PCR_GPIO_MISCCFG),
    Data32And,
    Data32Or
    );

  //
  // Program MISCCFG register for Community 3
  //
  MmioAndThenOr32 (
    (UINTN)PCH_PCR_ADDRESS (PID_GPIOCOM3, R_PCH_PCR_GPIO_MISCCFG),
    Data32And,
    Data32Or
    );

  return EFI_SUCCESS;
}

/**
  This procedure will get GPE number for provided GpioPad.
  PCH allows to configure mapping between GPIO groups and related GPE (GpioSetGroupToGpeDwX())
  what results in the fact that certain Pad can cause different General Purpose Event. Only three
  GPIO groups can be mapped to cause unique GPE (1-tier), all others groups will be under one common
  event (GPE_111 for 2-tier).

  1-tier:
  Returned GpeNumber is in range <0,95>. GpioGetGpeNumber() can be used
  to determine what _LXX ACPI method would be called on event on selected GPIO pad

  2-tier:
  Returned GpeNumber is 0x6F (111). All GPIO pads which are not mapped to 1-tier GPE
  will be under one master GPE_111 which is linked to _L6F ACPI method. If it is needed to determine
  what Pad from 2-tier has caused the event, _L6F method should check GPI_GPE_STS and GPI_GPE_EN
  registers for all GPIO groups not mapped to 1-tier GPE.

  @param[in]  GpioPad             GPIO pad
  @param[out] GpeNumber           GPE number

  @retval EFI_SUCCESS             The function completed successfully
  @retval EFI_INVALID_PARAMETER   Invalid group or pad number
**/
EFI_STATUS
GpioGetGpeNumber (
  IN  GPIO_PAD                  GpioPad,
  OUT UINT32                    *GpeNumber
  )
{
  GPIO_GROUP           GroupToGpeDw0;
  GPIO_GROUP           GroupToGpeDw1;
  GPIO_GROUP           GroupToGpeDw2;
  GPIO_GROUP           GpioGroupLowest;
  GPIO_GROUP           GpioGroupHighest;
  UINT32               GroupIndex;
  GPIO_GROUP           Group;
  UINT32               PadNumber;
  GPIO_GROUP_INFO      *GpioGroupInfo;
  UINTN                GpioGroupInfoLength;

  GpioGroupInfo = GpioGetGroupInfoTable (&GpioGroupInfoLength);

  Group = GpioGetGroupFromGpioPad (GpioPad);
  GroupIndex = GpioGetGroupIndexFromGpioPad (GpioPad);
  PadNumber = GpioGetPadNumberFromGpioPad (GpioPad);

DEBUG_CODE_BEGIN();
  if (!GpioIsCorrectPadForThisChipset (GpioPad)) {
    DEBUG ((DEBUG_ERROR, "GPIO ERROR: Incorrect GpioPad define used on this chipset (Group=%d, Pad=%d)!\n", GroupIndex, PadNumber));
    ASSERT (FALSE);
    return EFI_UNSUPPORTED;
  }
DEBUG_CODE_END();

  GpioGroupLowest = GpioGetLowestGroup ();
  GpioGroupHighest = GpioGetHighestGroup ();

  //
  // Check if group argument exceeds GPIO group range
  //
  if ((GroupIndex < GpioGetGroupIndexFromGroup (GpioGroupLowest)) || (GroupIndex > GpioGetGroupIndexFromGroup (GpioGroupHighest))) {
    DEBUG ((DEBUG_ERROR, "GPIO ERROR: Group argument (%d) exceeds GPIO group range\n", GroupIndex));
    ASSERT (FALSE);
    return EFI_INVALID_PARAMETER;
  }

  //
  // Check if legal pad number
  //
  if (PadNumber >= GpioGroupInfo[GroupIndex].PadPerGroup) {
    DEBUG ((DEBUG_ERROR, "GPIO ERROR: Pin number (%d) exceeds possible range for this group\n", PadNumber));
    ASSERT (FALSE);
    return EFI_INVALID_PARAMETER;
  }

  //
  // Get GPIO groups mapping to 1-tier GPE
  //
  GpioGetGroupToGpeDwX (&GroupToGpeDw0,&GroupToGpeDw1,&GroupToGpeDw2);

  if (Group == GroupToGpeDw0) {
    *GpeNumber = PadNumber;
  } else if (Group== GroupToGpeDw1) {
    *GpeNumber = PadNumber + 32;
  } else if (Group == GroupToGpeDw2) {
    *GpeNumber = PadNumber + 64;
  } else {
    //
    // If Group number doesn't match any of above then
    // it means than certain pad is routed to 2-tier GPE
    // which all are under GPE_111 (0x6F)
    //
    *GpeNumber = PCH_GPIO_2_TIER_MASTER_GPE_NUMBER;
  }

  return EFI_SUCCESS;
}

/**
  This procedure is used to clear SMI STS for a specified Pad

  @param[in]  GpioPad             GPIO pad

  @retval EFI_SUCCESS             The function completed successfully
  @retval EFI_INVALID_PARAMETER   Invalid group or pad number
**/
EFI_STATUS
GpioClearGpiSmiSts (
  IN GPIO_PAD                   GpioPad
  )
{
  UINT32               GroupIndex;
  UINT32               PadNumber;
  GPIO_GROUP_INFO      *GpioGroupInfo;
  UINTN                GpioGroupInfoLength;

  GpioGroupInfo = GpioGetGroupInfoTable (&GpioGroupInfoLength);

  GroupIndex = GpioGetGroupIndexFromGpioPad (GpioPad);
  PadNumber = GpioGetPadNumberFromGpioPad (GpioPad);

DEBUG_CODE_BEGIN();
  if (!GpioIsCorrectPadForThisChipset (GpioPad)) {
    DEBUG ((DEBUG_ERROR, "GPIO ERROR: Incorrect GpioPad define used on this chipset (Group=%d, Pad=%d)!\n", GroupIndex, PadNumber));
    ASSERT (FALSE);
    return EFI_UNSUPPORTED;
  }
DEBUG_CODE_END();

  //
  // Check if group argument exceeds GPIO GROUP INFO array
  //
  if ((UINTN)GroupIndex >= GpioGroupInfoLength) {
    DEBUG ((DEBUG_ERROR, "GPIO ERROR: Group argument (%d) exceeds GPIO group range\n", GroupIndex));
    ASSERT (FALSE);
    return EFI_INVALID_PARAMETER;
  }

  //
  // Check if legal pad number
  //
  if (PadNumber >= GpioGroupInfo[GroupIndex].PadPerGroup) {
    DEBUG ((DEBUG_ERROR, "GPIO ERROR: Pin number (%d) exceeds possible range for this group\n", PadNumber));
    ASSERT (FALSE);
    return EFI_INVALID_PARAMETER;
  }

  //
  // Check if group has GPI SMI register
  //
  if (GpioGroupInfo[GroupIndex].SmiStsOffset == NO_REGISTER_FOR_PROPERTY) {
    return EFI_INVALID_PARAMETER;
  }
  //
  // Clear all GPI SMI Status bits by writing '1'
  //
  MmioWrite32 (
    PCH_PCR_ADDRESS (GpioGroupInfo[GroupIndex].Community, GpioGroupInfo[GroupIndex].SmiStsOffset),
    (UINT32)(BIT0 << PadNumber)
    );

  return EFI_SUCCESS;
}

/**
  This procedure is used by PchSmiDispatcher and will clear
  all GPI SMI Status bits

  @retval EFI_SUCCESS             The function completed successfully
  @retval EFI_INVALID_PARAMETER   Invalid group or pad number
**/
EFI_STATUS
GpioClearAllGpiSmiSts (
  VOID
  )
{
  UINT32               GroupIndex;
  GPIO_GROUP_INFO      *GpioGroupInfo;
  UINTN                GpioGroupInfoLength;

  GpioGroupInfo = GpioGetGroupInfoTable (&GpioGroupInfoLength);

  for (GroupIndex = 0; GroupIndex < GpioGroupInfoLength; GroupIndex++) {
    //
    // Check if group has GPI SMI register
    //
    if (GpioGroupInfo[GroupIndex].SmiStsOffset == NO_REGISTER_FOR_PROPERTY) {
      continue;
    }
    //
    // Clear all GPI SMI Status bits by writing '1'
    //
    MmioWrite32 (
      PCH_PCR_ADDRESS (GpioGroupInfo[GroupIndex].Community, GpioGroupInfo[GroupIndex].SmiStsOffset),
      (UINT32)0xFFFFFFFF
      );
  }
  return EFI_SUCCESS;
}

/**
  This procedure is used to disable all GPI SMI

  @retval EFI_SUCCESS             The function completed successfully
  @retval EFI_INVALID_PARAMETER   Invalid group or pad number
**/
EFI_STATUS
GpioDisableAllGpiSmi (
  VOID
  )
{
  GPIO_GROUP_INFO      *GpioGroupInfo;
  UINT32               GroupIndex;
  UINTN                GpioGroupInfoLength;

  GpioGroupInfo = GpioGetGroupInfoTable (&GpioGroupInfoLength);

  for (GroupIndex = 0; GroupIndex < GpioGroupInfoLength; GroupIndex++) {
    //
    // Check if group has GPI SMI register
    //
    if (GpioGroupInfo[GroupIndex].SmiEnOffset == NO_REGISTER_FOR_PROPERTY) {
      continue;
    }

    //
    // Disable all GPI SMI
    //
    MmioWrite32 (
      PCH_PCR_ADDRESS (GpioGroupInfo[GroupIndex].Community, GpioGroupInfo[GroupIndex].SmiEnOffset),
      (UINT32)0x0
      );
  }
  return EFI_SUCCESS;
}

/**
  This procedure is used to register GPI SMI dispatch function.

  @param[in]  GpioPad             GPIO pad
  @param[out] GpiNum              GPI number

  @retval EFI_SUCCESS             The function completed successfully
  @retval EFI_INVALID_PARAMETER   Invalid group or pad number
**/
EFI_STATUS
GpioGetGpiSmiNum (
  IN GPIO_PAD          GpioPad,
  OUT UINTN            *GpiNum
  )
{
  UINT32               GroupIndex;
  UINT32               Index;
  UINT32               PadNumber;
  GPIO_GROUP_INFO      *GpioGroupInfo;
  UINTN                GpioGroupInfoLength;

  GpioGroupInfo = GpioGetGroupInfoTable (&GpioGroupInfoLength);

  GroupIndex = GpioGetGroupIndexFromGpioPad (GpioPad);
  PadNumber = GpioGetPadNumberFromGpioPad (GpioPad);

DEBUG_CODE_BEGIN();
  if (!GpioIsCorrectPadForThisChipset (GpioPad)) {
    DEBUG ((DEBUG_ERROR, "GPIO ERROR: Incorrect GpioPad define used on this chipset (Group=%d, Pad=%d)!\n", GroupIndex, PadNumber));
    ASSERT (FALSE);
    return EFI_UNSUPPORTED;
  }
DEBUG_CODE_END();

  //
  // Check if group argument exceeds GPIO GROUP INFO array
  //
  if ((UINTN)GroupIndex >= GpioGroupInfoLength) {
    DEBUG ((DEBUG_ERROR, "GPIO ERROR: Group argument (%d) exceeds GPIO group range\n", GroupIndex));
    return EFI_INVALID_PARAMETER;
  }

  //
  // Check if legal pad number
  //
  if (PadNumber >= GpioGroupInfo[GroupIndex].PadPerGroup){
    DEBUG ((DEBUG_ERROR, "GPIO ERROR: Pin number (%d) exceeds possible range for this group\n", PadNumber));
    return EFI_INVALID_PARAMETER;
  }

  *GpiNum = 0;

  for (Index = 0; Index < (UINT32)GroupIndex; Index++) {
    *GpiNum += (UINTN)(GpioGroupInfo[Index].PadPerGroup);
  }
  *GpiNum += (UINTN)PadNumber;

  return EFI_SUCCESS;
}

/**
  This procedure is used to check GPIO inputs belongs to 2 tier or 1 tier architecture

  @param[in]  GpioPad             GPIO pad

  @retval     Data                0 means 1-tier, 1 means 2-tier
**/
BOOLEAN
GpioCheckFor2Tier (
  IN GPIO_PAD                  GpioPad
  )
{
  UINT32               Data32;

  GpioGetGpeNumber (GpioPad, &Data32);
  if(Data32 == PCH_GPIO_2_TIER_MASTER_GPE_NUMBER) {
    return TRUE;
  }

  return FALSE;
}

/**
  This procedure is used to clear GPE STS for a specified GpioPad

  @param[in]  GpioPad             GPIO pad

  @retval EFI_SUCCESS             The function completed successfully
  @retval EFI_INVALID_PARAMETER   Invalid group or pad number
**/
EFI_STATUS
GpioClearGpiGpeSts (
  IN GPIO_PAD                  GpioPad
  )
{
  UINT32               GroupIndex;
  UINT32               PadNumber;
  GPIO_GROUP_INFO      *GpioGroupInfo;
  UINTN                GpioGroupInfoLength;

  GpioGroupInfo = GpioGetGroupInfoTable (&GpioGroupInfoLength);

  GroupIndex = GpioGetGroupIndexFromGpioPad (GpioPad);
  PadNumber = GpioGetPadNumberFromGpioPad (GpioPad);

  //
  // Check if group argument exceeds GPIO GROUP INFO array
  //
  if ((UINTN)GroupIndex >= GpioGroupInfoLength) {
    DEBUG ((DEBUG_ERROR, "GPIO ERROR: Group argument (%d) exceeds GPIO group range\n", GroupIndex));
    ASSERT (FALSE);
    return EFI_INVALID_PARAMETER;
  }

  //
  // Check if legal pad number
  //
  if (PadNumber >= GpioGroupInfo[GroupIndex].PadPerGroup) {
    DEBUG ((DEBUG_ERROR, "GPIO ERROR: Pin number (%d) exceeds possible range for this group\n", PadNumber));
    ASSERT (FALSE);
    return EFI_INVALID_PARAMETER;
  }

  //
  // Check if group has GPI GPE register
  //
  if (GpioGroupInfo[GroupIndex].GpiGpeStsOffset == NO_REGISTER_FOR_PROPERTY) {
    return EFI_INVALID_PARAMETER;
  }

  // Check for 2-tier
  if(!(GpioCheckFor2Tier (GpioPad))) {
    return EFI_INVALID_PARAMETER;
  }

  //
  // Clear all GPI SMI Status bits by writing '1'
  //
  MmioWrite32 (
    PCH_PCR_ADDRESS (GpioGroupInfo[GroupIndex].Community, GpioGroupInfo[GroupIndex].GpiGpeStsOffset),
    (UINT32)(BIT0 << PadNumber)
    );

  return EFI_SUCCESS;
}

/**
  This procedure is used to read GPE STS for a specified Pad

  @param[in]  GpioPad             GPIO pad
  @param[out] Data                GPE STS data

  @retval EFI_SUCCESS             The function completed successfully
  @retval EFI_INVALID_PARAMETER   Invalid group or pad number
**/
EFI_STATUS
GpioGetGpiGpeSts (
  IN GPIO_PAD                  GpioPad,
  OUT UINT32*                  Data
  )
{
  UINT32               Data32;
  UINT32               Mask;
  UINT32               GroupIndex;
  UINT32               PadNumber;
  GPIO_GROUP_INFO      *GpioGroupInfo;
  UINTN                GpioGroupInfoLength;

  *Data = 0xFFFFFFFF;

  GpioGroupInfo = GpioGetGroupInfoTable (&GpioGroupInfoLength);

  GroupIndex = GpioGetGroupIndexFromGpioPad (GpioPad);
  PadNumber = GpioGetPadNumberFromGpioPad (GpioPad);

  //
  // Check if group argument exceeds GPIO GROUP INFO array
  //
  if ((UINTN)GroupIndex >= GpioGroupInfoLength) {
    DEBUG ((DEBUG_ERROR, "GPIO ERROR: Group argument (%d) exceeds GPIO group range\n", GroupIndex));
    ASSERT (FALSE);
    return EFI_INVALID_PARAMETER;
  }

  //
  // Check if legal pad number
  //
  if (PadNumber >= GpioGroupInfo[GroupIndex].PadPerGroup) {
    DEBUG ((DEBUG_ERROR, "GPIO ERROR: Pin number (%d) exceeds possible range for this group\n", PadNumber));
    ASSERT (FALSE);
    return EFI_INVALID_PARAMETER;
  }

  //
  // Check if group has GPI GPE register
  //
  if (GpioGroupInfo[GroupIndex].GpiGpeStsOffset == NO_REGISTER_FOR_PROPERTY) {
    return EFI_INVALID_PARAMETER;
  }

  // Check for 2-tier
  if(!(GpioCheckFor2Tier (GpioPad))) {
    return EFI_INVALID_PARAMETER;
  }

  //
  // Read GPI GPE Status bits
  //
  Data32 = MmioRead32(
    PCH_PCR_ADDRESS(GpioGroupInfo[GroupIndex].Community, GpioGroupInfo[GroupIndex].GpiGpeStsOffset)
    );

  Mask = (UINT32)(BIT0 << PadNumber);
  Data32 = (Data32 & Mask) >> PadNumber;
  *Data = Data32;

  return EFI_SUCCESS;
}

/**
  This procedure will set GPIO Input Rout SCI

  @param[in] GpioPad             GPIO pad
  @param[in] Value                Value for GPIRoutSCI

  @retval EFI_SUCCESS             The function completed successfully
  @retval EFI_INVALID_PARAMETER   Invalid group or pad number
**/
EFI_STATUS
GpioSetGpiRoutSci (
  IN GPIO_PAD                  GpioPad,
  IN UINT32                    Value
  )
{
  EFI_STATUS           Status;

  Value <<= N_PCH_GPIO_RX_SCI_ROUTE;
  Status = GpioReadWritePadCfgReg (
             GpioPad,
             0,
             B_PCH_GPIO_RX_SCI_ROUTE,
             TRUE,
             &Value
             );
  ASSERT_EFI_ERROR (Status);
  return Status;
}

/**
  This procedure will set GPIO Input Rout SMI

  @param[in] GpioPad             GPIO pad
  @param[in] Value                Value for GPIRoutSMI

  @retval EFI_SUCCESS             The function completed successfully
  @retval EFI_INVALID_PARAMETER   Invalid group or pad number
**/
EFI_STATUS
GpioSetGpiRoutSmi (
  IN GPIO_PAD                  GpioPad,
  IN UINT32                    Value
  )
{
  EFI_STATUS  Status;

  Value <<= N_PCH_GPIO_RX_SMI_ROUTE;
  Status = GpioReadWritePadCfgReg (
             GpioPad,
             0,
             B_PCH_GPIO_RX_SMI_ROUTE,
             TRUE,
             &Value
             );
  ASSERT_EFI_ERROR (Status);
  return Status;
}

/**
  This procedure will set GPI SMI Enable setting for selected pad

  @param[in]  GpioPad               GPIO pad
  @param[in]  PadGpiSmiEn         GPI SMI Enable setting for selected pad

  @retval EFI_SUCCESS             The function completed successfully
  @retval EFI_INVALID_PARAMETER   Invalid group or pad number
**/
EFI_STATUS
GpioSetGpiSmiPadEn (
  IN GPIO_PAD                  GpioPad,
  IN UINT32                    PadGpiSmiEn
  )
{
  GPIO_GROUP           Group;
  GPIO_GROUP           GpioGroupOffset;
  UINT32               NumberOfGroups;
  EFI_STATUS  Status;

  GpioGroupOffset = GpioGetLowestGroup ();
  NumberOfGroups = GpioGetNumberOfGroups ();

  Group = GpioGetGroupFromGpioPad (GpioPad);

  //
  // Check if group argument exceeds GPIO group range
  //
  if ((Group < GpioGroupOffset) || (Group >= NumberOfGroups + GpioGroupOffset)) {
    return EFI_INVALID_PARAMETER;
  }

  Status = GpioReadWriteReg (
             GpioSmiEnableRegister,
             Group,
             0,
             GpioPad,
             TRUE,
             TRUE,
             &PadGpiSmiEn
             );
  ASSERT_EFI_ERROR (Status);
  return Status;
}

/**
  This procedure will set GPI General Purpose Event Enable setting for selected pad

  @param[in]  GpioPad               GPIO pad
  @param[in]  PadGpiGpeEn         GPI General Purpose Event Enable setting for selected pad

  @retval EFI_SUCCESS             The function completed successfully
  @retval EFI_INVALID_PARAMETER   Invalid group or pad number
**/
EFI_STATUS
GpioSetGpiGpePadEn (
  IN GPIO_PAD                  GpioPad,
  IN UINT32                    PadGpiGpeEn
  )
{
  GPIO_GROUP           Group;
  GPIO_GROUP           GpioGroupOffset;
  UINT32               NumberOfGroups;
  EFI_STATUS           Status;

  GpioGroupOffset = GpioGetLowestGroup ();
  NumberOfGroups = GpioGetNumberOfGroups ();

  Group = GpioGetGroupFromGpioPad (GpioPad);

  //
  // Check if group argument exceeds GPIO group range
  //
  if ((Group < GpioGroupOffset) || (Group >= NumberOfGroups + GpioGroupOffset)) {
    return EFI_INVALID_PARAMETER;
  }


  Status = GpioReadWriteReg (
             GpioGpeEnableRegister,
             Group,
             0,
             GpioPad,
             TRUE,
             TRUE,
             &PadGpiGpeEn
             );
  ASSERT_EFI_ERROR (Status);
  return Status;
}

/**
  Check if given GPIO Pad is locked

  @param[in]  GroupIndex                GPIO group index
  @param[in]  PadNumber                 GPIO pad number

  @retval TRUE                          Pad is locked
  @retval FALSE                         Pad is not locked
**/
BOOLEAN
GpioIsPadLocked (
  IN  UINT32                 GroupIndex,
  IN  GPIO_PAD               PadNumber
  )
{
  UINT32               RegVal;
  GPIO_GROUP_INFO      *GpioGroupInfo;
  UINTN                GpioGroupInfoLength;

  GpioGroupInfo = GpioGetGroupInfoTable (&GpioGroupInfoLength);

  // Read PADCFGLOCK register
  //
  RegVal = MmioRead32 ((UINTN)PCH_PCR_ADDRESS (GpioGroupInfo[GroupIndex].Community, GpioGroupInfo[GroupIndex].PadCfgLockOffset));

  return (((RegVal >> PadNumber) & 0x1) == 1);
}

/**
  Locks multiple GPIO pads using GPIO_INIT_CONFIG array.
  Only locking is applied and no other GPIO pad configuration is changed.

  @param[in] NumberOfItems              Number of GPIO pads to be locked
  @param[in] GpioInitTableAddress       GPIO initialization table

  @retval EFI_SUCCESS                   The function completed successfully
  @retval EFI_INVALID_PARAMETER         Invalid group or pad number
  @retval EFI_UNSUPPORTED               Incorrect GPIO pad definition
**/
static
EFI_STATUS
GpioLockPads (
  IN UINT32                    NumberOfItems,
  IN GPIO_INIT_CONFIG          *GpioInitTableAddress
  )
{
  UINT32               Index;
  UINT32               PadsToLock[V_PCH_GPIO_GROUP_MAX];
  UINT32               PadsToLockTx[V_PCH_GPIO_GROUP_MAX];
  GPIO_GROUP_INFO      *GpioGroupInfo;
  UINTN                GpioGroupInfoLength;
  GPIO_GROUP           GpioGroupOffset;
  UINT32               NumberOfGroups;
  GPIO_PAD_OWN         PadOwnVal;
  GPIO_INIT_CONFIG     *GpioData;
  GPIO_GROUP           Group;
  UINT32               GroupIndex;
  UINT32               PadNumber;
  PCH_SERIES           PchSeries;

  PchSeries = GetPchSeries ();
  PadOwnVal = GpioPadOwnHost;

  ZeroMem (PadsToLock, sizeof (PadsToLock));
  ZeroMem (PadsToLockTx, sizeof (PadsToLockTx));

  GpioGroupInfo = GpioGetGroupInfoTable (&GpioGroupInfoLength);

  GpioGroupOffset = GpioGetLowestGroup ();
  NumberOfGroups = GpioGetNumberOfGroups ();

  for (Index = 0; Index < NumberOfItems; Index ++) {

    GpioData   = &GpioInitTableAddress[Index];

    Group      = GpioGetGroupFromGpioPad (GpioData->GpioPad);
    GroupIndex = GpioGetGroupIndexFromGpioPad (GpioData->GpioPad);
    PadNumber  = GpioGetPadNumberFromGpioPad (GpioData->GpioPad);

    //
    // Checking GroupIndex to avoid Buffer Overflows or Array Out of Index
    //
    if (GroupIndex >= V_PCH_GPIO_GROUP_MAX) {
      ASSERT (FALSE);
      continue;
    }

    //
    // Check if group argument exceeds GPIO group range
    //
    if ((Group < GpioGroupOffset) || (Group >= NumberOfGroups + GpioGroupOffset)) {
      return EFI_INVALID_PARAMETER;
    }

    //
    // Check if legal pin number
    //
    if (PadNumber >= GpioGroupInfo[GroupIndex].PadPerGroup){
      return EFI_INVALID_PARAMETER;
    }

    //
    // Check if selected GPIO Pad is not owned by CSME/ISH
    //
    GpioGetPadOwnership (GpioData->GpioPad, &PadOwnVal);

    if (PadOwnVal != GpioPadOwnHost) {
      continue;
    }

    //
    // Update information on Pad Configuration Lock
    //
    PadsToLock[GroupIndex] |= ((GpioData->GpioConfig.LockConfig >> 0x1) & 0x1) << PadNumber;

    //
    // Update information on Pad Configuration Lock Tx
    //
    PadsToLockTx[GroupIndex] |= ((GpioData->GpioConfig.LockConfig >> 0x2) & 0x1) << PadNumber;
  }

  for (Index = 0; Index < NumberOfGroups; Index++) {
    //
    // Write Pad Configuration Lock
    //
    if (PadsToLock[Index] != 0) {
      GpioLockPadCfgForGroupDw (Index + GpioGroupOffset, 0, PadsToLock[Index]);
    }

    //
    // Write Pad Configuration Lock Tx
    //
    if (PadsToLockTx[Index] != 0) {
      GpioLockPadCfgTxForGroupDw (Index + GpioGroupOffset, 0, PadsToLockTx[Index]);
    }
  }

  return EFI_SUCCESS;
}

/**
  Locks GPIO pads according to GPIO_INIT_CONFIG array from
  gPlatformGpioConfigGuid HOB. Only locking is applied and no other GPIO pad
  configuration is changed.

  @retval EFI_SUCCESS                   The function completed successfully
  @retval EFI_NOT_FOUND                 gPlatformGpioConfigGuid not found
**/
EFI_STATUS
GpioLockGpios (
  VOID
  )
{
  EFI_HOB_GUID_TYPE *GpioConfigHob;
  GPIO_INIT_CONFIG  *GpioConfig;
  UINT16            GpioConfigSize;

  GpioConfigHob = GetFirstGuidHob (&gPlatformGpioConfigGuid);
  if (GpioConfigHob == NULL) {
    return EFI_NOT_FOUND;
  }
  ASSERT (GET_GUID_HOB_DATA_SIZE (GpioConfigHob) % sizeof (GpioConfig[0]) == 0);
  GpioConfigSize = GET_GUID_HOB_DATA_SIZE (GpioConfigHob) / sizeof (GpioConfig[0]);
  GpioConfig = GET_GUID_HOB_DATA (GpioConfigHob);
  GpioLockPads (GpioConfigSize, GpioConfig);

  return EFI_SUCCESS;
}

/**
  Unlocks all PCH GPIO pads

  @retval None
**/
VOID
GpioUnlockAllGpios (
  VOID
  )
{
  GPIO_GROUP           GpioGroupOffset;
  UINT32               NumberOfGroups;
  UINT32               Index;

  GpioGroupOffset = GpioGetLowestGroup ();
  NumberOfGroups = GpioGetNumberOfGroups ();

  for (Index = 0; Index < NumberOfGroups; Index++) {
    //
    // Reset Pad Configuration Lock
    //
    GpioUnlockPadCfgForGroupDw (Index + GpioGroupOffset, 0, 0xFFFFFFFF);

    //
    // Reset Pad Configuration Lock Tx
    //
    GpioUnlockPadCfgTxForGroupDw (Index + GpioGroupOffset, 0, 0xFFFFFFFF);
  }
}