[mirror_edk2.git] / MdeModulePkg / Universal / Disk / RamDiskDxe / RamDiskProtocol.c

/** @file\r
  The realization of EFI_RAM_DISK_PROTOCOL.\r
\r
  Copyright (c) 2016 - 2019, Intel Corporation. All rights reserved.<BR>\r
  (C) Copyright 2016 Hewlett Packard Enterprise Development LP<BR>\r
  Copyright (c) Microsoft Corporation.<BR>\r
  SPDX-License-Identifier: BSD-2-Clause-Patent\r
\r
**/\r
\r
#include "RamDiskImpl.h"\r
\r
RAM_DISK_PRIVATE_DATA  mRamDiskPrivateDataTemplate = {\r
  RAM_DISK_PRIVATE_DATA_SIGNATURE,\r
  NULL\r
};\r
\r
MEDIA_RAM_DISK_DEVICE_PATH  mRamDiskDeviceNodeTemplate = {\r
  {\r
    MEDIA_DEVICE_PATH,\r
    MEDIA_RAM_DISK_DP,\r
    {\r
      (UINT8)(sizeof (MEDIA_RAM_DISK_DEVICE_PATH)),\r
      (UINT8)((sizeof (MEDIA_RAM_DISK_DEVICE_PATH)) >> 8)\r
    }\r
  }\r
};\r
\r
BOOLEAN  mRamDiskSsdtTableKeyValid = FALSE;\r
UINTN    mRamDiskSsdtTableKey;\r
\r
/**\r
  Initialize the RAM disk device node.\r
\r
  @param[in]      PrivateData     Points to RAM disk private data.\r
  @param[in, out] RamDiskDevNode  Points to the RAM disk device node.\r
\r
**/\r
VOID\r
RamDiskInitDeviceNode (\r
  IN     RAM_DISK_PRIVATE_DATA       *PrivateData,\r
  IN OUT MEDIA_RAM_DISK_DEVICE_PATH  *RamDiskDevNode\r
  )\r
{\r
  WriteUnaligned64 (\r
    (UINT64 *)&(RamDiskDevNode->StartingAddr[0]),\r
    (UINT64)PrivateData->StartingAddr\r
    );\r
  WriteUnaligned64 (\r
    (UINT64 *)&(RamDiskDevNode->EndingAddr[0]),\r
    (UINT64)PrivateData->StartingAddr + PrivateData->Size - 1\r
    );\r
  CopyGuid (&RamDiskDevNode->TypeGuid, &PrivateData->TypeGuid);\r
  RamDiskDevNode->Instance = PrivateData->InstanceNumber;\r
}\r
\r
/**\r
  Initialize and publish NVDIMM root device SSDT in ACPI table.\r
\r
  @retval EFI_SUCCESS        The NVDIMM root device SSDT is published.\r
  @retval Others             The NVDIMM root device SSDT is not published.\r
\r
**/\r
EFI_STATUS\r
RamDiskPublishSsdt (\r
  VOID\r
  )\r
{\r
  EFI_STATUS                   Status;\r
  EFI_ACPI_DESCRIPTION_HEADER  *Table;\r
  UINTN                        SectionInstance;\r
  UINTN                        TableSize;\r
\r
  Status          = EFI_SUCCESS;\r
  SectionInstance = 0;\r
\r
  //\r
  // Scan all the EFI raw section instances in FV to find the NVDIMM root\r
  // device SSDT.\r
  //\r
  while (TRUE) {\r
    Status = GetSectionFromFv (\r
               &gEfiCallerIdGuid,\r
               EFI_SECTION_RAW,\r
               SectionInstance,\r
               (VOID **)&Table,\r
               &TableSize\r
               );\r
    if (EFI_ERROR (Status)) {\r
      break;\r
    }\r
\r
    if (Table->OemTableId == SIGNATURE_64 ('R', 'a', 'm', 'D', 'i', 's', 'k', ' ')) {\r
      Status = mAcpiTableProtocol->InstallAcpiTable (\r
                                     mAcpiTableProtocol,\r
                                     Table,\r
                                     TableSize,\r
                                     &mRamDiskSsdtTableKey\r
                                     );\r
      ASSERT_EFI_ERROR (Status);\r
\r
      if (!EFI_ERROR (Status)) {\r
        mRamDiskSsdtTableKeyValid = TRUE;\r
      }\r
\r
      FreePool (Table);\r
      return Status;\r
    } else {\r
      FreePool (Table);\r
      SectionInstance++;\r
    }\r
  }\r
\r
  return Status;\r
}\r
\r
/**\r
  Publish the RAM disk NVDIMM Firmware Interface Table (NFIT) to the ACPI\r
  table.\r
\r
  @param[in] PrivateData          Points to RAM disk private data.\r
\r
  @retval EFI_SUCCESS             The RAM disk NFIT has been published.\r
  @retval others                  The RAM disk NFIT has not been published.\r
\r
**/\r
EFI_STATUS\r
RamDiskPublishNfit (\r
  IN RAM_DISK_PRIVATE_DATA  *PrivateData\r
  )\r
{\r
  EFI_STATUS                   Status;\r
  EFI_MEMORY_DESCRIPTOR        *MemoryMap;\r
  EFI_MEMORY_DESCRIPTOR        *MemoryMapEntry;\r
  EFI_MEMORY_DESCRIPTOR        *MemoryMapEnd;\r
  UINTN                        TableIndex;\r
  VOID                         *TableHeader;\r
  EFI_ACPI_TABLE_VERSION       TableVersion;\r
  UINTN                        TableKey;\r
  EFI_ACPI_DESCRIPTION_HEADER  *NfitHeader;\r
  EFI_ACPI_6_1_NFIT_SYSTEM_PHYSICAL_ADDRESS_RANGE_STRUCTURE\r
           *SpaRange;\r
  VOID     *Nfit;\r
  UINT32   NfitLen;\r
  UINTN    MemoryMapSize;\r
  UINTN    MapKey;\r
  UINTN    DescriptorSize;\r
  UINT32   DescriptorVersion;\r
  UINT64   CurrentData;\r
  UINT8    Checksum;\r
  BOOLEAN  MemoryFound;\r
\r
  //\r
  // Get the EFI memory map.\r
  //\r
  MemoryMapSize = 0;\r
  MemoryMap     = NULL;\r
  MemoryFound   = FALSE;\r
\r
  Status = gBS->GetMemoryMap (\r
                  &MemoryMapSize,\r
                  MemoryMap,\r
                  &MapKey,\r
                  &DescriptorSize,\r
                  &DescriptorVersion\r
                  );\r
  ASSERT (Status == EFI_BUFFER_TOO_SMALL);\r
  do {\r
    MemoryMap = (EFI_MEMORY_DESCRIPTOR *)AllocatePool (MemoryMapSize);\r
    ASSERT (MemoryMap != NULL);\r
    Status = gBS->GetMemoryMap (\r
                    &MemoryMapSize,\r
                    MemoryMap,\r
                    &MapKey,\r
                    &DescriptorSize,\r
                    &DescriptorVersion\r
                    );\r
    if (EFI_ERROR (Status)) {\r
      FreePool (MemoryMap);\r
    }\r
  } while (Status == EFI_BUFFER_TOO_SMALL);\r
\r
  ASSERT_EFI_ERROR (Status);\r
\r
  MemoryMapEntry = MemoryMap;\r
  MemoryMapEnd   = (EFI_MEMORY_DESCRIPTOR *)((UINT8 *)MemoryMap + MemoryMapSize);\r
  while ((UINTN)MemoryMapEntry < (UINTN)MemoryMapEnd) {\r
    if ((MemoryMapEntry->Type == EfiReservedMemoryType) &&\r
        (MemoryMapEntry->PhysicalStart <= PrivateData->StartingAddr) &&\r
        (MemoryMapEntry->PhysicalStart +\r
         MultU64x32 (MemoryMapEntry->NumberOfPages, EFI_PAGE_SIZE)\r
         >= PrivateData->StartingAddr + PrivateData->Size))\r
    {\r
      MemoryFound = TRUE;\r
      DEBUG ((\r
        DEBUG_INFO,\r
        "RamDiskPublishNfit: RAM disk with reserved memory type, will publish to NFIT.\n"\r
        ));\r
      break;\r
    }\r
\r
    MemoryMapEntry = NEXT_MEMORY_DESCRIPTOR (MemoryMapEntry, DescriptorSize);\r
  }\r
\r
  FreePool (MemoryMap);\r
\r
  if (!MemoryFound) {\r
    return EFI_NOT_FOUND;\r
  }\r
\r
  //\r
  // Determine whether there is a NFIT already in the ACPI table.\r
  //\r
  Status      = EFI_SUCCESS;\r
  TableIndex  = 0;\r
  TableKey    = 0;\r
  TableHeader = NULL;\r
\r
  while (!EFI_ERROR (Status)) {\r
    Status = mAcpiSdtProtocol->GetAcpiTable (\r
                                 TableIndex,\r
                                 (EFI_ACPI_SDT_HEADER **)&TableHeader,\r
                                 &TableVersion,\r
                                 &TableKey\r
                                 );\r
    if (!EFI_ERROR (Status)) {\r
      TableIndex++;\r
\r
      if (((EFI_ACPI_SDT_HEADER *)TableHeader)->Signature ==\r
          EFI_ACPI_6_1_NVDIMM_FIRMWARE_INTERFACE_TABLE_STRUCTURE_SIGNATURE)\r
      {\r
        break;\r
      }\r
    }\r
  }\r
\r
  if (!EFI_ERROR (Status)) {\r
    //\r
    // A NFIT is already in the ACPI table.\r
    //\r
    DEBUG ((\r
      DEBUG_INFO,\r
      "RamDiskPublishNfit: A NFIT is already exist in the ACPI Table.\n"\r
      ));\r
\r
    NfitHeader = (EFI_ACPI_DESCRIPTION_HEADER *)TableHeader;\r
    NfitLen    = NfitHeader->Length + sizeof (EFI_ACPI_6_1_NFIT_SYSTEM_PHYSICAL_ADDRESS_RANGE_STRUCTURE);\r
    Nfit       = AllocateZeroPool (NfitLen);\r
    if (Nfit == NULL) {\r
      return EFI_OUT_OF_RESOURCES;\r
    }\r
\r
    CopyMem (Nfit, TableHeader, NfitHeader->Length);\r
\r
    //\r
    // Update the NFIT head pointer.\r
    //\r
    NfitHeader = (EFI_ACPI_DESCRIPTION_HEADER *)Nfit;\r
\r
    //\r
    // Uninstall the origin NFIT from the ACPI table.\r
    //\r
    Status = mAcpiTableProtocol->UninstallAcpiTable (\r
                                   mAcpiTableProtocol,\r
                                   TableKey\r
                                   );\r
    ASSERT_EFI_ERROR (Status);\r
\r
    if (EFI_ERROR (Status)) {\r
      FreePool (Nfit);\r
      return Status;\r
    }\r
\r
    //\r
    // Append the System Physical Address (SPA) Range Structure at the end\r
    // of the origin NFIT.\r
    //\r
    SpaRange = (EFI_ACPI_6_1_NFIT_SYSTEM_PHYSICAL_ADDRESS_RANGE_STRUCTURE *)\r
               ((UINT8 *)Nfit + NfitHeader->Length);\r
\r
    //\r
    // Update the length field of the NFIT\r
    //\r
    NfitHeader->Length = NfitLen;\r
\r
    //\r
    // The checksum will be updated after the new contents are appended.\r
    //\r
    NfitHeader->Checksum = 0;\r
  } else {\r
    //\r
    // Assumption is made that if no NFIT is in the ACPI table, there is no\r
    // NVDIMM root device in the \SB scope.\r
    // Therefore, a NVDIMM root device will be reported via Secondary System\r
    // Description Table (SSDT).\r
    //\r
    Status = RamDiskPublishSsdt ();\r
    if (EFI_ERROR (Status)) {\r
      return Status;\r
    }\r
\r
    //\r
    // No NFIT is in the ACPI table, we will create one here.\r
    //\r
    DEBUG ((\r
      DEBUG_INFO,\r
      "RamDiskPublishNfit: No NFIT is in the ACPI Table, will create one.\n"\r
      ));\r
\r
    NfitLen = sizeof (EFI_ACPI_6_1_NVDIMM_FIRMWARE_INTERFACE_TABLE) +\r
              sizeof (EFI_ACPI_6_1_NFIT_SYSTEM_PHYSICAL_ADDRESS_RANGE_STRUCTURE);\r
    Nfit = AllocateZeroPool (NfitLen);\r
    if (Nfit == NULL) {\r
      return EFI_OUT_OF_RESOURCES;\r
    }\r
\r
    SpaRange = (EFI_ACPI_6_1_NFIT_SYSTEM_PHYSICAL_ADDRESS_RANGE_STRUCTURE *)\r
               ((UINT8 *)Nfit + sizeof (EFI_ACPI_6_1_NVDIMM_FIRMWARE_INTERFACE_TABLE));\r
\r
    NfitHeader                  = (EFI_ACPI_DESCRIPTION_HEADER *)Nfit;\r
    NfitHeader->Signature       = EFI_ACPI_6_1_NVDIMM_FIRMWARE_INTERFACE_TABLE_STRUCTURE_SIGNATURE;\r
    NfitHeader->Length          = NfitLen;\r
    NfitHeader->Revision        = EFI_ACPI_6_1_NVDIMM_FIRMWARE_INTERFACE_TABLE_REVISION;\r
    NfitHeader->Checksum        = 0;\r
    NfitHeader->OemRevision     = PcdGet32 (PcdAcpiDefaultOemRevision);\r
    NfitHeader->CreatorId       = PcdGet32 (PcdAcpiDefaultCreatorId);\r
    NfitHeader->CreatorRevision = PcdGet32 (PcdAcpiDefaultCreatorRevision);\r
    CurrentData                 = PcdGet64 (PcdAcpiDefaultOemTableId);\r
    CopyMem (NfitHeader->OemId, PcdGetPtr (PcdAcpiDefaultOemId), sizeof (NfitHeader->OemId));\r
    CopyMem (&NfitHeader->OemTableId, &CurrentData, sizeof (UINT64));\r
  }\r
\r
  //\r
  // Fill in the content of the SPA Range Structure.\r
  //\r
  SpaRange->Type                             = EFI_ACPI_6_1_NFIT_SYSTEM_PHYSICAL_ADDRESS_RANGE_STRUCTURE_TYPE;\r
  SpaRange->Length                           = sizeof (EFI_ACPI_6_1_NFIT_SYSTEM_PHYSICAL_ADDRESS_RANGE_STRUCTURE);\r
  SpaRange->SystemPhysicalAddressRangeBase   = PrivateData->StartingAddr;\r
  SpaRange->SystemPhysicalAddressRangeLength = PrivateData->Size;\r
  CopyGuid (&SpaRange->AddressRangeTypeGUID, &PrivateData->TypeGuid);\r
\r
  Checksum             = CalculateCheckSum8 ((UINT8 *)Nfit, NfitHeader->Length);\r
  NfitHeader->Checksum = Checksum;\r
\r
  //\r
  // Publish the NFIT to the ACPI table.\r
  // Note, since the NFIT might be modified by other driver, therefore, we\r
  // do not track the returning TableKey from the InstallAcpiTable().\r
  //\r
  Status = mAcpiTableProtocol->InstallAcpiTable (\r
                                 mAcpiTableProtocol,\r
                                 Nfit,\r
                                 NfitHeader->Length,\r
                                 &TableKey\r
                                 );\r
  ASSERT_EFI_ERROR (Status);\r
\r
  FreePool (Nfit);\r
\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  PrivateData->InNfit = TRUE;\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Unpublish the RAM disk NVDIMM Firmware Interface Table (NFIT) from the\r
  ACPI table.\r
\r
  @param[in] PrivateData          Points to RAM disk private data.\r
\r
  @retval EFI_SUCCESS             The RAM disk NFIT has been unpublished.\r
  @retval others                  The RAM disk NFIT has not been unpublished.\r
\r
**/\r
EFI_STATUS\r
RamDiskUnpublishNfit (\r
  IN RAM_DISK_PRIVATE_DATA  *PrivateData\r
  )\r
{\r
  EFI_STATUS                   Status;\r
  UINTN                        TableIndex;\r
  VOID                         *TableHeader;\r
  EFI_ACPI_TABLE_VERSION       TableVersion;\r
  UINTN                        TableKey;\r
  EFI_ACPI_DESCRIPTION_HEADER  *NewNfitHeader;\r
  EFI_ACPI_6_1_NFIT_SYSTEM_PHYSICAL_ADDRESS_RANGE_STRUCTURE\r
                                      *SpaRange;\r
  VOID                                *NewNfit;\r
  VOID                                *NewNfitPtr;\r
  EFI_ACPI_6_1_NFIT_STRUCTURE_HEADER  *NfitStructHeader;\r
  UINT32                              NewNfitLen;\r
  UINT32                              RemainLen;\r
  UINT8                               Checksum;\r
\r
  //\r
  // Find the NFIT in the ACPI table.\r
  //\r
  Status      = EFI_SUCCESS;\r
  TableIndex  = 0;\r
  TableKey    = 0;\r
  TableHeader = NULL;\r
\r
  while (!EFI_ERROR (Status)) {\r
    Status = mAcpiSdtProtocol->GetAcpiTable (\r
                                 TableIndex,\r
                                 (EFI_ACPI_SDT_HEADER **)&TableHeader,\r
                                 &TableVersion,\r
                                 &TableKey\r
                                 );\r
    if (!EFI_ERROR (Status)) {\r
      TableIndex++;\r
\r
      if (((EFI_ACPI_SDT_HEADER *)TableHeader)->Signature ==\r
          EFI_ACPI_6_1_NVDIMM_FIRMWARE_INTERFACE_TABLE_STRUCTURE_SIGNATURE)\r
      {\r
        break;\r
      }\r
    }\r
  }\r
\r
  if (EFI_ERROR (Status)) {\r
    //\r
    // No NFIT is found in the ACPI table.\r
    //\r
    return EFI_NOT_FOUND;\r
  }\r
\r
  NewNfitLen = ((EFI_ACPI_DESCRIPTION_HEADER *)TableHeader)->Length -\r
               sizeof (EFI_ACPI_6_1_NFIT_SYSTEM_PHYSICAL_ADDRESS_RANGE_STRUCTURE);\r
\r
  //\r
  // After removing this RAM disk from the NFIT, if no other structure is in\r
  // the NFIT, we just remove the NFIT and the SSDT which is used to report\r
  // the NVDIMM root device.\r
  //\r
  if (NewNfitLen == sizeof (EFI_ACPI_6_1_NVDIMM_FIRMWARE_INTERFACE_TABLE)) {\r
    //\r
    // Remove the NFIT.\r
    //\r
    Status = mAcpiTableProtocol->UninstallAcpiTable (\r
                                   mAcpiTableProtocol,\r
                                   TableKey\r
                                   );\r
    ASSERT_EFI_ERROR (Status);\r
    if (EFI_ERROR (Status)) {\r
      return Status;\r
    }\r
\r
    //\r
    // Remove the SSDT which is used by RamDiskDxe driver to report the NVDIMM\r
    // root device.\r
    // We do not care the return status since this SSDT might already be\r
    // uninstalled by other drivers to update the information of the NVDIMM\r
    // root device.\r
    //\r
    if (mRamDiskSsdtTableKeyValid) {\r
      mRamDiskSsdtTableKeyValid = FALSE;\r
\r
      mAcpiTableProtocol->UninstallAcpiTable (\r
                            mAcpiTableProtocol,\r
                            mRamDiskSsdtTableKey\r
                            );\r
    }\r
\r
    return EFI_SUCCESS;\r
  }\r
\r
  NewNfit = AllocateZeroPool (NewNfitLen);\r
  if (NewNfit == NULL) {\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  //\r
  // Get a copy of the old NFIT header content.\r
  //\r
  CopyMem (NewNfit, TableHeader, sizeof (EFI_ACPI_6_1_NVDIMM_FIRMWARE_INTERFACE_TABLE));\r
  NewNfitHeader           = (EFI_ACPI_DESCRIPTION_HEADER *)NewNfit;\r
  NewNfitHeader->Length   = NewNfitLen;\r
  NewNfitHeader->Checksum = 0;\r
\r
  //\r
  // Copy the content of required NFIT structures.\r
  //\r
  NewNfitPtr       = (UINT8 *)NewNfit + sizeof (EFI_ACPI_6_1_NVDIMM_FIRMWARE_INTERFACE_TABLE);\r
  RemainLen        = NewNfitLen - sizeof (EFI_ACPI_6_1_NVDIMM_FIRMWARE_INTERFACE_TABLE);\r
  NfitStructHeader = (EFI_ACPI_6_1_NFIT_STRUCTURE_HEADER *)\r
                     ((UINT8 *)TableHeader + sizeof (EFI_ACPI_6_1_NVDIMM_FIRMWARE_INTERFACE_TABLE));\r
  while (RemainLen > 0) {\r
    if ((NfitStructHeader->Type == EFI_ACPI_6_1_NFIT_SYSTEM_PHYSICAL_ADDRESS_RANGE_STRUCTURE_TYPE) &&\r
        (NfitStructHeader->Length == sizeof (EFI_ACPI_6_1_NFIT_SYSTEM_PHYSICAL_ADDRESS_RANGE_STRUCTURE)))\r
    {\r
      SpaRange = (EFI_ACPI_6_1_NFIT_SYSTEM_PHYSICAL_ADDRESS_RANGE_STRUCTURE *)NfitStructHeader;\r
\r
      if ((SpaRange->SystemPhysicalAddressRangeBase == PrivateData->StartingAddr) &&\r
          (SpaRange->SystemPhysicalAddressRangeLength == PrivateData->Size) &&\r
          (CompareGuid (&SpaRange->AddressRangeTypeGUID, &PrivateData->TypeGuid)))\r
      {\r
        //\r
        // Skip the SPA Range Structure for the RAM disk to be unpublished\r
        // from NFIT.\r
        //\r
        NfitStructHeader = (EFI_ACPI_6_1_NFIT_STRUCTURE_HEADER *)\r
                           ((UINT8 *)NfitStructHeader + NfitStructHeader->Length);\r
        continue;\r
      }\r
    }\r
\r
    //\r
    // Copy the content of origin NFIT.\r
    //\r
    CopyMem (NewNfitPtr, NfitStructHeader, NfitStructHeader->Length);\r
    NewNfitPtr = (UINT8 *)NewNfitPtr + NfitStructHeader->Length;\r
\r
    //\r
    // Move to the header of next NFIT structure.\r
    //\r
    RemainLen       -= NfitStructHeader->Length;\r
    NfitStructHeader = (EFI_ACPI_6_1_NFIT_STRUCTURE_HEADER *)\r
                       ((UINT8 *)NfitStructHeader + NfitStructHeader->Length);\r
  }\r
\r
  Checksum                = CalculateCheckSum8 ((UINT8 *)NewNfit, NewNfitHeader->Length);\r
  NewNfitHeader->Checksum = Checksum;\r
\r
  Status = mAcpiTableProtocol->UninstallAcpiTable (\r
                                 mAcpiTableProtocol,\r
                                 TableKey\r
                                 );\r
  ASSERT_EFI_ERROR (Status);\r
\r
  if (EFI_ERROR (Status)) {\r
    FreePool (NewNfit);\r
    return Status;\r
  }\r
\r
  //\r
  // Publish the NFIT to the ACPI table.\r
  // Note, since the NFIT might be modified by other driver, therefore, we\r
  // do not track the returning TableKey from the InstallAcpiTable().\r
  //\r
  Status = mAcpiTableProtocol->InstallAcpiTable (\r
                                 mAcpiTableProtocol,\r
                                 NewNfit,\r
                                 NewNfitLen,\r
                                 &TableKey\r
                                 );\r
  ASSERT_EFI_ERROR (Status);\r
\r
  FreePool (NewNfit);\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Register a RAM disk with specified address, size and type.\r
\r
  @param[in]  RamDiskBase    The base address of registered RAM disk.\r
  @param[in]  RamDiskSize    The size of registered RAM disk.\r
  @param[in]  RamDiskType    The type of registered RAM disk. The GUID can be\r
                             any of the values defined in section 9.3.6.9, or a\r
                             vendor defined GUID.\r
  @param[in]  ParentDevicePath\r
                             Pointer to the parent device path. If there is no\r
                             parent device path then ParentDevicePath is NULL.\r
  @param[out] DevicePath     On return, points to a pointer to the device path\r
                             of the RAM disk device.\r
                             If ParentDevicePath is not NULL, the returned\r
                             DevicePath is created by appending a RAM disk node\r
                             to the parent device path. If ParentDevicePath is\r
                             NULL, the returned DevicePath is a RAM disk device\r
                             path without appending. This function is\r
                             responsible for allocating the buffer DevicePath\r
                             with the boot service AllocatePool().\r
\r
  @retval EFI_SUCCESS             The RAM disk is registered successfully.\r
  @retval EFI_INVALID_PARAMETER   DevicePath or RamDiskType is NULL.\r
                                  RamDiskSize is 0.\r
  @retval EFI_ALREADY_STARTED     A Device Path Protocol instance to be created\r
                                  is already present in the handle database.\r
  @retval EFI_OUT_OF_RESOURCES    The RAM disk register operation fails due to\r
                                  resource limitation.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
RamDiskRegister (\r
  IN UINT64                     RamDiskBase,\r
  IN UINT64                     RamDiskSize,\r
  IN EFI_GUID                   *RamDiskType,\r
  IN EFI_DEVICE_PATH            *ParentDevicePath     OPTIONAL,\r
  OUT EFI_DEVICE_PATH_PROTOCOL  **DevicePath\r
  )\r
{\r
  EFI_STATUS                  Status;\r
  RAM_DISK_PRIVATE_DATA       *PrivateData;\r
  RAM_DISK_PRIVATE_DATA       *RegisteredPrivateData;\r
  MEDIA_RAM_DISK_DEVICE_PATH  *RamDiskDevNode;\r
  UINTN                       DevicePathSize;\r
  LIST_ENTRY                  *Entry;\r
\r
  if ((0 == RamDiskSize) || (NULL == RamDiskType) || (NULL == DevicePath)) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  //\r
  // Add check to prevent data read across the memory boundary\r
  //\r
  if ((RamDiskSize > MAX_UINTN) ||\r
      (RamDiskBase > MAX_UINTN - RamDiskSize + 1))\r
  {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  RamDiskDevNode = NULL;\r
\r
  //\r
  // Create a new RAM disk instance and initialize its private data\r
  //\r
  PrivateData = AllocateCopyPool (\r
                  sizeof (RAM_DISK_PRIVATE_DATA),\r
                  &mRamDiskPrivateDataTemplate\r
                  );\r
  if (NULL == PrivateData) {\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  PrivateData->StartingAddr = RamDiskBase;\r
  PrivateData->Size         = RamDiskSize;\r
  CopyGuid (&PrivateData->TypeGuid, RamDiskType);\r
  InitializeListHead (&PrivateData->ThisInstance);\r
\r
  //\r
  // Generate device path information for the registered RAM disk\r
  //\r
  RamDiskDevNode = AllocateCopyPool (\r
                     sizeof (MEDIA_RAM_DISK_DEVICE_PATH),\r
                     &mRamDiskDeviceNodeTemplate\r
                     );\r
  if (NULL == RamDiskDevNode) {\r
    Status = EFI_OUT_OF_RESOURCES;\r
    goto ErrorExit;\r
  }\r
\r
  RamDiskInitDeviceNode (PrivateData, RamDiskDevNode);\r
\r
  *DevicePath = AppendDevicePathNode (\r
                  ParentDevicePath,\r
                  (EFI_DEVICE_PATH_PROTOCOL *)RamDiskDevNode\r
                  );\r
  if (NULL == *DevicePath) {\r
    Status = EFI_OUT_OF_RESOURCES;\r
    goto ErrorExit;\r
  }\r
\r
  PrivateData->DevicePath = *DevicePath;\r
\r
  //\r
  // Check whether the created device path is already present in the handle\r
  // database\r
  //\r
  if (!IsListEmpty (&RegisteredRamDisks)) {\r
    DevicePathSize = GetDevicePathSize (PrivateData->DevicePath);\r
\r
    BASE_LIST_FOR_EACH (Entry, &RegisteredRamDisks) {\r
      RegisteredPrivateData = RAM_DISK_PRIVATE_FROM_THIS (Entry);\r
      if (DevicePathSize == GetDevicePathSize (RegisteredPrivateData->DevicePath)) {\r
        //\r
        // Compare device path\r
        //\r
        if ((CompareMem (\r
               PrivateData->DevicePath,\r
               RegisteredPrivateData->DevicePath,\r
               DevicePathSize\r
               )) == 0)\r
        {\r
          *DevicePath = NULL;\r
          Status      = EFI_ALREADY_STARTED;\r
          goto ErrorExit;\r
        }\r
      }\r
    }\r
  }\r
\r
  //\r
  // Fill Block IO protocol informations for the RAM disk\r
  //\r
  RamDiskInitBlockIo (PrivateData);\r
\r
  //\r
  // Install EFI_DEVICE_PATH_PROTOCOL & EFI_BLOCK_IO(2)_PROTOCOL on a new\r
  // handle\r
  //\r
  Status = gBS->InstallMultipleProtocolInterfaces (\r
                  &PrivateData->Handle,\r
                  &gEfiBlockIoProtocolGuid,\r
                  &PrivateData->BlockIo,\r
                  &gEfiBlockIo2ProtocolGuid,\r
                  &PrivateData->BlockIo2,\r
                  &gEfiDevicePathProtocolGuid,\r
                  PrivateData->DevicePath,\r
                  NULL\r
                  );\r
  if (EFI_ERROR (Status)) {\r
    goto ErrorExit;\r
  }\r
\r
  //\r
  // Insert the newly created one to the registered RAM disk list\r
  //\r
  InsertTailList (&RegisteredRamDisks, &PrivateData->ThisInstance);\r
\r
  gBS->ConnectController (PrivateData->Handle, NULL, NULL, TRUE);\r
\r
  FreePool (RamDiskDevNode);\r
\r
  if ((mAcpiTableProtocol != NULL) && (mAcpiSdtProtocol != NULL)) {\r
    RamDiskPublishNfit (PrivateData);\r
  }\r
\r
  return EFI_SUCCESS;\r
\r
ErrorExit:\r
  if (RamDiskDevNode != NULL) {\r
    FreePool (RamDiskDevNode);\r
  }\r
\r
  if (PrivateData != NULL) {\r
    if (PrivateData->DevicePath) {\r
      FreePool (PrivateData->DevicePath);\r
    }\r
\r
    FreePool (PrivateData);\r
  }\r
\r
  return Status;\r
}\r
\r
/**\r
  Unregister a RAM disk specified by DevicePath.\r
\r
  @param[in] DevicePath      A pointer to the device path that describes a RAM\r
                             Disk device.\r
\r
  @retval EFI_SUCCESS             The RAM disk is unregistered successfully.\r
  @retval EFI_INVALID_PARAMETER   DevicePath is NULL.\r
  @retval EFI_UNSUPPORTED         The device specified by DevicePath is not a\r
                                  valid ramdisk device path and not supported\r
                                  by the driver.\r
  @retval EFI_NOT_FOUND           The RAM disk pointed by DevicePath doesn't\r
                                  exist.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
RamDiskUnregister (\r
  IN  EFI_DEVICE_PATH_PROTOCOL  *DevicePath\r
  )\r
{\r
  LIST_ENTRY                  *Entry;\r
  LIST_ENTRY                  *NextEntry;\r
  BOOLEAN                     Found;\r
  UINT64                      StartingAddr;\r
  UINT64                      EndingAddr;\r
  EFI_DEVICE_PATH_PROTOCOL    *Header;\r
  MEDIA_RAM_DISK_DEVICE_PATH  *RamDiskDevNode;\r
  RAM_DISK_PRIVATE_DATA       *PrivateData;\r
\r
  if (NULL == DevicePath) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  //\r
  // Locate the RAM disk device node.\r
  //\r
  RamDiskDevNode = NULL;\r
  Header         = DevicePath;\r
  do {\r
    //\r
    // Test if the current device node is a RAM disk.\r
    //\r
    if ((MEDIA_DEVICE_PATH == Header->Type) &&\r
        (MEDIA_RAM_DISK_DP == Header->SubType))\r
    {\r
      RamDiskDevNode = (MEDIA_RAM_DISK_DEVICE_PATH *)Header;\r
\r
      break;\r
    }\r
\r
    Header = NextDevicePathNode (Header);\r
  } while ((Header->Type != END_DEVICE_PATH_TYPE));\r
\r
  if (NULL == RamDiskDevNode) {\r
    return EFI_UNSUPPORTED;\r
  }\r
\r
  Found        = FALSE;\r
  StartingAddr = ReadUnaligned64 ((UINT64 *)&(RamDiskDevNode->StartingAddr[0]));\r
  EndingAddr   = ReadUnaligned64 ((UINT64 *)&(RamDiskDevNode->EndingAddr[0]));\r
\r
  if (!IsListEmpty (&RegisteredRamDisks)) {\r
    BASE_LIST_FOR_EACH_SAFE (Entry, NextEntry, &RegisteredRamDisks) {\r
      PrivateData = RAM_DISK_PRIVATE_FROM_THIS (Entry);\r
\r
      //\r
      // Unregister the RAM disk given by its starting address, ending address\r
      // and type guid.\r
      //\r
      if ((StartingAddr == PrivateData->StartingAddr) &&\r
          (EndingAddr == PrivateData->StartingAddr + PrivateData->Size - 1) &&\r
          (CompareGuid (&RamDiskDevNode->TypeGuid, &PrivateData->TypeGuid)))\r
      {\r
        //\r
        // Remove the content for this RAM disk in NFIT.\r
        //\r
        if (PrivateData->InNfit) {\r
          RamDiskUnpublishNfit (PrivateData);\r
        }\r
\r
        //\r
        // Uninstall the EFI_DEVICE_PATH_PROTOCOL & EFI_BLOCK_IO(2)_PROTOCOL\r
        //\r
        gBS->UninstallMultipleProtocolInterfaces (\r
               PrivateData->Handle,\r
               &gEfiBlockIoProtocolGuid,\r
               &PrivateData->BlockIo,\r
               &gEfiBlockIo2ProtocolGuid,\r
               &PrivateData->BlockIo2,\r
               &gEfiDevicePathProtocolGuid,\r
               (EFI_DEVICE_PATH_PROTOCOL *)PrivateData->DevicePath,\r
               NULL\r
               );\r
\r
        RemoveEntryList (&PrivateData->ThisInstance);\r
\r
        if (RamDiskCreateHii == PrivateData->CreateMethod) {\r
          //\r
          // If a RAM disk is created within HII, then the RamDiskDxe driver\r
          // driver is responsible for freeing the allocated memory for the\r
          // RAM disk.\r
          //\r
          FreePool ((VOID *)(UINTN)PrivateData->StartingAddr);\r
        }\r
\r
        FreePool (PrivateData->DevicePath);\r
        FreePool (PrivateData);\r
        Found = TRUE;\r
\r
        break;\r
      }\r
    }\r
  }\r
\r
  if (TRUE == Found) {\r
    return EFI_SUCCESS;\r
  } else {\r
    return EFI_NOT_FOUND;\r
  }\r
}\r