FvOnFv2Thunk.c

Go to the documentation of this file.

 
#include <PiDxe.h>
#include <Protocol/FirmwareVolume2.h>
#include <Protocol/FirmwareVolume.h>
#include <Library/BaseLib.h>
#include <Library/DebugLib.h>
#include <Library/UefiBootServicesTableLib.h>
#include <Library/UefiDriverEntryPoint.h>
#include <Library/UefiLib.h>
#include <Library/MemoryAllocationLib.h>
 
#define FIRMWARE_VOLUME_PRIVATE_DATA_SIGNATURE  SIGNATURE_32 ('f', 'v', 't', 'h')
 
typedef struct {
  UINTN                            Signature;
  EFI_FIRMWARE_VOLUME_PROTOCOL     FirmwareVolume;
  EFI_FIRMWARE_VOLUME2_PROTOCOL    *FirmwareVolume2;
} FIRMWARE_VOLUME_PRIVATE_DATA;
 
#define FIRMWARE_VOLUME_PRIVATE_DATA_FROM_THIS(a)  CR (a, FIRMWARE_VOLUME_PRIVATE_DATA, FirmwareVolume, FIRMWARE_VOLUME_PRIVATE_DATA_SIGNATURE)
 
FRAMEWORK_EFI_FV_ATTRIBUTES
Fv2AttributesToFvAttributes (
  IN  EFI_FV_ATTRIBUTES  Fv2Attributes
  )
{
  //
  // Clear those filed that is not defined in Framework FV spec and Alignment conversion.
  //
  return (Fv2Attributes & 0x1ff) | ((UINTN)EFI_FV_ALIGNMENT_2 << RShiftU64 ((Fv2Attributes & EFI_FV2_ALIGNMENT), 16));
}
 
EFI_STATUS
EFIAPI
FvGetVolumeAttributes (
  IN  EFI_FIRMWARE_VOLUME_PROTOCOL  *This,
  OUT FRAMEWORK_EFI_FV_ATTRIBUTES   *Attributes
  )
{
  EFI_STATUS                     Status;
  FIRMWARE_VOLUME_PRIVATE_DATA   *Private;
  EFI_FIRMWARE_VOLUME2_PROTOCOL  *FirmwareVolume2;
 
  Private         = FIRMWARE_VOLUME_PRIVATE_DATA_FROM_THIS (This);
  FirmwareVolume2 = Private->FirmwareVolume2;
 
  Status = FirmwareVolume2->GetVolumeAttributes (
                              FirmwareVolume2,
                              Attributes
                              );
  if (!EFI_ERROR (Status)) {
    *Attributes = Fv2AttributesToFvAttributes (*Attributes);
  }
 
  return Status;
}
 
EFI_STATUS
EFIAPI
FvSetVolumeAttributes (
  IN EFI_FIRMWARE_VOLUME_PROTOCOL     *This,
  IN OUT FRAMEWORK_EFI_FV_ATTRIBUTES  *Attributes
  )
{
  FIRMWARE_VOLUME_PRIVATE_DATA   *Private;
  EFI_FIRMWARE_VOLUME2_PROTOCOL  *FirmwareVolume2;
  EFI_FV_ATTRIBUTES              Fv2Attributes;
  EFI_STATUS                     Status;
 
  Private         = FIRMWARE_VOLUME_PRIVATE_DATA_FROM_THIS (This);
  FirmwareVolume2 = Private->FirmwareVolume2;
 
  Fv2Attributes = (*Attributes & 0x1ff);
  Status        = FirmwareVolume2->SetVolumeAttributes (
                                     FirmwareVolume2,
                                     &Fv2Attributes
                                     );
 
  *Attributes = Fv2AttributesToFvAttributes (Fv2Attributes);
 
  return Status;
}
 
EFI_STATUS
EFIAPI
FvReadFile (
  IN EFI_FIRMWARE_VOLUME_PROTOCOL  *This,
  IN EFI_GUID                      *NameGuid,
  IN OUT VOID                      **Buffer,
  IN OUT UINTN                     *BufferSize,
  OUT EFI_FV_FILETYPE              *FoundType,
  OUT EFI_FV_FILE_ATTRIBUTES       *FileAttributes,
  OUT UINT32                       *AuthenticationStatus
  )
{
  FIRMWARE_VOLUME_PRIVATE_DATA   *Private;
  EFI_FIRMWARE_VOLUME2_PROTOCOL  *FirmwareVolume2;
  EFI_STATUS                     Status;
 
  Private         = FIRMWARE_VOLUME_PRIVATE_DATA_FROM_THIS (This);
  FirmwareVolume2 = Private->FirmwareVolume2;
 
  Status = FirmwareVolume2->ReadFile (
                              FirmwareVolume2,
                              NameGuid,
                              Buffer,
                              BufferSize,
                              FoundType,
                              FileAttributes,
                              AuthenticationStatus
                              );
 
  //
  // For Framework FV attrbutes, only alignment fields are valid.
  //
  *FileAttributes = *FileAttributes & EFI_FV_FILE_ATTRIB_ALIGNMENT;
 
  return Status;
}
 
EFI_STATUS
EFIAPI
FvReadSection (
  IN EFI_FIRMWARE_VOLUME_PROTOCOL  *This,
  IN EFI_GUID                      *NameGuid,
  IN EFI_SECTION_TYPE              SectionType,
  IN UINTN                         SectionInstance,
  IN OUT VOID                      **Buffer,
  IN OUT UINTN                     *BufferSize,
  OUT UINT32                       *AuthenticationStatus
  )
{
  FIRMWARE_VOLUME_PRIVATE_DATA   *Private;
  EFI_FIRMWARE_VOLUME2_PROTOCOL  *FirmwareVolume2;
 
  Private         = FIRMWARE_VOLUME_PRIVATE_DATA_FROM_THIS (This);
  FirmwareVolume2 = Private->FirmwareVolume2;
 
  return FirmwareVolume2->ReadSection (
                            FirmwareVolume2,
                            NameGuid,
                            SectionType,
                            SectionInstance,
                            Buffer,
                            BufferSize,
                            AuthenticationStatus
                            );
}
 
EFI_STATUS
EFIAPI
FvWriteFile (
  IN EFI_FIRMWARE_VOLUME_PROTOCOL      *This,
  IN UINT32                            NumberOfFiles,
  IN FRAMEWORK_EFI_FV_WRITE_POLICY     WritePolicy,
  IN FRAMEWORK_EFI_FV_WRITE_FILE_DATA  *FileData
  )
{
  FIRMWARE_VOLUME_PRIVATE_DATA   *Private;
  EFI_FIRMWARE_VOLUME2_PROTOCOL  *FirmwareVolume2;
  EFI_FV_WRITE_FILE_DATA         *PiFileData;
  EFI_STATUS                     Status;
  UINTN                          Index;
 
  Private         = FIRMWARE_VOLUME_PRIVATE_DATA_FROM_THIS (This);
  FirmwareVolume2 = Private->FirmwareVolume2;
 
  PiFileData = AllocateCopyPool (sizeof (EFI_FV_WRITE_FILE_DATA), FileData);
  ASSERT (PiFileData != NULL);
 
  //
  // Framework Spec assume firmware files are Memory-Mapped.
  //
  for (Index = 0; Index < NumberOfFiles; Index++) {
    PiFileData[Index].FileAttributes |= EFI_FV_FILE_ATTRIB_MEMORY_MAPPED;
  }
 
  Status = FirmwareVolume2->WriteFile (
                              FirmwareVolume2,
                              NumberOfFiles,
                              WritePolicy,
                              (EFI_FV_WRITE_FILE_DATA *)FileData
                              );
 
  FreePool (PiFileData);
  return Status;
}
 
EFI_STATUS
EFIAPI
FvGetNextFile (
  IN EFI_FIRMWARE_VOLUME_PROTOCOL  *This,
  IN OUT VOID                      *Key,
  IN OUT EFI_FV_FILETYPE           *FileType,
  OUT EFI_GUID                     *NameGuid,
  OUT EFI_FV_FILE_ATTRIBUTES       *Attributes,
  OUT UINTN                        *Size
  )
{
  FIRMWARE_VOLUME_PRIVATE_DATA   *Private;
  EFI_FIRMWARE_VOLUME2_PROTOCOL  *FirmwareVolume2;
  EFI_STATUS                     Status;
 
  Private         = FIRMWARE_VOLUME_PRIVATE_DATA_FROM_THIS (This);
  FirmwareVolume2 = Private->FirmwareVolume2;
 
  Status = FirmwareVolume2->GetNextFile (
                              FirmwareVolume2,
                              Key,
                              FileType,
                              NameGuid,
                              Attributes,
                              Size
                              );
 
  //
  // For Framework FV attrbutes, only alignment fields are valid.
  //
  *Attributes = *Attributes & EFI_FV_FILE_ATTRIB_ALIGNMENT;
 
  return Status;
}
 
//
// Firmware Volume Protocol template
//
EFI_EVENT  mFvRegistration;
 
FIRMWARE_VOLUME_PRIVATE_DATA  gFirmwareVolumePrivateDataTemplate = {
  FIRMWARE_VOLUME_PRIVATE_DATA_SIGNATURE,
  {
    FvGetVolumeAttributes,
    FvSetVolumeAttributes,
    FvReadFile,
    FvReadSection,
    FvWriteFile,
    FvGetNextFile,
    0,
    NULL
  },
  NULL
};
 
//
// Module globals
//
 
VOID
EFIAPI
FvNotificationEvent (
  IN  EFI_EVENT  Event,
  IN  VOID       *Context
  )
{
  EFI_STATUS                    Status;
  UINTN                         BufferSize;
  EFI_HANDLE                    Handle;
  FIRMWARE_VOLUME_PRIVATE_DATA  *Private;
  EFI_FIRMWARE_VOLUME_PROTOCOL  *FirmwareVolume;
 
  while (TRUE) {
    BufferSize = sizeof (Handle);
    Status     = gBS->LocateHandle (
                        ByRegisterNotify,
                        &gEfiFirmwareVolume2ProtocolGuid,
                        mFvRegistration,
                        &BufferSize,
                        &Handle
                        );
    if (EFI_ERROR (Status)) {
      //
      // Exit Path of While Loop....
      //
      break;
    }
 
    //
    // Skip this handle if the Firmware Volume Protocol is already installed
    //
    Status = gBS->HandleProtocol (
                    Handle,
                    &gEfiFirmwareVolumeProtocolGuid,
                    (VOID **)&FirmwareVolume
                    );
    if (!EFI_ERROR (Status)) {
      continue;
    }
 
    //
    // Allocate private data structure
    //
    Private = AllocateCopyPool (sizeof (FIRMWARE_VOLUME_PRIVATE_DATA), &gFirmwareVolumePrivateDataTemplate);
    if (Private == NULL) {
      continue;
    }
 
    //
    // Retrieve the Firmware Volume2 Protocol
    //
    Status = gBS->HandleProtocol (
                    Handle,
                    &gEfiFirmwareVolume2ProtocolGuid,
                    (VOID **)&Private->FirmwareVolume2
                    );
    if (EFI_ERROR (Status)) {
      DEBUG ((DEBUG_INFO, "OCFV: HandleProtocol FirmwareVolume2 failure: %r\n", Status));
    }
 
    //
    // Fill in rest of private data structure
    //
    Private->FirmwareVolume.KeySize      = Private->FirmwareVolume2->KeySize;
    Private->FirmwareVolume.ParentHandle = Private->FirmwareVolume2->ParentHandle;
 
    //
    // Install Firmware Volume Protocol onto same handle
    //
    Status = gBS->InstallMultipleProtocolInterfaces (
                    &Handle,
                    &gEfiFirmwareVolumeProtocolGuid,
                    &Private->FirmwareVolume,
                    NULL
                    );
    if (EFI_ERROR (Status)) {
      DEBUG ((DEBUG_INFO, "OCFV: Install FirmwareVolume protocol failure: %r\n", Status));
    }
  }
}
 
EFI_STATUS
EFIAPI
InitializeFirmwareVolume2 (
  IN EFI_HANDLE        ImageHandle,
  IN EFI_SYSTEM_TABLE  *SystemTable
  )
{
  EfiCreateProtocolNotifyEvent (
    &gEfiFirmwareVolume2ProtocolGuid,
    TPL_CALLBACK,
    FvNotificationEvent,
    NULL,
    &mFvRegistration
    );
  return EFI_SUCCESS;
}