FmpDevicePkg/FmpDxe: Use new FmpDeviceLib APIs

REF: https://bugzilla.tianocore.org/show_bug.cgi?id=1525

Update FmpDxe to support multiple controllers and use
new FmpDeviceLib APIs to support Stop/Unload and to
set the context for the worker functions in the
FmpDeviceLib.

Cc: Sean Brogan <sean.brogan@microsoft.com>
Cc: Bret Barkelew <Bret.Barkelew@microsoft.com>
Cc: Liming Gao <liming.gao@intel.com>
Signed-off-by: Michael D Kinney <michael.d.kinney@intel.com>
Reviewed-by: Eric Jin <eric.jin@intel.com>
Reviewed-by: Liming Gao <liming.gao@intel.com>

1 files changed, 368 insertions, 218 deletions

diff --git a/FmpDevicePkg/FmpDxe/FmpDxe.c b/FmpDevicePkg/FmpDxe/FmpDxe.c
index f485f5b939..dab3310834 100644
--- a/FmpDevicePkg/FmpDxe/FmpDxe.c
+++ b/FmpDevicePkg/FmpDxe/FmpDxe.c
@@ -4,46 +4,13 @@
   information provided through PCDs and libraries.

 

   Copyright (c) 2016, Microsoft Corporation. All rights reserved.<BR>

-  Copyright (c) 2018, Intel Corporation. All rights reserved.<BR>

+  Copyright (c) 2018 - 2019, Intel Corporation. All rights reserved.<BR>

 

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

 

 **/

 

-#include <PiDxe.h>

-#include <Library/DebugLib.h>

-#include <Library/BaseLib.h>

-#include <Library/BaseMemoryLib.h>

-#include <Library/UefiBootServicesTableLib.h>

-#include <Library/MemoryAllocationLib.h>

-#include <Library/UefiLib.h>

-#include <Library/FmpAuthenticationLib.h>

-#include <Library/FmpDeviceLib.h>

-#include <Library/FmpPayloadHeaderLib.h>

-#include <Library/CapsuleUpdatePolicyLib.h>

-#include <Protocol/FirmwareManagement.h>

-#include <Protocol/FirmwareManagementProgress.h>

-#include <Guid/SystemResourceTable.h>

-#include <Guid/EventGroup.h>

-#include "VariableSupport.h"

-

-#define VERSION_STRING_NOT_SUPPORTED  L"VERSION STRING NOT SUPPORTED"

-#define VERSION_STRING_NOT_AVAILABLE  L"VERSION STRING NOT AVAILABLE"

-

-/**

-  Check to see if any of the keys in PcdFmpDevicePkcs7CertBufferXdr matches

-  the test key.  PcdFmpDeviceTestKeySha256Digest contains the SHA256 hash of

-  the test key.  For each key in PcdFmpDevicePkcs7CertBufferXdr, compute the

-  SHA256 hash and compare it to PcdFmpDeviceTestKeySha256Digest.  If the

-  SHA256 hash matches or there is then error computing the SHA256 hash, then

-  set PcdTestKeyUsed to TRUE.  Skip this check if PcdTestKeyUsed is already

-  TRUE or PcdFmpDeviceTestKeySha256Digest is not exactly SHA256_DIGEST_SIZE

-  bytes.

-**/

-VOID

-DetectTestKey (

-  VOID

-  );

+#include "FmpDxe.h"

 

 ///

 /// FILE_GUID from FmpDxe.inf.  When FmpDxe.inf is used in a platform, the

@@ -56,30 +23,73 @@ const EFI_GUID  mDefaultModuleFileGuid = {
   0x78ef0a56, 0x1cf0, 0x4535, { 0xb5, 0xda, 0xf6, 0xfd, 0x2f, 0x40, 0x5a, 0x11 }

 };

 

-EFI_FIRMWARE_IMAGE_DESCRIPTOR  mDesc;

-BOOLEAN                        mDescriptorPopulated     = FALSE;

-BOOLEAN                        mRuntimeVersionSupported = TRUE;

-BOOLEAN                        mFmpInstalled            = FALSE;

-

 ///

-/// Function pointer to progress function

+/// TRUE if FmpDeviceLib manages a single firmware storage device.

 ///

-EFI_FIRMWARE_MANAGEMENT_UPDATE_IMAGE_PROGRESS  mProgressFunc      = NULL;

-BOOLEAN                                        mProgressSupported = FALSE;

+BOOLEAN  mFmpSingleInstance = FALSE;

 

-CHAR16  *mImageIdName = NULL;

-UINT64  mImageId      = 0x1;

-CHAR16  *mVersionName = NULL;

+///

+/// Firmware Management Protocol instance that is initialized in the entry

+/// point from PCD settings.

+///

+EDKII_FIRMWARE_MANAGEMENT_PROGRESS_PROTOCOL  mFmpProgress;

 

-EFI_EVENT  mFmpDeviceLockEvent;

 //

-// Indicates if an attempt has been made to lock a

-// FLASH storage device by calling FmpDeviceLock().

-// A FLASH storage device may not support being locked,

-// so this variable is set to TRUE even if FmpDeviceLock()

-// returns an error.

+// Template of the private context structure for the Firmware Management

+// Protocol instance

 //

-BOOLEAN    mFmpDeviceLocked = FALSE;

+const FIRMWARE_MANAGEMENT_PRIVATE_DATA  mFirmwareManagementPrivateDataTemplate = {

+  FIRMWARE_MANAGEMENT_PRIVATE_DATA_SIGNATURE,  // Signature

+  NULL,                                        // Handle

+  {                                            // Fmp

+    GetTheImageInfo,

+    GetTheImage,

+    SetTheImage,

+    CheckTheImage,

+    GetPackageInfo,

+    SetPackageInfo

+  },

+  FALSE,                                       // DescriptorPopulated

+  {                                            // Desc

+    1,     // ImageIndex

+    //

+    // ImageTypeId

+    //

+    { 0x00000000, 0x0000, 0x0000, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00} },

+    1,     // ImageId

+    NULL,  // ImageIdName

+    0,     // Version

+    NULL,  // VersionName

+    0,     // Size

+    0,     // AttributesSupported

+    0,     // AttributesSetting

+    0,     // Compatibilities

+    0,     // LowestSupportedImageVersion

+    0,     // LastAttemptVersion

+    0,     // LastAttemptStatus

+    0      // HardwareInstance

+  },

+  NULL,                                        // ImageIdName

+  NULL,                                        // VersionName

+  TRUE,                                        // RuntimeVersionSupported

+  NULL,                                        // FmpDeviceLockEvent

+  FALSE                                        // FmpDeviceLocked

+};

+

+///

+/// GUID that is used to create event used to lock the firmware storage device.

+///

+EFI_GUID  *mLockGuid = NULL;

+

+///

+/// Progress() function pointer passed into SetTheImage()

+///

+EFI_FIRMWARE_MANAGEMENT_UPDATE_IMAGE_PROGRESS  mProgressFunc = NULL;

+

+///

+/// Null-terminated Unicode string retrieved from PcdFmpDeviceImageIdName.

+///

+CHAR16  *mImageIdName = NULL;

 

 /**

   Callback function to report the process of the firmware updating.

@@ -111,10 +121,6 @@ FmpDxeProgress (
 

   Status = EFI_UNSUPPORTED;

 

-  if (!mProgressSupported) {

-    return Status;

-  }

-

   if (mProgressFunc == NULL) {

     return Status;

   }

@@ -125,7 +131,6 @@ FmpDxeProgress (
   Status = mProgressFunc (((Completion * 92) / 100) + 6);

 

   if (Status == EFI_UNSUPPORTED) {

-    mProgressSupported = FALSE;

     mProgressFunc = NULL;

   }

 

@@ -183,7 +188,7 @@ GetImageTypeNameString (
   2. Check if we have a variable for lowest supported version (this will be updated with each capsule applied)

   3. Check Fixed at build PCD

 

-  Take the largest value

+  @return  The largest value

 

 **/

 UINT32

@@ -237,101 +242,117 @@ GetLowestSupportedVersion (
 }

 

 /**

-  Populates the EFI_FIRMWARE_IMAGE_DESCRIPTOR structure in the module global

-  variable mDesc.

+  Populates the EFI_FIRMWARE_IMAGE_DESCRIPTOR structure in the private

+  context structure.

+

+  @param[in] Private  Pointer to the private context structure for the

+                      Firmware Management Protocol instance.

 

 **/

 VOID

 PopulateDescriptor (

-  VOID

+  FIRMWARE_MANAGEMENT_PRIVATE_DATA  *Private

   )

 {

   EFI_STATUS  Status;

 

-  mDesc.ImageIndex = 1;

-  CopyGuid (&mDesc.ImageTypeId, GetImageTypeIdGuid());

-  mDesc.ImageId = mImageId;

-  mDesc.ImageIdName = GetImageTypeNameString();

+  if (Private->DescriptorPopulated) {

+    return;

+  }

+

+  Private->Descriptor.ImageIndex = 1;

+  CopyGuid (&Private->Descriptor.ImageTypeId, GetImageTypeIdGuid());

+  Private->Descriptor.ImageId     = Private->Descriptor.ImageIndex;

+  Private->Descriptor.ImageIdName = GetImageTypeNameString();

 

   //

   // Get the version.  Some devices don't support getting the firmware version

   // at runtime.  If FmpDeviceLib does not support returning a version, then

   // it is stored in a UEFI variable.

   //

-  Status = FmpDeviceGetVersion (&mDesc.Version);

+  Status = FmpDeviceGetVersion (&Private->Descriptor.Version);

   if (Status == EFI_UNSUPPORTED) {

-    mRuntimeVersionSupported = FALSE;

-    mDesc.Version = GetVersionFromVariable();

+    Private->RuntimeVersionSupported = FALSE;

+    Private->Descriptor.Version = GetVersionFromVariable();

   } else if (EFI_ERROR (Status)) {

     //

     // Unexpected error.   Use default version.

     //

     DEBUG ((DEBUG_ERROR, "FmpDxe: GetVersion() from FmpDeviceLib (%s) returned %r\n", GetImageTypeNameString(), Status));

-    mDesc.Version = DEFAULT_VERSION;

+    Private->Descriptor.Version = DEFAULT_VERSION;

   }

 

   //

   // Free the current version name.  Shouldn't really happen but this populate

   // function could be called multiple times (to refresh).

   //

-  if (mVersionName != NULL) {

-    FreePool (mVersionName);

-    mVersionName = NULL;

+  if (Private->Descriptor.VersionName != NULL) {

+    FreePool (Private->Descriptor.VersionName);

+    Private->Descriptor.VersionName = NULL;

   }

 

   //

   // Attempt to get the version string from the FmpDeviceLib

   //

-  Status = FmpDeviceGetVersionString (&mVersionName);

+  Status = FmpDeviceGetVersionString (&Private->Descriptor.VersionName);

   if (Status == EFI_UNSUPPORTED) {

     DEBUG ((DEBUG_INFO, "FmpDxe: GetVersionString() unsupported in FmpDeviceLib.\n"));

-    mVersionName = AllocateCopyPool (

-                     sizeof (VERSION_STRING_NOT_SUPPORTED),

-                     VERSION_STRING_NOT_SUPPORTED

-                     );

+    Private->Descriptor.VersionName = AllocateCopyPool (

+                                        sizeof (VERSION_STRING_NOT_SUPPORTED),

+                                        VERSION_STRING_NOT_SUPPORTED

+                                        );

   } else if (EFI_ERROR (Status)) {

     DEBUG ((DEBUG_INFO, "FmpDxe: GetVersionString() not available in FmpDeviceLib.\n"));

-    mVersionName = AllocateCopyPool (

-                     sizeof (VERSION_STRING_NOT_AVAILABLE),

-                     VERSION_STRING_NOT_AVAILABLE

-                     );

+    Private->Descriptor.VersionName = AllocateCopyPool (

+                                        sizeof (VERSION_STRING_NOT_AVAILABLE),

+                                        VERSION_STRING_NOT_AVAILABLE

+                                        );

   }

 

-  mDesc.VersionName = mVersionName;

-

-  mDesc.LowestSupportedImageVersion = GetLowestSupportedVersion();

+  Private->Descriptor.LowestSupportedImageVersion = GetLowestSupportedVersion();

 

   //

   // Get attributes from the FmpDeviceLib

   //

-  FmpDeviceGetAttributes (&mDesc.AttributesSupported, &mDesc.AttributesSetting);

+  FmpDeviceGetAttributes (

+    &Private->Descriptor.AttributesSupported,

+    &Private->Descriptor.AttributesSetting

+    );

 

   //

   // Force set the updatable bits in the attributes;

   //

-  mDesc.AttributesSupported |= IMAGE_ATTRIBUTE_IMAGE_UPDATABLE;

-  mDesc.AttributesSetting   |= IMAGE_ATTRIBUTE_IMAGE_UPDATABLE;

+  Private->Descriptor.AttributesSupported |= IMAGE_ATTRIBUTE_IMAGE_UPDATABLE;

+  Private->Descriptor.AttributesSetting   |= IMAGE_ATTRIBUTE_IMAGE_UPDATABLE;

 

   //

   // Force set the authentication bits in the attributes;

   //

-  mDesc.AttributesSupported |= (IMAGE_ATTRIBUTE_AUTHENTICATION_REQUIRED);

-  mDesc.AttributesSetting   |= (IMAGE_ATTRIBUTE_AUTHENTICATION_REQUIRED);

+  Private->Descriptor.AttributesSupported |= (IMAGE_ATTRIBUTE_AUTHENTICATION_REQUIRED);

+  Private->Descriptor.AttributesSetting   |= (IMAGE_ATTRIBUTE_AUTHENTICATION_REQUIRED);

 

-  mDesc.Compatibilities = 0;

+  Private->Descriptor.Compatibilities = 0;

 

   //

   // Get the size of the firmware image from the FmpDeviceLib

   //

-  Status = FmpDeviceGetSize (&mDesc.Size);

+  Status = FmpDeviceGetSize (&Private->Descriptor.Size);

   if (EFI_ERROR (Status)) {

-    mDesc.Size = 0;

+    Private->Descriptor.Size = 0;

   }

 

-  mDesc.LastAttemptVersion = GetLastAttemptVersionFromVariable ();

-  mDesc.LastAttemptStatus  = GetLastAttemptStatusFromVariable ();

+  Private->Descriptor.LastAttemptVersion = GetLastAttemptVersionFromVariable ();

+  Private->Descriptor.LastAttemptStatus  = GetLastAttemptStatusFromVariable ();

 

-  mDescriptorPopulated = TRUE;

+  //

+  // Get the hardware instance from FmpDeviceLib

+  //

+  Status = FmpDeviceGetHardwareInstance (&Private->Descriptor.HardwareInstance);

+  if (Status == EFI_UNSUPPORTED) {

+    Private->Descriptor.HardwareInstance = 0;

+  }

+

+  Private->DescriptorPopulated = TRUE;

 }

 

 /**

@@ -385,11 +406,18 @@ GetTheImageInfo (
   OUT    CHAR16                            **PackageVersionName

   )

 {

-  EFI_STATUS Status;

+  EFI_STATUS                        Status;

+  FIRMWARE_MANAGEMENT_PRIVATE_DATA  *Private;

 

   Status = EFI_SUCCESS;

 

   //

+  // Retrieve the private context structure

+  //

+  Private = FIRMWARE_MANAGEMENT_PRIVATE_DATA_FROM_THIS (This);

+  FmpDeviceSetContext (Private->Handle, &Private->FmpDeviceContext);

+

+  //

   // Check for valid pointer

   //

   if (ImageInfoSize == NULL) {

@@ -424,15 +452,15 @@ GetTheImageInfo (
   //

   *ImageInfoSize = sizeof (EFI_FIRMWARE_IMAGE_DESCRIPTOR);

 

-

-  if (!mDescriptorPopulated) {

-    PopulateDescriptor();

-  }

+  //

+  // make sure the descriptor has already been loaded

+  //

+  PopulateDescriptor (Private);

 

   //

   // Copy the image descriptor

   //

-  CopyMem (ImageInfo, &mDesc, sizeof (EFI_FIRMWARE_IMAGE_DESCRIPTOR));

+  CopyMem (ImageInfo, &Private->Descriptor, sizeof (EFI_FIRMWARE_IMAGE_DESCRIPTOR));

 

   *DescriptorVersion = EFI_FIRMWARE_IMAGE_DESCRIPTOR_VERSION;

   *DescriptorCount = 1;

@@ -483,12 +511,19 @@ GetTheImage (
   IN OUT UINTN                             *ImageSize

   )

 {

-  EFI_STATUS  Status;

-  UINTN       Size;

+  EFI_STATUS                        Status;

+  FIRMWARE_MANAGEMENT_PRIVATE_DATA  *Private;

+  UINTN                             Size;

 

   Status = EFI_SUCCESS;

 

   //

+  // Retrieve the private context structure

+  //

+  Private = FIRMWARE_MANAGEMENT_PRIVATE_DATA_FROM_THIS (This);

+  FmpDeviceSetContext (Private->Handle, &Private->FmpDeviceContext);

+

+  //

   // Check to make sure index is 1 (only 1 image for this device)

   //

   if (ImageIndex != 1) {

@@ -632,18 +667,19 @@ CheckTheImage (
   OUT UINT32                            *ImageUpdatable

   )

 {

-  EFI_STATUS  Status;

-  UINTN       RawSize;

-  VOID        *FmpPayloadHeader;

-  UINTN       FmpPayloadSize;

-  UINT32      Version;

-  UINT32      FmpHeaderSize;

-  UINTN       AllHeaderSize;

-  UINT32      Index;

-  VOID        *PublicKeyData;

-  UINTN       PublicKeyDataLength;

-  UINT8       *PublicKeyDataXdr;

-  UINT8       *PublicKeyDataXdrEnd;

+  EFI_STATUS                        Status;

+  FIRMWARE_MANAGEMENT_PRIVATE_DATA  *Private;

+  UINTN                             RawSize;

+  VOID                              *FmpPayloadHeader;

+  UINTN                             FmpPayloadSize;

+  UINT32                            Version;

+  UINT32                            FmpHeaderSize;

+  UINTN                             AllHeaderSize;

+  UINT32                            Index;

+  VOID                              *PublicKeyData;

+  UINTN                             PublicKeyDataLength;

+  UINT8                             *PublicKeyDataXdr;

+  UINT8                             *PublicKeyDataXdrEnd;

 

   Status           = EFI_SUCCESS;

   RawSize          = 0;

@@ -654,11 +690,15 @@ CheckTheImage (
   AllHeaderSize    = 0;

 

   //

+  // Retrieve the private context structure

+  //

+  Private = FIRMWARE_MANAGEMENT_PRIVATE_DATA_FROM_THIS (This);

+  FmpDeviceSetContext (Private->Handle, &Private->FmpDeviceContext);

+

+  //

   // make sure the descriptor has already been loaded

   //

-  if (!mDescriptorPopulated) {

-    PopulateDescriptor();

-  }

+  PopulateDescriptor (Private);

 

   if (ImageUpdatable == NULL) {

     DEBUG ((DEBUG_ERROR, "FmpDxe: CheckImage() - ImageUpdatable Pointer Parameter is NULL.\n"));

@@ -776,11 +816,11 @@ CheckTheImage (
   //

   // Check the lowest supported version

   //

-  if (Version < mDesc.LowestSupportedImageVersion) {

+  if (Version < Private->Descriptor.LowestSupportedImageVersion) {

     DEBUG (

       (DEBUG_ERROR,

       "FmpDxe: CheckTheImage() - Version Lower than lowest supported version. 0x%08X < 0x%08X\n",

-      Version, mDesc.LowestSupportedImageVersion)

+      Version, Private->Descriptor.LowestSupportedImageVersion)

       );

     *ImageUpdatable = IMAGE_UPDATABLE_INVALID_OLD;

     Status = EFI_SUCCESS;

@@ -880,17 +920,18 @@ SetTheImage (
   OUT CHAR16                                         **AbortReason

   )

 {

-  EFI_STATUS  Status;

-  UINT32      Updateable;

-  BOOLEAN     BooleanValue;

-  UINT32      FmpHeaderSize;

-  VOID        *FmpHeader;

-  UINTN       FmpPayloadSize;

-  UINT32      AllHeaderSize;

-  UINT32      IncommingFwVersion;

-  UINT32      LastAttemptStatus;

-  UINT32      Version;

-  UINT32      LowestSupportedVersion;

+  EFI_STATUS                        Status;

+  FIRMWARE_MANAGEMENT_PRIVATE_DATA  *Private;

+  UINT32                            Updateable;

+  BOOLEAN                           BooleanValue;

+  UINT32                            FmpHeaderSize;

+  VOID                              *FmpHeader;

+  UINTN                             FmpPayloadSize;

+  UINT32                            AllHeaderSize;

+  UINT32                            IncommingFwVersion;

+  UINT32                            LastAttemptStatus;

+  UINT32                            Version;

+  UINT32                            LowestSupportedVersion;

 

   Status             = EFI_SUCCESS;

   Updateable         = 0;

@@ -902,6 +943,11 @@ SetTheImage (
   IncommingFwVersion = 0;

   LastAttemptStatus  = LAST_ATTEMPT_STATUS_ERROR_UNSUCCESSFUL;

 

+  //

+  // Retrieve the private context structure

+  //

+  Private = FIRMWARE_MANAGEMENT_PRIVATE_DATA_FROM_THIS (This);

+  FmpDeviceSetContext (Private->Handle, &Private->FmpDeviceContext);

 

   SetLastAttemptVersionInVariable (IncommingFwVersion); //set to 0 to clear any previous results.

 

@@ -909,7 +955,7 @@ SetTheImage (
   // if we have locked the device, then skip the set operation.

   // it should be blocked by hardware too but we can catch here even faster

   //

-  if (mFmpDeviceLocked) {

+  if (Private->FmpDeviceLocked) {

     DEBUG ((DEBUG_ERROR, "FmpDxe: SetTheImage() - Device is already locked.  Can't update.\n"));

     Status = EFI_UNSUPPORTED;

     goto cleanup;

@@ -963,7 +1009,6 @@ SetTheImage (
   }

 

   mProgressFunc = Progress;

-  mProgressSupported = TRUE;

 

   //

   // Checking the image is at least 1%

@@ -1084,7 +1129,7 @@ SetTheImage (
   //

   // Update the version stored in variable

   //

-  if (!mRuntimeVersionSupported) {

+  if (!Private->RuntimeVersionSupported) {

     Version = DEFAULT_VERSION;

     GetFmpPayloadHeaderVersion (FmpHeader, FmpPayloadSize, &Version);

     SetVersionInVariable (Version);

@@ -1103,7 +1148,6 @@ SetTheImage (
 

 cleanup:

   mProgressFunc = NULL;

-  mProgressSupported = FALSE;

   SetLastAttemptStatusInVariable (LastAttemptStatus);

 

   if (Progress != NULL) {

@@ -1117,7 +1161,7 @@ cleanup:
   // Need repopulate after SetImage is called to

   // update LastAttemptVersion and LastAttemptStatus.

   //

-  mDescriptorPopulated = FALSE;

+  Private->DescriptorPopulated = FALSE;

 

   return Status;

 }

@@ -1228,12 +1272,16 @@ FmpDxeLockEventNotify (
   IN VOID       *Context

   )

 {

-  EFI_STATUS  Status;

+  EFI_STATUS                        Status;

+  FIRMWARE_MANAGEMENT_PRIVATE_DATA  *Private;

+

+  Private = (FIRMWARE_MANAGEMENT_PRIVATE_DATA *)Context;

 

-  if (!mFmpDeviceLocked) {

+  if (!Private->FmpDeviceLocked) {

     //

     // Lock the firmware device

     //

+    FmpDeviceSetContext (Private->Handle, &Private->FmpDeviceContext);

     Status = FmpDeviceLock();

     if (EFI_ERROR (Status)) {

       if (Status != EFI_UNSUPPORTED) {

@@ -1242,7 +1290,7 @@ FmpDxeLockEventNotify (
         DEBUG ((DEBUG_WARN, "FmpDxe: FmpDeviceLock() returned error.  Status = %r\n", Status));

       }

     }

-    mFmpDeviceLocked = TRUE;

+    Private->FmpDeviceLocked = TRUE;

   }

 }

 

@@ -1262,86 +1310,199 @@ InstallFmpInstance (
   IN EFI_HANDLE  Handle

   )

 {

-  EFI_STATUS                                   Status;

-  EFI_FIRMWARE_MANAGEMENT_PROTOCOL             *Fmp;

-  EDKII_FIRMWARE_MANAGEMENT_PROGRESS_PROTOCOL  *FmpProgress;

+  EFI_STATUS                        Status;

+  EFI_FIRMWARE_MANAGEMENT_PROTOCOL  *Fmp;

+  FIRMWARE_MANAGEMENT_PRIVATE_DATA  *Private;

 

-  Status      = EFI_SUCCESS;

-  Fmp         = NULL;

-  FmpProgress = NULL;

+  DEBUG ((DEBUG_ERROR, "InstallFmpInstance: Entry\n"));

 

   //

   // Only allow a single FMP Protocol instance to be installed

   //

-  if (mFmpInstalled) {

+  Status = gBS->OpenProtocol (

+                  Handle,

+                  &gEfiFirmwareManagementProtocolGuid,

+                  (VOID **)&Fmp,

+                  NULL,

+                  NULL,

+                  EFI_OPEN_PROTOCOL_GET_PROTOCOL

+                  );

+  if (!EFI_ERROR (Status)) {

     return EFI_ALREADY_STARTED;

   }

 

   //

   // Allocate FMP Protocol instance

   //

-  Fmp = AllocateZeroPool (sizeof (EFI_FIRMWARE_MANAGEMENT_PROTOCOL));

-  if (Fmp == NULL) {

-    DEBUG ((DEBUG_ERROR, "FmpDxe: Failed to allocate memory for FMP Protocol instance.\n"));

+  Private = AllocateCopyPool (

+              sizeof (mFirmwareManagementPrivateDataTemplate),

+              &mFirmwareManagementPrivateDataTemplate

+              );

+  if (Private == NULL) {

+    DEBUG ((DEBUG_ERROR, "FmpDxe: Failed to allocate memory for private structure.\n"));

     Status = EFI_OUT_OF_RESOURCES;

     goto cleanup;

   }

 

   //

-  // Allocate FMP Progress Protocol instance

+  // Initialize private context data structure

   //

-  FmpProgress = AllocateZeroPool (sizeof (EDKII_FIRMWARE_MANAGEMENT_PROGRESS_PROTOCOL));

-  if (FmpProgress == NULL) {

-    DEBUG ((DEBUG_ERROR, "FmpDxe: Failed to allocate memory for FMP Progress Protocol instance.\n"));

-    Status = EFI_OUT_OF_RESOURCES;

-    FreePool (Fmp);

+  DEBUG ((DEBUG_ERROR, "InstallFmpInstance: Initialize private context data structure\n"));

+

+  Private->Handle = Handle;

+

+  Private->FmpDeviceContext = NULL;

+  Status = FmpDeviceSetContext (Private->Handle, &Private->FmpDeviceContext);

+  if (Status == EFI_UNSUPPORTED) {

+    Private->FmpDeviceContext = NULL;

+  } else if (EFI_ERROR (Status)) {

     goto cleanup;

   }

 

-  //

-  // Set up FMP Protocol function pointers

-  //

-  Fmp->GetImageInfo   = GetTheImageInfo;

-  Fmp->GetImage       = GetTheImage;

-  Fmp->SetImage       = SetTheImage;

-  Fmp->CheckImage     = CheckTheImage;

-  Fmp->GetPackageInfo = GetPackageInfo;

-  Fmp->SetPackageInfo = SetPackageInfo;

+  DEBUG ((DEBUG_ERROR, "InstallFmpInstance: Lock events\n"));

 

-  //

-  // Fill in FMP Progress Protocol fields for Version 1

-  //

-  FmpProgress->Version                        = 1;

-  FmpProgress->ProgressBarForegroundColor.Raw = PcdGet32 (PcdFmpDeviceProgressColor);

-  FmpProgress->WatchdogSeconds                = PcdGet8 (PcdFmpDeviceProgressWatchdogTimeInSeconds);

+  if (IsLockFmpDeviceAtLockEventGuidRequired ()) {

+    //

+    // Lock all UEFI Variables used by this module.

+    //

+    Status = LockAllFmpVariables ();

+    if (EFI_ERROR (Status)) {

+      DEBUG ((DEBUG_ERROR, "FmpDxe: Failed to lock variables.  Status = %r.\n", Status));

+    } else {

+      DEBUG ((DEBUG_INFO, "FmpDxe: All variables locked\n"));

+    }

+

+    //

+    // Create and register notify function to lock the FMP device.

+    //

+    Status = gBS->CreateEventEx (

+                    EVT_NOTIFY_SIGNAL,

+                    TPL_CALLBACK,

+                    FmpDxeLockEventNotify,

+                    Private,

+                    mLockGuid,

+                    &Private->FmpDeviceLockEvent

+                    );

+    if (EFI_ERROR (Status)) {

+      DEBUG ((DEBUG_ERROR, "FmpDxe: Failed to register notification.  Status = %r\n", Status));

+    }

+    ASSERT_EFI_ERROR (Status);

+  } else {

+    DEBUG ((DEBUG_VERBOSE, "FmpDxe: Not registering notification to call FmpDeviceLock() because mfg mode\n"));

+  }

 

   //

   // Install FMP Protocol and FMP Progress Protocol

   //

+  DEBUG ((DEBUG_ERROR, "InstallFmpInstance: Install FMP Protocol and FMP Progress Protocol\n"));

+

   Status = gBS->InstallMultipleProtocolInterfaces (

-                  &Handle,

-                  &gEfiFirmwareManagementProtocolGuid,

-                  Fmp,

-                  &gEdkiiFirmwareManagementProgressProtocolGuid,

-                  FmpProgress,

+                  &Private->Handle,

+                  &gEfiFirmwareManagementProtocolGuid, &Private->Fmp,

+                  &gEdkiiFirmwareManagementProgressProtocolGuid, &mFmpProgress,

                   NULL

                   );

 

   if (EFI_ERROR (Status)) {

-    DEBUG ((DEBUG_ERROR, "FmpDxe: FMP Protocol install error. Status = %r.\n", Status));

-    FreePool (Fmp);

+    DEBUG ((DEBUG_ERROR, "FmpDxe: Protocol install error. Status = %r.\n", Status));

     goto cleanup;

   }

 

-  DEBUG ((DEBUG_INFO, "FmpDxe: FMP Protocol Installed!\n"));

-  mFmpInstalled = TRUE;

+  DEBUG ((DEBUG_INFO, "FmpDxe: Protocols Installed!\n"));

 

 cleanup:

 

+  if (EFI_ERROR (Status)) {

+    if (Private != NULL) {

+      if (Private->FmpDeviceLockEvent != NULL) {

+        gBS->CloseEvent (Private->FmpDeviceLockEvent);

+      }

+      FreePool (Private);

+    }

+  }

+

   return Status;

 }

 

 /**

+  Function to uninstall FMP instance.

+

+  @param[in]  Handle  The device handle to install a FMP instance on.

+

+  @retval  EFI_SUCCESS            FMP Installed

+  @retval  EFI_INVALID_PARAMETER  Handle was invalid

+  @retval  other                  Error installing FMP

+

+**/

+EFI_STATUS

+EFIAPI

+UninstallFmpInstance (

+  IN EFI_HANDLE  Handle

+  )

+{

+  EFI_STATUS                        Status;

+  EFI_FIRMWARE_MANAGEMENT_PROTOCOL  *Fmp;

+  FIRMWARE_MANAGEMENT_PRIVATE_DATA  *Private;

+

+  Status = gBS->OpenProtocol (

+                  Handle,

+                  &gEfiFirmwareManagementProtocolGuid,

+                  (VOID **)&Fmp,

+                  NULL,

+                  NULL,

+                  EFI_OPEN_PROTOCOL_GET_PROTOCOL

+                  );

+  if (EFI_ERROR (Status)) {

+    return Status;

+  }

+

+  Private = FIRMWARE_MANAGEMENT_PRIVATE_DATA_FROM_THIS (Fmp);

+  FmpDeviceSetContext (Private->Handle, &Private->FmpDeviceContext);

+

+  if (Private->FmpDeviceLockEvent != NULL) {

+    gBS->CloseEvent (Private->FmpDeviceLockEvent);

+  }

+

+  Status = gBS->UninstallMultipleProtocolInterfaces (

+                  Private->Handle,

+                  &gEfiFirmwareManagementProtocolGuid, &Private->Fmp,

+                  &gEdkiiFirmwareManagementProgressProtocolGuid, &mFmpProgress,

+                  NULL

+                  );

+  if (EFI_ERROR (Status)) {

+    return Status;

+  }

+

+  FmpDeviceSetContext (NULL, &Private->FmpDeviceContext);

+

+  FreePool (Private);

+

+  return EFI_SUCCESS;

+}

+

+/**

+  Unloads the application and its installed protocol.

+

+  @param ImageHandle       Handle that identifies the image to be unloaded.

+  @param  SystemTable      The system table.

+

+  @retval EFI_SUCCESS      The image has been unloaded.

+

+**/

+EFI_STATUS

+EFIAPI

+FmpDxeLibDestructor (

+  IN EFI_HANDLE        ImageHandle,

+  IN EFI_SYSTEM_TABLE  *SystemTable

+  )

+{

+  if (mFmpSingleInstance) {

+    return UninstallFmpInstance (ImageHandle);

+  }

+  return EFI_SUCCESS;

+}

+

+/**

   Main entry for this driver/library.

 

   @param[in] ImageHandle  Image handle this driver.

@@ -1356,7 +1517,6 @@ FmpDxeEntryPoint (
   )

 {

   EFI_STATUS  Status;

-  EFI_GUID    *LockGuid;

 

   //

   // Verify that a new FILE_GUID value has been provided in the <Defines>

@@ -1381,49 +1541,28 @@ FmpDxeEntryPoint (
     ASSERT (FALSE);

   }

 

+

   //

   // Detects if PcdFmpDevicePkcs7CertBufferXdr contains a test key.

   //

   DetectTestKey ();

 

-  if (IsLockFmpDeviceAtLockEventGuidRequired ()) {

-    //

-    // Lock all UEFI Variables used by this module.

-    //

-    Status = LockAllFmpVariables ();

-    if (EFI_ERROR (Status)) {

-      DEBUG ((DEBUG_ERROR, "FmpDxe: Failed to lock variables.  Status = %r.\n", Status));

-    } else {

-      DEBUG ((DEBUG_INFO, "FmpDxe: All variables locked\n"));

-    }

-

-    //

-    // Register notify function to lock the FMP device.

-    // The lock event GUID is retrieved from PcdFmpDeviceLockEventGuid.

-    // If PcdFmpDeviceLockEventGuid is not the size of an EFI_GUID, then

-    // gEfiEndOfDxeEventGroupGuid is used.

-    //

-    LockGuid = &gEfiEndOfDxeEventGroupGuid;

-    if (PcdGetSize (PcdFmpDeviceLockEventGuid) == sizeof (EFI_GUID)) {

-      LockGuid = (EFI_GUID *)PcdGetPtr (PcdFmpDeviceLockEventGuid);

-    }

-    DEBUG ((DEBUG_INFO, "FmpDxe: Lock GUID: %g\n", LockGuid));

+  //

+  // Fill in FMP Progress Protocol fields for Version 1

+  //

+  mFmpProgress.Version                        = 1;

+  mFmpProgress.ProgressBarForegroundColor.Raw = PcdGet32 (PcdFmpDeviceProgressColor);

+  mFmpProgress.WatchdogSeconds                = PcdGet8 (PcdFmpDeviceProgressWatchdogTimeInSeconds);

 

-    Status = gBS->CreateEventEx (

-                    EVT_NOTIFY_SIGNAL,

-                    TPL_CALLBACK,

-                    FmpDxeLockEventNotify,

-                    NULL,

-                    LockGuid,

-                    &mFmpDeviceLockEvent

-                    );

-    if (EFI_ERROR (Status)) {

-      DEBUG ((DEBUG_ERROR, "FmpDxe: Failed to register notification.  Status = %r\n", Status));

-    }

-    ASSERT_EFI_ERROR (Status);

-  } else {

-    DEBUG ((DEBUG_VERBOSE, "FmpDxe: Not registering notification to call FmpDeviceLock() because mfg mode\n"));

+  // The lock event GUID is retrieved from PcdFmpDeviceLockEventGuid.

+  // If PcdFmpDeviceLockEventGuid is not the size of an EFI_GUID, then

+  // gEfiEndOfDxeEventGroupGuid is used.

+  //

+  mLockGuid = &gEfiEndOfDxeEventGroupGuid;

+  if (PcdGetSize (PcdFmpDeviceLockEventGuid) == sizeof (EFI_GUID)) {

+    mLockGuid = (EFI_GUID *)PcdGetPtr (PcdFmpDeviceLockEventGuid);

   }

+  DEBUG ((DEBUG_INFO, "FmpDxe: Lock GUID: %g\n", mLockGuid));

 

   //

   // Register with library the install function so if the library uses

@@ -1433,8 +1572,15 @@ FmpDxeEntryPoint (
   //

   Status = RegisterFmpInstaller (InstallFmpInstance);

   if (Status == EFI_UNSUPPORTED) {

+    mFmpSingleInstance = TRUE;

     DEBUG ((DEBUG_INFO, "FmpDxe: FmpDeviceLib registration returned EFI_UNSUPPORTED.  Installing single FMP instance.\n"));

-    Status = InstallFmpInstance (ImageHandle);

+    Status = RegisterFmpUninstaller (UninstallFmpInstance);

+    if (Status == EFI_UNSUPPORTED) {

+      Status = InstallFmpInstance (ImageHandle);

+    } else {

+      DEBUG ((DEBUG_ERROR, "FmpDxe: FmpDeviceLib RegisterFmpInstaller and RegisterFmpUninstaller do not match.\n"));

+      Status = EFI_UNSUPPORTED;

+    }

   } else if (EFI_ERROR (Status)) {

     DEBUG ((DEBUG_ERROR, "FmpDxe: FmpDeviceLib registration returned %r.  No FMP installed.\n", Status));

   } else {

@@ -1442,6 +1588,10 @@ FmpDxeEntryPoint (
       DEBUG_INFO,

       "FmpDxe: FmpDeviceLib registration returned EFI_SUCCESS.  Expect FMP to be installed during the BDS/Device connection phase.\n"

       ));

+    Status = RegisterFmpUninstaller (UninstallFmpInstance);

+    if (EFI_ERROR (Status)) {

+      DEBUG ((DEBUG_ERROR, "FmpDxe: FmpDeviceLib RegisterFmpInstaller and RegisterFmpUninstaller do not match.\n"));

+    }

   }

 

   return Status;