/** @file
  Copyright (c) 2016, Linaro, Ltd. All rights reserved.<BR>

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

**/

#include <PiDxe.h>

#include <Guid/NonDiscoverableDevice.h>

#include <Library/BaseMemoryLib.h>
#include <Library/DebugLib.h>
#include <Library/DevicePathLib.h>
#include <Library/MemoryAllocationLib.h>
#include <Library/NonDiscoverableDeviceRegistrationLib.h>
#include <Library/UefiBootServicesTableLib.h>

#include <Protocol/DevicePath.h>
#include <Protocol/NonDiscoverableDevice.h>

/**
  Get Guid form the type of non-discoverable device.

  @param[in]  Type    The type of non-discoverable device.

  @retval   Return the Guid.

**/
STATIC
CONST EFI_GUID *
GetGuidFromType (
  IN  NON_DISCOVERABLE_DEVICE_TYPE  Type
  )
{
  switch (Type) {
  case NonDiscoverableDeviceTypeAhci:
    return &gEdkiiNonDiscoverableAhciDeviceGuid;

  case NonDiscoverableDeviceTypeAmba:
    return &gEdkiiNonDiscoverableAmbaDeviceGuid;

  case NonDiscoverableDeviceTypeEhci:
    return &gEdkiiNonDiscoverableEhciDeviceGuid;

  case NonDiscoverableDeviceTypeNvme:
    return &gEdkiiNonDiscoverableNvmeDeviceGuid;

  case NonDiscoverableDeviceTypeOhci:
    return &gEdkiiNonDiscoverableOhciDeviceGuid;

  case NonDiscoverableDeviceTypeSdhci:
    return &gEdkiiNonDiscoverableSdhciDeviceGuid;

  case NonDiscoverableDeviceTypeUfs:
    return &gEdkiiNonDiscoverableUfsDeviceGuid;

  case NonDiscoverableDeviceTypeUhci:
    return &gEdkiiNonDiscoverableUhciDeviceGuid;

  case NonDiscoverableDeviceTypeXhci:
    return &gEdkiiNonDiscoverableXhciDeviceGuid;

  default:
    return NULL;
  }
}

#pragma pack (1)
typedef struct {
  VENDOR_DEVICE_PATH                  Vendor;
  UINT64                              BaseAddress;
  UINT8                               ResourceType;
  EFI_DEVICE_PATH_PROTOCOL            End;
} NON_DISCOVERABLE_DEVICE_PATH;
#pragma pack ()

/**
  Register a non-discoverable MMIO device.

  @param[in]      Type                The type of non-discoverable device
  @param[in]      DmaType             Whether the device is DMA coherent
  @param[in]      InitFunc            Initialization routine to be invoked when
                                      the device is enabled
  @param[in,out]  Handle              The handle onto which to install the
                                      non-discoverable device protocol.
                                      If Handle is NULL or *Handle is NULL, a
                                      new handle will be allocated.
  @param[in]      NumMmioResources    The number of UINTN base/size pairs that
                                      follow, each describing an MMIO region
                                      owned by the device
  @param[in]  ...                     The variable argument list which contains the
                                      info about MmioResources.

  @retval EFI_SUCCESS                 The registration succeeded.
  @retval EFI_INVALID_PARAMETER       An invalid argument was given
  @retval Other                       The registration failed.

**/
EFI_STATUS
EFIAPI
RegisterNonDiscoverableMmioDevice (
  IN      NON_DISCOVERABLE_DEVICE_TYPE      Type,
  IN      NON_DISCOVERABLE_DEVICE_DMA_TYPE  DmaType,
  IN      NON_DISCOVERABLE_DEVICE_INIT      InitFunc,
  IN OUT  EFI_HANDLE                        *Handle OPTIONAL,
  IN      UINTN                             NumMmioResources,
  ...
  )
{
  NON_DISCOVERABLE_DEVICE             *Device;
  NON_DISCOVERABLE_DEVICE_PATH        *DevicePath;
  EFI_HANDLE                          LocalHandle;
  EFI_STATUS                          Status;
  UINTN                               AllocSize;
  UINTN                               Index;
  VA_LIST                             Args;
  EFI_ACPI_ADDRESS_SPACE_DESCRIPTOR   *Desc;
  EFI_ACPI_END_TAG_DESCRIPTOR         *End;
  UINTN                               Base, Size;

  if (Type >= NonDiscoverableDeviceTypeMax ||
      DmaType >= NonDiscoverableDeviceDmaTypeMax ||
      NumMmioResources == 0) {
    return EFI_INVALID_PARAMETER;
  }

  if (Handle == NULL) {
    Handle = &LocalHandle;
    LocalHandle = NULL;
  }

  AllocSize = sizeof *Device +
              NumMmioResources * sizeof (EFI_ACPI_ADDRESS_SPACE_DESCRIPTOR) +
              sizeof (EFI_ACPI_END_TAG_DESCRIPTOR);
  Device = (NON_DISCOVERABLE_DEVICE *)AllocateZeroPool (AllocSize);
  if (Device == NULL) {
    return EFI_OUT_OF_RESOURCES;
  }

  Device->Type = GetGuidFromType (Type);
  ASSERT (Device->Type != NULL);

  Device->DmaType = DmaType;
  Device->Initialize = InitFunc;
  Device->Resources = (EFI_ACPI_ADDRESS_SPACE_DESCRIPTOR *)(Device + 1);

  VA_START (Args, NumMmioResources);
  for (Index = 0; Index < NumMmioResources; Index++) {
    Desc = &Device->Resources [Index];
    Base = VA_ARG (Args, UINTN);
    Size = VA_ARG (Args, UINTN);

    Desc->Desc                  = ACPI_ADDRESS_SPACE_DESCRIPTOR;
    Desc->Len                   = sizeof *Desc - 3;
    Desc->AddrRangeMin          = Base;
    Desc->AddrLen               = Size;
    Desc->AddrRangeMax          = Base + Size - 1;
    Desc->ResType               = ACPI_ADDRESS_SPACE_TYPE_MEM;
    Desc->AddrSpaceGranularity  = ((EFI_PHYSICAL_ADDRESS)Base + Size > SIZE_4GB) ? 64 : 32;
    Desc->AddrTranslationOffset = 0;
  }
  VA_END (Args);

  End = (EFI_ACPI_END_TAG_DESCRIPTOR *)&Device->Resources [NumMmioResources];

  End->Desc     = ACPI_END_TAG_DESCRIPTOR;
  End->Checksum = 0;

  DevicePath = (NON_DISCOVERABLE_DEVICE_PATH *)CreateDeviceNode (
                                                 HARDWARE_DEVICE_PATH,
                                                 HW_VENDOR_DP,
                                                 sizeof (*DevicePath));
  if (DevicePath == NULL) {
    Status = EFI_OUT_OF_RESOURCES;
    goto FreeDevice;
  }

  CopyGuid (&DevicePath->Vendor.Guid, &gEdkiiNonDiscoverableDeviceProtocolGuid);

  //
  // Use the base address and type of the first region to
  // make the device path unique
  //
  DevicePath->BaseAddress = Device->Resources [0].AddrRangeMin;
  DevicePath->ResourceType = Device->Resources [0].ResType;

  SetDevicePathNodeLength (&DevicePath->Vendor,
    sizeof (*DevicePath) - sizeof (DevicePath->End));
  SetDevicePathEndNode (&DevicePath->End);

  Status = gBS->InstallMultipleProtocolInterfaces (Handle,
                  &gEdkiiNonDiscoverableDeviceProtocolGuid, Device,
                  &gEfiDevicePathProtocolGuid, DevicePath,
                  NULL);
  if (EFI_ERROR(Status)) {
    goto FreeDevicePath;
  }
  return EFI_SUCCESS;

FreeDevicePath:
  FreePool(DevicePath);

FreeDevice:
  FreePool(Device);

  return Status;
}