/** @file
  96boards Secure96 mezzanine board DXE driver.

  Copyright (c) 2018, Linaro, Ltd. All rights reserved.<BR>

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

#include <PiDxe.h>
#include <libfdt.h>
#include <Library/BaseLib.h>
#include <Library/DebugLib.h>
#include <Library/DxeServicesLib.h>
#include <Library/UefiBootServicesTableLib.h>
#include <Library/UefiLib.h>
#include <Protocol/LsConnector.h>
#include <Protocol/Mezzanine.h>

#include "Secure96.h"

#define SECURE96_SSDT_OEM_TABLE_ID SIGNATURE_64('S','E','C','U','R','E','9','6')

STATIC CONST UINT32 mI2cAtmelSha204aSlaveAddress[] = {
  ATSHA204A_SLAVE_ADDRESS,

  //
  // The Atmel AtSha204a has an annoying 'wake' mode where it will only wake
  // up if SDA is held low for a certain amount of time. Attempting to access
  // a device at address 0x0 at 100 kHz should be sufficient to create this
  // wake condition, so add address 0x0 to the slave addresses.
  //
  0
};

STATIC CONST EFI_I2C_DEVICE mI2c0Devices[] = {
  {
    &gAtSha204aI2cDeviceGuid,                     // DeviceGuid
    0,                                            // DeviceIndex
    0,                                            // HardwareRevision
    0,                                            // I2C bus configuration
    ARRAY_SIZE (mI2cAtmelSha204aSlaveAddress),    // SlaveAddressCount
    mI2cAtmelSha204aSlaveAddress                  // SlaveAddressArray
  }
};

STATIC CONST CHAR8 mLedNodes[][46] = {
  "/fragment@2/__overlay__/gpio-leds/secure96-u1",
  "/fragment@2/__overlay__/gpio-leds/secure96-u2",
  "/fragment@2/__overlay__/gpio-leds/secure96-u3",
  "/fragment@2/__overlay__/gpio-leds/secure96-u4",
};

STATIC
VOID
SetOverlayFragmentTarget (
  VOID            *Overlay,
  CONST CHAR8     *NodeName,
  CONST CHAR8     *Target
  )
{
  INT32       Node;
  INT32       Err;

  Node = fdt_path_offset (Overlay, NodeName);
  ASSERT (Node > 0);

  Err = fdt_setprop (Overlay, Node, "target-path", Target,
          AsciiStrLen (Target) + 1);
  if (Err) {
    DEBUG ((DEBUG_ERROR, "%a: fdt_setprop() failed - %a\n",
      __FUNCTION__, fdt_strerror (Err)));
  }
}

STATIC
VOID
FixupOverlay (
  VOID        *Dtb,
  VOID        *Overlay
  )
{
  INT32       Node;
  UINT32      GpioPhandle;
  UINTN       Idx;
  UINT32      *GpioProp;
  INT32       Err;

  //
  // Set the correct GPIO phandle in the LED nodes
  //
  Node = fdt_path_offset (Dtb, FixedPcdGetPtr (PcdGpioParent));
  ASSERT (Node > 0);

  GpioPhandle = fdt_get_phandle (Dtb, Node);
  if (!GpioPhandle) {
    //
    // Node has no phandle yet -> create one
    //
    GpioPhandle = 1 + fdt_get_max_phandle (Dtb);
    ASSERT (GpioPhandle >= 1);

    Err = fdt_setprop_u32 (Dtb, Node, "phandle", GpioPhandle);
    if (Err) {
      DEBUG ((DEBUG_ERROR,
        "%a: fdt_setprop_u32(.., .., \"phandle\", 0x%x) failed - %a\n",
        __FUNCTION__, GpioPhandle, fdt_strerror (Err)));
    }
  }

  for (Idx = 0; Idx < ARRAY_SIZE (mLedNodes); Idx++) {
    Node = fdt_path_offset (Overlay, mLedNodes[Idx]);
    ASSERT (Node > 0);

    GpioProp = fdt_getprop_w (Overlay, Node, "gpios", NULL);
    ASSERT (GpioProp != NULL);

    *GpioProp = cpu_to_fdt32 (GpioPhandle);
  }

  SetOverlayFragmentTarget (Overlay, "/fragment@0",
    FixedPcdGetPtr (PcdI2c0Parent));

  SetOverlayFragmentTarget (Overlay, "/fragment@1",
    FixedPcdGetPtr (PcdSpiParent));
}

/**
  Apply the mezzanine's DT overlay

  @param[in]      This      Pointer to the MEZZANINE_PROTOCOL instance.
  @param[in,out]  Dtb       Pointer to the device tree blob

  @return   EFI_SUCCESS     Operation succeeded.
  @return   other           An error has occurred.
**/
STATIC
EFI_STATUS
ApplyDeviceTreeOverlay (
  IN      MEZZANINE_PROTOCOL    *This,
  IN  OUT VOID                  *Dtb
  )
{
  VOID            *Overlay;
  UINTN           OverlaySize;
  EFI_STATUS      Status;
  INT32           Err;
  UINTN           Index;

  //
  // Load the raw overlay DTB image from the raw section of this FFS file.
  //
  for (Index = 0;; Index++) {
    Status = GetSectionFromFv (&gEfiCallerIdGuid,
               EFI_SECTION_RAW, Index, &Overlay, &OverlaySize);
    if (EFI_ERROR (Status)) {
      return EFI_NOT_FOUND;
    }
    if (!fdt_check_header (Overlay)) {
      break;
    }
  }

  //
  // Fix up unresolved references in the overlay.
  //
  FixupOverlay (Dtb, Overlay);

  //
  // Merge the overlay with the DTB
  //
  Err = fdt_overlay_apply (Dtb, Overlay);
  if (Err) {
    DEBUG ((DEBUG_ERROR, "%a: fdt_overlay_apply() failed - %a\n",
      __FUNCTION__, fdt_strerror (Err)));
    return EFI_NOT_FOUND;
  }

  return EFI_SUCCESS;
}

/**
  Install the mezzanine's SSDT table

  @param[in]      This      Pointer to the MEZZANINE_PROTOCOL instance.
  @param[in]      Dtb       Pointer to the device tree blob

  @return   EFI_SUCCESS     Operation succeeded.
  @return   other           An error has occurred.
**/
STATIC
EFI_STATUS
EFIAPI
InstallSsdtTable (
  IN      MEZZANINE_PROTOCOL        *This,
  IN      EFI_ACPI_TABLE_PROTOCOL   *AcpiProtocol
  )
{
  EFI_ACPI_DESCRIPTION_HEADER   *Ssdt;
  UINTN                         SsdtSize;
  EFI_STATUS                    Status;
  UINTN                         Index;
  UINTN                         TableKey;

  //
  // Load SSDT table from the raw section of this FFS file.
  //
  for (Index = 0;; Index++) {
    Status = GetSectionFromFv (&gEfiCallerIdGuid, EFI_SECTION_RAW, Index,
               (VOID **)&Ssdt, &SsdtSize);
    if (EFI_ERROR (Status)) {
      return EFI_NOT_FOUND;
    }
    if (SsdtSize >= sizeof (EFI_ACPI_DESCRIPTION_HEADER) &&
        Ssdt->OemTableId == SECURE96_SSDT_OEM_TABLE_ID) {
      break;
    }
  }
  return AcpiProtocol->InstallAcpiTable (AcpiProtocol, Ssdt, SsdtSize,
                         &TableKey);
}

STATIC MEZZANINE_PROTOCOL mMezzanine = {
  ApplyDeviceTreeOverlay,
  InstallSsdtTable,
  ARRAY_SIZE (mI2c0Devices),
  0,
  mI2c0Devices,
  NULL,
  NULL,
};

EFI_STATUS
EFIAPI
Secure96DxeEntryPoint (
  IN EFI_HANDLE         ImageHandle,
  IN EFI_SYSTEM_TABLE   *SystemTable
  )
{
  EFI_STATUS              Status;
  LS_CONNECTOR_PROTOCOL   *LsConnector;

  Status = gBS->LocateProtocol (&g96BoardsLsConnectorProtocolGuid, NULL,
                  (VOID **)&LsConnector);
  ASSERT_EFI_ERROR (Status);

  if (LsConnector->MezzanineType != MezzanineSecure96) {
    return EFI_NOT_FOUND;
  }

  return gBS->InstallProtocolInterface (&ImageHandle,
                &g96BoardsMezzanineProtocolGuid,
                EFI_NATIVE_INTERFACE,
                &mMezzanine);
}