init. 1AQQW051HEADmaster

1 files changed, 1006 insertions, 0 deletions

diff --git a/Core/CORE_DXE/Partition/Partition.c b/Core/CORE_DXE/Partition/Partition.c
new file mode 100644
index 0000000..78cbb10
--- /dev/null
+++ b/Core/CORE_DXE/Partition/Partition.c
@@ -0,0 +1,1006 @@
+//**********************************************************************
+//**********************************************************************
+//**                                                                  **
+//**        (C)Copyright 1985-2011, American Megatrends, Inc.         **
+//**                                                                  **
+//**                       All Rights Reserved.                       **
+//**                                                                  **
+//**      5555 Oakbrook Parkway, Suite 200, Norcross, GA 30093        **
+//**                                                                  **
+//**                       Phone: (770)-246-8600                      **
+//**                                                                  **
+//**********************************************************************
+//**********************************************************************
+
+//**********************************************************************
+// $Header: /Alaska/SOURCE/Core/CORE_DXE/Partition/Partition.c 21    10/27/11 3:57p Artems $
+//
+// $Revision: 21 $
+//
+// $Date: 10/27/11 3:57p $
+//**********************************************************************
+// Revision History
+// ----------------
+// $Log: /Alaska/SOURCE/Core/CORE_DXE/Partition/Partition.c $
+// 
+// 21    10/27/11 3:57p Artems
+// EIP 73250: Verified DriverBinding Stop function frees all resources
+// allocated by Start function
+// 
+// 20    10/25/11 12:01p Artems
+// EIP 70530: Fixed bugs reported by SCT 2.3.1
+// 
+// 19    8/12/11 12:16p Artems
+// EIP 64107: Added changes for module to be compliant with UEFI
+// specification v 2.3.1
+// 
+// 18    5/02/11 5:58p Artems
+// EIP 59571: Extended partition driver functionality - support of BlockIO
+// protocol version 3
+// 
+// 17    2/05/11 3:52p Artems
+// Removed previous check-in changes
+// 
+// 16    1/06/11 5:59p Oleksiyy
+// [TAG]        EIP28607 
+// [Category]   Improvement
+// [Description]    System was hanging for some time if Floppy Media
+// removed while writing in meda in progress.
+// EFI_TPL_CALLBACK priority level rised during media related calls.
+// [Files]          DiskIo.c, Info.c, MediaAccess.c, Open.c, Partition.c
+// 
+// 15    2/04/10 3:06p Oleksiyy
+// EIP 31633 Minor fixes. OpenProtocol error status handling added to 
+// DriverBindingStop function. 
+// 
+// 14    8/28/09 9:10a Felixp
+// Component Name protocol implementation is upadted  to support both 
+// ComponentName and ComponentName2 protocols
+// (based on value of the EFI_SPECIFICATION_VERSION SDL token).
+// 
+// 13    7/09/09 5:01p Oleksiyy
+// Files clean-up
+//
+// 12    1/16/09 11:25a Felixp
+// Bug fix in the DriverBindingStop function.
+// The stop function was unconditionally closing disk I/O protocol.
+// The protocol should only be closed when no child devices exist.
+//
+// 11    1/07/08 4:21p Robert
+// Updated for coding standard
+//
+// 10    4/26/07 9:32a Robert
+// Updated for CHM and Coding Standard compliance
+//
+// 8     3/23/07 5:13p Robert
+// More coding standard changes and updated the copyright date
+//
+// 7     3/22/07 5:39p Robert
+// Updated Files for coding standard
+//
+// 6     10/10/06 3:43p Yakovlevs
+// Uncommented GPT Partition discovery
+//
+// 5     8/24/06 12:34p Felixp
+// x64 support (fixes for warnings/errors)
+//
+// 3     10/28/05 8:36p Felixp
+// DriverBindingSupported: Device Path test changed from BY_DRIVER to
+// TEST_PROTOCOL
+//
+// 2     2/08/05 12:50p Felixp
+// Bug fix in ReadBlocks and WriteBlocks: attemp to read/write
+// Last LBA on the partition returned EFI_INVALID_PARAMETER
+//
+//**********************************************************************
+//<AMI_FHDR_START>
+//
+// Name:    Partition.c
+//
+// Description: EFI Partition Generic Driver. Provides the Driver
+//      Binding protocol and a Block I/O protocol for Partition detection
+//      and interaction
+//
+//<AMI_FHDR_END>
+//**********************************************************************
+//;-------------------------------------------------------------------------
+// Includes
+#include "partition.h"
+
+
+//;-------------------------------------------------------------------------
+// Global Variables
+EFI_BOOT_SERVICES   *gBS;
+EFI_GUID    gUnusedPartitionGuid = EFI_PART_TYPE_UNUSED_GUID;
+static EFI_GUID gEfiDriverBindingProtocolGuid = EFI_DRIVER_BINDING_PROTOCOL_GUID;
+
+EFI_STATUS  gDevicePathStatus = EFI_SUCCESS;
+EFI_STATUS  gDiskIoStatus = EFI_SUCCESS;
+
+//;-------------------------------------------------------------------------
+//GUID Variables
+static EFI_GUID gDevicePathGuid = EFI_DEVICE_PATH_PROTOCOL_GUID;
+EFI_GUID    gBlockIoGuid    = EFI_BLOCK_IO_PROTOCOL_GUID;
+EFI_GUID    gDiskIoGuid     = EFI_DISK_IO_PROTOCOL_GUID;
+
+//;-------------------------------------------------------------------------
+// Function Prototypes
+EFI_STATUS DriverBindingSupported (
+    IN EFI_DRIVER_BINDING_PROTOCOL    *This,
+    IN EFI_HANDLE                     ControllerHandle,
+    IN EFI_DEVICE_PATH_PROTOCOL               *RemainingDevicePath  );
+
+EFI_STATUS EFIAPI DriverBindingStart (
+    IN EFI_DRIVER_BINDING_PROTOCOL    *This,
+    IN EFI_HANDLE                     ControllerHandle,
+    IN EFI_DEVICE_PATH_PROTOCOL               *RemainingDevicePath  );
+
+EFI_STATUS EFIAPI DriverBindingStop (
+    IN  EFI_DRIVER_BINDING_PROTOCOL   *This,
+    IN  EFI_HANDLE                    ControllerHandle,
+    IN  UINTN                         NumberOfChildren,
+    IN  EFI_HANDLE                    *ChildHandleBuffer);
+
+EFI_STATUS Reset (
+    IN EFI_BLOCK_IO_PROTOCOL  *This,
+    IN BOOLEAN        ExtendedVerification);
+
+EFI_STATUS ReadBlocks (
+    IN EFI_BLOCK_IO_PROTOCOL      *This,
+    IN UINT32                 MediaId,
+    IN EFI_LBA                Lba,
+    IN UINTN                  BufferSize,
+    OUT VOID                  *Buffer  );
+
+EFI_STATUS WriteBlocks (
+    IN EFI_BLOCK_IO_PROTOCOL          *This,
+    IN UINT32                 MediaId,
+    IN EFI_LBA                Lba,
+    IN UINTN                  BufferSize,
+    OUT VOID                  *Buffer );
+
+EFI_STATUS FlushBlocks ( IN EFI_BLOCK_IO_PROTOCOL  *PartBlockIo);
+
+//;-------------------------------------------------------------------------
+// Protocol Definition
+EFI_BLOCK_IO_PROTOCOL   mPartitionBlockIo =
+{
+    EFI_BLOCK_IO_PROTOCOL_REVISION3,
+    NULL,
+    Reset,
+    ReadBlocks,
+    WriteBlocks,
+    FlushBlocks
+};
+
+
+//;-------------------------------------------------------------------------
+// Partition Driver Binding Procol
+EFI_DRIVER_BINDING_PROTOCOL gPartitionDriverBinding =
+{
+    DriverBindingSupported,
+    DriverBindingStart,
+    DriverBindingStop,
+    0x10,
+    NULL,
+    NULL
+};
+
+
+//;-------------------------------------------------------------------------
+// Function Definitions
+#ifdef EFI_DEBUG
+#ifndef EFI_COMPONENT_NAME2_PROTOCOL_GUID //old Core
+#ifndef LANGUAGE_CODE_ENGLISH
+#define LANGUAGE_CODE_ENGLISH "eng"
+#endif
+static BOOLEAN LanguageCodesEqual(
+    CONST CHAR8* LangCode1, CONST CHAR8* LangCode2
+){
+    return    LangCode1[0]==LangCode2[0] 
+           && LangCode1[1]==LangCode2[1]
+           && LangCode1[2]==LangCode2[2];
+}
+static EFI_GUID gEfiComponentName2ProtocolGuid = EFI_COMPONENT_NAME_PROTOCOL_GUID;
+#endif
+//Driver Name
+static UINT16 *gDriverName=L"AMI Partition Driver";
+
+//<AMI_PHDR_START>
+//--------------------------------------------------------------------------
+//
+// Procedure:  ComponentNameGetControllerName
+//
+// Description: Retrieves a Unicode string that is the user readable name of
+//              the controller that is being managed by an EFI Driver.
+//
+// Input:
+//    This - A pointer to the EFI_COMPONENT_NAME_PROTOCOL
+//          instance.
+//    ControllerHandle - The handle of a controller that the driver specified
+//          by This is managing.  This handle specifies the controller whose
+//          name is to be returned.
+//    ChildHandle - The handle of the child controller to retrieve the name
+//          of.  This is an optional parameter that may be NULL.  It will be
+//          NULL for device drivers.  It will also be NULL for a bus drivers
+//          that wish to retrieve the name of the bus controller.  It will
+//          not be NULL for a bus driver that wishes to retrieve the name of
+//          a child controller.
+//    Language - A pointer to a three character ISO 639-2 language identifier.
+//          This is the language of the controller name that that the caller
+//          is requesting, and it must match one of the languages specified
+//          in Supported Languages.  The number of languages supported by a
+//          driver is up to the driver writer.
+//
+// Output:
+//    ControllerName - A pointer to the Unicode string to return.  This
+//          Unicode string is the name of the controller specified by
+//          ControllerHandle and ChildHandle in the language specified by
+//          Language from the point of view of thedriver specified by This.
+//
+// Returns:
+//    EFI_SUCCESS - The Unicode string for the user readable name in the
+//          language specified by Language for the driver specified by This
+//          was returned in DriverName.
+//    EFI_INVALID_PARAMETER - ControllerHandle is not a valid EFI_HANDLE.
+//    EFI_INVALID_PARAMETER - ChildHandle is not NULL and it is not a valid
+//                            EFI_HANDLE.
+//    EFI_INVALID_PARAMETER - Language is NULL.
+//    EFI_INVALID_PARAMETER - ControllerName is NULL.
+//    EFI_UNSUPPORTED - The driver specified by This is not currently
+//          managing the controller specified by ControllerHandle and
+//          ChildHandle.
+//    EFI_UNSUPPORTED - The driver specified by This does not support the
+//          language specified by Language.
+//
+// Referrals:
+//
+// Notes:
+//--------------------------------------------------------------------------
+//<AMI_PHDR_END>
+static EFI_STATUS ComponentNameGetControllerName (
+    IN  EFI_COMPONENT_NAME2_PROTOCOL  *This,
+    IN  EFI_HANDLE                   ControllerHandle,
+    IN  EFI_HANDLE                   ChildHandle        OPTIONAL,
+    IN  CHAR8                        *Language,
+    OUT CHAR16                       **ControllerName )
+{
+    return EFI_UNSUPPORTED;
+}
+
+//<AMI_PHDR_START>
+//--------------------------------------------------------------------------
+// Procedure: ComponentNameGetDriverName
+//
+// Description: Returns the Driver Name if the language is supported
+//
+// Input:
+//          This - Pointer to the instance of this driver
+//          Language - Current operating language
+//          DriverName - return parameter that will contain the Driver's Name
+//
+// Output: DriverName - return parameter that will contain the Driver's Name
+//
+// Returns:
+//      EFI_SUCCESS - Driver loaded
+//      EFI_INVALID_PARAMETER - If the Language or DriverName variable is
+//              not defined
+//      EFI_UNSUPPORTED - If the current laungage is not supported
+//
+// Referrals:
+//
+// Notes:
+//--------------------------------------------------------------------------
+//<AMI_PHDR_END>
+static EFI_STATUS ComponentNameGetDriverName(
+    IN  EFI_COMPONENT_NAME2_PROTOCOL  *This,
+    IN  CHAR8                        *Language,
+    OUT CHAR16                       **DriverName)
+{
+    //Supports only English
+    if (!Language || !DriverName) return EFI_INVALID_PARAMETER;
+    
+    if (!LanguageCodesEqual( Language, LANGUAGE_CODE_ENGLISH)) 
+        return EFI_UNSUPPORTED;
+    else 
+        *DriverName=gDriverName;
+    
+    return EFI_SUCCESS;
+}
+
+//Component Name Protocol
+static EFI_COMPONENT_NAME2_PROTOCOL gComponentName =
+{
+    ComponentNameGetDriverName,
+    ComponentNameGetControllerName,
+    LANGUAGE_CODE_ENGLISH
+};
+#endif
+
+
+//<AMI_PHDR_START>
+//--------------------------------------------------------------------------
+// Procedure: PartitionEntryPoint
+//
+// Description: Register Driver Binding protocol for this driver.
+//
+// Input:
+//      ImageHandle - Identification Handle for the Partition
+//              Block I/O driver
+//      *SystemTable - Pointer to the EFI System Table
+//
+// Returns:
+//      EFI_SUCCESS - Driver Binding Protocol Loaded
+//       other       - Driver Binding Protocol not loaded
+//
+// Referrals: InitAmiLib InstallMultipleProtocolInterfaces
+//--------------------------------------------------------------------------
+//<AMI_PHDR_END>
+EFI_STATUS PartitionEntryPoint (
+    IN EFI_HANDLE         ImageHandle,
+    IN EFI_SYSTEM_TABLE   *SystemTable
+)
+{
+    EFI_STATUS  Status;
+    
+    InitAmiLib(ImageHandle, SystemTable);
+    
+    gBS = SystemTable->BootServices;
+    
+    // initiaize the ImageHandle and DriverBindingHandle
+    gPartitionDriverBinding.DriverBindingHandle = NULL;
+    gPartitionDriverBinding.ImageHandle = ImageHandle;
+    
+    // Install driver binding protocol here
+    Status = gBS->InstallMultipleProtocolInterfaces (
+                 &gPartitionDriverBinding.DriverBindingHandle,
+                 &gEfiDriverBindingProtocolGuid,
+                 &gPartitionDriverBinding,
+#ifdef EFI_DEBUG
+                 &gEfiComponentName2ProtocolGuid, &gComponentName,
+#endif
+                 NULL);
+                 
+                 
+    return Status;
+}
+
+
+//<AMI_PHDR_START>
+//--------------------------------------------------------------------------
+// Procedure: DriverBindingSupported
+//
+// Description: Test to see if this driver supports ControllerHandle. Any
+//      ControllerHandle than contains a BlockIo and DiskIo protocol can be
+//      supported.
+//
+// Input:
+//    This                - Protocol instance pointer.
+//    ControllerHandle    - Handle of device to test
+//    RemainingDevicePath - Not used
+//
+// Output: None
+//
+// Returns:
+//    EFI_SUCCESS          - This driver supports this device
+//    EFI_ALREADY_STARTED - This driver is already running on this device
+//    other               - This driver does not support this device
+//
+// Referrals: OpenProtocol CloseProtocol
+//--------------------------------------------------------------------------
+//<AMI_PHDR_END>
+static EFI_STATUS DriverBindingSupported (
+    IN EFI_DRIVER_BINDING_PROTOCOL    *This,
+    IN EFI_HANDLE                     ControllerHandle,
+    IN EFI_DEVICE_PATH_PROTOCOL               *RemainingDevicePath
+)
+{
+    EFI_DISK_IO_PROTOCOL                    *DiskIo;
+    EFI_STATUS                  Status;
+    
+    // see if the DevicePath is installed on controllerHandle
+    Status = gBS->OpenProtocol(ControllerHandle, &gDevicePathGuid,
+                               NULL,   This->DriverBindingHandle,
+                               ControllerHandle, EFI_OPEN_PROTOCOL_TEST_PROTOCOL);
+                               
+    if (EFI_ERROR(Status))
+        return Status;
+        
+    // Close the Device Path Protocol once the tests have been done
+    gBS->CloseProtocol(ControllerHandle, &gDevicePathGuid,
+                       This->DriverBindingHandle, ControllerHandle);
+                       
+    // see if the DiskIo has already been started on controllerHandle
+    Status = gBS->OpenProtocol(ControllerHandle, &gDiskIoGuid,
+                               &DiskIo, This->DriverBindingHandle,
+                               ControllerHandle, EFI_OPEN_PROTOCOL_BY_DRIVER);
+                               
+    if (EFI_ERROR(Status))
+        return Status;
+        
+    // Close the DiskIo protocol once the tests have been done
+    gBS->CloseProtocol(ControllerHandle, &gDiskIoGuid,
+                       This->DriverBindingHandle, ControllerHandle);
+                       
+    // Now check for BlockIo Protocol
+    Status = gBS->OpenProtocol(ControllerHandle, &gBlockIoGuid,
+                               NULL, This->DriverBindingHandle, ControllerHandle,
+                               EFI_OPEN_PROTOCOL_TEST_PROTOCOL);
+                               
+    // return the status of finding the BlockIo protocol.
+    //  if it gets this far the driver supports this device
+    return Status;
+}
+
+
+//<AMI_PHDR_START>
+//--------------------------------------------------------------------------
+// Procedure: DriverBindingStart
+//
+// Description: Start this driver on ControllerHandle by opening a Block IO and
+//      Disk IO protocol, reading Device Path, and creating a child handle with
+//      a Disk IO and device path protocol.
+//
+// Input:
+//    This                - Protocol instance pointer.
+//    ControllerHandle    - Handle of device to bind driver to
+//    RemainingDevicePath - Not used
+//
+// Output: None
+//
+// Return:
+//    EFI_SUCCESS         - This driver is added to DeviceHandle
+//    other               - This driver does not support this device
+//
+// Referrals: OpenProtocol CloseProtocol GptDiscoverPartitions
+//      ElToritoCreateChildHandle MbrCreateChildHandle
+//
+//--------------------------------------------------------------------------
+//<AMI_PHDR_END>
+static EFI_STATUS EFIAPI DriverBindingStart (
+    IN EFI_DRIVER_BINDING_PROTOCOL    *This,
+    IN EFI_HANDLE                     ControllerHandle,
+    IN EFI_DEVICE_PATH_PROTOCOL               *RemainingDevicePath
+)
+{
+    EFI_DEVICE_PATH_PROTOCOL    *ParentDevicePath;
+    EFI_STATUS              Status;
+    EFI_BLOCK_IO_PROTOCOL           *BlockIo;
+    EFI_DISK_IO_PROTOCOL                *DiskIo;
+    
+    // Open the BlockIo protocol first because we are opening it by
+    //  GET_PROTOCOL, if this fails it does not need to be closed. It is
+    //  opened by GET_PROTOCOL because DiskIo already opens it BY_DRIVER
+    Status = gBS->OpenProtocol(ControllerHandle, &gBlockIoGuid,
+                               &BlockIo, This->DriverBindingHandle,
+                               ControllerHandle, EFI_OPEN_PROTOCOL_GET_PROTOCOL);
+                               
+    if (EFI_ERROR (Status))
+        return Status;
+        
+    Status = gBS->OpenProtocol(ControllerHandle, &gDevicePathGuid,
+                               &ParentDevicePath,  This->DriverBindingHandle,
+                               ControllerHandle, EFI_OPEN_PROTOCOL_GET_PROTOCOL);
+                               
+    if  (EFI_ERROR (Status))
+        return Status;
+        
+    // Check to see if the Controller has already been started by
+    //  another driver
+    // Now open the DiskIo protocol for the controller
+    Status = gBS->OpenProtocol(ControllerHandle, &gDiskIoGuid,
+                               &DiskIo, This->DriverBindingHandle,
+                               ControllerHandle, EFI_OPEN_PROTOCOL_BY_DRIVER);
+                               
+    if  (EFI_ERROR (Status))
+    {
+        // if there is an error, close all opened protocols, only close
+        //  this one if
+        // Close the Device Path protocol once the tests have been done
+        gBS->CloseProtocol(ControllerHandle, &gDevicePathGuid,
+                           This->DriverBindingHandle, ControllerHandle);
+                           
+        return Status;
+    }
+    
+    
+    // parse the devices and create the child   handles
+    if (BlockIo->Media->MediaPresent == TRUE)
+    {
+        Status = EFI_NOT_FOUND;
+        
+        // search for the children
+        Status = GptDiscoverPartitions(This, BlockIo, DiskIo,
+                                       ParentDevicePath, ControllerHandle);
+                                       
+        if (EFI_ERROR(Status))
+            Status = ElToritoCreateChildHandle(This, BlockIo, DiskIo,
+                                               ParentDevicePath, ControllerHandle);
+                                               
+        if (EFI_ERROR(Status))
+            Status = MbrCreateChildHandle(This, BlockIo, DiskIo,
+                                          ParentDevicePath, ControllerHandle);
+    }
+    
+    else
+        Status = EFI_NO_MEDIA;
+        
+        
+    // Now close all protocols  That were not already started
+    if (EFI_ERROR(Status) )
+    {
+        gBS->CloseProtocol(ControllerHandle, &gDevicePathGuid,
+                           This->DriverBindingHandle, ControllerHandle);
+                           
+        gBS->CloseProtocol(ControllerHandle, &gDiskIoGuid,
+                           This->DriverBindingHandle, ControllerHandle);
+    }
+    
+    return Status;
+}
+
+
+//<AMI_PHDR_START>
+//--------------------------------------------------------------------------
+// Procedure: DriverBindingStop
+//
+// Description: Stop this driver on ControllerHandle. Support stoping
+//      any child handles created by this driver.
+//
+// Input:
+//    This              - Protocol instance pointer.
+//    DeviceHandle      - Handle of device to stop driver on
+//    NumberOfChildren  - Number of Children in the ChildHandleBuffer
+//    ChildHandleBuffer - List of handles for the children we need to stop.
+//
+// Output: None
+//
+// Return:
+//    EFI_SUCCESS         - This driver is removed DeviceHandle
+//    other               - This driver was not removed from this device
+//
+// Referrals: CloseProtocol OpenProtocol FlushBlocks MemCmp FreePool
+//      UninstallMultipleProtocolInterfaces
+//
+//--------------------------------------------------------------------------
+//<AMI_PHDR_END>
+static EFI_STATUS EFIAPI DriverBindingStop  (
+    IN  EFI_DRIVER_BINDING_PROTOCOL   *This,
+    IN  EFI_HANDLE                    ControllerHandle,
+    IN  UINTN                         NumberOfChildren,
+    IN  EFI_HANDLE                    *ChildHandleBuffer
+)
+{
+
+    EFI_HANDLE  Handle = *ChildHandleBuffer;
+    PARTITION_DATA  *Child = NULL;
+    EFI_BLOCK_IO_PROTOCOL   *BlockIo;
+    EFI_GUID        *PartType = NULL;
+    BOOLEAN         ChildrenLeft = FALSE;
+    EFI_STATUS      Status;
+    UINTN           Idx = 0;
+    
+    
+    // Close these protocols if there are no children left
+    if (NumberOfChildren == 0)
+    {
+        gBS->CloseProtocol(ControllerHandle, &gDiskIoGuid,
+                           This->DriverBindingHandle, ControllerHandle);
+                           
+        return  EFI_SUCCESS;
+    }
+    
+    // There are children, uninstall protocols and uninstall interfaces,
+    //  and free memory
+    while (Idx < NumberOfChildren)
+    {
+        Status = gBS->OpenProtocol(ChildHandleBuffer[Idx], &gBlockIoGuid,
+                          (VOID **)&BlockIo, This->DriverBindingHandle,
+                          ControllerHandle, EFI_OPEN_PROTOCOL_GET_PROTOCOL);
+        if (EFI_ERROR(Status)) 
+        {
+            Idx++;
+            continue;
+        }
+                          
+        Child = (PARTITION_DATA *)BlockIo;
+        
+        // clear all buffers for the current device
+        BlockIo->FlushBlocks(BlockIo);
+        
+        // now close all handles
+        gBS->CloseProtocol(ControllerHandle, &gDiskIoGuid,
+                           This->DriverBindingHandle, ChildHandleBuffer[Idx]);
+                           
+        // look for a non 0 Partition type GUID
+        // if non zero, set the point to the address, otherwise leave pointer
+        //  as zero
+        if (MemCmp(&Child->PartGuid, &gUnusedPartitionGuid, sizeof(EFI_GUID)))
+            PartType = &Child->PartGuid;
+            
+        // Create the new handle for the child device
+        Status = gBS->UninstallMultipleProtocolInterfaces (
+                     ChildHandleBuffer[Idx],
+                     &gDevicePathGuid,   Child->DevPath,
+                     &gBlockIoGuid,      &Child->BlockIo,
+                     PartType,           NULL,
+                     NULL );
+                     
+        if (EFI_ERROR(Status))
+            ChildrenLeft = TRUE;
+            
+        // free the memory that was allocated for The Child handle and the
+        //  device path for the child handle
+
+
+        if (Child->DevPath != NULL)
+            gBS->FreePool(Child->DevPath);
+                
+        if (Child->BlockIo.Media != NULL)
+            gBS->FreePool(Child->BlockIo.Media);
+                
+        gBS->FreePool(Child);
+
+        
+        // Increment Child Handle Pointer
+        Idx++;
+        
+        // clear PartGuid pointer for the next child
+        PartType = NULL;
+    }
+    
+    // if there are childrem left, exit with error
+    if (ChildrenLeft == TRUE)
+        return EFI_DEVICE_ERROR;
+        
+    return EFI_SUCCESS;
+}
+
+
+//<AMI_PHDR_START>
+//--------------------------------------------------------------------------
+// Procedure: Reset
+//
+// Description: Reset the parent Block Device.
+//
+// Input:
+//    This                 - Protocol instance pointer.
+//    ExtendedVerification - Driver may perform diagnostics on reset.
+//
+// Output: None
+//
+// Return:
+//    EFI_SUCCESS            - The device was reset.
+//    EFI_DEVICE_ERROR      - The device is not functioning properly and could
+//                            not be reset.
+//
+// Referrals: ParentBlockIo->Reset
+//--------------------------------------------------------------------------
+//<AMI_PHDR_END>
+EFI_STATUS Reset (
+    IN EFI_BLOCK_IO_PROTOCOL      *This,
+    IN BOOLEAN            ExtendedVerification
+)
+{
+    PARTITION_DATA  *PartData;
+    
+    if (This == NULL)
+        return EFI_INVALID_PARAMETER;
+        
+    // Find the parent's BlockIo Protocol
+    PartData = (PARTITION_DATA *) This;
+    
+    return PartData->ParentBlockIo->Reset(PartData->ParentBlockIo,
+                                          ExtendedVerification);
+}
+
+
+//<AMI_PHDR_START>
+//--------------------------------------------------------------------------
+// Procedure: ReadBlocks
+//
+// Description: Reads blocks from the parent device
+//
+// Input:
+//    This       - Protocol instance pointer.
+//    MediaId    - Id of the media, changes every time the media is replaced.
+//    Lba        - The starting Logical Block Address to read from
+//    BufferSize - Size of Buffer, must be a multiple of device block size.
+//
+// Output:
+//    Buffer     - Buffer containing read data
+//
+// Return:
+//    EFI_SUCCESS           - The data was read correctly from the device.
+//    EFI_DEVICE_ERROR      - The device reported an error while performing the read.
+//    EFI_NO_MEDIA          - There is no media in the device.
+//    EFI_MEDIA_CHANGED     - The MediaId does not match the current device.
+//    EFI_BAD_BUFFER_SIZE   - The Buffer was not a multiple of the block size of the
+//                            device.
+//    EFI_INVALID_PARAMETER - The read request contains device addresses that are not
+//                            valid for the device.
+//
+// Referrals: Mul64 ReadDisk
+//
+//--------------------------------------------------------------------------
+//<AMI_PHDR_END>
+EFI_STATUS ReadBlocks ( IN EFI_BLOCK_IO_PROTOCOL  *This,
+                        IN UINT32     MediaId,
+                        IN EFI_LBA    Lba,
+                        IN UINTN    BufferSize,
+                        OUT VOID    *Buffer
+                      )
+{
+    PARTITION_DATA  *PartData;
+    EFI_DISK_IO_PROTOCOL        *DiskIo;
+    UINT64          Start;
+    
+    if (This == NULL)
+        return EFI_INVALID_PARAMETER;
+    
+    // Find the parent BlockIo Protocol
+    PartData = (PARTITION_DATA *) This;
+
+    if(MediaId != PartData->BlockIo.Media->MediaId)
+        return EFI_MEDIA_CHANGED;
+
+    if(BufferSize == 0)
+        return EFI_SUCCESS;
+    
+    if (BufferSize % PartData->BlockIo.Media->BlockSize != 0)
+        return EFI_BAD_BUFFER_SIZE;
+        
+    // calculate the byte from which to start the read
+    Start = (Mul64(PartData->StartingLba,
+                   PartData->ParentBlockIo->Media->BlockSize) +
+             Mul64(Lba, This->Media->BlockSize));
+             
+    // check to see if the read will go beyond the end of the
+    //  current partition
+    if ( ((Start + BufferSize - 1) >=
+            Mul64(PartData->EndingLba+1,
+                  PartData->ParentBlockIo->Media->BlockSize)) ||
+            (Buffer ==  NULL))
+        return EFI_INVALID_PARAMETER;
+        
+        
+    // Make call directly to DiskIo of  the device
+
+    DiskIo  = PartData->ParentDiskIo;
+    
+    return DiskIo->ReadDisk(DiskIo, MediaId, Start, BufferSize, Buffer);
+}
+
+
+//<AMI_PHDR_START>
+//--------------------------------------------------------------------------
+// Procedure: WriteBlocks
+//
+// Description: Write blocks to the parent device
+//
+// Input:
+//      This       - Protocol instance pointer.
+//      MediaId    - Id of the media, changes every time the media is replaced.
+//      Lba        - The starting Logical Block Address to read from
+//      BufferSize - Size of Buffer, must be a multiple of device block size.
+//      Buffer     - Buffer containing read data
+//
+// Output: None
+//
+// Return:
+//    EFI_SUCCESS           - The data was written correctly to the device.
+//    EFI_WRITE_PROTECTED   - The device can not be written to.
+//    EFI_DEVICE_ERROR      - The device reported an error while performing the write.
+//    EFI_NO_MEDIA          - There is no media in the device.
+//    EFI_MEDIA_CHANGED     - The MediaId does not match the current device.
+//    EFI_BAD_BUFFER_SIZE   - The Buffer was not a multiple of the block size of the
+//                            device.
+//    EFI_INVALID_PARAMETER - The write request contains a LBA that is not
+//                            valid for the device.
+//
+// Referrals: Mul64 WriteDisk
+//--------------------------------------------------------------------------
+//<AMI_PHDR_END>
+EFI_STATUS WriteBlocks (
+    IN EFI_BLOCK_IO_PROTOCOL  *This,
+    IN UINT32         MediaId,
+    IN EFI_LBA        Lba,
+    IN UINTN          BufferSize,
+    IN VOID           *Buffer
+)
+{
+    PARTITION_DATA  *PartData;
+    EFI_DISK_IO_PROTOCOL        *DiskIo;
+    UINT64          Start;
+
+    if (This == NULL)
+        return EFI_INVALID_PARAMETER;
+
+    // Find the parent BlockIo Protocol
+    PartData = (PARTITION_DATA *) This;
+
+    if(MediaId != PartData->BlockIo.Media->MediaId)
+        return EFI_MEDIA_CHANGED;
+    
+    if (BufferSize % PartData->BlockIo.Media->BlockSize != 0)
+        return EFI_BAD_BUFFER_SIZE;
+        
+    // calculated the start address of the write command
+    Start = Mul64(PartData->StartingLba,
+                  PartData->ParentBlockIo->Media->BlockSize) +
+            Mul64(Lba, This->Media->BlockSize);
+            
+    if ( ((Start + BufferSize - 1) >=
+            Mul64(PartData->EndingLba+1,
+                  PartData->ParentBlockIo->Media->BlockSize)) ||
+            (Buffer ==  NULL))
+        return EFI_INVALID_PARAMETER;
+        
+    DiskIo = PartData->ParentDiskIo;
+    
+    return DiskIo->WriteDisk(DiskIo, MediaId, Start, BufferSize, Buffer);
+}
+
+
+//<AMI_PHDR_START>
+//--------------------------------------------------------------------------
+// Procedure: FlushBlocks
+//
+// Description: Flush the parent Block Device.
+//
+// Input:  This - Protocol instance pointer.
+//
+// Output: None
+//
+// Return:
+//    EFI_SUCCESS       - All outstanding data was written to the device
+//    EFI_DEVICE_ERROR - The device reported an error while writing back
+//                      the data
+//    EFI_NO_MEDIA     - There is no media in the device.
+//
+// Referrals: ParentBlockIo->FlushBlocks
+//--------------------------------------------------------------------------
+//<AMI_PHDR_END>
+EFI_STATUS FlushBlocks (
+    IN EFI_BLOCK_IO_PROTOCOL  *This
+)
+{
+    PARTITION_DATA  *PartData;
+    
+    if (This == NULL)
+        return EFI_INVALID_PARAMETER;
+        
+    PartData = (PARTITION_DATA *) This;
+    
+    // return the same value that the device specific BlockIo instance returns
+    return PartData->ParentBlockIo->FlushBlocks(PartData->ParentBlockIo);
+}
+
+
+//<AMI_PHDR_START>
+//--------------------------------------------------------------------------
+// Procedure: CreateChildHandle
+//
+// Description: Generic create child handle for the partition driver.  This
+//      should work for GPT, MBR, and El Torito.
+//
+// Input:
+//      *This - Pointer to the current instance of the blockIo protocol
+//      *PData - a pointer to the start of the private data structure for
+//          the partition
+//      BlockSize - the blocksize for the partition
+//
+// Output:
+//
+// Return:
+//      EFI_SUCCESS - Child created
+//      other - no child created
+//
+// Referrals: AllocatePool FreePool CopyMem MemCmp Div64 OpenProtocol
+//    InstallMultipleProtocolInterfaces UninstallMultipleProtocolInterfaces
+//--------------------------------------------------------------------------
+//<AMI_PHDR_END>
+EFI_STATUS  CreateChildHandle(
+    IN  EFI_DRIVER_BINDING_PROTOCOL *This,
+    IN  PARTITION_DATA              *PData,
+    IN  UINT32                      BlockSize
+)
+{
+    PARTITION_DATA      *Child;
+    EFI_BLOCK_IO_MEDIA  *Media;
+    EFI_STATUS          Status;
+    EFI_GUID            *PartType = NULL;
+    UINTN               Temp;
+    
+    
+    // allocate memory for the Child handle
+    Status = gBS->AllocatePool(EfiBootServicesData, sizeof(PARTITION_DATA), &Child);
+    if (EFI_ERROR(Status))
+        return EFI_OUT_OF_RESOURCES;
+        
+    Status = gBS->AllocatePool(EfiBootServicesData, sizeof(EFI_BLOCK_IO_MEDIA), &Media);
+    if (EFI_ERROR(Status)) {
+        gBS->FreePool(Child);
+        return EFI_OUT_OF_RESOURCES;
+    }
+    
+    // Copy the data from one location to the other,
+    gBS->CopyMem(Child, PData, sizeof(PARTITION_DATA));
+    
+    // get the BlockIo protocol for the partition driver and the
+    //  media information from the parent device
+    gBS->CopyMem(&Child->BlockIo, &mPartitionBlockIo, sizeof(EFI_BLOCK_IO_PROTOCOL));
+                 
+    // just point to the media info for the device, that way we don't have to
+    // worry about changing values
+    Child->BlockIo.Media = Media;
+    
+    gBS->CopyMem(Media, PData->ParentBlockIo->Media, sizeof(EFI_BLOCK_IO_MEDIA));
+                 
+    Media->LogicalPartition = TRUE;
+    Media->BlockSize = BlockSize;
+    Media->IoAlign = 1;                             //no alignment requirements
+    Media->LowestAlignedLba = 0;                   //added in Revision 2
+    Media->LogicalBlocksPerPhysicalBlock = 0;      //added in Revision 2
+    Media->OptimalTransferLengthGranularity = 0;   //added in Revision 3
+    
+    // Calculate the last block of the partition
+    Media->LastBlock = Div64( Mul64(PData->EndingLba - PData->StartingLba + 1,
+                                    Child->ParentBlockIo->Media->BlockSize),
+                              BlockSize, &Temp) - 1;
+                              
+    // look for a non 0 Partition type GUID
+    // if non zero, set the point to the address, otherwise leave
+    //  pointer as zero
+    if (MemCmp(&Child->PartGuid, &gUnusedPartitionGuid, sizeof(EFI_GUID)))
+        PartType = &Child->PartGuid;
+        
+    // Create the new handle for the child device
+    Child->Handle = NULL;
+    Status = gBS->InstallMultipleProtocolInterfaces (
+                                    &Child->Handle,
+                                    &gDevicePathGuid, Child->DevPath,
+                                    &gBlockIoGuid, &Child->BlockIo,
+                                    PartType, NULL,
+                                    NULL );
+             
+    // Now open the diskIo protocol for the child, if the install multiple
+    //  protocol interface returns SUCCESS
+    if (!EFI_ERROR(Status)) {
+        Status = gBS->OpenProtocol ( Child->ParentHandle, 
+                                     &gDiskIoGuid,
+                                     &Child->ParentDiskIo, 
+                                     This->DriverBindingHandle,
+                                     Child->Handle, 
+                                     EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER );
+                                   
+        if (EFI_ERROR(Status)) {
+            Status = gBS->UninstallMultipleProtocolInterfaces (
+                                    &Child->Handle,
+                                    &gDevicePathGuid, Child->DevPath,
+                                    &gBlockIoGuid, &Child->BlockIo,
+                                    PartType, NULL,
+                                    NULL );
+        //free all resources
+            gBS->FreePool(Child->DevPath);
+            gBS->FreePool(Media);
+            gBS->FreePool(Child);
+        }
+    }
+    
+    return Status;
+}
+
+//**********************************************************************
+//**********************************************************************
+//**                                                                  **
+//**        (C)Copyright 1985-2011, American Megatrends, Inc.         **
+//**                                                                  **
+//**                       All Rights Reserved.                       **
+//**                                                                  **
+//**      5555 Oakbrook Parkway, Suite 200, Norcross, GA 30093        **
+//**                                                                  **
+//**                       Phone: (770)-246-8600                      **
+//**                                                                  **
+//**********************************************************************
+//**********************************************************************