/**
*
*  Copyright (c) 2018, Marvell International Ltd. All rights reserved.
*
*  SPDX-License-Identifier: BSD-2-Clause-Patent
*
**/

#include <Protocol/I2cIo.h>

#include <Pi/PiI2c.h>

#include "MvPca95xxDxe.h"

STATIC PCA95XX *mPca95xxInstance;

STATIC MV_GPIO_DEVICE_PATH mDevicePathTemplate = {
  {
    {
      HARDWARE_DEVICE_PATH,
      HW_VENDOR_DP,
      {
        (UINT8) (sizeof (VENDOR_DEVICE_PATH) +
                 sizeof (MV_GPIO_DRIVER_TYPE)),
        (UINT8) ((sizeof (VENDOR_DEVICE_PATH) +
                 sizeof (MV_GPIO_DRIVER_TYPE)) >> 8),
      },
    },
    EFI_CALLER_ID_GUID
  },
  MV_GPIO_DRIVER_TYPE_PCA95XX,
  {
    END_DEVICE_PATH_TYPE,
    END_ENTIRE_DEVICE_PATH_SUBTYPE,
    {
      sizeof(EFI_DEVICE_PATH_PROTOCOL),
      0
    }
  }
};

STATIC PCA95XX_PIN_COUNT mPca95xxPinCount[PCA95XX_MAX_ID] = {
  PCA9505_PIN_COUNT,
  PCA9534_PIN_COUNT,
  PCA9535_PIN_COUNT,
  PCA9536_PIN_COUNT,
  PCA9537_PIN_COUNT,
  PCA9538_PIN_COUNT,
  PCA9539_PIN_COUNT,
  PCA9554_PIN_COUNT,
  PCA9555_PIN_COUNT,
  PCA9556_PIN_COUNT,
  PCA9557_PIN_COUNT,
};

#if !defined(MDEPKG_NDEBUG)
/**

Routine Description:

  Verifies if controller index / GPIO pin values
  are within proper boundaries.

Arguments:

  ControllerIndex - index of controller
  GpioPin - which pin to read

Returns:

  EFI_SUCCESS           - GPIO pin / controller index are proper
  EFI_INVALID_PARAMETER - GPIO pin / controller index is out of range
**/
STATIC
EFI_STATUS
MvPca95xxValidate (
  IN UINTN ControllerIndex,
  IN UINTN GpioPin
  )
{
  UINTN ControllerId;

  if (ControllerIndex >= mPca95xxInstance->GpioExpanderCount) {
    DEBUG ((DEBUG_ERROR,
      "%a: Invalid GPIO ControllerIndex: %d\n",
      __FUNCTION__,
      ControllerIndex));
    return EFI_INVALID_PARAMETER;
  }

  ControllerId = mPca95xxInstance->GpioExpanders[ControllerIndex].ChipId;

  if (GpioPin >= mPca95xxPinCount[ControllerId]) {
    DEBUG ((DEBUG_ERROR,
      "%a: GPIO pin #%d not available in Controller#%d\n",
      __FUNCTION__,
      GpioPin,
      ControllerIndex));
    return EFI_INVALID_PARAMETER;
  }

  return EFI_SUCCESS;
}
#endif

EFI_STATUS
EFIAPI
MvPca95xxGetI2c (
  IN     UINTN                 ControllerIndex,
  IN OUT EFI_I2C_IO_PROTOCOL **I2cIo
  )
{
  UINTN        I2cBus, I2cAddress;
  UINTN        HandleCount, Index;
  EFI_HANDLE  *HandleBuffer;
  EFI_STATUS   Status;

  I2cBus = mPca95xxInstance->GpioExpanders[ControllerIndex].I2cBus;
  I2cAddress = mPca95xxInstance->GpioExpanders[ControllerIndex].I2cAddress;

  /* Locate Handles of all EfiI2cIoProtocol producers */
  Status = gBS->LocateHandleBuffer (ByProtocol,
                  &gEfiI2cIoProtocolGuid,
                  NULL,
                  &HandleCount,
                  &HandleBuffer);
  if (EFI_ERROR (Status)) {
    DEBUG ((DEBUG_ERROR, "%a: Unable to locate handles\n", __FUNCTION__));
    return Status;
  }

  /* Iterate over all protocol producers and pick one upon DeviceIndex match */
  for (Index = 0; Index < HandleCount; Index++) {
    Status = gBS->OpenProtocol (HandleBuffer[Index],
                    &gEfiI2cIoProtocolGuid,
                    (VOID **)I2cIo,
                    gImageHandle,
                    NULL,
                    EFI_OPEN_PROTOCOL_GET_PROTOCOL);
    if (EFI_ERROR (Status)) {
      DEBUG ((DEBUG_ERROR, "%a: Unable to open protocol\n", __FUNCTION__));
      gBS->FreePool (HandleBuffer);
      return Status;
    }
    if ((*I2cIo)->DeviceIndex == I2C_DEVICE_INDEX (I2cBus, I2cAddress)) {
      gBS->FreePool (HandleBuffer);
      return EFI_SUCCESS;
    }
  }

  gBS->FreePool (HandleBuffer);

  return EFI_NOT_FOUND;
}

EFI_STATUS
EFIAPI
MvPca95xxI2cTransfer (
  IN EFI_I2C_IO_PROTOCOL *I2cIo,
  IN UINT8                Address,
  IN UINT8               *Buffer,
  IN UINT32               Flag
  )
{
  EFI_I2C_REQUEST_PACKET *RequestPacket;
  UINTN RequestPacketSize;
  UINT8 AddressBuffer;
  EFI_STATUS Status;

  RequestPacketSize = sizeof (UINTN) +
                      sizeof (EFI_I2C_OPERATION) * PCA95XX_OPERATION_COUNT;
  RequestPacket = AllocateZeroPool (RequestPacketSize);
  if (RequestPacket == NULL) {
    return EFI_OUT_OF_RESOURCES;
  }

  /* Operations contain address and payload, consecutively. */
  RequestPacket->OperationCount = PCA95XX_OPERATION_COUNT;
  RequestPacket->Operation[0].LengthInBytes = PCA95XX_OPERATION_LENGTH;
  RequestPacket->Operation[0].Buffer = &AddressBuffer;
  RequestPacket->Operation[0].Buffer[0] = Address & MAX_UINT8;
  RequestPacket->Operation[1].LengthInBytes = PCA95XX_OPERATION_LENGTH;
  RequestPacket->Operation[1].Buffer = Buffer;
  RequestPacket->Operation[1].Flags = Flag;

  Status = I2cIo->QueueRequest (I2cIo, 0, NULL, RequestPacket, NULL);
  if (EFI_ERROR (Status)) {
    DEBUG ((DEBUG_ERROR,
      "%a: transmission error: 0x%d\n",
      __FUNCTION__,
      Status));
  }

  gBS->FreePool(RequestPacket);

  return Status;
}

STATIC
EFI_STATUS
MvPca95xxReadRegs (
  IN  EFI_I2C_IO_PROTOCOL *I2cIo,
  IN  UINT8                Reg,
  OUT UINT8               *RegVal
  )
{
  return MvPca95xxI2cTransfer (I2cIo, Reg, RegVal, I2C_FLAG_READ);
}

STATIC
EFI_STATUS
MvPca95xxWriteRegs (
  IN  EFI_I2C_IO_PROTOCOL *I2cIo,
  IN  UINTN                Reg,
  IN  UINT8                RegVal
  )
{
  return MvPca95xxI2cTransfer (I2cIo, Reg, &RegVal, I2C_FLAG_NORESTART);
}

STATIC
EFI_STATUS
MvPca95xxSetOutputValue (
  IN UINTN               ControllerIndex,
  IN UINTN               GpioPin,
  IN EMBEDDED_GPIO_MODE  Mode
  )
{
  EFI_I2C_IO_PROTOCOL *I2cIo;
  EFI_STATUS Status;
  UINT8 RegVal;
  UINTN Bank;

  Status = MvPca95xxGetI2c (ControllerIndex, &I2cIo);
  if (EFI_ERROR (Status)) {
    DEBUG ((DEBUG_ERROR, "%a: fail to get I2C protocol\n", __FUNCTION__));
    return EFI_DEVICE_ERROR;
  }

  Bank = GpioPin / PCA95XX_BANK_SIZE;

  Status = MvPca95xxReadRegs (I2cIo, PCA95XX_OUTPUT_REG + Bank, &RegVal);
  if (EFI_ERROR (Status)) {
    DEBUG ((DEBUG_ERROR, "%a: fail to read device register\n", __FUNCTION__));
    return EFI_DEVICE_ERROR;
  }

  if (Mode == GPIO_MODE_OUTPUT_1) {
    RegVal |= (1 << (GpioPin % PCA95XX_BANK_SIZE));
  } else {
    RegVal &= ~(1 << (GpioPin % PCA95XX_BANK_SIZE));
  }

  Status = MvPca95xxWriteRegs (I2cIo, PCA95XX_OUTPUT_REG + Bank, RegVal);
  if (EFI_ERROR (Status)) {
    DEBUG ((DEBUG_ERROR, "%a: fail to write device register\n", __FUNCTION__));
    return EFI_DEVICE_ERROR;
  }

  return EFI_SUCCESS;
}

STATIC
EFI_STATUS
MvPca95xxSetDirection (
  IN UINTN              ControllerIndex,
  IN UINTN              GpioPin,
  IN EMBEDDED_GPIO_MODE Mode
  )
{
  EFI_I2C_IO_PROTOCOL *I2cIo;
  EFI_STATUS Status;
  UINT8 RegVal;
  UINTN Bank;

  Status = MvPca95xxGetI2c (ControllerIndex, &I2cIo);
  if (EFI_ERROR (Status)) {
    DEBUG ((DEBUG_ERROR, "%a: fail to get I2C protocol\n", __FUNCTION__));
    return Status;
  }

  Bank = GpioPin / PCA95XX_BANK_SIZE;

  Status = MvPca95xxReadRegs (I2cIo, PCA95XX_DIRECTION_REG + Bank, &RegVal);
  if (EFI_ERROR (Status)) {
    DEBUG ((DEBUG_ERROR, "%a: fail to read device register\n", __FUNCTION__));
    return Status;
  }

  if (Mode == GPIO_MODE_INPUT) {
    RegVal |= (1 << (GpioPin % PCA95XX_BANK_SIZE));
  } else {
    RegVal &= ~(1 << (GpioPin % PCA95XX_BANK_SIZE));
  }

  Status = MvPca95xxWriteRegs (I2cIo, PCA95XX_DIRECTION_REG + Bank, RegVal);
  if (EFI_ERROR (Status)) {
    DEBUG ((DEBUG_ERROR, "%a: fail to write device register\n", __FUNCTION__));
    return Status;
  }

  return EFI_SUCCESS;
}

STATIC
EFI_STATUS
MvPca95xxReadMode (
  IN  UINTN               ControllerIndex,
  IN  UINTN               GpioPin,
  OUT EMBEDDED_GPIO_MODE *Mode
  )
{
  EFI_I2C_IO_PROTOCOL *I2cIo;
  EFI_STATUS Status;
  UINT8 RegVal;
  UINTN Bank;

  ASSERT_EFI_ERROR (MvPca95xxValidate (ControllerIndex, GpioPin));

  Status = MvPca95xxGetI2c (ControllerIndex, &I2cIo);
  if (EFI_ERROR (Status)) {
    DEBUG ((DEBUG_ERROR, "%a: fail to get I2C protocol\n", __FUNCTION__));
    return Status;
  }

  Bank = GpioPin / PCA95XX_BANK_SIZE;

  Status = MvPca95xxReadRegs (I2cIo, PCA95XX_DIRECTION_REG + Bank, &RegVal);
  if (EFI_ERROR (Status)) {
    DEBUG ((DEBUG_ERROR, "%a: fail to read device register\n", __FUNCTION__));
    return Status;
  }

  if (RegVal & (1 << (GpioPin % PCA95XX_BANK_SIZE))) {
    *Mode = GPIO_MODE_INPUT;
  } else {
    Status = MvPca95xxReadRegs (I2cIo, PCA95XX_INPUT_REG + Bank, &RegVal);
    if (EFI_ERROR (Status)) {
      DEBUG ((DEBUG_ERROR, "%a: fail to read device register\n", __FUNCTION__));
      return Status;
    }

    if (RegVal & (1 << (GpioPin % PCA95XX_BANK_SIZE))) {
      *Mode = GPIO_MODE_OUTPUT_1;
    } else {
      *Mode = GPIO_MODE_OUTPUT_0;
    }
  }

  return EFI_SUCCESS;
}

/**

Routine Description:

  Gets the mode (function) of a GPIO pin

Arguments:

  This  - pointer to protocol
  Gpio  - which pin
  Mode  - pointer to output mode value

Returns:

  EFI_SUCCESS           - mode value retrieved
  EFI_INVALID_PARAMETER - Mode is a null pointer or Gpio pin is out of range

**/
STATIC
EFI_STATUS
MvPca95xxGetMode (
  IN  EMBEDDED_GPIO       *This,
  IN  EMBEDDED_GPIO_PIN    Gpio,
  OUT EMBEDDED_GPIO_MODE  *Mode
  )
{
  EFI_STATUS Status;
  UINTN ControllerIndex;
  UINTN GpioPin;

  GpioPin = GPIO_PIN (Gpio);
  ControllerIndex = GPIO_PORT (Gpio);

  ASSERT_EFI_ERROR (MvPca95xxValidate (ControllerIndex, GpioPin));

  Status = MvPca95xxReadMode (ControllerIndex, GpioPin, Mode);
  if (EFI_ERROR (Status)) {
    DEBUG ((DEBUG_ERROR,
      "%a: fail to get pin %d of controller#%d mode\n",
      __FUNCTION__,
      GpioPin,
      ControllerIndex));
  }

  return Status;
}

/**

Routine Description:

  Gets the state of a GPIO pin

Arguments:

  This  - pointer to protocol
  Gpio  - which pin to read
  Value - state of the pin

Returns:

  EFI_SUCCESS           - GPIO state returned in Value
  EFI_INVALID_PARAMETER - Value is NULL pointer or Gpio pin is out of range
**/
STATIC
EFI_STATUS
MvPca95xxGet (
  IN  EMBEDDED_GPIO      *This,
  IN  EMBEDDED_GPIO_PIN   Gpio,
  OUT UINTN              *Value
  )
{
  EFI_I2C_IO_PROTOCOL *I2cIo;
  EFI_STATUS Status;
  UINTN ControllerIndex;
  UINTN GpioPin;
  UINT8 RegVal;
  UINTN Bank;

  GpioPin = GPIO_PIN (Gpio);
  ControllerIndex = GPIO_PORT (Gpio);

  ASSERT_EFI_ERROR (MvPca95xxValidate (ControllerIndex, GpioPin));

  Status = MvPca95xxGetI2c (ControllerIndex, &I2cIo);
  if (EFI_ERROR (Status)) {
    DEBUG ((DEBUG_ERROR, "%a: fail to get I2C protocol\n", __FUNCTION__));
    return Status;
  }

  Bank = GpioPin / PCA95XX_BANK_SIZE;

  Status = MvPca95xxReadRegs (I2cIo, PCA95XX_INPUT_REG + Bank, &RegVal);
  if (EFI_ERROR (Status)) {
    DEBUG ((DEBUG_ERROR, "%a: fail to read device register\n", __FUNCTION__));
    return Status;
  }

  if (RegVal & (1 << (GpioPin % PCA95XX_BANK_SIZE))) {
    *Value = 1;
  } else {
    *Value = 0;
  }

  return EFI_SUCCESS;
}

/**

Routine Description:

  Sets the state of a GPIO pin

Arguments:

  This  - pointer to protocol
  Gpio  - which pin to modify
  Mode  - mode to set

Returns:

  EFI_SUCCESS           - GPIO set as requested
  EFI_UNSUPPORTED       - Mode is not supported
  EFI_INVALID_PARAMETER - Gpio pin is out of range
**/
STATIC
EFI_STATUS
MvPca95xxSet (
  IN EMBEDDED_GPIO       *This,
  IN EMBEDDED_GPIO_PIN   Gpio,
  IN EMBEDDED_GPIO_MODE  Mode
  )
{
  EFI_STATUS Status;
  UINTN ControllerIndex;
  UINTN GpioPin;

  GpioPin = GPIO_PIN (Gpio);
  ControllerIndex = GPIO_PORT (Gpio);

  ASSERT_EFI_ERROR (MvPca95xxValidate (ControllerIndex, GpioPin));

  switch (Mode) {
  case GPIO_MODE_OUTPUT_0:
  case GPIO_MODE_OUTPUT_1:
    Status = MvPca95xxSetOutputValue (ControllerIndex, GpioPin, Mode);
    if (EFI_ERROR (Status)) {
      DEBUG ((DEBUG_ERROR, "%a: fail to set ouput value\n", __FUNCTION__));
      return Status;
    }

  /* Fall-through */
  case GPIO_MODE_INPUT:
    Status = MvPca95xxSetDirection (ControllerIndex, GpioPin, Mode);
    if (EFI_ERROR (Status)) {
      DEBUG ((DEBUG_ERROR, "%a: fail to set direction\n", __FUNCTION__));
      return Status;
    }
    break;

  default:
    return EFI_UNSUPPORTED;
  }

  return EFI_SUCCESS;
}

/**

Routine Description:

  Sets the pull-up / pull-down resistor of a GPIO pin

Arguments:

  This  - pointer to protocol
  Gpio  - which pin
  Direction - pull-up, pull-down, or none

Returns:

  EFI_UNSUPPORTED - Can not perform the requested operation

**/
EFI_STATUS
EFIAPI
MvPca95xxSetPull (
  IN EMBEDDED_GPIO       *This,
  IN EMBEDDED_GPIO_PIN   Gpio,
  IN EMBEDDED_GPIO_PULL  Direction
  )
{
  return EFI_UNSUPPORTED;
}

STATIC
VOID
MvPca95xxInitProtocol (
  IN EMBEDDED_GPIO *GpioProtocol
  )
{
  GpioProtocol->Get     = MvPca95xxGet;
  GpioProtocol->Set     = MvPca95xxSet;
  GpioProtocol->GetMode = MvPca95xxGetMode;
  GpioProtocol->SetPull = MvPca95xxSetPull;
}

EFI_STATUS
EFIAPI
MvPca95xxEntryPoint (
  IN EFI_HANDLE       ImageHandle,
  IN EFI_SYSTEM_TABLE *SystemTable
  )
{
  MARVELL_BOARD_DESC_PROTOCOL *MvBoardProtocol;
  MV_BOARD_GPIO_DESCRIPTION *GpioDescription;
  MV_GPIO_DEVICE_PATH *Pca95xxDevicePath;
  EFI_STATUS Status;

  /* Obtain list of available controllers */
  Status = gBS->LocateProtocol (&gMarvellBoardDescProtocolGuid,
                  NULL,
                  (VOID **)&MvBoardProtocol);
  if (EFI_ERROR (Status)) {
    DEBUG ((DEBUG_ERROR,
      "%a: Cannot locate BoardDesc protocol\n",
      __FUNCTION__));
    return Status;
  }

  Status = MvBoardProtocol->GpioDescriptionGet (MvBoardProtocol,
             &GpioDescription);
  if (EFI_ERROR (Status)) {
    DEBUG ((DEBUG_ERROR,
      "%a: Cannot get GPIO board desc from BoardDesc protocol\n",
      __FUNCTION__));
    return Status;
  } else if (GpioDescription->GpioExpanders == NULL) {
    /* Silently exit, if the board does not support the controllers */
    return EFI_SUCCESS;
  }

  Pca95xxDevicePath = AllocateCopyPool (sizeof (MV_GPIO_DEVICE_PATH),
                        &mDevicePathTemplate);
  if (Pca95xxDevicePath == NULL) {
    DEBUG ((DEBUG_ERROR,
      "%a: Fail to allocate Pca95xxDevicePath\n",
      __FUNCTION__));
    return EFI_OUT_OF_RESOURCES;
  }

  mPca95xxInstance = AllocateZeroPool (sizeof (PCA95XX));
  if (mPca95xxInstance == NULL) {
    DEBUG ((DEBUG_ERROR,
      "%a: Fail to allocate mPca95xxInstance\n",
      __FUNCTION__));
    Status = EFI_OUT_OF_RESOURCES;
    goto ErrPca95xxInstanceAlloc;
  }

  MvPca95xxInitProtocol (&mPca95xxInstance->GpioProtocol);

  mPca95xxInstance->Signature = PCA95XX_GPIO_SIGNATURE;
  mPca95xxInstance->GpioExpanders = GpioDescription->GpioExpanders;
  mPca95xxInstance->GpioExpanderCount = GpioDescription->GpioExpanderCount;

  Status = gBS->InstallMultipleProtocolInterfaces (
                  &(mPca95xxInstance->ControllerHandle),
                  &gEmbeddedGpioProtocolGuid,
                  &(mPca95xxInstance->GpioProtocol),
                  &gEfiDevicePathProtocolGuid,
                  (EFI_DEVICE_PATH_PROTOCOL *)Pca95xxDevicePath,
                  NULL);
  if (EFI_ERROR (Status)) {
    goto ErrInstallProtocols;
  }

  return EFI_SUCCESS;

ErrInstallProtocols:
  gBS->FreePool (mPca95xxInstance);

ErrPca95xxInstanceAlloc:
  gBS->FreePool (Pca95xxDevicePath);

  return Status;
}