init. 1AQQW051HEADmaster

5 files changed, 3993 insertions, 0 deletions

diff --git a/EDK/Foundation/Core/Dxe/Hand/DriverSupport.c b/EDK/Foundation/Core/Dxe/Hand/DriverSupport.c
new file mode 100644
index 0000000..0597475
--- /dev/null
+++ b/EDK/Foundation/Core/Dxe/Hand/DriverSupport.c
@@ -0,0 +1,860 @@
+/*++
+
+Copyright (c) 2004 - 2011, Intel Corporation                                                         
+All rights reserved. This program and the accompanying materials                          
+are licensed and made available under the terms and conditions of the BSD License         
+which accompanies this distribution.  The full text of the license may be found at        
+http://opensource.org/licenses/bsd-license.php                                            
+                                                                                          
+THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     
+WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             
+
+Module Name:
+
+    DriverSupport.c
+    
+Abstract:
+
+    EFI Driver Support Protocol
+
+Revision History
+
+--*/
+
+#include "Tiano.h"
+#include "hand.h"
+#include "EfiPerf.h"
+
+
+//
+// Driver Consumed Protocol Prototypes
+//
+#include EFI_PROTOCOL_DEFINITION(DriverBinding)
+#include EFI_PROTOCOL_DEFINITION(PlatformDriverOverride)
+#include EFI_PROTOCOL_DEFINITION(BusSpecificDriverOverride)
+
+
+
+#ifdef FIRMWARE_PERFORMANCE
+STATIC
+EFI_STATUS
+GetHandleFromDriverBinding (
+  IN EFI_DRIVER_BINDING_PROTOCOL           *DriverBindingNeed,
+  OUT  EFI_HANDLE                          *Handle 
+  );
+#endif
+
+//
+// Driver Support Function Prototypes
+//
+STATIC
+EFI_STATUS 
+CoreConnectSingleController (
+  IN  EFI_HANDLE                ControllerHandle,
+  IN  EFI_HANDLE                *DriverImageHandle    OPTIONAL,
+  IN  EFI_DEVICE_PATH_PROTOCOL  *RemainingDevicePath  OPTIONAL
+  );
+
+//
+// Driver Support Functions
+//
+
+EFI_BOOTSERVICE11
+EFI_STATUS 
+EFIAPI
+CoreConnectController (
+  IN  EFI_HANDLE                ControllerHandle,
+  IN  EFI_HANDLE                *DriverImageHandle    OPTIONAL,
+  IN  EFI_DEVICE_PATH_PROTOCOL  *RemainingDevicePath  OPTIONAL,
+  IN  BOOLEAN                   Recursive
+  )
+/*++
+
+Routine Description:
+
+  Connects one or more drivers to a controller.
+
+Arguments:
+
+  ControllerHandle            - Handle of the controller to be connected.
+
+  DriverImageHandle           - DriverImageHandle A pointer to an ordered list of driver image handles.
+
+  RemainingDevicePath         - RemainingDevicePath A pointer to the device path that specifies a child of the
+                                controller specified by ControllerHandle.
+    
+  Recursive                   - Whether the function would be called recursively or not.
+
+Returns:
+
+  Status code.
+
+--*/
+{
+  EFI_STATUS                           Status;
+  EFI_STATUS                           ReturnStatus;
+  IHANDLE                              *Handle;
+  PROTOCOL_INTERFACE                   *Prot;
+  EFI_LIST_ENTRY                       *Link;
+  EFI_LIST_ENTRY                       *ProtLink;
+  OPEN_PROTOCOL_DATA                   *OpenData;
+  EFI_DEVICE_PATH_PROTOCOL             *AlignedRemainingDevicePath;
+  
+  //
+  // Make sure ControllerHandle is valid
+  //
+  Status = CoreValidateHandle (ControllerHandle);
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+
+  Handle = ControllerHandle;
+
+  //
+  // Connect all drivers to ControllerHandle 
+  //
+  AlignedRemainingDevicePath = NULL;
+  if (RemainingDevicePath != NULL) {
+    AlignedRemainingDevicePath = CoreDuplicateDevicePath (RemainingDevicePath);
+  }
+  ReturnStatus = CoreConnectSingleController (
+                   ControllerHandle,
+                   DriverImageHandle,
+                   AlignedRemainingDevicePath
+                   );
+  if (AlignedRemainingDevicePath != NULL) {
+    CoreFreePool (AlignedRemainingDevicePath);
+  }
+
+  //
+  // If not recursive, then just return after connecting drivers to ControllerHandle
+  //
+  if (!Recursive) {
+    return ReturnStatus;
+  }
+
+  //
+  // If recursive, then connect all drivers to all of ControllerHandle's children
+  //
+  CoreAcquireProtocolLock ();
+  for (Link = Handle->Protocols.ForwardLink; Link != &Handle->Protocols; Link = Link->ForwardLink) {
+    Prot = CR(Link, PROTOCOL_INTERFACE, Link, PROTOCOL_INTERFACE_SIGNATURE);
+    for (ProtLink = Prot->OpenList.ForwardLink; 
+           ProtLink != &Prot->OpenList; 
+           ProtLink = ProtLink->ForwardLink) {
+        OpenData = CR (ProtLink, OPEN_PROTOCOL_DATA, Link, OPEN_PROTOCOL_DATA_SIGNATURE);
+        if ((OpenData->Attributes & EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER) != 0) {
+          CoreReleaseProtocolLock ();
+          Status = CoreConnectController (
+                          OpenData->ControllerHandle,
+                          NULL,
+                          NULL,
+                          TRUE
+                          ); 
+          CoreAcquireProtocolLock ();
+        }
+    }
+  }
+  CoreReleaseProtocolLock ();
+  
+  return ReturnStatus;
+}
+
+VOID
+AddSortedDriverBindingProtocol (
+  IN      EFI_HANDLE                   DriverBindingHandle,
+  IN OUT  UINTN                        *NumberOfSortedDriverBindingProtocols, 
+  IN OUT  EFI_DRIVER_BINDING_PROTOCOL  **SortedDriverBindingProtocols,
+  IN      UINTN                        DriverBindingHandleCount,
+  IN OUT  EFI_HANDLE                   *DriverBindingHandleBuffer
+  )
+/*++
+
+Routine Description:
+
+  Add Driver Binding Protocols from Context Driver Image Handles to sorted 
+   Driver Binding Protocol list.
+
+Arguments:
+
+  DriverBindingHandle - Handle of the driver binding protocol.
+
+  NumberOfSortedDriverBindingProtocols - Number Of sorted driver binding protocols
+
+  SortedDriverBindingProtocols - The sorted protocol list.                        
+    
+  DriverBindingHandleCount - Driver Binding Handle Count.
+
+  DriverBindingHandleBuffer - The buffer of driver binding protocol to be modified.
+
+Returns:
+
+  None.
+
+--*/
+{
+  EFI_STATUS                   Status;
+  EFI_DRIVER_BINDING_PROTOCOL  *DriverBinding;
+  UINTN                        Index;
+
+  //
+  // Make sure the DriverBindingHandle is valid
+  //
+  Status = CoreValidateHandle (DriverBindingHandle);
+  if (EFI_ERROR (Status)) {
+    return;
+  }
+
+  //
+  // Retrieve the Driver Binding Protocol from DriverBindingHandle
+  //
+  Status = CoreHandleProtocol(
+             DriverBindingHandle,
+             &gEfiDriverBindingProtocolGuid,
+             &DriverBinding
+             );
+  //
+  // If DriverBindingHandle does not support the Driver Binding Protocol then return
+  //
+  if (EFI_ERROR (Status) || DriverBinding == NULL) {
+    return;
+  }
+
+  //
+  // See if DriverBinding is already in the sorted list
+  //
+  for (Index = 0; Index < *NumberOfSortedDriverBindingProtocols; Index++) {
+    if (DriverBinding == SortedDriverBindingProtocols[Index]) {
+      return;
+    }
+  }
+
+  //
+  // Add DriverBinding to the end of the list
+  //
+  SortedDriverBindingProtocols[*NumberOfSortedDriverBindingProtocols] = DriverBinding;
+  *NumberOfSortedDriverBindingProtocols = *NumberOfSortedDriverBindingProtocols + 1;
+
+  //
+  // Mark the cooresponding handle in DriverBindingHandleBuffer as used
+  //
+  for (Index = 0; Index < DriverBindingHandleCount; Index++) {
+    if (DriverBindingHandleBuffer[Index] == DriverBindingHandle) {
+      DriverBindingHandleBuffer[Index] = NULL;
+    }
+  }
+}
+ 
+STATIC
+EFI_STATUS 
+CoreConnectSingleController (
+  IN  EFI_HANDLE                ControllerHandle,
+  IN  EFI_HANDLE                *ContextDriverImageHandles OPTIONAL,
+  IN  EFI_DEVICE_PATH_PROTOCOL  *RemainingDevicePath       OPTIONAL     
+  )
+/*++
+
+Routine Description:
+
+  Connects a controller to a driver.
+
+Arguments:
+
+  ControllerHandle            - Handle of the controller to be connected.
+  ContextDriverImageHandles   - DriverImageHandle A pointer to an ordered list of driver image handles.
+  RemainingDevicePath         - RemainingDevicePath A pointer to the device path that specifies a child 
+                                of the controller specified by ControllerHandle.
+    
+Returns:
+
+  EFI_SUCCESS           - One or more drivers were connected to ControllerHandle.
+  EFI_OUT_OF_RESOURCES  - No enough system resources to complete the request.
+  EFI_NOT_FOUND         - No drivers were connected to ControllerHandle.
+
+--*/
+{
+  EFI_STATUS                                 Status;
+  UINTN                                      Index;
+  EFI_HANDLE                                 DriverImageHandle;
+  UINTN                                      PlatformDriverOverrideHandleCount;
+  EFI_HANDLE                                 *PlatformDriverOverrideHandleBuffer;
+  EFI_PLATFORM_DRIVER_OVERRIDE_PROTOCOL      *PlatformDriverOverride;
+  EFI_BUS_SPECIFIC_DRIVER_OVERRIDE_PROTOCOL  *BusSpecificDriverOverride;
+  UINTN                                      DriverBindingHandleCount;
+  EFI_HANDLE                                 *DriverBindingHandleBuffer;
+  EFI_DRIVER_BINDING_PROTOCOL                *DriverBinding;
+  UINTN                                      NumberOfSortedDriverBindingProtocols;
+  EFI_DRIVER_BINDING_PROTOCOL                **SortedDriverBindingProtocols;
+  UINT32                                     HighestVersion;
+  UINTN                                      HighestIndex;
+  UINTN                                      SortIndex;
+  BOOLEAN                                    OneStarted;
+  BOOLEAN                                    DriverFound;
+
+#ifdef FIRMWARE_PERFORMANCE
+  EFI_HANDLE                                 DriverBindingHandle;
+#endif
+
+  //
+  // Initialize local variables
+  //
+  DriverBindingHandleCount              = 0;
+  DriverBindingHandleBuffer             = NULL;
+  PlatformDriverOverrideHandleCount     = 0;
+  PlatformDriverOverrideHandleBuffer    = NULL;
+  NumberOfSortedDriverBindingProtocols  = 0;
+  SortedDriverBindingProtocols          = NULL;
+
+  //
+  // Get list of all Driver Binding Protocol Instances
+  //
+  Status = CoreLocateHandleBuffer (
+             ByProtocol,   
+             &gEfiDriverBindingProtocolGuid,  
+             NULL,
+             &DriverBindingHandleCount, 
+             &DriverBindingHandleBuffer
+             );
+  if (EFI_ERROR (Status) || (DriverBindingHandleCount == 0)) {
+    return EFI_NOT_FOUND;
+  }
+
+  //
+  // Allocate a duplicate array for the sorted Driver Binding Protocol Instances
+  //
+  SortedDriverBindingProtocols = CoreAllocateBootServicesPool (sizeof (VOID *) * DriverBindingHandleCount);
+  if (SortedDriverBindingProtocols == NULL) {
+    CoreFreePool (DriverBindingHandleBuffer);
+    return EFI_OUT_OF_RESOURCES;
+  }
+
+  //
+  // Add Driver Binding Protocols from Context Driver Image Handles first
+  //
+  if (ContextDriverImageHandles != NULL) {
+    for (Index = 0; ContextDriverImageHandles[Index] != NULL; Index++) {
+      AddSortedDriverBindingProtocol (
+        ContextDriverImageHandles[Index],
+        &NumberOfSortedDriverBindingProtocols, 
+        SortedDriverBindingProtocols,
+        DriverBindingHandleCount,
+        DriverBindingHandleBuffer
+        );
+    }
+  }
+
+  //
+  // Add the Platform Driver Override Protocol drivers for ControllerHandle next
+  //
+  Status = CoreLocateProtocol (
+             &gEfiPlatformDriverOverrideProtocolGuid, 
+             NULL, 
+             &PlatformDriverOverride
+             );
+  if (!EFI_ERROR (Status) && (PlatformDriverOverride != NULL)) {
+    DriverImageHandle = NULL;
+    do {
+      Status = PlatformDriverOverride->GetDriver (
+                                         PlatformDriverOverride,
+                                         ControllerHandle,
+                                         &DriverImageHandle
+                                         );
+      if (!EFI_ERROR (Status)) {
+        AddSortedDriverBindingProtocol (
+          DriverImageHandle,
+          &NumberOfSortedDriverBindingProtocols, 
+          SortedDriverBindingProtocols,
+          DriverBindingHandleCount,
+          DriverBindingHandleBuffer
+          );
+      }
+    } while (!EFI_ERROR (Status));
+  }
+
+  //
+  // Get the Bus Specific Driver Override Protocol instance on the Controller Handle
+  //
+  Status = CoreHandleProtocol(
+             ControllerHandle,  
+             &gEfiBusSpecificDriverOverrideProtocolGuid, 
+             &BusSpecificDriverOverride
+             );
+  if (!EFI_ERROR (Status) && (BusSpecificDriverOverride != NULL)) {
+    DriverImageHandle = NULL;
+    do {
+      Status = BusSpecificDriverOverride->GetDriver (
+                                            BusSpecificDriverOverride,
+                                            &DriverImageHandle
+                                            );
+      if (!EFI_ERROR (Status)) {
+        AddSortedDriverBindingProtocol (
+          DriverImageHandle,
+          &NumberOfSortedDriverBindingProtocols, 
+          SortedDriverBindingProtocols,
+          DriverBindingHandleCount,
+          DriverBindingHandleBuffer
+          );
+      }
+    } while (!EFI_ERROR (Status));
+  }
+
+  //
+  // Then add all the remaining Driver Binding Protocols
+  //
+  SortIndex = NumberOfSortedDriverBindingProtocols;
+  for (Index = 0; Index < DriverBindingHandleCount; Index++) {
+    AddSortedDriverBindingProtocol (
+      DriverBindingHandleBuffer[Index],
+      &NumberOfSortedDriverBindingProtocols, 
+      SortedDriverBindingProtocols,
+      DriverBindingHandleCount,
+      DriverBindingHandleBuffer
+      );
+  }
+
+  //
+  // Free the Driver Binding Handle Buffer
+  //
+  CoreFreePool (DriverBindingHandleBuffer);
+
+  //
+  // Sort the remaining DriverBinding Protocol based on their Version field from
+  // highest to lowest.
+  //
+  for ( ; SortIndex < DriverBindingHandleCount; SortIndex++) {
+    HighestVersion = SortedDriverBindingProtocols[SortIndex]->Version;
+    HighestIndex   = SortIndex;
+    for (Index = SortIndex + 1; Index < DriverBindingHandleCount; Index++) {
+      if (SortedDriverBindingProtocols[Index]->Version > HighestVersion) {
+        HighestVersion = SortedDriverBindingProtocols[Index]->Version;
+        HighestIndex   = Index;
+      }
+    }
+    if (SortIndex != HighestIndex) {
+      DriverBinding = SortedDriverBindingProtocols[SortIndex];
+      SortedDriverBindingProtocols[SortIndex] = SortedDriverBindingProtocols[HighestIndex];
+      SortedDriverBindingProtocols[HighestIndex] = DriverBinding;
+    }
+  }
+
+  //
+  // Loop until no more drivers can be started on ControllerHandle
+  //
+  OneStarted = FALSE;
+  do {
+
+    //
+    // Loop through the sorted Driver Binding Protocol Instances in order, and see if
+    // any of the Driver Binding Protocols support the controller specified by 
+    // ControllerHandle.
+    //
+    DriverBinding = NULL;
+    DriverFound = FALSE;
+    for (Index = 0; (Index < NumberOfSortedDriverBindingProtocols) && !DriverFound; Index++) {
+      if (SortedDriverBindingProtocols[Index] != NULL) {
+        DriverBinding = SortedDriverBindingProtocols[Index];
+        Status = DriverBinding->Supported(
+                                  DriverBinding, 
+                                  ControllerHandle,
+                                  RemainingDevicePath
+                                  );
+        if (!EFI_ERROR (Status)) {
+          SortedDriverBindingProtocols[Index] = NULL;
+          DriverFound = TRUE;
+
+          //
+          // A driver was found that supports ControllerHandle, so attempt to start the driver
+          // on ControllerHandle.
+          //
+
+#ifdef FIRMWARE_PERFORMANCE
+          GetHandleFromDriverBinding (DriverBinding, &DriverBindingHandle);
+#endif 
+
+          PERF_START (DriverBindingHandle, DRIVERBINDING_START_TOK, NULL, 0);
+          Status = DriverBinding->Start (
+                                    DriverBinding, 
+                                    ControllerHandle,
+                                    RemainingDevicePath
+                                    );
+          PERF_END (DriverBindingHandle, DRIVERBINDING_START_TOK, NULL, 0);
+
+          if (!EFI_ERROR (Status)) {
+            //
+            // The driver was successfully started on ControllerHandle, so set a flag
+            //
+            OneStarted = TRUE;
+          }
+        }
+      }
+    }
+  } while (DriverFound);
+
+  //
+  // Free any buffers that were allocated with AllocatePool()
+  //
+  CoreFreePool (SortedDriverBindingProtocols);
+
+  //
+  // If at least one driver was started on ControllerHandle, then return EFI_SUCCESS.
+  //
+  if (OneStarted) {
+    return EFI_SUCCESS;
+  } 
+
+  //
+  // If no drivers started and RemainingDevicePath is an End Device Path Node, then return EFI_SUCCESS
+  //
+  if (RemainingDevicePath != NULL) {
+    if (IsDevicePathEnd (RemainingDevicePath)) {
+      return EFI_SUCCESS;
+    }
+  } 
+
+  //
+  // Otherwise, no drivers were started on ControllerHandle, so return EFI_NOT_FOUND
+  //
+  return EFI_NOT_FOUND;
+}
+
+EFI_BOOTSERVICE11
+EFI_STATUS 
+EFIAPI
+CoreDisconnectController (
+  IN  EFI_HANDLE  ControllerHandle,
+  IN  EFI_HANDLE  DriverImageHandle  OPTIONAL,
+  IN  EFI_HANDLE  ChildHandle        OPTIONAL
+  )
+/*++
+
+Routine Description:
+
+  Disonnects a controller from a driver
+
+Arguments:
+
+  ControllerHandle  - ControllerHandle The handle of the controller from which driver(s) 
+                        are to be disconnected.
+  DriverImageHandle - DriverImageHandle The driver to disconnect from ControllerHandle.
+  ChildHandle       - ChildHandle The handle of the child to destroy.
+
+Returns:
+
+  EFI_SUCCESS           -  One or more drivers were disconnected from the controller.
+  EFI_SUCCESS           -  On entry, no drivers are managing ControllerHandle.
+  EFI_SUCCESS           -  DriverImageHandle is not NULL, and on entry DriverImageHandle is not managing ControllerHandle.
+  EFI_INVALID_PARAMETER -  ControllerHandle is not a valid EFI_HANDLE.
+  EFI_INVALID_PARAMETER -  DriverImageHandle is not NULL, and it is not a valid EFI_HANDLE.
+  EFI_INVALID_PARAMETER -  ChildHandle is not NULL, and it is not a valid EFI_HANDLE.
+  EFI_OUT_OF_RESOURCES  -  There are not enough resources available to disconnect any drivers from ControllerHandle.
+  EFI_DEVICE_ERROR      -  The controller could not be disconnected because of a device error.
+
+--*/
+{
+  EFI_STATUS                          Status;
+  IHANDLE                             *Handle;
+  EFI_HANDLE                          *DriverImageHandleBuffer;
+  EFI_HANDLE                          *ChildBuffer;
+  UINTN                               Index;
+  UINTN                               HandleIndex;
+  UINTN                               DriverImageHandleCount;
+  UINTN                               ChildrenToStop;
+  UINTN                               ChildBufferCount;
+  UINTN                               StopCount;
+  BOOLEAN                             Duplicate;
+  BOOLEAN                             ChildHandleValid;
+  BOOLEAN                             DriverImageHandleValid;
+  EFI_LIST_ENTRY                      *Link;
+  EFI_LIST_ENTRY                      *ProtLink;
+  OPEN_PROTOCOL_DATA                  *OpenData;
+  PROTOCOL_INTERFACE                  *Prot;
+  EFI_DRIVER_BINDING_PROTOCOL         *DriverBinding;
+
+  //
+  // Make sure ControllerHandle is valid
+  //
+  Status = CoreValidateHandle (ControllerHandle);
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+
+  //
+  // Make sure ChildHandle is valid if it is not NULL
+  //
+  if (ChildHandle != NULL) {
+    Status = CoreValidateHandle (ChildHandle);
+    if (EFI_ERROR (Status)) {
+      return Status;
+    }
+  }
+
+  Handle = ControllerHandle;
+
+  //
+  // Get list of drivers that are currently managing ControllerHandle
+  //
+  DriverImageHandleBuffer = NULL;
+  DriverImageHandleCount  = 1;  
+  
+  if (DriverImageHandle == NULL) {
+    //
+    // Look at each protocol interface for a match
+    //
+    DriverImageHandleCount = 0;
+
+    CoreAcquireProtocolLock ();
+    for (Link = Handle->Protocols.ForwardLink; Link != &Handle->Protocols; Link = Link->ForwardLink) {
+      Prot = CR(Link, PROTOCOL_INTERFACE, Link, PROTOCOL_INTERFACE_SIGNATURE);
+      for (ProtLink = Prot->OpenList.ForwardLink; 
+           ProtLink != &Prot->OpenList; 
+           ProtLink = ProtLink->ForwardLink) {
+        OpenData = CR (ProtLink, OPEN_PROTOCOL_DATA, Link, OPEN_PROTOCOL_DATA_SIGNATURE);
+        if ((OpenData->Attributes & EFI_OPEN_PROTOCOL_BY_DRIVER) != 0) {
+          DriverImageHandleCount++;
+        }
+      }
+    }
+    CoreReleaseProtocolLock ();
+    
+    //
+    // If there are no drivers managing this controller, then return EFI_SUCCESS
+    //
+    if (DriverImageHandleCount == 0) {
+      Status = EFI_SUCCESS;
+      goto Done;
+    }
+
+    DriverImageHandleBuffer = CoreAllocateBootServicesPool (sizeof (EFI_HANDLE) * DriverImageHandleCount);
+    if (DriverImageHandleBuffer == NULL) {
+      Status = EFI_OUT_OF_RESOURCES;
+      goto Done;
+    }
+
+    DriverImageHandleCount = 0;
+
+    CoreAcquireProtocolLock ();
+    for (Link = Handle->Protocols.ForwardLink; Link != &Handle->Protocols; Link = Link->ForwardLink) {
+      Prot = CR(Link, PROTOCOL_INTERFACE, Link, PROTOCOL_INTERFACE_SIGNATURE);
+      for (ProtLink = Prot->OpenList.ForwardLink; 
+           ProtLink != &Prot->OpenList; 
+           ProtLink = ProtLink->ForwardLink) {
+        OpenData = CR (ProtLink, OPEN_PROTOCOL_DATA, Link, OPEN_PROTOCOL_DATA_SIGNATURE);
+        if ((OpenData->Attributes & EFI_OPEN_PROTOCOL_BY_DRIVER) != 0) {
+          Duplicate = FALSE;
+          for (Index = 0; Index< DriverImageHandleCount; Index++) {
+            if (DriverImageHandleBuffer[Index] == OpenData->AgentHandle) {
+              Duplicate = TRUE;
+              break;
+            }
+          }
+          if (!Duplicate) {
+            DriverImageHandleBuffer[DriverImageHandleCount] = OpenData->AgentHandle;
+            DriverImageHandleCount++;
+          }
+        }
+      }
+    }
+    CoreReleaseProtocolLock ();
+  }
+
+  StopCount = 0;
+  for (HandleIndex = 0; HandleIndex < DriverImageHandleCount; HandleIndex++) {
+
+    if (DriverImageHandleBuffer != NULL) {
+      DriverImageHandle = DriverImageHandleBuffer[HandleIndex];
+    }
+
+    //
+    // Get the Driver Binding Protocol of the driver that is managing this controller
+    //
+    Status = CoreHandleProtocol (
+               DriverImageHandle,  
+               &gEfiDriverBindingProtocolGuid,   
+               &DriverBinding
+               );
+    if (EFI_ERROR (Status) || (DriverBinding == NULL)) {
+      Status = EFI_INVALID_PARAMETER;
+      goto Done;
+    }
+
+    //
+    // Look at each protocol interface for a match
+    //
+    DriverImageHandleValid = FALSE;
+    ChildBufferCount = 0;
+
+    CoreAcquireProtocolLock ();
+    for (Link = Handle->Protocols.ForwardLink; Link != &Handle->Protocols; Link = Link->ForwardLink) {
+      Prot = CR(Link, PROTOCOL_INTERFACE, Link, PROTOCOL_INTERFACE_SIGNATURE);
+      for (ProtLink = Prot->OpenList.ForwardLink; 
+           ProtLink != &Prot->OpenList; 
+           ProtLink = ProtLink->ForwardLink) {
+        OpenData = CR (ProtLink, OPEN_PROTOCOL_DATA, Link, OPEN_PROTOCOL_DATA_SIGNATURE);
+        if (OpenData->AgentHandle == DriverImageHandle) {
+          if ((OpenData->Attributes & EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER) != 0) {
+            ChildBufferCount++;
+          } 
+          if ((OpenData->Attributes & EFI_OPEN_PROTOCOL_BY_DRIVER) != 0) {
+            DriverImageHandleValid = TRUE;
+          }
+        }
+      }
+    }
+    CoreReleaseProtocolLock ();
+
+    if (DriverImageHandleValid) {
+      ChildHandleValid = FALSE;
+      ChildBuffer = NULL;
+      if (ChildBufferCount != 0) {
+        ChildBuffer = CoreAllocateBootServicesPool (sizeof (EFI_HANDLE) * ChildBufferCount);
+        if (ChildBuffer == NULL) {
+          Status = EFI_OUT_OF_RESOURCES;
+          goto Done;
+        }
+
+        ChildBufferCount = 0;
+
+        CoreAcquireProtocolLock ();
+        for (Link = Handle->Protocols.ForwardLink; Link != &Handle->Protocols; Link = Link->ForwardLink) {
+          Prot = CR(Link, PROTOCOL_INTERFACE, Link, PROTOCOL_INTERFACE_SIGNATURE);
+          for (ProtLink = Prot->OpenList.ForwardLink; 
+               ProtLink != &Prot->OpenList; 
+               ProtLink = ProtLink->ForwardLink) {
+            OpenData = CR (ProtLink, OPEN_PROTOCOL_DATA, Link, OPEN_PROTOCOL_DATA_SIGNATURE);
+            if ((OpenData->AgentHandle == DriverImageHandle) &&
+                ((OpenData->Attributes & EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER) != 0)) {
+              Duplicate = FALSE;
+              for (Index = 0; Index < ChildBufferCount; Index++) {
+                if (ChildBuffer[Index] == OpenData->ControllerHandle) {
+                  Duplicate = TRUE;
+                  break;
+                }
+              }
+              if (!Duplicate) {
+                ChildBuffer[ChildBufferCount] = OpenData->ControllerHandle;
+                if (ChildHandle == ChildBuffer[ChildBufferCount]) {
+                  ChildHandleValid = TRUE;
+                }
+                ChildBufferCount++;
+              }
+            }
+          }
+        }
+        CoreReleaseProtocolLock ();
+      }
+
+      if (ChildHandle == NULL || ChildHandleValid) {
+        ChildrenToStop = 0;
+        Status = EFI_SUCCESS;
+        if (ChildBufferCount > 0) {
+          if (ChildHandle != NULL) {
+            ChildrenToStop = 1;
+            Status = DriverBinding->Stop (DriverBinding, ControllerHandle, ChildrenToStop, &ChildHandle);
+          } else {
+            ChildrenToStop = ChildBufferCount;
+            Status = DriverBinding->Stop (DriverBinding, ControllerHandle, ChildrenToStop, ChildBuffer);
+          }
+        }
+        if (!EFI_ERROR (Status) && ((ChildHandle == NULL) || (ChildBufferCount == ChildrenToStop))) {
+          Status = DriverBinding->Stop (DriverBinding, ControllerHandle, 0, NULL);
+        }
+        if (!EFI_ERROR (Status)) {
+          StopCount++;
+        }
+      }
+
+      if (ChildBuffer != NULL) {
+        CoreFreePool (ChildBuffer);
+      }
+    }
+  }
+
+  if (StopCount > 0) {
+    Status = EFI_SUCCESS;
+  } else {
+    Status = EFI_NOT_FOUND;
+  }
+  
+Done:  
+
+  if (DriverImageHandleBuffer != NULL) {
+    CoreFreePool (DriverImageHandleBuffer);
+  }
+
+  return Status;
+}
+
+
+
+#ifdef FIRMWARE_PERFORMANCE
+STATIC
+EFI_STATUS
+GetHandleFromDriverBinding (
+  IN   EFI_DRIVER_BINDING_PROTOCOL           *DriverBindingNeed,
+  OUT  EFI_HANDLE                            *Handle 
+ )
+/*++
+
+Routine Description:
+
+  Locate the driver binding handle which a specified driver binding protocol installed on.
+
+Arguments:
+
+  DriverBindingNeed  - The specified driver binding protocol.
+  
+  Handle             - The driver binding handle which the protocol installed on.
+  
+
+Returns:
+
+  EFI_NOT_FOUND         - Could not find the handle.
+  
+  EFI_SUCCESS           - Successfully find the associated driver binding handle.
+  
+--*/ 
+ {
+  EFI_STATUS                          Status ;
+  EFI_DRIVER_BINDING_PROTOCOL         *DriverBinding;
+  UINTN                               DriverBindingHandleCount;
+  EFI_HANDLE                          *DriverBindingHandleBuffer;
+  UINTN                               Index;
+  
+  DriverBindingHandleCount = 0;
+  DriverBindingHandleBuffer = NULL;
+  *Handle = NULL_HANDLE;
+  Status = gBS->LocateHandleBuffer (
+              ByProtocol,   
+              &gEfiDriverBindingProtocolGuid,  
+              NULL,
+              &DriverBindingHandleCount, 
+              &DriverBindingHandleBuffer
+              );
+  if (EFI_ERROR (Status) || DriverBindingHandleCount == 0) {
+    return EFI_NOT_FOUND;
+  }
+  
+  for (Index = 0 ; Index < DriverBindingHandleCount; Index++ ) {
+    Status = gBS->OpenProtocol(
+                      DriverBindingHandleBuffer[Index],
+                      &gEfiDriverBindingProtocolGuid,
+                      &DriverBinding,
+                      gDxeCoreImageHandle,
+                      NULL,
+                      EFI_OPEN_PROTOCOL_GET_PROTOCOL
+                      );
+                      
+   if (!EFI_ERROR (Status) && DriverBinding != NULL) {
+    
+    if ( DriverBinding == DriverBindingNeed ) {
+      *Handle = DriverBindingHandleBuffer[Index];
+      CoreFreePool (DriverBindingHandleBuffer);         
+      return EFI_SUCCESS ;
+    }
+   }
+ }
+ 
+ CoreFreePool (DriverBindingHandleBuffer);
+ return EFI_NOT_FOUND ;
+}
+#endif
\ No newline at end of file
diff --git a/EDK/Foundation/Core/Dxe/Hand/Notify.c b/EDK/Foundation/Core/Dxe/Hand/Notify.c
new file mode 100644
index 0000000..8b12657
--- /dev/null
+++ b/EDK/Foundation/Core/Dxe/Hand/Notify.c
@@ -0,0 +1,335 @@
+/*++
+
+Copyright (c) 2004, Intel Corporation                                                         
+All rights reserved. This program and the accompanying materials                          
+are licensed and made available under the terms and conditions of the BSD License         
+which accompanies this distribution.  The full text of the license may be found at        
+http://opensource.org/licenses/bsd-license.php                                            
+                                                                                          
+THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     
+WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             
+
+Module Name:
+
+  notify.c
+
+Abstract:
+
+  EFI notify infrastructure
+
+
+
+Revision History
+
+--*/
+
+#include "hand.h"
+
+
+
+VOID
+CoreNotifyProtocolEntry (
+  IN PROTOCOL_ENTRY   *ProtEntry
+  )
+/*++
+
+Routine Description:
+
+  Signal event for every protocol in protocol entry.
+
+Arguments:
+
+  ProtEntry     - Protocol entry
+
+Returns:
+
+--*/
+{
+  PROTOCOL_NOTIFY     *ProtNotify;
+  EFI_LIST_ENTRY      *Link;
+
+  ASSERT_LOCKED (&gProtocolDatabaseLock);
+
+  for (Link=ProtEntry->Notify.ForwardLink; Link != &ProtEntry->Notify; Link=Link->ForwardLink) {
+    ProtNotify = CR(Link, PROTOCOL_NOTIFY, Link, PROTOCOL_NOTIFY_SIGNATURE);
+    CoreSignalEvent (ProtNotify->Event);
+  }
+}
+
+
+PROTOCOL_INTERFACE *
+CoreRemoveInterfaceFromProtocol (
+  IN IHANDLE        *Handle,
+  IN EFI_GUID       *Protocol,
+  IN VOID           *Interface
+  )
+/*++
+
+Routine Description:
+
+  Removes Protocol from the protocol list (but not the handle list).
+
+Arguments:
+
+  Handle -  The handle to remove protocol on.
+
+  Protocol  -  GUID of the protocol to be moved
+
+  Interface - The interface of the protocol
+
+Returns:
+
+  Protocol Entry
+
+--*/
+{
+  PROTOCOL_INTERFACE  *Prot;
+  PROTOCOL_NOTIFY     *ProtNotify;
+  PROTOCOL_ENTRY      *ProtEntry;
+  EFI_LIST_ENTRY      *Link;
+
+  ASSERT_LOCKED (&gProtocolDatabaseLock);
+
+  Prot = CoreFindProtocolInterface (Handle, Protocol, Interface);
+  if (Prot != NULL) {
+
+    ProtEntry = Prot->Protocol;
+
+    //
+    // If there's a protocol notify location pointing to this entry, back it up one
+    //
+
+    for(Link = ProtEntry->Notify.ForwardLink; Link != &ProtEntry->Notify; Link=Link->ForwardLink) {
+      ProtNotify = CR(Link, PROTOCOL_NOTIFY, Link, PROTOCOL_NOTIFY_SIGNATURE);
+
+      if (ProtNotify->Position == &Prot->ByProtocol) {
+        ProtNotify->Position = Prot->ByProtocol.BackLink;
+      }
+    }
+
+    //
+    // Remove the protocol interface entry
+    //
+
+    RemoveEntryList (&Prot->ByProtocol);
+  }
+
+  return Prot;
+}
+
+
+EFI_BOOTSERVICE
+EFI_STATUS
+EFIAPI
+CoreRegisterProtocolNotify (
+  IN EFI_GUID       *Protocol,
+  IN EFI_EVENT      Event,
+  OUT  VOID           **Registration
+  )
+/*++
+
+Routine Description:
+
+  Add a new protocol notification record for the request protocol.
+
+Arguments:
+
+  Protocol      - The requested protocol to add the notify registration
+
+  Event         - The event to signal 
+
+  Registration  - Returns the registration record
+
+
+Returns:
+
+  EFI_INVALID_PARAMETER       - Invalid parameter
+
+  EFI_SUCCESS                 - Successfully returned the registration record that has been added
+  
+--*/
+{
+  PROTOCOL_ENTRY      *ProtEntry;
+  PROTOCOL_NOTIFY     *ProtNotify;
+  EFI_STATUS        Status;
+  
+  if ((Protocol == NULL) || (Event == NULL) || (Registration == NULL))  {
+    return EFI_INVALID_PARAMETER;
+  }
+
+  CoreAcquireProtocolLock ();
+
+  ProtNotify = NULL;
+  
+  //
+  // Get the protocol entry to add the notification too
+  //
+
+  ProtEntry = CoreFindProtocolEntry (Protocol, TRUE);
+  if (ProtEntry != NULL) {
+
+    //
+    // Allocate a new notification record
+    //
+
+    ProtNotify = CoreAllocateBootServicesPool (sizeof(PROTOCOL_NOTIFY));
+
+    if (ProtNotify != NULL) {
+      
+      ProtNotify->Signature = PROTOCOL_NOTIFY_SIGNATURE;
+      ProtNotify->Protocol = ProtEntry;
+      ProtNotify->Event = Event;
+      //
+      // start at the begining
+      //
+      ProtNotify->Position = &ProtEntry->Protocols; 
+
+      InsertTailList (&ProtEntry->Notify, &ProtNotify->Link);
+    }
+  }
+
+  CoreReleaseProtocolLock ();
+
+  //
+  // Done.  If we have a protocol notify entry, then return it.
+  // Otherwise, we must have run out of resources trying to add one
+  //
+
+  Status = EFI_OUT_OF_RESOURCES;
+  if (ProtNotify != NULL) {
+    *Registration = ProtNotify;
+    Status = EFI_SUCCESS;
+  }
+
+  return Status;
+}
+
+
+EFI_BOOTSERVICE
+EFI_STATUS
+EFIAPI
+CoreReinstallProtocolInterface (
+  IN EFI_HANDLE     UserHandle,
+  IN EFI_GUID       *Protocol,
+  IN VOID           *OldInterface,
+  IN VOID           *NewInterface
+  )
+/*++
+
+Routine Description:
+
+  Reinstall a protocol interface on a device handle.  The OldInterface for Protocol is replaced by the NewInterface.
+
+Arguments:
+
+  UserHandle    - Handle on which the interface is to be reinstalled
+  Protocol      - The numeric ID of the interface
+  OldInterface  - A pointer to the old interface
+  NewInterface  - A pointer to the new interface 
+
+
+Returns:
+
+  Status code.
+
+  On EFI_SUCCESS            The protocol interface was installed
+  On EFI_NOT_FOUND          The OldInterface on the handle was not found
+  On EFI_INVALID_PARAMETER  One of the parameters has an invalid value
+  
+--*/
+{
+  EFI_STATUS                Status;
+  IHANDLE                   *Handle;
+  PROTOCOL_INTERFACE        *Prot;
+  PROTOCOL_ENTRY            *ProtEntry;
+
+  Status = CoreValidateHandle (UserHandle);
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+
+  if (Protocol == NULL) {
+    return EFI_INVALID_PARAMETER;
+  }
+
+  Handle = (IHANDLE *) UserHandle;
+
+  //
+  // Lock the protocol database
+  //
+  CoreAcquireProtocolLock ();
+
+  //
+  // Check that Protocol exists on UserHandle, and Interface matches the interface in the database
+  //
+  Prot = CoreFindProtocolInterface (UserHandle, Protocol, OldInterface);
+  if (Prot == NULL) {
+    CoreReleaseProtocolLock ();
+    return EFI_NOT_FOUND;
+  }
+
+  //
+  // Attempt to disconnect all drivers that are using the protocol interface that is about to be reinstalled
+  //
+  Status = CoreDisconnectControllersUsingProtocolInterface (
+             UserHandle,
+             Prot
+             );
+  if (EFI_ERROR (Status)) {
+    //
+    // One or more drivers refused to release, so return the error
+    //
+    CoreReleaseProtocolLock ();
+    return Status;
+  }
+
+  //
+  // Remove the protocol interface from the protocol
+  //
+  Prot = CoreRemoveInterfaceFromProtocol (Handle, Protocol, OldInterface);
+
+  if (Prot == NULL) {
+    CoreReleaseProtocolLock ();
+    return EFI_NOT_FOUND;
+  }
+
+  ProtEntry = Prot->Protocol;
+
+  //
+  // Update the interface on the protocol
+  //
+  Prot->Interface = NewInterface;
+
+  //
+  // Add this protocol interface to the tail of the
+  // protocol entry
+  //
+  InsertTailList (&ProtEntry->Protocols, &Prot->ByProtocol);
+
+  //
+  // Update the Key to show that the handle has been created/modified
+  //
+  gHandleDatabaseKey++;
+  Handle->Key = gHandleDatabaseKey;
+
+  //
+  // Release the lock and connect all drivers to UserHandle
+  //
+  CoreReleaseProtocolLock ();
+  Status = CoreConnectController (
+                  UserHandle, 
+                  NULL, 
+                  NULL, 
+                  TRUE
+                  );
+  CoreAcquireProtocolLock ();
+  
+  //
+  // Notify the notification list for this protocol
+  //
+  CoreNotifyProtocolEntry (ProtEntry);
+
+  CoreReleaseProtocolLock ();
+  
+  return EFI_SUCCESS;
+}
diff --git a/EDK/Foundation/Core/Dxe/Hand/hand.h b/EDK/Foundation/Core/Dxe/Hand/hand.h
new file mode 100644
index 0000000..d048073
--- /dev/null
+++ b/EDK/Foundation/Core/Dxe/Hand/hand.h
@@ -0,0 +1,339 @@
+/*++
+
+Copyright (c) 2004, Intel Corporation                                                         
+All rights reserved. This program and the accompanying materials                          
+are licensed and made available under the terms and conditions of the BSD License         
+which accompanies this distribution.  The full text of the license may be found at        
+http://opensource.org/licenses/bsd-license.php                                            
+                                                                                          
+THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     
+WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             
+
+Module Name:
+
+  hand.h
+
+Abstract:
+
+  EFI internal protocol definitions
+
+
+
+Revision History
+
+--*/
+
+#ifndef  _HAND_H_
+#define  _HAND_H_
+
+#include "Tiano.h"
+#include "DxeCore.h"
+
+//
+// IHANDLE - contains a list of protocol handles
+//
+
+#define EFI_HANDLE_SIGNATURE            EFI_SIGNATURE_32('h','n','d','l')
+typedef struct {
+  UINTN               Signature;
+  EFI_LIST_ENTRY      AllHandles;     // All handles list of IHANDLE
+  EFI_LIST_ENTRY      Protocols;      // List of PROTOCOL_INTERFACE's for this handle
+  UINTN               LocateRequest;  // 
+  UINT64              Key;            // The Handle Database Key value when this handle was last created or modified
+} IHANDLE;
+
+#define ASSERT_IS_HANDLE(a)  ASSERT((a)->Signature == EFI_HANDLE_SIGNATURE)
+
+
+//
+// PROTOCOL_ENTRY - each different protocol has 1 entry in the protocol 
+// database.  Each handler that supports this protocol is listed, along
+// with a list of registered notifies.
+//
+
+#define PROTOCOL_ENTRY_SIGNATURE        EFI_SIGNATURE_32('p','r','t','e')
+typedef struct {
+  UINTN               Signature;
+  EFI_LIST_ENTRY      AllEntries;             // All entries
+  EFI_GUID            ProtocolID;             // ID of the protocol
+  EFI_LIST_ENTRY      Protocols;              // All protocol interfaces
+  EFI_LIST_ENTRY      Notify;                 // Registerd notification handlers
+} PROTOCOL_ENTRY;
+
+//
+// PROTOCOL_INTERFACE - each protocol installed on a handle is tracked
+// with a protocol interface structure
+//
+
+#define PROTOCOL_INTERFACE_SIGNATURE  EFI_SIGNATURE_32('p','i','f','c')
+typedef struct {
+  UINTN                       Signature;
+  EFI_HANDLE                  Handle;     // Back pointer
+  EFI_LIST_ENTRY              Link;       // Link on IHANDLE.Protocols
+  EFI_LIST_ENTRY              ByProtocol; // Link on PROTOCOL_ENTRY.Protocols
+  PROTOCOL_ENTRY              *Protocol;  // The protocol ID
+  VOID                        *Interface; // The interface value
+                                          
+  EFI_LIST_ENTRY              OpenList;       // OPEN_PROTOCOL_DATA list.
+  UINTN                       OpenListCount;  
+  
+  EFI_HANDLE                  ControllerHandle;
+
+} PROTOCOL_INTERFACE;
+
+#define OPEN_PROTOCOL_DATA_SIGNATURE  EFI_SIGNATURE_32('p','o','d','l')
+
+typedef struct {
+  UINTN                       Signature;
+  EFI_LIST_ENTRY              Link;
+
+  EFI_HANDLE                  AgentHandle;
+  EFI_HANDLE                  ControllerHandle;
+  UINT32                      Attributes;
+  UINT32                      OpenCount;
+} OPEN_PROTOCOL_DATA;
+
+
+//
+// PROTOCOL_NOTIFY - used for each register notification for a protocol
+//
+
+#define PROTOCOL_NOTIFY_SIGNATURE       EFI_SIGNATURE_32('p','r','t','n')
+typedef struct {
+  UINTN               Signature;
+  PROTOCOL_ENTRY      *Protocol;
+  EFI_LIST_ENTRY      Link;                   // All notifications for this protocol
+  EFI_EVENT           Event;                  // Event to notify
+  EFI_LIST_ENTRY      *Position;              // Last position notified
+} PROTOCOL_NOTIFY;
+
+//
+// Internal prototypes
+//
+
+
+PROTOCOL_ENTRY  *
+CoreFindProtocolEntry (
+  IN EFI_GUID     *Protocol,
+  IN BOOLEAN      Create
+  )
+/*++
+
+Routine Description:
+
+  Finds the protocol entry for the requested protocol.
+  
+  N.B.  The gProtocolDatabaseLock must be owned
+
+Arguments:
+  
+  Protocol  - The ID of the protocol 
+
+  Create    - Create a new entry if not found
+
+Returns:
+
+  Protocol entry
+
+--*/
+;
+
+VOID
+CoreNotifyProtocolEntry (
+  IN PROTOCOL_ENTRY       *ProtEntry
+  )
+/*++
+
+Routine Description:
+
+  Signal event for every protocol in protocol entry.
+
+Arguments:
+
+  ProtEntry     - Protocol entry
+
+Returns:
+
+--*/
+;
+
+PROTOCOL_INTERFACE *
+CoreFindProtocolInterface (
+  IN IHANDLE              *Handle,
+  IN EFI_GUID             *Protocol,
+  IN VOID                 *Interface
+  )
+/*++
+
+Routine Description:
+
+  Finds the protocol instance for the requested handle and protocol.
+  
+  Note: This function doesn't do parameters checking, it's caller's responsibility 
+        to pass in valid parameters.
+  
+Arguments:
+  
+  Handle    - The handle to search the protocol on
+  
+  Protocol  - GUID of the protocol
+
+  Interface - The interface for the protocol being searched
+
+Returns:
+
+  Protocol instance (NULL: Not found)
+
+--*/
+;
+
+PROTOCOL_INTERFACE *
+CoreRemoveInterfaceFromProtocol (
+  IN IHANDLE              *Handle,
+  IN EFI_GUID             *Protocol,
+  IN VOID                 *Interface
+  )
+/*++
+
+Routine Description:
+
+  Removes Protocol from the protocol list (but not the handle list).
+
+Arguments:
+
+  Handle -  The handle to remove protocol on.
+
+  Protocol  -  GUID of the protocol to be moved
+
+  Interface - The interface of the protocol
+
+Returns:
+
+  Protocol Entry
+
+--*/
+;
+
+EFI_STATUS
+CoreUnregisterProtocolNotify (
+  IN EFI_EVENT            Event
+  )
+/*++
+
+Routine Description:
+
+  Removes all the events in the protocol database that match Event.
+
+Arguments:
+  
+  Event   - The event to search for in the protocol database.
+
+Returns:
+
+  EFI_SUCCESS when done searching the entire database.
+
+--*/
+;
+
+EFI_STATUS
+CoreDisconnectControllersUsingProtocolInterface (
+  IN EFI_HANDLE           UserHandle,
+  IN PROTOCOL_INTERFACE   *Prot
+  )
+/*++
+
+Routine Description:
+
+  Attempts to disconnect all drivers that are using the protocol interface being queried.
+  If failed, reconnect all drivers disconnected.
+  
+  Note: This function doesn't do parameters checking, it's caller's responsibility 
+        to pass in valid parameters.
+
+Arguments:
+
+  UserHandle  - The handle on which the protocol is installed 
+  Prot        - The protocol to disconnect drivers from
+
+Returns:
+
+  EFI_SUCCESS       - Drivers using the protocol interface are all disconnected
+  EFI_ACCESS_DENIED - Failed to disconnect one or all of the drivers
+
+--*/
+;
+
+VOID
+CoreAcquireProtocolLock (
+  VOID
+  )
+/*++
+
+Routine Description:
+
+  Acquire lock on gProtocolDatabaseLock.
+  
+Arguments:
+
+  None
+  
+Returns:
+
+  None
+
+--*/
+;
+
+VOID
+CoreReleaseProtocolLock (
+  VOID
+  )
+/*++
+
+Routine Description:
+
+  Release lock on gProtocolDatabaseLock.
+  
+Arguments:
+
+  None
+  
+Returns:
+
+  None
+
+--*/
+;
+
+EFI_STATUS
+CoreValidateHandle (
+  IN  EFI_HANDLE                UserHandle
+  )
+/*++
+
+Routine Description:
+
+  Check whether a handle is a valid EFI_HANDLE
+  
+Arguments:
+
+  UserHandle		-	The handle to check
+  
+Returns:
+
+  EFI_INVALID_PARAMETER		-	The handle is NULL or not a valid EFI_HANDLE.
+  
+  EFI_SUCCESS							-	The handle is valid EFI_HANDLE.
+
+--*/
+;
+
+//
+// Externs
+//
+
+extern EFI_LOCK         gProtocolDatabaseLock;
+extern EFI_LIST_ENTRY   gHandleList;
+extern UINT64           gHandleDatabaseKey;
+
+#endif
diff --git a/EDK/Foundation/Core/Dxe/Hand/handle.c b/EDK/Foundation/Core/Dxe/Hand/handle.c
new file mode 100644
index 0000000..45874b4
--- /dev/null
+++ b/EDK/Foundation/Core/Dxe/Hand/handle.c
@@ -0,0 +1,1716 @@
+/*++
+
+Copyright (c) 2004, Intel Corporation
+All rights reserved. This program and the accompanying materials                          
+are licensed and made available under the terms and conditions of the BSD License         
+which accompanies this distribution.  The full text of the license may be found at        
+http://opensource.org/licenses/bsd-license.php                                            
+                                                                                          
+THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     
+WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             
+
+Module Name:
+
+  handle.c
+
+Abstract:
+
+  EFI handle & protocol handling
+
+
+
+Revision History
+
+--*/
+
+#include "hand.h"
+#include EFI_PROTOCOL_DEFINITION (DevicePath)
+#include EFI_PROTOCOL_DEFINITION (LoadedImage)
+#include EFI_PROTOCOL_DEFINITION (DebugMask)
+
+//
+// mProtocolDatabase     - A list of all protocols in the system.  (simple list for now)
+// gHandleList           - A list of all the handles in the system
+// gProtocolDatabaseLock - Lock to protect the mProtocolDatabase
+// gHandleDatabaseKey    -  The Key to show that the handle has been created/modified
+//
+static EFI_LIST_ENTRY  mProtocolDatabase     = INITIALIZE_LIST_HEAD_VARIABLE (mProtocolDatabase);
+EFI_LIST_ENTRY         gHandleList           = INITIALIZE_LIST_HEAD_VARIABLE (gHandleList);
+EFI_LOCK               gProtocolDatabaseLock = EFI_INITIALIZE_LOCK_VARIABLE (EFI_TPL_NOTIFY);
+UINT64                 gHandleDatabaseKey    = 0;
+
+
+VOID
+CoreAcquireProtocolLock (
+  VOID
+  )
+/*++
+
+Routine Description:
+
+  Acquire lock on gProtocolDatabaseLock.
+  
+Arguments:
+
+  None
+  
+Returns:
+
+  None
+
+--*/
+{
+  CoreAcquireLock (&gProtocolDatabaseLock);
+}
+
+
+VOID
+CoreReleaseProtocolLock (
+  VOID
+  )
+/*++
+
+Routine Description:
+
+  Release lock on gProtocolDatabaseLock.
+  
+Arguments:
+
+  None
+  
+Returns:
+
+  None
+
+--*/
+{
+  CoreReleaseLock (&gProtocolDatabaseLock);
+}
+
+
+EFI_STATUS
+CoreValidateHandle (
+  IN  EFI_HANDLE                UserHandle
+  )
+/*++
+
+Routine Description:
+
+  Check whether a handle is a valid EFI_HANDLE
+  
+Arguments:
+
+  UserHandle    - The handle to check
+  
+Returns:
+
+  EFI_INVALID_PARAMETER   - The handle is NULL or not a valid EFI_HANDLE.
+
+  EFI_SUCCESS             - The handle is valid EFI_HANDLE.
+
+--*/
+{
+  IHANDLE             *Handle;
+
+  Handle = (IHANDLE *)UserHandle;
+  if (Handle == NULL) {
+    return EFI_INVALID_PARAMETER;
+  }
+  if (Handle->Signature != EFI_HANDLE_SIGNATURE) {
+    return EFI_INVALID_PARAMETER;
+  }
+  return EFI_SUCCESS;
+}
+
+
+PROTOCOL_ENTRY  *
+CoreFindProtocolEntry (
+  IN EFI_GUID   *Protocol,
+  IN BOOLEAN    Create
+  )
+/*++
+
+Routine Description:
+
+  Finds the protocol entry for the requested protocol.
+  
+  N.B.  The gProtocolDatabaseLock must be owned
+
+Arguments:
+  
+  Protocol  - The ID of the protocol 
+
+  Create    - Create a new entry if not found
+
+Returns:
+
+  Protocol entry
+
+--*/
+{
+  EFI_LIST_ENTRY      *Link;
+  PROTOCOL_ENTRY      *Item;
+  PROTOCOL_ENTRY      *ProtEntry;
+
+  ASSERT_LOCKED(&gProtocolDatabaseLock);
+
+  //
+  // Search the database for the matching GUID
+  //
+
+  ProtEntry = NULL;
+  for (Link = mProtocolDatabase.ForwardLink; 
+       Link != &mProtocolDatabase; 
+       Link = Link->ForwardLink) {
+
+    Item = CR(Link, PROTOCOL_ENTRY, AllEntries, PROTOCOL_ENTRY_SIGNATURE);
+    if (EfiCompareGuid (&Item->ProtocolID, Protocol)) {
+
+      //
+      // This is the protocol entry
+      //
+
+      ProtEntry = Item;
+      break;
+    }
+  }
+
+  //
+  // If the protocol entry was not found and Create is TRUE, then 
+  // allocate a new entry
+  //     
+  if ((ProtEntry == NULL) && Create) {
+    ProtEntry = CoreAllocateBootServicesPool (sizeof(PROTOCOL_ENTRY));
+    
+    if (ProtEntry != NULL) {
+      //
+      // Initialize new protocol entry structure
+      //
+      ProtEntry->Signature = PROTOCOL_ENTRY_SIGNATURE;
+      ProtEntry->ProtocolID = *Protocol;
+      InitializeListHead (&ProtEntry->Protocols);
+      InitializeListHead (&ProtEntry->Notify);
+
+      //
+      // Add it to protocol database
+      //
+      InsertTailList (&mProtocolDatabase, &ProtEntry->AllEntries);
+    }
+  }
+
+  return ProtEntry;
+}
+
+
+PROTOCOL_INTERFACE *
+CoreFindProtocolInterface (
+  IN IHANDLE        *Handle,
+  IN EFI_GUID       *Protocol,
+  IN VOID           *Interface
+  )
+/*++
+
+Routine Description:
+
+  Finds the protocol instance for the requested handle and protocol.
+  
+  Note: This function doesn't do parameters checking, it's caller's responsibility 
+        to pass in valid parameters.
+  
+Arguments:
+  
+  Handle    - The handle to search the protocol on
+  
+  Protocol  - GUID of the protocol
+
+  Interface - The interface for the protocol being searched
+
+Returns:
+
+  Protocol instance (NULL: Not found)
+
+--*/  
+{
+  PROTOCOL_INTERFACE  *Prot;
+  PROTOCOL_ENTRY      *ProtEntry;
+  EFI_LIST_ENTRY      *Link;
+
+  ASSERT_LOCKED(&gProtocolDatabaseLock);
+  Prot = NULL;
+
+  //
+  // Lookup the protocol entry for this protocol ID
+  //
+
+  ProtEntry = CoreFindProtocolEntry (Protocol, FALSE);
+  if (ProtEntry != NULL) {
+
+    //
+    // Look at each protocol interface for any matches
+    //
+    for (Link = Handle->Protocols.ForwardLink; Link != &Handle->Protocols; Link=Link->ForwardLink) {
+
+      //
+      // If this protocol interface matches, remove it
+      //
+      Prot = CR(Link, PROTOCOL_INTERFACE, Link, PROTOCOL_INTERFACE_SIGNATURE);
+      if (Prot->Interface == Interface && Prot->Protocol == ProtEntry) {
+        break;
+      }
+
+      Prot = NULL;
+    }
+  }
+
+  return Prot;
+}
+
+STATIC
+EFI_STATUS
+CoreUnregisterProtocolNotifyEvent (
+  IN EFI_EVENT      Event
+  )
+/*++
+
+Routine Description:
+
+  Removes an event from a register protocol notify list on a protocol.
+
+Arguments:
+  
+  Event   - The event to search for in the protocol database.
+
+Returns:
+
+  EFI_SUCCESS   if the event was found and removed.
+  EFI_NOT_FOUND if the event was not found in the protocl database.
+
+--*/
+{
+  EFI_LIST_ENTRY     *Link;
+  PROTOCOL_ENTRY     *ProtEntry;
+  EFI_LIST_ENTRY     *NotifyLink;
+  PROTOCOL_NOTIFY    *ProtNotify;
+
+  CoreAcquireProtocolLock ();
+
+  for ( Link =  mProtocolDatabase.ForwardLink; 
+        Link != &mProtocolDatabase; 
+        Link =  Link->ForwardLink) {
+
+    ProtEntry = CR(Link, PROTOCOL_ENTRY, AllEntries, PROTOCOL_ENTRY_SIGNATURE);
+
+    for ( NotifyLink =  ProtEntry->Notify.ForwardLink; 
+          NotifyLink != &ProtEntry->Notify; 
+          NotifyLink =  NotifyLink->ForwardLink) {
+
+      ProtNotify = CR(NotifyLink, PROTOCOL_NOTIFY, Link, PROTOCOL_NOTIFY_SIGNATURE);
+
+      if (ProtNotify->Event == Event) {
+        RemoveEntryList(&ProtNotify->Link);
+        CoreFreePool(ProtNotify);
+        CoreReleaseProtocolLock ();
+        return EFI_SUCCESS;
+      }
+    }
+  }
+
+  CoreReleaseProtocolLock ();
+  return EFI_NOT_FOUND;
+}
+
+
+EFI_STATUS
+CoreUnregisterProtocolNotify (
+  IN EFI_EVENT      Event
+  )
+/*++
+
+Routine Description:
+
+  Removes all the events in the protocol database that match Event.
+
+Arguments:
+  
+  Event   - The event to search for in the protocol database.
+
+Returns:
+
+  EFI_SUCCESS when done searching the entire database.
+
+--*/
+{
+  EFI_STATUS       Status;
+
+  do {
+    Status = CoreUnregisterProtocolNotifyEvent (Event);
+  } while (!EFI_ERROR (Status));
+
+  return EFI_SUCCESS;
+}
+
+
+EFI_BOOTSERVICE
+EFI_STATUS
+EFIAPI
+CoreInstallProtocolInterface (
+  IN OUT EFI_HANDLE     *UserHandle,
+  IN EFI_GUID           *Protocol,
+  IN EFI_INTERFACE_TYPE InterfaceType,
+  IN VOID               *Interface
+  )
+/*++
+
+Routine Description:
+
+  Wrapper function to CoreInstallProtocolInterfaceNotify.  This is the public API which
+  Calls the private one which contains a BOOLEAN parameter for notifications
+
+Arguments:
+
+  UserHandle     - The handle to install the protocol handler on,
+                    or NULL if a new handle is to be allocated
+
+  Protocol       - The protocol to add to the handle
+
+  InterfaceType  - Indicates whether Interface is supplied in native form.
+
+  Interface      - The interface for the protocol being added
+
+Returns:
+
+  Status code    
+
+--*/
+{
+  return CoreInstallProtocolInterfaceNotify (
+            UserHandle, 
+            Protocol, 
+            InterfaceType, 
+            Interface, 
+            TRUE
+            );
+}
+
+EFI_STATUS
+CoreInstallProtocolInterfaceNotify (
+  IN OUT EFI_HANDLE     *UserHandle,
+  IN EFI_GUID           *Protocol,
+  IN EFI_INTERFACE_TYPE InterfaceType,
+  IN VOID               *Interface,
+  IN BOOLEAN            Notify
+  )
+/*++
+
+Routine Description:
+
+  Installs a protocol interface into the boot services environment.
+
+Arguments:
+
+  UserHandle     - The handle to install the protocol handler on,
+                   or NULL if a new handle is to be allocated
+
+  Protocol       - The protocol to add to the handle
+
+  InterfaceType  - Indicates whether Interface is supplied in native form.
+
+  Interface      - The interface for the protocol being added
+
+  Notify         - indicates whether notify the notification list 
+                   for this protocol
+
+Returns:
+
+  EFI_INVALID_PARAMETER     - Invalid parameter
+  
+  EFI_OUT_OF_RESOURCES       - No enough buffer to allocate
+  
+  EFI_SUCCESS               - Protocol interface successfully installed
+
+--*/
+{
+  PROTOCOL_INTERFACE  *Prot;
+  PROTOCOL_ENTRY      *ProtEntry;
+  IHANDLE             *Handle;
+  EFI_STATUS          Status;
+  VOID                *ExistingInterface;
+  
+  DEBUG_CODE (
+    UINTN             ErrorLevel;
+  )
+
+  //
+  // returns EFI_INVALID_PARAMETER if InterfaceType is invalid.
+  // Also added check for invalid UserHandle and Protocol pointers.
+  //
+  if (UserHandle == NULL || Protocol == NULL) {
+    return EFI_INVALID_PARAMETER;
+  }
+
+  if (InterfaceType != EFI_NATIVE_INTERFACE) {
+    return EFI_INVALID_PARAMETER;
+  }
+
+  //
+  // Print debug message
+  //
+  DEBUG_CODE (
+    if (EfiCompareGuid (Protocol, &gEfiLoadedImageProtocolGuid) ||
+        EfiCompareGuid (Protocol, &gEfiDebugMaskProtocolGuid)) {
+      //
+      // Print these protocols only at EFI_D_INFO level, for cleaner log.
+      // They are installed for every DXE driver.
+      //
+      ErrorLevel = EFI_D_INFO;
+    } else {
+      ErrorLevel = EFI_D_ERROR;
+    }
+    DEBUG ((ErrorLevel, "InstallProtocolInterface: %g %x\n", Protocol, Interface));
+  )
+  Status = EFI_OUT_OF_RESOURCES;
+  Prot = NULL;
+  Handle = NULL;
+
+  ASSERT (NULL != gBS);
+
+  if (*UserHandle != NULL_HANDLE) {
+    Status = CoreHandleProtocol (*UserHandle, Protocol, (VOID **)&ExistingInterface);
+    if (!EFI_ERROR (Status)) {
+      return EFI_INVALID_PARAMETER;
+    }
+  }
+
+  //
+  // Lock the protocol database 
+  //
+  CoreAcquireProtocolLock ();
+
+  //
+  // Lookup the Protocol Entry for the requested protocol
+  //
+  ProtEntry = CoreFindProtocolEntry (Protocol, TRUE);
+  if (ProtEntry == NULL) {
+    goto Done;
+  }
+
+  //
+  // Allocate a new protocol interface structure
+  //
+  Prot = CoreAllocateZeroBootServicesPool (sizeof(PROTOCOL_INTERFACE));
+  if (Prot == NULL) {
+    Status = EFI_OUT_OF_RESOURCES;
+    goto Done;
+  }
+
+  //
+  // If caller didn't supply a handle, allocate a new one
+  //
+  Handle = (IHANDLE *)*UserHandle;
+  if (Handle == NULL) {
+    Handle = CoreAllocateZeroBootServicesPool (sizeof(IHANDLE));
+    if (Handle == NULL) {
+      Status = EFI_OUT_OF_RESOURCES;
+      goto Done;
+    }
+
+    //
+    // Initialize new handler structure
+    //
+    Handle->Signature = EFI_HANDLE_SIGNATURE;
+    InitializeListHead (&Handle->Protocols);
+
+    //
+    // Initialize the Key to show that the handle has been created/modified
+    //
+    gHandleDatabaseKey++;
+    Handle->Key = gHandleDatabaseKey;
+
+    //
+    // Add this handle to the list global list of all handles
+    // in the system
+    //
+    InsertTailList (&gHandleList, &Handle->AllHandles);
+  } 
+
+  Status = CoreValidateHandle (Handle);
+  if (EFI_ERROR (Status)) {
+    goto Done;
+  }
+
+  //
+  // Each interface that is added must be unique
+  //
+  ASSERT (CoreFindProtocolInterface (Handle, Protocol, Interface) == NULL);
+
+  //
+  // Initialize the protocol interface structure
+  //
+  Prot->Signature = PROTOCOL_INTERFACE_SIGNATURE;
+  Prot->Handle = Handle;
+  Prot->Protocol = ProtEntry;
+  Prot->Interface = Interface;
+
+  //
+  // Initalize OpenProtocol Data base
+  //
+  InitializeListHead (&Prot->OpenList);
+  Prot->OpenListCount = 0;
+
+  //
+  // Add this protocol interface to the head of the supported 
+  // protocol list for this handle
+  //
+  InsertHeadList (&Handle->Protocols, &Prot->Link);
+
+  //
+  // Add this protocol interface to the tail of the 
+  // protocol entry
+  // 
+  InsertTailList (&ProtEntry->Protocols, &Prot->ByProtocol);
+
+  //
+  // Notify the notification list for this protocol 
+  //
+  if (Notify) {
+    CoreNotifyProtocolEntry (ProtEntry);
+  }
+  Status = EFI_SUCCESS;
+
+Done:
+  //
+  // Done, unlock the database and return
+  //
+  CoreReleaseProtocolLock ();
+  if (!EFI_ERROR (Status)) {
+    //
+    // Return the new handle back to the caller
+    //
+    *UserHandle = Handle;
+  } else {
+    //
+    // There was an error, clean up
+    //
+    if (Prot != NULL) {
+      CoreFreePool (Prot);
+    }
+  }
+
+  return Status;
+}
+
+
+EFI_BOOTSERVICE11
+EFI_STATUS
+EFIAPI
+CoreInstallMultipleProtocolInterfaces (
+  IN OUT EFI_HANDLE           *Handle,
+  ...
+  )
+/*++
+
+Routine Description:
+
+  Installs a list of protocol interface into the boot services environment.
+  This function calls InstallProtocolInterface() in a loop. If any error
+  occures all the protocols added by this function are removed. This is 
+  basically a lib function to save space.
+
+Arguments:
+
+  Handle      - The handle to install the protocol handlers on,
+                or NULL if a new handle is to be allocated
+  ...         - EFI_GUID followed by protocol instance. A NULL terminates the 
+                list. The pairs are the arguments to InstallProtocolInterface().
+                All the protocols are added to Handle.
+
+Returns:
+
+  EFI_INVALID_PARAMETER       - Handle is NULL.
+  
+  EFI_SUCCESS                 - Protocol interfaces successfully installed.
+
+--*/
+{
+  VA_LIST                   args;
+  EFI_STATUS                Status;
+  EFI_GUID                  *Protocol;
+  VOID                      *Interface;
+  EFI_TPL                   OldTpl;
+  UINTN                     Index;
+  EFI_HANDLE                OldHandle;
+  EFI_HANDLE                DeviceHandle;
+  EFI_DEVICE_PATH_PROTOCOL  *DevicePath;
+  
+  if (Handle == NULL) {
+    return EFI_INVALID_PARAMETER;
+  }
+  
+  //
+  // Syncronize with notifcations. 
+  // 
+  OldTpl = CoreRaiseTpl (EFI_TPL_NOTIFY);
+  OldHandle = *Handle;
+
+  //
+  // Check for duplicate device path and install the protocol interfaces
+  //
+  VA_START (args, Handle);
+  for (Index = 0, Status = EFI_SUCCESS; !EFI_ERROR (Status); Index++) {
+    //
+    // If protocol is NULL, then it's the end of the list
+    //
+    Protocol = VA_ARG (args, EFI_GUID *);
+    if (Protocol == NULL) {
+      break;
+    }
+
+    Interface = VA_ARG (args, VOID *);
+
+    //
+    // Make sure you are installing on top a device path that has already been added.
+    //
+    if (EfiCompareGuid (Protocol, &gEfiDevicePathProtocolGuid)) {
+      DeviceHandle = NULL;
+      DevicePath   = Interface;
+      Status = CoreLocateDevicePath (&gEfiDevicePathProtocolGuid, &DevicePath, &DeviceHandle);
+      if (!EFI_ERROR (Status) && (DeviceHandle != NULL_HANDLE) && IsDevicePathEnd(DevicePath)) {
+        Status = EFI_ALREADY_STARTED;
+        continue;
+      }
+    }
+  
+    //
+    // Install it
+    //
+    Status = CoreInstallProtocolInterface (Handle, Protocol, EFI_NATIVE_INTERFACE, Interface);
+  }
+  
+  //
+  // If there was an error, remove all the interfaces that were installed without any errors
+  //
+  if (EFI_ERROR (Status)) {
+    //
+    // Reset the va_arg back to the first argument.
+    //
+    VA_START (args, Handle);
+    for (; Index > 1; Index--) {
+      Protocol = VA_ARG (args, EFI_GUID *);
+      Interface = VA_ARG (args, VOID *);
+      CoreUninstallProtocolInterface (*Handle, Protocol, Interface);
+    }        
+    *Handle = OldHandle;
+  }
+
+  //
+  // Done
+  //
+  CoreRestoreTpl (OldTpl);
+  return Status;
+}
+
+EFI_STATUS
+CoreDisconnectControllersUsingProtocolInterface (
+  IN EFI_HANDLE           UserHandle,
+  IN PROTOCOL_INTERFACE   *Prot
+  )
+/*++
+
+Routine Description:
+
+  Attempts to disconnect all drivers that are using the protocol interface being queried.
+  If failed, reconnect all drivers disconnected.
+  
+  Note: This function doesn't do parameters checking, it's caller's responsibility 
+        to pass in valid parameters.
+
+Arguments:
+
+  UserHandle  - The handle on which the protocol is installed 
+  Prot        - The protocol to disconnect drivers from
+
+Returns:
+
+  EFI_SUCCESS       - Drivers using the protocol interface are all disconnected
+  EFI_ACCESS_DENIED - Failed to disconnect one or all of the drivers
+
+--*/
+{
+  EFI_STATUS            Status;
+  BOOLEAN               ItemFound;
+  EFI_LIST_ENTRY        *Link;
+  OPEN_PROTOCOL_DATA    *OpenData;
+
+  Status = EFI_SUCCESS;
+  
+  //
+  // Attempt to disconnect all drivers from this protocol interface
+  //
+  do {
+    ItemFound = FALSE;
+    for ( Link = Prot->OpenList.ForwardLink;
+          (Link != &Prot->OpenList) && !ItemFound;
+          Link = Link->ForwardLink ) {
+      OpenData = CR (Link, OPEN_PROTOCOL_DATA, Link, OPEN_PROTOCOL_DATA_SIGNATURE);
+      if (OpenData->Attributes & EFI_OPEN_PROTOCOL_BY_DRIVER) {
+        ItemFound = TRUE;
+        CoreReleaseProtocolLock ();
+        Status = CoreDisconnectController (UserHandle, OpenData->AgentHandle, NULL);
+        CoreAcquireProtocolLock ();
+        if (EFI_ERROR (Status)) {
+           ItemFound = FALSE;
+           break;
+        }
+      }
+    }
+  } while (ItemFound);
+
+  if (!EFI_ERROR (Status)) {
+    //
+    // Attempt to remove BY_HANDLE_PROTOOCL and GET_PROTOCOL and TEST_PROTOCOL Open List items
+    //
+    do {
+      ItemFound = FALSE;
+      for ( Link = Prot->OpenList.ForwardLink;
+            (Link != &Prot->OpenList) && !ItemFound;
+            Link = Link->ForwardLink ) {
+        OpenData = CR (Link, OPEN_PROTOCOL_DATA, Link, OPEN_PROTOCOL_DATA_SIGNATURE);
+        if (OpenData->Attributes & 
+            (EFI_OPEN_PROTOCOL_BY_HANDLE_PROTOCOL | EFI_OPEN_PROTOCOL_GET_PROTOCOL | EFI_OPEN_PROTOCOL_TEST_PROTOCOL)) {
+          ItemFound = TRUE;
+          RemoveEntryList (&OpenData->Link);  
+          Prot->OpenListCount--;
+          CoreFreePool (OpenData);
+        }
+      }
+    } while (ItemFound);
+  }
+
+  //
+  // If there are errors or still has open items in the list, then reconnect all the drivers and return an error
+  //
+  if (EFI_ERROR (Status) || (Prot->OpenListCount > 0)) {
+    CoreReleaseProtocolLock ();
+    CoreConnectController (UserHandle, NULL, NULL, TRUE);
+    CoreAcquireProtocolLock ();
+    Status = EFI_ACCESS_DENIED;
+  }
+
+  return Status;
+}
+
+EFI_BOOTSERVICE
+EFI_STATUS
+EFIAPI
+CoreUninstallProtocolInterface (
+  IN EFI_HANDLE       UserHandle,
+  IN EFI_GUID         *Protocol,
+  IN VOID             *Interface
+  )
+/*++
+
+Routine Description:
+
+  Uninstalls all instances of a protocol:interfacer from a handle. 
+  If the last protocol interface is remove from the handle, the 
+  handle is freed.
+
+Arguments:
+
+  UserHandle      - The handle to remove the protocol handler from
+
+  Protocol        - The protocol, of protocol:interface, to remove
+
+  Interface       - The interface, of protocol:interface, to remove
+
+Returns:
+
+  EFI_INVALID_PARAMETER       - Protocol is NULL.
+  
+  EFI_SUCCESS                 - Protocol interface successfully uninstalled.
+
+--*/
+{
+  EFI_STATUS            Status;
+  IHANDLE               *Handle;
+  PROTOCOL_INTERFACE    *Prot;
+
+  //
+  // Check that Protocol is valid
+  //
+  if (Protocol == NULL) {
+    return EFI_INVALID_PARAMETER;
+  }
+
+  //
+  // Check that UserHandle is a valid handle
+  //
+  Status = CoreValidateHandle (UserHandle);
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+
+  //
+  // Lock the protocol database
+  //
+  CoreAcquireProtocolLock ();
+
+  //
+  // Check that Protocol exists on UserHandle, and Interface matches the interface in the database
+  //
+  Prot = CoreFindProtocolInterface (UserHandle, Protocol, Interface);
+  if (Prot == NULL) {
+    Status = EFI_NOT_FOUND;
+    goto Done;
+  }
+
+  //
+  // Attempt to disconnect all drivers that are using the protocol interface that is about to be removed
+  //
+  Status = CoreDisconnectControllersUsingProtocolInterface (
+             UserHandle,
+             Prot
+             );
+  if (EFI_ERROR (Status)) {
+    //
+    // One or more drivers refused to release, so return the error
+    //
+    goto Done;
+  }
+
+  //
+  // Remove the protocol interface from the protocol
+  //
+  Status = EFI_NOT_FOUND;
+  Handle = (IHANDLE *)UserHandle;
+  Prot   = CoreRemoveInterfaceFromProtocol (Handle, Protocol, Interface);
+
+  if (Prot != NULL) {
+    //
+    // Update the Key to show that the handle has been created/modified
+    //
+    gHandleDatabaseKey++;
+    Handle->Key = gHandleDatabaseKey;
+    
+    //
+    // Remove the protocol interface from the handle
+    //
+    RemoveEntryList (&Prot->Link);
+
+    //
+    // Free the memory
+    //
+    Prot->Signature = 0;
+    CoreFreePool (Prot);
+    Status = EFI_SUCCESS;
+  }
+
+  //
+  // If there are no more handlers for the handle, free the handle
+  //
+  if (IsListEmpty (&Handle->Protocols)) {
+    Handle->Signature = 0;
+    RemoveEntryList (&Handle->AllHandles);
+    CoreFreePool (Handle);
+  }
+
+Done:  
+  //
+  // Done, unlock the database and return
+  //
+  CoreReleaseProtocolLock ();
+  return Status;
+}
+
+
+EFI_BOOTSERVICE11
+EFI_STATUS
+EFIAPI
+CoreUninstallMultipleProtocolInterfaces (
+  IN EFI_HANDLE           Handle,
+  ...
+  )
+/*++
+
+Routine Description:
+
+  Uninstalls a list of protocol interface in the boot services environment. 
+  This function calls UnisatllProtocolInterface() in a loop. This is 
+  basically a lib function to save space.
+
+Arguments:
+
+  Handle      - The handle to uninstall the protocol
+
+  ...         - EFI_GUID followed by protocol instance. A NULL terminates the 
+                list. The pairs are the arguments to UninstallProtocolInterface().
+                All the protocols are added to Handle.
+
+Returns:
+
+  Status code    
+
+--*/
+{
+  EFI_STATUS      Status;
+  VA_LIST         args;
+  EFI_GUID        *Protocol;
+  VOID            *Interface;
+  UINTN           Index;
+
+  VA_START (args, Handle);
+  for (Index = 0, Status = EFI_SUCCESS; !EFI_ERROR (Status); Index++) {
+    //
+    // If protocol is NULL, then it's the end of the list
+    //
+    Protocol = VA_ARG (args, EFI_GUID *);
+    if (Protocol == NULL) {
+      break;
+    }
+
+    Interface = VA_ARG (args, VOID *);
+
+    //
+    // Uninstall it
+    //
+    Status = CoreUninstallProtocolInterface (Handle, Protocol, Interface);
+  }
+
+  //
+  // If there was an error, add all the interfaces that were
+  // uninstalled without any errors
+  //
+  if (EFI_ERROR (Status)) {
+    //
+    // Reset the va_arg back to the first argument.
+    //
+    VA_START (args, Handle);
+    for (; Index > 1; Index--) {
+      Protocol = VA_ARG(args, EFI_GUID *);
+      Interface = VA_ARG(args, VOID *);
+      CoreInstallProtocolInterface (&Handle, Protocol, EFI_NATIVE_INTERFACE, Interface);
+    }        
+  }
+
+  return Status;
+}    
+
+PROTOCOL_INTERFACE  *
+CoreGetProtocolInterface (
+  IN  EFI_HANDLE                UserHandle,
+  IN  EFI_GUID                  *Protocol
+  )
+/*++
+
+Routine Description:
+
+  Locate a certain GUID protocol interface in a Handle's protocols.
+
+Arguments:
+
+  UserHandle  - The handle to obtain the protocol interface on
+
+  Protocol    - The GUID of the protocol 
+
+Returns:
+
+  The requested protocol interface for the handle
+  
+--*/  
+{
+  EFI_STATUS          Status;
+  PROTOCOL_ENTRY      *ProtEntry;
+  PROTOCOL_INTERFACE  *Prot;
+  IHANDLE             *Handle;
+  EFI_LIST_ENTRY      *Link;
+
+  Status = CoreValidateHandle (UserHandle);
+  if (EFI_ERROR (Status)) {
+    return NULL;
+  }
+  
+  Handle = (IHANDLE *)UserHandle;
+
+  //
+  // Look at each protocol interface for a match
+  //
+  for (Link = Handle->Protocols.ForwardLink; Link != &Handle->Protocols; Link = Link->ForwardLink) {
+    Prot = CR(Link, PROTOCOL_INTERFACE, Link, PROTOCOL_INTERFACE_SIGNATURE);
+    ProtEntry = Prot->Protocol;
+    if (EfiCompareGuid (&ProtEntry->ProtocolID, Protocol)) {
+      return Prot;
+    }
+  }
+  return NULL;
+}
+
+EFI_BOOTSERVICE
+EFI_STATUS
+EFIAPI
+CoreHandleProtocol (
+  IN EFI_HANDLE       UserHandle,
+  IN EFI_GUID         *Protocol,
+  OUT VOID            **Interface
+  )
+/*++
+
+Routine Description:
+
+  Queries a handle to determine if it supports a specified protocol.
+
+Arguments:
+
+  UserHandle  - The handle being queried.
+
+  Protocol    - The published unique identifier of the protocol.
+
+  Interface   - Supplies the address where a pointer to the corresponding Protocol
+               Interface is returned.
+
+Returns:
+
+  The requested protocol interface for the handle
+  
+--*/  
+{
+  return CoreOpenProtocol (
+          UserHandle,     
+          Protocol, 
+          Interface, 
+          gDxeCoreImageHandle, 
+          NULL,     
+          EFI_OPEN_PROTOCOL_BY_HANDLE_PROTOCOL
+          );
+}
+
+EFI_BOOTSERVICE11
+EFI_STATUS
+EFIAPI
+CoreOpenProtocol (
+  IN  EFI_HANDLE                UserHandle,
+  IN  EFI_GUID                  *Protocol,
+  OUT VOID                      **Interface OPTIONAL,
+  IN  EFI_HANDLE                ImageHandle,
+  IN  EFI_HANDLE                ControllerHandle,
+  IN  UINT32                    Attributes
+  )
+/*++
+
+Routine Description:
+
+  Locates the installed protocol handler for the handle, and
+  invokes it to obtain the protocol interface. Usage information
+  is registered in the protocol data base.
+
+Arguments:
+
+  UserHandle     - The handle to obtain the protocol interface on
+
+  Protocol       - The ID of the protocol 
+
+  Interface      - The location to return the protocol interface
+
+  ImageHandle       - The handle of the Image that is opening the protocol interface
+                    specified by Protocol and Interface.
+  
+  ControllerHandle  - The controller handle that is requiring this interface.
+
+  Attributes     - The open mode of the protocol interface specified by Handle
+                    and Protocol.
+
+Returns:
+
+  EFI_INVALID_PARAMETER       - Protocol is NULL.
+  
+  EFI_SUCCESS                 - Get the protocol interface.
+  
+--*/
+{
+  EFI_STATUS          Status;
+  PROTOCOL_INTERFACE  *Prot;
+  EFI_LIST_ENTRY      *Link;
+  OPEN_PROTOCOL_DATA  *OpenData;
+  BOOLEAN             ByDriver;
+  BOOLEAN             Exclusive;
+  BOOLEAN             Disconnect;
+  BOOLEAN             ExactMatch;
+
+  //
+  // Check for invalid Protocol
+  //
+  if (Protocol == NULL) {
+    return EFI_INVALID_PARAMETER;
+  }
+
+  //
+  // Check for invalid Interface
+  //
+  if (Attributes != EFI_OPEN_PROTOCOL_TEST_PROTOCOL) {
+    if (Interface == NULL) {
+      return EFI_INVALID_PARAMETER;
+    } else {
+      *Interface = NULL;
+    }
+  }
+  
+  //
+  // Check for invalid UserHandle
+  //
+  Status = CoreValidateHandle (UserHandle);
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+
+  //
+  // Check for invalid Attributes
+  //
+  switch (Attributes) {
+  case EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER :
+    Status = CoreValidateHandle (ImageHandle);
+    if (EFI_ERROR (Status)) {
+      return Status;
+    }
+    Status = CoreValidateHandle (ControllerHandle);
+    if (EFI_ERROR (Status)) {
+      return Status;
+    }
+    if (UserHandle == ControllerHandle) {
+      return EFI_INVALID_PARAMETER;
+    }
+    break;
+  case EFI_OPEN_PROTOCOL_BY_DRIVER :
+  case EFI_OPEN_PROTOCOL_BY_DRIVER | EFI_OPEN_PROTOCOL_EXCLUSIVE :
+    Status = CoreValidateHandle (ImageHandle);
+    if (EFI_ERROR (Status)) {
+      return Status;
+    }
+    Status = CoreValidateHandle (ControllerHandle);
+    if (EFI_ERROR (Status)) {
+      return Status;
+    }
+    break;
+  case EFI_OPEN_PROTOCOL_EXCLUSIVE :
+    Status = CoreValidateHandle (ImageHandle);
+    if (EFI_ERROR (Status)) {
+      return Status;
+    }
+    break;
+  case EFI_OPEN_PROTOCOL_BY_HANDLE_PROTOCOL :
+  case EFI_OPEN_PROTOCOL_GET_PROTOCOL :
+  case EFI_OPEN_PROTOCOL_TEST_PROTOCOL :
+    break;
+  default:
+    return EFI_INVALID_PARAMETER;
+  }
+
+  //
+  // Lock the protocol database
+  //
+  CoreAcquireProtocolLock ();
+
+  //
+  // Look at each protocol interface for a match
+  //
+  Prot = CoreGetProtocolInterface (UserHandle, Protocol);
+  if (Prot == NULL) {
+    Status = EFI_UNSUPPORTED;
+    goto Done;
+  }
+
+  //
+  // This is the protocol interface entry for this protocol
+  //    
+  if (Attributes != EFI_OPEN_PROTOCOL_TEST_PROTOCOL) {
+    *Interface = Prot->Interface;
+  }
+  Status = EFI_SUCCESS;
+
+  ByDriver        = FALSE;
+  Exclusive       = FALSE;
+  for ( Link = Prot->OpenList.ForwardLink; Link != &Prot->OpenList; Link = Link->ForwardLink) {
+    OpenData = CR (Link, OPEN_PROTOCOL_DATA, Link, OPEN_PROTOCOL_DATA_SIGNATURE);
+    ExactMatch =  (BOOLEAN)((OpenData->AgentHandle == ImageHandle) && 
+                            (OpenData->Attributes == Attributes)  &&
+                            (OpenData->ControllerHandle == ControllerHandle));
+    if (OpenData->Attributes & EFI_OPEN_PROTOCOL_BY_DRIVER) {
+      ByDriver = TRUE;
+      if (ExactMatch) {
+        Status = EFI_ALREADY_STARTED;
+        goto Done;
+      }
+    }
+    if (OpenData->Attributes & EFI_OPEN_PROTOCOL_EXCLUSIVE) {
+      Exclusive = TRUE;
+    } else if (ExactMatch) {
+      OpenData->OpenCount++;
+      Status = EFI_SUCCESS;
+      goto Done;
+    }
+  }
+
+  //
+  // ByDriver  TRUE  -> A driver is managing (UserHandle, Protocol)
+  // ByDriver  FALSE -> There are no drivers managing (UserHandle, Protocol)
+  // Exclusive TRUE  -> Something has exclusive access to (UserHandle, Protocol)
+  // Exclusive FALSE -> Nothing has exclusive access to (UserHandle, Protocol)
+  //
+
+  switch (Attributes) {
+  case EFI_OPEN_PROTOCOL_BY_DRIVER :
+    if (Exclusive || ByDriver) {
+      Status = EFI_ACCESS_DENIED;
+      goto Done;
+    }
+    break;
+  case EFI_OPEN_PROTOCOL_BY_DRIVER | EFI_OPEN_PROTOCOL_EXCLUSIVE :
+  case EFI_OPEN_PROTOCOL_EXCLUSIVE :
+    if (Exclusive) {
+      Status = EFI_ACCESS_DENIED;
+      goto Done;
+    }
+    if (ByDriver) {
+      do {
+        Disconnect = FALSE;
+        for ( Link = Prot->OpenList.ForwardLink; (Link != &Prot->OpenList) && (!Disconnect); Link = Link->ForwardLink) {
+          OpenData = CR (Link, OPEN_PROTOCOL_DATA, Link, OPEN_PROTOCOL_DATA_SIGNATURE);
+          if (OpenData->Attributes & EFI_OPEN_PROTOCOL_BY_DRIVER) {
+            Disconnect = TRUE;
+            CoreReleaseProtocolLock ();
+            Status = CoreDisconnectController (UserHandle, OpenData->AgentHandle, NULL);
+            CoreAcquireProtocolLock ();
+            if (EFI_ERROR (Status)) {
+              Status = EFI_ACCESS_DENIED;
+              goto Done;
+            }
+          }
+        }
+      } while (Disconnect);
+    } 
+    break;
+  case EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER :
+  case EFI_OPEN_PROTOCOL_BY_HANDLE_PROTOCOL :
+  case EFI_OPEN_PROTOCOL_GET_PROTOCOL :
+  case EFI_OPEN_PROTOCOL_TEST_PROTOCOL :
+    break;
+  }
+
+  if (ImageHandle == NULL) {
+    Status = EFI_SUCCESS;
+    goto Done;
+  }
+  //
+  // Create new entry
+  //
+  OpenData = CoreAllocateBootServicesPool (sizeof(OPEN_PROTOCOL_DATA));
+  if (OpenData == NULL) {
+    Status = EFI_OUT_OF_RESOURCES;
+  } else {
+    OpenData->Signature         = OPEN_PROTOCOL_DATA_SIGNATURE;
+    OpenData->AgentHandle       = ImageHandle;
+    OpenData->ControllerHandle  = ControllerHandle;
+    OpenData->Attributes        = Attributes;
+    OpenData->OpenCount         = 1;
+    InsertTailList (&Prot->OpenList, &OpenData->Link);
+    Prot->OpenListCount++;
+    Status = EFI_SUCCESS;
+  }
+
+Done:
+  //
+  // Done. Release the database lock are return
+  //
+  CoreReleaseProtocolLock ();
+  return Status;
+}
+
+EFI_BOOTSERVICE11
+EFI_STATUS
+EFIAPI
+CoreCloseProtocol (
+  IN  EFI_HANDLE                UserHandle,
+  IN  EFI_GUID                  *Protocol,
+  IN  EFI_HANDLE                AgentHandle,
+  IN  EFI_HANDLE                ControllerHandle  
+  )
+/*++
+
+Routine Description:
+
+  Closes a protocol on a handle that was opened using OpenProtocol().
+
+Arguments:
+
+  UserHandle       -  The handle for the protocol interface that was previously opened
+                      with OpenProtocol(), and is now being closed.
+  Protocol         -  The published unique identifier of the protocol. It is the caller¡¯s
+                      responsibility to pass in a valid GUID.
+  AgentHandle      -  The handle of the agent that is closing the protocol interface.
+  ControllerHandle -  If the agent that opened a protocol is a driver that follows the
+                      EFI Driver Model, then this parameter is the controller handle
+                      that required the protocol interface. If the agent does not follow
+                      the EFI Driver Model, then this parameter is optional and may be NULL.
+
+Returns:
+
+  EFI_SUCCESS             - The protocol instance was closed.
+  EFI_INVALID_PARAMETER   - Handle, AgentHandle or ControllerHandle is not a valid EFI_HANDLE. 
+  EFI_NOT_FOUND           - Can not find the specified protocol or AgentHandle.
+  
+--*/
+{
+  EFI_STATUS          Status;
+  PROTOCOL_INTERFACE  *ProtocolInterface;
+  EFI_LIST_ENTRY      *Link;
+  OPEN_PROTOCOL_DATA  *OpenData;
+
+  //
+  // Check for invalid parameters
+  //
+  Status = CoreValidateHandle (UserHandle);
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+  Status = CoreValidateHandle (AgentHandle);
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+  if (ControllerHandle != NULL_HANDLE) {
+    Status = CoreValidateHandle (ControllerHandle);
+    if (EFI_ERROR (Status)) {
+      return Status;
+    }
+  }
+  if (Protocol == NULL) {
+    return EFI_INVALID_PARAMETER;
+  }
+
+  //
+  // Lock the protocol database
+  //
+  CoreAcquireProtocolLock ();
+
+  //
+  // Look at each protocol interface for a match
+  //
+  Status = EFI_NOT_FOUND;
+  ProtocolInterface = CoreGetProtocolInterface (UserHandle, Protocol);
+  if (ProtocolInterface == NULL) {
+    goto Done;
+  }
+
+  //
+  // Walk the Open data base looking for AgentHandle
+  //
+  Link = ProtocolInterface->OpenList.ForwardLink;
+  while (Link != &ProtocolInterface->OpenList) {
+    OpenData = CR (Link, OPEN_PROTOCOL_DATA, Link, OPEN_PROTOCOL_DATA_SIGNATURE);
+    Link = Link->ForwardLink;
+    if ((OpenData->AgentHandle == AgentHandle) && (OpenData->ControllerHandle == ControllerHandle)) {
+        RemoveEntryList (&OpenData->Link);  
+        ProtocolInterface->OpenListCount--;
+        CoreFreePool (OpenData);
+        Status = EFI_SUCCESS;
+    }
+  }
+
+Done:
+  //
+  // Done. Release the database lock and return.
+  //
+  CoreReleaseProtocolLock ();
+  return Status;
+}
+
+
+EFI_BOOTSERVICE11
+EFI_STATUS
+EFIAPI
+CoreOpenProtocolInformation (
+  IN  EFI_HANDLE                          UserHandle,
+  IN  EFI_GUID                            *Protocol,
+  OUT EFI_OPEN_PROTOCOL_INFORMATION_ENTRY **EntryBuffer,
+  OUT UINTN                               *EntryCount
+  )
+/*++
+
+Routine Description:
+
+  Return information about Opened protocols in the system
+
+Arguments:
+
+  UserHandle  - The handle to close the protocol interface on
+
+  Protocol    - The ID of the protocol 
+
+  EntryBuffer - A pointer to a buffer of open protocol information in the form of
+                EFI_OPEN_PROTOCOL_INFORMATION_ENTRY structures.
+
+  EntryCount  - Number of EntryBuffer entries
+
+Returns:
+
+  
+--*/
+{
+  EFI_STATUS                          Status;
+  PROTOCOL_INTERFACE                  *ProtocolInterface;
+  EFI_LIST_ENTRY                      *Link;
+  OPEN_PROTOCOL_DATA                  *OpenData;
+  EFI_OPEN_PROTOCOL_INFORMATION_ENTRY *Buffer;
+  UINTN                               Count;
+  UINTN                               Size;
+
+  *EntryBuffer = NULL;
+  *EntryCount = 0;
+
+  //
+  // Lock the protocol database
+  //
+  CoreAcquireProtocolLock ();
+
+  //
+  // Look at each protocol interface for a match
+  //
+  Status = EFI_NOT_FOUND;
+  ProtocolInterface = CoreGetProtocolInterface (UserHandle, Protocol);
+  if (ProtocolInterface == NULL) {
+    goto Done;
+  }
+
+  //
+  // Count the number of Open Entries
+  //
+  for ( Link = ProtocolInterface->OpenList.ForwardLink, Count = 0; 
+        (Link != &ProtocolInterface->OpenList) ;
+        Link = Link->ForwardLink  ) {
+    Count++;
+  } 
+
+  ASSERT (Count == ProtocolInterface->OpenListCount);
+
+  if (Count == 0) {
+    Size = sizeof(EFI_OPEN_PROTOCOL_INFORMATION_ENTRY);
+  } else {
+    Size = Count * sizeof(EFI_OPEN_PROTOCOL_INFORMATION_ENTRY);
+  }
+
+  Buffer = CoreAllocateBootServicesPool (Size);
+  if (Buffer == NULL) {
+    Status = EFI_OUT_OF_RESOURCES;
+    goto Done;
+  }
+
+  Status = EFI_SUCCESS;
+  for ( Link = ProtocolInterface->OpenList.ForwardLink, Count = 0; 
+        (Link != &ProtocolInterface->OpenList);
+        Link = Link->ForwardLink, Count++  ) {
+    OpenData = CR (Link, OPEN_PROTOCOL_DATA, Link, OPEN_PROTOCOL_DATA_SIGNATURE);
+
+    Buffer[Count].AgentHandle      = OpenData->AgentHandle;
+    Buffer[Count].ControllerHandle = OpenData->ControllerHandle;
+    Buffer[Count].Attributes       = OpenData->Attributes;
+    Buffer[Count].OpenCount        = OpenData->OpenCount;
+  } 
+
+  *EntryBuffer = Buffer;
+  *EntryCount = Count;
+        
+Done:
+  //
+  // Done. Release the database lock are return
+  //
+  CoreReleaseProtocolLock ();
+  return Status;
+}
+
+
+EFI_BOOTSERVICE11
+EFI_STATUS
+EFIAPI
+CoreProtocolsPerHandle (
+  IN EFI_HANDLE       UserHandle,
+  OUT EFI_GUID        ***ProtocolBuffer,
+  OUT UINTN           *ProtocolBufferCount
+  )
+/*++
+
+Routine Description:
+
+  Retrieves the list of protocol interface GUIDs that are installed on a handle in a buffer allocated
+ from pool.
+
+Arguments:
+
+  UserHandle           - The handle from which to retrieve the list of protocol interface
+                          GUIDs.
+
+  ProtocolBuffer       - A pointer to the list of protocol interface GUID pointers that are
+                          installed on Handle.
+
+  ProtocolBufferCount  - A pointer to the number of GUID pointers present in
+                          ProtocolBuffer.
+
+Returns:
+  EFI_SUCCESS   -  The list of protocol interface GUIDs installed on Handle was returned in
+                   ProtocolBuffer. The number of protocol interface GUIDs was
+                   returned in ProtocolBufferCount.
+  EFI_INVALID_PARAMETER   -  Handle is NULL.
+  EFI_INVALID_PARAMETER   -  Handle is not a valid EFI_HANDLE.
+  EFI_INVALID_PARAMETER   -  ProtocolBuffer is NULL.
+  EFI_INVALID_PARAMETER   -  ProtocolBufferCount is NULL.
+  EFI_OUT_OF_RESOURCES    -  There is not enough pool memory to store the results.
+  
+--*/
+{
+  EFI_STATUS                          Status;
+  IHANDLE                             *Handle;
+  PROTOCOL_INTERFACE                  *Prot;
+  EFI_LIST_ENTRY                      *Link;
+  UINTN                               ProtocolCount;
+  EFI_GUID                            **Buffer;
+
+  Status = CoreValidateHandle (UserHandle);
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+
+  Handle = (IHANDLE *)UserHandle;
+
+  if (ProtocolBuffer == NULL) {
+    return EFI_INVALID_PARAMETER;
+  }
+
+  if (ProtocolBufferCount == NULL) {
+    return EFI_INVALID_PARAMETER;
+  }
+
+  *ProtocolBufferCount = 0;
+
+  ProtocolCount = 0;
+
+  CoreAcquireProtocolLock ();
+  
+  for (Link = Handle->Protocols.ForwardLink; Link != &Handle->Protocols; Link = Link->ForwardLink) {
+    ProtocolCount++;
+  }
+
+  //
+  // If there are no protocol interfaces installed on Handle, then Handle is not a valid EFI_HANDLE
+  //
+  if (ProtocolCount == 0) {
+    Status = EFI_INVALID_PARAMETER;
+    goto Done;
+  }
+
+  Buffer = CoreAllocateBootServicesPool (sizeof (EFI_GUID *) * ProtocolCount);
+  if (Buffer == NULL) {
+    Status = EFI_OUT_OF_RESOURCES;
+    goto Done;
+  }
+
+  *ProtocolBuffer = Buffer;
+  *ProtocolBufferCount = ProtocolCount;
+
+  for ( Link = Handle->Protocols.ForwardLink, ProtocolCount = 0;
+        Link != &Handle->Protocols; 
+        Link = Link->ForwardLink, ProtocolCount++) {
+    Prot = CR(Link, PROTOCOL_INTERFACE, Link, PROTOCOL_INTERFACE_SIGNATURE);
+    Buffer[ProtocolCount] = &(Prot->Protocol->ProtocolID);
+  }
+  Status = EFI_SUCCESS;
+
+Done:
+  CoreReleaseProtocolLock ();
+  return Status;
+}
+
+
+UINT64
+CoreGetHandleDatabaseKey (
+  VOID
+  )
+/*++
+
+Routine Description:
+
+  return handle database key.
+
+Arguments:
+
+  None
+  
+Returns:
+  
+  Handle database key.
+  
+--*/
+{
+  return gHandleDatabaseKey;
+}
+
+
+VOID
+CoreConnectHandlesByKey (
+  UINT64  Key
+  )
+/*++
+
+Routine Description:
+
+  Go connect any handles that were created or modified while a image executed.
+
+Arguments:
+
+  Key  -  The Key to show that the handle has been created/modified
+
+Returns:
+  
+  None
+--*/
+{
+  UINTN           Count;
+  EFI_LIST_ENTRY  *Link;
+  EFI_HANDLE      *HandleBuffer;
+  IHANDLE         *Handle;
+  UINTN           Index;
+
+  //
+  // Lock the protocol database
+  //
+  CoreAcquireProtocolLock ();
+
+  for (Link = gHandleList.ForwardLink, Count = 0; Link != &gHandleList; Link = Link->ForwardLink) {
+    Handle = CR (Link, IHANDLE, AllHandles, EFI_HANDLE_SIGNATURE);
+    if (Handle->Key > Key) {
+      Count++;
+    }
+  }
+
+  HandleBuffer = CoreAllocateBootServicesPool (Count * sizeof (EFI_HANDLE));
+  if (HandleBuffer == NULL) {
+    CoreReleaseProtocolLock ();
+    return;
+  }
+  
+  for (Link = gHandleList.ForwardLink, Count = 0; Link != &gHandleList; Link = Link->ForwardLink) {
+    Handle = CR (Link, IHANDLE, AllHandles, EFI_HANDLE_SIGNATURE);
+    if (Handle->Key > Key) {
+      HandleBuffer[Count++] = Handle;
+    }
+  }
+
+  //
+  // Unlock the protocol database
+  //
+  CoreReleaseProtocolLock ();
+
+  //
+  // Connect all handles whose Key value is greater than Key
+  //
+  for (Index = 0; Index < Count; Index++) {
+    CoreConnectController (HandleBuffer[Index], NULL, NULL, TRUE);
+  }
+  
+  CoreFreePool(HandleBuffer);
+}
diff --git a/EDK/Foundation/Core/Dxe/Hand/locate.c b/EDK/Foundation/Core/Dxe/Hand/locate.c
new file mode 100644
index 0000000..4cd41e4
--- /dev/null
+++ b/EDK/Foundation/Core/Dxe/Hand/locate.c
@@ -0,0 +1,743 @@
+/*++
+
+Copyright (c) 2004 - 2011, Intel Corporation                                                         
+All rights reserved. This program and the accompanying materials                          
+are licensed and made available under the terms and conditions of the BSD License         
+which accompanies this distribution.  The full text of the license may be found at        
+http://opensource.org/licenses/bsd-license.php                                            
+                                                                                          
+THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     
+WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             
+
+Module Name:
+
+  locate.c
+
+Abstract:
+
+  Locate handle functions    
+
+Revision History
+
+--*/
+
+#include "hand.h"
+
+//
+// ProtocolRequest - Last LocateHandle request ID
+//
+UINTN mEfiLocateHandleRequest = 0;
+
+//
+// Internal prototypes
+//
+
+typedef struct {
+  EFI_GUID        *Protocol;
+  VOID            *SearchKey;
+  EFI_LIST_ENTRY  *Position;
+  PROTOCOL_ENTRY  *ProtEntry;
+} LOCATE_POSITION;
+
+typedef 
+IHANDLE *
+(* CORE_GET_NEXT) (
+  IN OUT LOCATE_POSITION    *Position,
+  OUT VOID                  **Interface
+  );
+
+STATIC
+IHANDLE *
+CoreGetNextLocateAllHandles (
+  IN OUT LOCATE_POSITION    *Position,
+  OUT VOID                  **Interface
+  );
+
+STATIC
+IHANDLE *
+CoreGetNextLocateByRegisterNotify (
+  IN OUT LOCATE_POSITION    *Position,
+  OUT VOID                  **Interface
+  );
+
+STATIC
+IHANDLE *
+CoreGetNextLocateByProtocol (
+  IN OUT LOCATE_POSITION    *Position,
+  OUT VOID                  **Interface
+  );
+
+//
+//
+//
+
+
+
+EFI_BOOTSERVICE 
+EFI_STATUS
+EFIAPI
+CoreLocateHandle (
+  IN EFI_LOCATE_SEARCH_TYPE   SearchType,
+  IN EFI_GUID                 *Protocol   OPTIONAL,
+  IN VOID                     *SearchKey  OPTIONAL,
+  IN OUT UINTN                *BufferSize,
+  OUT EFI_HANDLE              *Buffer
+  )
+/*++
+
+Routine Description:
+
+  Locates the requested handle(s) and returns them in Buffer.
+
+Arguments:
+
+  SearchType  - The type of search to perform to locate the handles
+
+  Protocol    - The protocol to search for
+  
+  SearchKey   - Dependant on SearchType
+
+  BufferSize  - On input the size of Buffer.  On output the 
+                size of data returned.  
+
+  Buffer      - The buffer to return the results in
+
+
+Returns:
+
+  EFI_BUFFER_TOO_SMALL      - Buffer too small, required buffer size is returned in BufferSize.
+
+  EFI_INVALID_PARAMETER     - Invalid parameter
+  
+  EFI_SUCCESS               - Successfully found the requested handle(s) and returns them in Buffer.
+  
+--*/
+{
+  EFI_STATUS          Status;
+  LOCATE_POSITION     Position;
+  PROTOCOL_NOTIFY     *ProtNotify;
+  CORE_GET_NEXT       GetNext;
+  UINTN               ResultSize;
+  IHANDLE             *Handle;
+  IHANDLE             **ResultBuffer;
+  VOID                *Interface;
+ 
+  if (BufferSize == NULL) {
+    return EFI_INVALID_PARAMETER;
+  }
+  
+  if ((*BufferSize > 0) && (Buffer == NULL)) {
+    return EFI_INVALID_PARAMETER;
+  }
+  
+  GetNext = NULL;
+  //
+  // Set initial position
+  //
+
+  Position.Protocol  = Protocol;
+  Position.SearchKey = SearchKey;
+  Position.Position  = &gHandleList;
+
+  ResultSize = 0;
+  ResultBuffer = (IHANDLE **) Buffer;
+  Status = EFI_SUCCESS;
+
+  //
+  // Lock the protocol database
+  //
+  
+  CoreAcquireProtocolLock ();
+
+  //
+  // Get the search function based on type
+  //
+  switch (SearchType) {
+  case AllHandles:      
+    GetNext = CoreGetNextLocateAllHandles;       
+    break;
+
+  case ByRegisterNotify:    
+    //
+    // Must have SearchKey for locate ByRegisterNotify
+    //
+    if (SearchKey == NULL) {
+      Status = EFI_INVALID_PARAMETER;
+      break;
+    }
+    GetNext = CoreGetNextLocateByRegisterNotify;   
+    break;
+
+  case ByProtocol:      
+    GetNext = CoreGetNextLocateByProtocol;
+    if (Protocol == NULL) {
+      Status = EFI_INVALID_PARAMETER;
+      break;
+    }
+    //
+    // Look up the protocol entry and set the head pointer
+    //
+    Position.ProtEntry = CoreFindProtocolEntry (Protocol, FALSE);
+    if (Position.ProtEntry == NULL) {
+      Status = EFI_NOT_FOUND;
+      break;
+    }
+    Position.Position = &Position.ProtEntry->Protocols;
+    break;
+
+  default:
+    Status = EFI_INVALID_PARAMETER;
+    break;
+  }
+
+  if (EFI_ERROR(Status) || (GetNext == NULL)) {
+    CoreReleaseProtocolLock ();
+    return Status;
+  }
+
+  //
+  // Enumerate out the matching handles
+  //
+  mEfiLocateHandleRequest += 1;
+  for (; ;) {
+    //
+    // Get the next handle.  If no more handles, stop
+    //
+    Handle = GetNext (&Position, &Interface);
+    if (NULL == Handle) {
+      break;
+    }
+
+    //
+    // Increase the resulting buffer size, and if this handle
+    // fits return it
+    //
+    ResultSize += sizeof(Handle);
+    if (ResultSize <= *BufferSize) {
+        *ResultBuffer = Handle;
+        ResultBuffer += 1;
+    }
+  }
+
+  //
+  // If the result is a zero length buffer, then there were no
+  // matching handles
+  //
+  if (ResultSize == 0) {
+    Status = EFI_NOT_FOUND;
+  } else {
+    //
+    // Return the resulting buffer size.  If it's larger than what
+    // was passed, then set the error code
+    //
+    if (ResultSize > *BufferSize) {
+      Status = EFI_BUFFER_TOO_SMALL;
+    } 
+    
+    *BufferSize = ResultSize;
+
+    if (SearchType == ByRegisterNotify && !EFI_ERROR(Status)) {
+      //
+      // If this is a search by register notify and a handle was
+      // returned, update the register notification position
+      // 
+      ProtNotify = SearchKey;
+      ProtNotify->Position = ProtNotify->Position->ForwardLink;
+    }
+  }
+
+  CoreReleaseProtocolLock ();
+  return Status;
+}
+
+
+STATIC
+IHANDLE *
+CoreGetNextLocateAllHandles (
+  IN OUT LOCATE_POSITION    *Position,
+  OUT VOID                  **Interface
+  )
+/*++
+
+Routine Description:
+
+  Routine to get the next Handle, when you are searching for all handles.
+
+Arguments:
+
+  Position  - Information about which Handle to seach for.
+
+  Interface - Return the interface structure for the matching protocol.
+  
+Returns:
+  IHANDLE - An IHANDLE is returned if the next Position is not the end of the
+            list. A NULL_HANDLE is returned if it's the end of the list.
+  
+--*/
+{
+  IHANDLE     *Handle;
+
+  //
+  // Next handle
+  //
+  Position->Position = Position->Position->ForwardLink;
+
+  //
+  // If not at the end of the list, get the handle
+  //
+  Handle      = NULL_HANDLE;
+  *Interface  = NULL;
+  if (Position->Position != &gHandleList) {
+    Handle = CR (Position->Position, IHANDLE, AllHandles, EFI_HANDLE_SIGNATURE);
+  }
+
+  return Handle;
+}
+
+
+STATIC
+IHANDLE *
+CoreGetNextLocateByRegisterNotify (
+  IN OUT LOCATE_POSITION    *Position,
+  OUT VOID                  **Interface
+  )
+/*++
+
+Routine Description:
+
+  Routine to get the next Handle, when you are searching for register protocol 
+  notifies.
+
+Arguments:
+
+  Position  - Information about which Handle to seach for.
+
+  Interface - Return the interface structure for the matching protocol.
+  
+Returns:
+  IHANDLE - An IHANDLE is returned if the next Position is not the end of the
+            list. A NULL_HANDLE is returned if it's the end of the list.
+  
+--*/
+{
+  IHANDLE             *Handle;
+  PROTOCOL_NOTIFY     *ProtNotify;
+  PROTOCOL_INTERFACE  *Prot;
+  EFI_LIST_ENTRY      *Link;    
+
+  Handle      = NULL_HANDLE;
+  *Interface  = NULL;
+  ProtNotify = Position->SearchKey;
+
+  //
+  // If this is the first request, get the next handle
+  //
+  if (ProtNotify != NULL) {
+    ASSERT(ProtNotify->Signature == PROTOCOL_NOTIFY_SIGNATURE);
+    Position->SearchKey = NULL;
+
+    //
+    // If not at the end of the list, get the next handle
+    //
+    Link = ProtNotify->Position->ForwardLink;
+    if (Link != &ProtNotify->Protocol->Protocols) {
+      Prot = CR (Link, PROTOCOL_INTERFACE, ByProtocol, PROTOCOL_INTERFACE_SIGNATURE);
+      Handle = (IHANDLE *) Prot->Handle;
+      *Interface = Prot->Interface;
+    }  
+  }
+
+  return Handle;
+}
+
+
+STATIC
+IHANDLE *
+CoreGetNextLocateByProtocol (
+  IN OUT LOCATE_POSITION    *Position,
+  OUT VOID                  **Interface
+  )
+/*++
+
+Routine Description:
+
+  Routine to get the next Handle, when you are searching for a given protocol.
+
+Arguments:
+
+  Position  - Information about which Handle to seach for.
+
+  Interface - Return the interface structure for the matching protocol.
+  
+Returns:
+  IHANDLE - An IHANDLE is returned if the next Position is not the end of the
+            list. A NULL_HANDLE is returned if it's the end of the list.
+  
+--*/
+{
+  IHANDLE             *Handle;
+  EFI_LIST_ENTRY      *Link;
+  PROTOCOL_INTERFACE  *Prot;
+ 
+  Handle      = NULL_HANDLE;
+  *Interface  = NULL;
+  for (; ;) {
+    //
+    // Next entry
+    //
+    Link = Position->Position->ForwardLink;
+    Position->Position = Link;
+
+    //
+    // If not at the end, return the handle
+    //
+    if (Link == &Position->ProtEntry->Protocols) {
+      Handle = NULL_HANDLE;
+      break;
+    }
+
+    //
+    // Get the handle
+    //
+    Prot = CR(Link, PROTOCOL_INTERFACE, ByProtocol, PROTOCOL_INTERFACE_SIGNATURE);
+    Handle = (IHANDLE *) Prot->Handle;
+    *Interface = Prot->Interface;
+
+    //
+    // If this handle has not been returned this request, then 
+    // return it now
+    //
+    if (Handle->LocateRequest != mEfiLocateHandleRequest) {
+      Handle->LocateRequest = mEfiLocateHandleRequest;
+      break;
+    }
+  }
+
+  return Handle;
+}
+
+
+EFI_BOOTSERVICE
+EFI_STATUS
+EFIAPI
+CoreLocateDevicePath (
+  IN EFI_GUID                       *Protocol,
+  IN OUT EFI_DEVICE_PATH_PROTOCOL   **DevicePath,
+  OUT EFI_HANDLE                    *Device
+  )
+/*++
+
+Routine Description:
+
+  Locates the handle to a device on the device path that best matches the specified protocol.
+
+Arguments:
+
+  Protocol    - The protocol to search for.
+  DevicePath  - On input, a pointer to a pointer to the device path. On output, the device
+                  path pointer is modified to point to the remaining part of the devicepath.
+  Device      - A pointer to the returned device handle.              
+
+Returns:
+
+  EFI_SUCCESS           - The resulting handle was returned.
+  EFI_NOT_FOUND         - No handles matched the search.
+  EFI_INVALID_PARAMETER - One of the parameters has an invalid value.
+
+--*/
+{
+  INTN                        SourceSize;
+  INTN                        Size;
+  INTN                        BestMatch;
+  UINTN                       HandleCount;
+  UINTN                       Index;
+  EFI_STATUS                  Status;
+  EFI_HANDLE                  *Handles;
+  EFI_HANDLE                  Handle;
+  EFI_HANDLE                  BestDevice;
+  EFI_DEVICE_PATH_PROTOCOL    *SourcePath;
+  EFI_DEVICE_PATH_PROTOCOL    *TmpDevicePath;
+  
+  if (Protocol == NULL) {
+    return EFI_INVALID_PARAMETER;
+  }
+  
+  if ((DevicePath == NULL) || (*DevicePath == NULL)) {
+    return EFI_INVALID_PARAMETER;
+  }
+  
+  BestDevice = NULL;
+  SourcePath = *DevicePath;
+  TmpDevicePath = SourcePath;
+  while (!IsDevicePathEnd (TmpDevicePath)) {
+    if (EfiIsDevicePathEndInstance (TmpDevicePath)) {
+      //
+      // If DevicePath is a multi-instance device path,
+      // the function will operate on the first instance 
+      //
+      break;
+    }
+    TmpDevicePath = NextDevicePathNode (TmpDevicePath);
+  }
+
+  SourceSize = (UINTN) TmpDevicePath - (UINTN) SourcePath;
+
+  //
+  // Get a list of all handles that support the requested protocol
+  //
+  Status = CoreLocateHandleBuffer (ByProtocol, Protocol, NULL, &HandleCount, &Handles);
+  if (EFI_ERROR (Status) || HandleCount == 0) {
+    return EFI_NOT_FOUND;
+  }
+
+  BestMatch = -1;
+  for(Index = 0; Index < HandleCount; Index += 1) {
+    Handle = Handles[Index];
+    Status = CoreHandleProtocol (Handle, &gEfiDevicePathProtocolGuid, &TmpDevicePath);
+    if (EFI_ERROR (Status)) {
+      //
+      // If this handle doesn't support device path, then skip it
+      //
+      continue;
+    }
+
+    //
+    // Check if DevicePath is first part of SourcePath
+    //
+    Size = CoreDevicePathSize (TmpDevicePath) - sizeof(EFI_DEVICE_PATH_PROTOCOL);
+    if ((Size <= SourceSize) && EfiCompareMem (SourcePath, TmpDevicePath, Size) == 0) {
+      //
+      // If the size is equal to the best match, then we
+      // have a duplice device path for 2 different device
+      // handles
+      //
+      ASSERT (Size != BestMatch);
+      
+      //
+      // We've got a match, see if it's the best match so far
+      //
+      if (Size > BestMatch) {
+        BestMatch = Size;
+        BestDevice = Handle;
+      }
+    }
+  }
+
+  CoreFreePool (Handles);
+   
+  //
+  // If there wasn't any match, then no parts of the device path was found.  
+  // Which is strange since there is likely a "root level" device path in the system.
+  //
+  if (BestMatch == -1) {
+    return EFI_NOT_FOUND;
+  }
+
+  if (Device == NULL) {
+    return  EFI_INVALID_PARAMETER;
+  }
+  *Device = BestDevice;
+  
+  //
+  // Return the remaining part of the device path
+  //
+  *DevicePath = (EFI_DEVICE_PATH_PROTOCOL *) (((UINT8 *) SourcePath) + BestMatch);
+  return EFI_SUCCESS;
+}
+
+
+EFI_BOOTSERVICE11 
+EFI_STATUS
+EFIAPI
+CoreLocateProtocol (
+  IN  EFI_GUID  *Protocol,
+  IN  VOID      *Registration OPTIONAL,
+  OUT VOID      **Interface
+  )
+/*++
+
+Routine Description:
+
+  Return the first Protocol Interface that matches the Protocol GUID. If
+  Registration is pasased in return a Protocol Instance that was just add
+  to the system. If Retistration is NULL return the first Protocol Interface
+  you find.
+
+Arguments:
+
+  Protocol     - The protocol to search for
+  
+  Registration - Optional Registration Key returned from RegisterProtocolNotify() 
+
+  Interface    - Return the Protocol interface (instance).
+
+Returns:
+
+  EFI_SUCCESS - If a valid Interface is returned
+  
+  EFI_INVALID_PARAMETER       - Invalid parameter
+  
+  EFI_NOT_FOUND               - Protocol interface not found
+
+--*/
+{
+  EFI_STATUS              Status;
+  LOCATE_POSITION         Position;
+  PROTOCOL_NOTIFY         *ProtNotify;
+  IHANDLE                 *Handle;
+
+  if (Interface == NULL) {
+    return EFI_INVALID_PARAMETER;
+  }
+  
+  if (Protocol == NULL) {
+    return EFI_NOT_FOUND;
+  }
+  
+  *Interface = NULL;
+  Status = EFI_SUCCESS;
+
+  //
+  // Set initial position
+  //
+  Position.Protocol  = Protocol;
+  Position.SearchKey = Registration;
+  Position.Position  = &gHandleList;
+  
+  //
+  // Lock the protocol database
+  //
+  CoreAcquireProtocolLock ();
+
+  mEfiLocateHandleRequest += 1;
+
+  if (NULL == Registration) {
+    //
+    // Look up the protocol entry and set the head pointer
+    //
+    Position.ProtEntry = CoreFindProtocolEntry (Protocol, FALSE);
+    if (Position.ProtEntry == NULL) {
+      Status = EFI_NOT_FOUND;
+      goto Done;
+    }
+    Position.Position = &Position.ProtEntry->Protocols;
+
+    Handle = CoreGetNextLocateByProtocol (&Position, Interface);
+  } else {
+    Handle = CoreGetNextLocateByRegisterNotify (&Position, Interface);   
+  }
+
+  if (NULL == Handle) {
+    Status = EFI_NOT_FOUND;
+  } else if (NULL != Registration) {
+    //
+    // If this is a search by register notify and a handle was
+    // returned, update the register notification position
+    // 
+    ProtNotify = Registration;
+    ProtNotify->Position = ProtNotify->Position->ForwardLink;
+  }
+
+Done:
+  CoreReleaseProtocolLock ();
+  return Status;
+}
+
+
+EFI_BOOTSERVICE11 
+EFI_STATUS
+EFIAPI
+CoreLocateHandleBuffer (
+  IN EFI_LOCATE_SEARCH_TYPE       SearchType,
+  IN EFI_GUID                     *Protocol OPTIONAL,
+  IN VOID                         *SearchKey OPTIONAL,
+  IN OUT UINTN                    *NumberHandles,
+  OUT EFI_HANDLE                  **Buffer
+  )
+/*++
+
+Routine Description:
+
+  Function returns an array of handles that support the requested protocol 
+  in a buffer allocated from pool. This is a version of CoreLocateHandle()
+  that allocates a buffer for the caller.
+
+Arguments:
+
+  SearchType           - Specifies which handle(s) are to be returned.
+  Protocol             - Provides the protocol to search by.   
+                         This parameter is only valid for SearchType ByProtocol.
+  SearchKey            - Supplies the search key depending on the SearchType.
+  NumberHandles      - The number of handles returned in Buffer.
+  Buffer               - A pointer to the buffer to return the requested array of 
+                         handles that support Protocol.
+
+Returns:
+  
+  EFI_SUCCESS          - The result array of handles was returned.
+  EFI_NOT_FOUND        - No handles match the search. 
+  EFI_OUT_OF_RESOURCES - There is not enough pool memory to store the matching results.
+  EFI_INVALID_PARAMETER   - Invalid parameter
+
+--*/
+{
+  EFI_STATUS          Status;
+  UINTN               BufferSize;
+
+  if (NumberHandles == NULL) {
+    return EFI_INVALID_PARAMETER;
+  }
+
+  if (Buffer == NULL) {
+    return EFI_INVALID_PARAMETER;
+  }
+
+  BufferSize = 0;
+  *NumberHandles = 0;
+  *Buffer = NULL;
+  Status = CoreLocateHandle (
+             SearchType,
+             Protocol,
+             SearchKey,
+             &BufferSize,
+             *Buffer
+             );
+  //
+  // LocateHandleBuffer() returns incorrect status code if SearchType is
+  // invalid.
+  //
+  // Add code to correctly handle expected errors from CoreLocateHandle().
+  //
+  if (EFI_ERROR(Status)) {
+    switch (Status) {
+    case EFI_BUFFER_TOO_SMALL:
+      break;
+    case EFI_INVALID_PARAMETER:
+      return Status;
+    default:
+      return EFI_NOT_FOUND;
+    }
+  }
+
+  *Buffer = CoreAllocateBootServicesPool (BufferSize);
+  if (*Buffer == NULL) {
+    return EFI_OUT_OF_RESOURCES;
+  }
+
+  Status = CoreLocateHandle (
+             SearchType,
+             Protocol,
+             SearchKey,
+             &BufferSize,
+             *Buffer
+             );
+
+  *NumberHandles = BufferSize/sizeof(EFI_HANDLE);
+  if (EFI_ERROR(Status)) {
+    *NumberHandles = 0;
+  }
+
+  return Status;
+}
+
+