//**********************************************************************
//**********************************************************************
//**                                                                  **
//**        (C)Copyright 1985-2012, American Megatrends, Inc.         **
//**                                                                  **
//**                       All Rights Reserved.                       **
//**                                                                  **
//**         5555 Oakbrook Pkwy, Suite 200, Norcross, GA 30093        **
//**                                                                  **
//**                       Phone: (770)-246-8600                      **
//**                                                                  **
//**********************************************************************
//**********************************************************************
// $Header: /Alaska/SOURCE/Core/Modules/IdeBus/IdeBus.c 65    8/16/12 3:01a Rajeshms $
//
// $Revision: 65 $
//
// $Date: 8/16/12 3:01a $
//**********************************************************************
// Revision History
// ----------------
// $Log: /Alaska/SOURCE/Core/Modules/IdeBus/IdeBus.c $
// 
// 65    8/16/12 3:01a Rajeshms
// [TAG]  		EIP97048 
// [Category]  	New Feature
// [Description]  	ATAPI PassThru Support using
// EFI_EXT_SCSI_PASS_THRU_PROTOCOL.
// [Files]  		AhciBus.c, AhciController.c, IdeBus.c, Atapi.c, PIDEBus.h,
// PAhciBus.h, ScsiPassThruAtapi.sdl, ScsiPassThruAtapi.mak,
// ScsiPassThruAtapi.c, ScsiPassThruAtapiSupport.h, ScsiPassThruAtapi.chm,
// ScsiPassThruExt.h
// 
// 64    8/16/12 2:25a Anandakrishnanl
// [TAG]  		EIP97113
// [Category]  	Improvement
// [Description]  	AtaPassThru - Module Enhancement
// [Files]  		AtaPassThru.c,
// AtaPassThruSupport.h,AtaPassThru.mak,IdeBus.c,AhciBus.c
// 
// 63    8/13/12 10:19a Artems
// [TAG]  		EIP97928
// [Category]  	Bug Fix
// [Severity]  	Important
// [Symptom]  	System doesn't detect drives in IDE mode
// [RootCause]  	Ide driver returns EFI_ERROR if AtaPassThru protocol is
// absent
// [Solution]  	Make driver to return EFI_SUCCESS as long as there are no
// IDE-related errors
// [Files]  		Idebus.c
// 
// 62    7/20/12 6:13a Anandakrishnanl
// [TAG]  		EIP88683
// [Category]  	New Feature
// [Description]  	EFI_ATA_PASS_THRU_PROTOCOL Support for Aptio IDE
// [Files]  		AhciBus.c
// AhciBus.h
// AInt13.h
// IdeBus.c
// IdeBus.h
// PIDEBus.h
// PAhciBus.h
// AtaPassThru.sdl
// AtaPassThru.mak	
// AtaPassThru.c	
// AtaPassThruSupport.h
// AtaPassThru.chm
// 
// 61    6/13/12 8:49a Anandakrishnanl
// [TAG]  		EIP92381
// [Category]  	Improvement
// [Description]  	A slip of pen in function IdeBusStart
// [Files]  		IdeBus.c
// 
// 60    12/05/11 6:12p Rajkumarkc
// [TAG]  		EIP77142 
// [Category]  	Improvement
// [Description]	Added the function 'IdeNonDataCommandExp' in the
// 'IDE_BUS_PROTOCOL' and removed
//               the existing function 'IdeNonDataCommand' for supporting
// the upper 24bits of LBA.
// [Files]
//     Ata.c
//     IdeBus.c
//     Idebus.h
//     PIDEBus.h
// 
// 59    11/16/11 12:35a Rameshr
// [TAG]  		EIP74970
// [Category]  	Improvement
// [Description]  	Generic GUID variables should be defined as static, or
// not used at all
// [Files]  		Idebus.c
// 
// 57    11/04/11 5:45a Rameshr
// [TAG]  		EIP73035
// [Category]  	Improvement
// [Description]  	Status used on line 2561, conditionally not set.
// Initilized to EFI_SUCCESS to avoid Junk values.
// [Files]  		Idebus.c
// 
// 56    11/03/11 6:07a Rajeshms
// [TAG]  		EIP73260
// [Category]  	Improvement
// [Description]  	IDE Driver Follow the UEFI Driver Model as per the UEFI
// Spec. and STOP function was Verified.
// [Files]  		IdeBus.c
// 
// 55    9/27/11 3:13a Rajeshms
// [TAG]  		EIP69295
// [Category]  	Improvement
// [Description]  	The Timeout values used by IDE and AHCI drivers are
// made as SDL tokens, so that the timeout values can be varied.
// [Files]  		IdeBusBoard.c, CORE_DXE.sdl, AhciSmm.h, AhciBus.h, IDESMM.h,
// Ata.c, Atapi.c, IdeBus.c, IdeBus.h, IdeBusMaster.c, IdeBusBoard.h
// 
// 54    8/22/11 2:56a Anandakrishnanl
// [TAG]  		EIP62912
// [Category]  	Improvement
// [Description]  	Opal Security Definitions Should be Moved to PIDEBUS.h
// from StorageSecurityProtocol.h
// StorageSecurityProtocol.h included in OPAL security driver module will
// give build error when disabled without sdl token #if
// OpalSecurity_SUPPORT properly placed in Ahcibus and IdeBus drivers. But
// Bus driver should not depend on any tokens. For this reason need to
// move OPAL_SEC_INIT_PROTOCOL_GUID in Pidebus.h
// [Files]  		IdeBus.c
// Pidebus.h
// OpalSecurity.cif
// OpalSecurity.h
// IdeOpalSec.c
// AhciOpalSec.c
// 
// 53    7/07/11 2:04a Lavanyap
// [TAG]  		EIP60503
// [Description]  	Added proper comment in InitAcousticSupport() function
// header
// [Files]  		IdeBus.c
// 
// 52    7/07/11 1:56a Lavanyap
// [TAG]  		EIP55207 
// [Category]  	Improvement
// [Description]  	Ide Bus Drive Component Name does not remove trailing
// spaces from drive name
// [Files]  		IdeBus.c
// 
// 51    6/13/11 1:27p Artems
// Made file build when OpalSecurity module is absent
// 
// 50    5/19/11 3:10a Anandakrishnanl
// [TAG]  		EIP53565
// [Category]  	New Feature
// [Description]  	UEFI2.3+ Specifications defines Storage Security
// protocol which needs to be implemented.
// [Files]  		AhciBus.c,IdeBus.c,AHCIOpalSec.c,IDEOpalSec.c,OpalSecurity.c
// ,OpalSecurity.chm,OpalSecurity.cif,OpalSecurity.h,OpalSecurity.mak,Opal
// Security.sdl,PIDEBus.h,StorageSecurityProtocol.CIF,StorageSecurityProto
// col.h
// 
// 49    5/02/11 12:38a Rameshr
// [TAG]- EIP 58703
// [Category]-IMPROVEMENT
// [Description]- Implement correct behavior when RemainingDevicePath
// passed to Supported() function consist only of end node, as described
// in UEFI specification Version 2.3.1, page 10.1
// EFI_DRIVER_BINDING_PROTOCOL.Supported() and Start() 
// [Files]- Idebus.c
// 
// 48    5/02/11 12:23a Rameshr
// [TAG]- EIP 58686
// [Category]-IMPROVEMENT
// [Description]- Update implementation of EFI_BLOCK_IO_PROTOCOL as
// described in UEFI specification Version 2.3.1, page 12.8
// [Files]- Idebus.c, Atapi.c
// 
// 47    4/12/11 4:05a Rameshr
// [TAG]- EIP 53710
// [Category]- New Feature
// [Description]- ATAPI ODD loading type information added into ATAPI
// device structure 
// [Files]- Atapi.c, Idebus.c, IdeBus.h 
// 
// 46    12/23/10 3:54a Lavanyap
// [TAG] - EIP41445
// [Category] - NEW FEATURE
// [Description] - Created SataPioDataOut and AtaPioDataOut protocol
// function that can accept additional input parameters.
// [Files] - AhciBus.h, AhciBus.c, AhciController.c, Ata.c, IdeBus.c,
//           IdeBus.h, IdeBusMaster.c,PAhciBus.h, PIdeBus.h
// 
// 45    9/24/10 2:43a Rameshr
// [TAG]- EIP 42817
// [Category]-IMPROVEMENT
// [Description]- Ide Smart checks HDDs for errors moved after Idebus
// Device path has been installed.
// [Files]- AhciBus.c, IdeBus.c
// 
// 44    8/25/10 4:16a Rameshr
// New Feature: EIP 37748
// Description: Move all the IDEBus Source driver SDL token into IdeBus
// Bin Driver.
// FilesModified: Ata.c, Atapi.c, idebus.c, IdeBus.h,
// IdebuscomponentName.c, IdeBusmaster.c IdeBusSrc.mak IdebusSrc.sdl
// IdeHpa.c, IdePowerManagement.c
// 
// 43    7/20/10 4:18p Pats
// EIP 38384: Sytem will get halt with the P-ATA to S-ATA transfer card on
// APTIO 4.6.4.
// Problem: Feature and Sector Count values are reversed in the invocation
// of IdeNonDataCommand to set DEV_CONFIG_FREEZE_LOCK.
// Solution: Fixed Feature and Sector Count values.
// 
// 42    5/26/10 6:02a Rameshr
// Checked the Device Configuration Overlay feature set supported status
// before sending the DEV_CONFIG_FREEZE_LOCK 
// EIP 38384
// 
// 41    4/16/10 4:05p Pats
// EIP 30719: Support for the HDD with sector size more than 512bytes.
// 
// 40    1/11/10 12:10p Krishnakumarg
// Update for Eip 11835 - To implement Acoustic Management function
// Eip 30041 - Aptio 4 Device Initiated Power Management (DipM) support
// for SATA devices
// 
// 39    9/04/09 3:29p Krishnakumarg
// Acoustic Management function updated to set acoustic level according to
// setup option EIP:11835
// CreateIdeDevicePath will now use EFI_OPEN_PROTOCOL_GET_PROTOCOL instead
// of EFI_OPEN_PROTOCOL_BY_DRIVER in openprotocol function.
// 
// 38    8/28/09 11:21a Felixp
// Component Name protocol implementation is upadted  to support both 
// ComponentName and ComponentName2 protocols
// (based on value of the EFI_SPECIFICATION_VERSION SDL token).
// 
// 37    7/01/09 12:23p Rameshr
// Coding Standard and File header updated.
//
// 36    6/22/09 11:38a Rameshr
// Odd Type information Saved in Atapi Device Structure.
// EIP:21548
//
// 35    5/01/09 11:01a Rameshr
// Symptom: Disconnect the IDE controller, make system to hang on debug
// mode
// Solution: IdeBlockIoDev pointer has wrong address, that make Freepool
// to hang the system. Corrected the IdeBlockIoDev address
//
// 34    4/28/09 7:17p Rameshr
// HDD password support in RAID mode
// EIP:20421
//
// 33    4/14/09 1:01p Rameshr
// When INTEL_IDE_PROTOCOL = 1, the IdeBus driver does not check if modes
// are valid in the SupportedModes data before assigning them to
// IdeBusInterface
// EIP 21195
//
// 32    11/02/09 11:16a Anandakrishnanl
// BUGFIX: Removed ASSERT Since AhciBus Driver presence may return Status
// Other than Success
//
// 31    12/31/08 3:07p Rameshraju
// BugFix- Validate the PIO mode before programming the PIO mode into the
// device EIP:17885
//
// 30    14/08/08 10:52a Anandakrishnanl
// Compatible Mode AHCI Support Added and Sdl Token Added in IdeBusSrc.sdl
//
// 29    8/06/08 10:37a Rameshraju
// Corrected problem in debug info print.
//
// 28    5/14/08 4:43p Rameshraju
// Error code added if error happens while configuring device or
// controller.
//
// 27    4/22/08 2:02p Felixp
// DXE_IDE_DETECT progress code moved from ATA.c to IdeBus.c
// DXE_IDE_ENABLE progress code added
//
// 26    3/27/08 11:21a Srinin
// CreateIdeDevicePath() modified to create a devicepath
// even if Remaining devicepath is not NULL.
//
// 25    7/03/08 5:45p Anandakrishnanl
// Added Smart related Changes since Smart is a seperate driver now and
// smart calls are now made protocol driven. Removed Sdl tokens that are
// used previously
//
// 24    3/06/08 5:20p Ambikas
//
// 23    3/06/08 4:41p Ambikas
//
// 22    3/04/08 7:51p Felixp
//
// 20    28/02/08 7:07p Anandakrishnanl
// Added HddSecurity Protocol to support security module as a separate
// driver.
//
// 19    10/23/07 4:17p Felixp
// IDE Security support moved from Sources to Binary
//
// 18    22/06/07 12:40p Anandakrishnanl
// HardDisk Security Support Module Added.
// Need ACPI Module and SB Module and under Core\Include we updated
// Setup.h.
// Also New IdeBus bin module.
//
// 17    5/04/07 12:53p Srinin
// In AHCI and RAID mode, PI reg is ignored. Always controller is in
// Native mode.
//
// 16    4/19/07 12:55p Felixp
//  - Minor bug fix: initialize block size by default with
// CDROM_BLOCK_SIZE for ATAPI devices (along with DiskIo.c changes
// resolves SCT failure)
//  - File reformatted to comply with AMI coding standards
//
// 13    4/16/07 6:29p Felixp
// Minor bug fix: initialize block size by default with CDROM_BLOCK_SIZE
// for ATAPI devices
//
// 12    13/04/07 3:01p Anandakrishnanl
// Ide Bus Module - Update source files to comply with AMI coding
// standard"!!!
//
// 11    12/19/06 6:12p Srinin
// Software setting Preserve bit set for SATA devices.
//
// 10    11/17/06 3:05p Ambikas
//
// 9     10/27/06 4:20p Felixp
// enable IDE interrupts at the exit boot services event handler
// (required to boot EFI vista)
//
// 8     8/09/06 3:34p Pavell
//
// 7     5/19/06 10:30p Felixp
// Device Path code updated to use NODE_LENGTH macros to remove direct
// access to the Length field
//
// 6     3/21/06 4:42p Srinin
// Build error Fixed.
//
// 5     3/13/06 2:20a Felixp
//
// 4     1/09/06 11:36a Felixp
//
// 2     12/14/05 3:04p Srinin
// CallBack added to support HDD password support during S3 Resume.
//
// 1     12/01/05 9:43a Felixp
//
// 16    11/03/05 10:55a Srinin
// For Busmaster transfer, Buffer should be DWORD aligned.
//
// 15    10/21/05 1:39p Srinin
// Removed Media detection for Atapi devices during Detection process.
//
// 14    8/22/05 4:31p Srinin
// ATA/ATAPI identification changed.
//
// 13    2/11/05 6:16p Felixp
// - Cleanup (duplication of library functions removed)
// - Code optimized by using DPAddNode instead of DPAdd
// - AllocatePool + ZeroMem replaced with MallocZ
//
// 12    2/01/05 12:58p Srinin
// IDE HotPlug Support added.
//
// 11    1/31/05 11:14a Srinin
// Fixed ComponentName display issue for IDE devices.
//
// 10    1/28/05 1:19p Felixp
// IdeBus is linked together with CORE_DXE
//
// 9     1/18/05 3:22p Felixp
// PrintDebugMessage renamed to Trace
//
// 8     1/13/05 4:23p Srinin
// Host Protection Area Support added.
//
// 7     1/11/05 2:26p Srinin
// IDE Power Management Support added.
//
// 5     1/10/05 11:29a Srinin
// SMART Support added.
//
// 4     1/05/05 3:55p Srinin
// Acoustic management Support added.
//
// 3     1/05/05 11:21a Srinin
// BusMaster and Password Support added.
//
// 2     12/21/04 4:57p Markw
// Modified device path defines for consistency.
//
// 1     12/10/04 1:01p Srinin
// Initial Checkin of IdeBus Driver.
//
//
//<AMI_FHDR_START>
//----------------------------------------------------------------------------
//
// Name: IdeBus.c
//
// Description:	Provides IDE Block IO protocol
//
//----------------------------------------------------------------------------
//<AMI_FHDR_END>


#include "IdeBus.h"
#include <Protocol\IdeBusBoard.h>

static EFI_GUID     gEfiIdeBusInitProtocolGuid      = IDE_BUS_INIT_PROTOCOL_GUID;
static EFI_GUID     gIdeBusDriverBindingProtocolGuid = EFI_DRIVER_BINDING_PROTOCOL_GUID;
static EFI_GUID     gEfiDiskInfoProtocolGuid        = EFI_DISK_INFO_PROTOCOL_GUID;
static EFI_GUID     gEfiIdeDiskInfoProtocolGuid     = EFI_DISK_INFO_IDE_INTERFACE_GUID;
static EFI_GUID     gIdeSetupProtocolguid           = IDE_SETUP_PROTOCOL_GUID;
static EFI_GUID     gEfiBootScriptSaveGuid          = EFI_BOOT_SCRIPT_SAVE_GUID;
static EFI_GUID     gDevicePathProtocolGuid         = EFI_DEVICE_PATH_PROTOCOL_GUID;
static EFI_GUID     gEfiBlockIoProtocolGuid         = EFI_BLOCK_IO_PROTOCOL_GUID;
static EFI_GUID     gHddSecurityInitProtocolGuid    = HDD_SECURITY_INIT_PROTOCOL_GUID;
static EFI_GUID     gHddSmartInitProtocolGuid       = HDD_SMART_INIT_PROTOCOL_GUID;
static EFI_GUID     gHddSecurityEndProtocolGuid     = HDD_SECURITY_END_PROTOCOL_GUID;
static EFI_GUID     gPlatformIdeProtocolGuid        = PLATFORM_IDE_PROTOCOL_GUID;
static EFI_GUID     gOpalSecInitProtocolGuid        = OPAL_SEC_INIT_PROTOCOL_GUID;
static EFI_GUID     gSMARTProtocolGuid              = IDE_SMART_INTERFACE_GUID;
static EFI_GUID     gAtaPassThruInitProtocolGuid    = ATA_PASS_THRU_INIT_PROTOCOL_GUID; 
static EFI_GUID     gScsiPassThruAtapiInitProtocolGuid = SCSI_PASS_THRU_ATAPI_INIT_PROTOCOL_GUID;

EFI_GUID            gSecurityModeProtocolGuid       = IDE_SECURITY_INTERFACE_GUID;
EFI_GUID            gPowerMgmtProtocolGuid          = IDE_POWER_MGMT_INTERFACE_GUID;
EFI_GUID            gHPAProtocolGuid                = IDE_HPA_INTERFACE_GUID;


EFI_EVENT                          gIDEBusEvtBootScript      = NULL;
EFI_EVENT                          gIDEBusEvtMiscSmmFeatures = NULL;

SCSI_PASS_THRU_ATAPI_INIT_PROTOCOL   *gScsiPassThruAtapiInitProtocol; 
ATA_PASS_THRU_INIT_PROTOCOL        *AtaPassThruInitProtocol;  
OPAL_SECURITY_INIT_PROTOCOL        *OpalSecInitProtocol;
HDD_SECURITY_INIT_PROTOCOL         *HddSecurityInitProtocol;
HDD_SMART_INIT_PROTOCOL            *HddSmartInitProtocol;
IDE_SETUP_PROTOCOL		           *gIdeSetupProtocol;
PLATFORM_IDE_PROTOCOL              *gPlatformIdeProtocol;

extern EFI_COMPONENT_NAME_PROTOCOL gIdeBusControllerDriverName;

//
// Instantiate PLATFORM_IDE_PROTOCOL with default SDL Token values 
//

PLATFORM_IDE_PROTOCOL        gPlatformIdeProtocolInstance = {
    2,                                       //Protocol Revision
    1,                                       //MasterSlaveEnumeration
    1,                                       //IdeBusMasterSupport
    1,                                       //AtapiBusMasterSupport
    1,                                       //AcousticManagementSupport
    0,                                       //IdePowerManagementSupport
    5,                                       //StandbyTimeout
    0,                                       //AdvPowerManagementSupport
    1,                                       //AdvPowerManagementLevel
    0,                                       //PowerupInStandbySupport
    0,                                       //PowerupInStandbyMode
    0,                                       //IdePwrManagementInterfaceSupport
    0,                                       //HostProtectedAreaSupport
    0,                                       //IdeHPSupport
    1,                                       //EfiIdeProtocol
    0,                                       //AhciCompatibleMode
    0,                                       //SBIdeSupport
    1,                                       //HddPowerLossInS3
    0,                                       //DiPMSupport
    0,                                       //DisableSoftSetPrev
    0,                                       //ForceHddPasswordPrompt
    EFI_IDE_CONTROLLER_INIT_PROTOCOL_GUID,   //gIdeControllerProtocolGuid
    EFI_COMPONENT_NAME_PROTOCOL_GUID,        //gComponentNameProtocolGuid
    10000,                                   //S3BusyClearTimeout
    5000,                                    //DmaAtaCompleteCommandTimeout
    16000,                                   //DmaAtaPiCompleteCommandTimeout
    5000,                                    //AtaPiResetCommandTimeout
    16000,                                   //AtaPiBusyClearTimeout
    10000                                    //PoweonBusyClearTimeout 
};

EFI_DRIVER_BINDING_PROTOCOL        gIdeBusDriverBinding = {
    IdeBusSupported,
    IdeBusStart,
    IdeBusStop,
    IDE_BUS_DRIVER_VERSION,  // version
    NULL,                    // ImageHandle
    NULL                     // DriverBindingHandle
};

// Global Buffer pointer used for Bus Mastering
VOID                               *gDescriptorBuffer = NULL;

VOID InitMiscConfig (
    IN IDE_BUS_PROTOCOL    *IdeBusInterface
);

//<AMI_PHDR_START>
//---------------------------------------------------------------------------
//
// Procedure:	IdeBusExitBootServices
//
// Description:	  Enables IDE controller interrupt on ExitBootServices
//
// Input:
//      Event   - The Event that is being processed
//      Context - Event Context
//
// Output: None
//
// Modified:
//
// Referrals:
//
// Notes:
//
//---------------------------------------------------------------------------
//<AMI_PHDR_END>
VOID EFIAPI IdeBusExitBootServices(
    IN EFI_EVENT Event,
    IN VOID      *Context )
{
    EFI_STATUS            Status;
    UINTN                 Count;
    EFI_HANDLE            Buffer[0x100];
    UINTN                 BufferSize = sizeof(Buffer);
    UINT8                 i;
    UINT8                 j;
    UINT8                 k;
    IDE_BUS_INIT_PROTOCOL *IdeBusInitProtocol;
    IDE_BUS_PROTOCOL      *pIdeBusProtocol;
    UINT64                IdeDevControlReg;
    UINT64                IdeDevReg;
    UINT8                 Data8 = 0;

    Status = pBS->LocateHandle(
        ByProtocol,
        &gEfiIdeBusInitProtocolGuid,
        NULL,
        &BufferSize,
        Buffer
        );

    if ( !EFI_ERROR( Status )) {
        Count = BufferSize / sizeof(EFI_HANDLE);

        for ( i = 0; i < Count; i++ )
        {
            Status = pBS->HandleProtocol( Buffer[i], &gEfiIdeBusInitProtocolGuid, &IdeBusInitProtocol );

            if ( !Status ) {
                for ( j = 0; j < 2; j++ )
                {
                    for ( k = 0; k < 2; k++ )
                    {
                        if ( IdeBusInitProtocol->pIdeBusProtocol[j][k] ) {
                            if ( IdeBusInitProtocol->IdeBusInitData[j][k] == DEVICE_CONFIGURED_SUCCESSFULLY ) {
                                pIdeBusProtocol = IdeBusInitProtocol->pIdeBusProtocol[j][k];

                                //
                                //Dev select
                                //  
                                Data8     = pIdeBusProtocol->IdeDevice.Device << 4;
                                IdeDevReg = (UINT64)pIdeBusProtocol->IdeDevice.Regs.CommandBlock.DeviceReg;
                                pIdeBusProtocol->PciIO->Io.Write(
                                    pIdeBusProtocol->PciIO,
                                    EfiPciIoWidthUint8,
                                    EFI_PCI_IO_PASS_THROUGH_BAR,
                                    IdeDevReg,
                                    1,
                                    &Data8
                                    );


                                Data8 = 0;
                                //  
                                //Enable IDE Controller interrupt
                                //
                                IdeDevControlReg = (UINT64)pIdeBusProtocol->IdeDevice.Regs.ControlBlock.AlternateStatusReg;
                                pIdeBusProtocol->PciIO->Io.Write(
                                    pIdeBusProtocol->PciIO,
                                    EfiPciIoWidthUint8,
                                    EFI_PCI_IO_PASS_THROUGH_BAR,
                                    IdeDevControlReg,
                                    1,
                                    &Data8
                                    );
                            }
                        }
                    }
                }
            }
        }
    }
}

//<AMI_PHDR_START>
//---------------------------------------------------------------------------
//
// Procedure:	IdeBusEntryPoint
//
// Description:	Installs gIdeBusDriverBinding protocol
//
// Input:
//	IN EFI_HANDLE        ImageHandle,
//	IN EFI_SYSTEM_TABLE  *SystemTable
//
// Output:
//	EFI_STATUS
//
// Modified:
//
// Referrals: InitAmiLib InstallMultipleProtocolInterfaces
//
// Notes:
//  Here is the control flow of this function:
//  1. Initialize Ami Lib.
//	2. Install Driver Binding Protocol
//  3. Return EFI_SUCCESS.
//---------------------------------------------------------------------------
//<AMI_PHDR_END>
EFI_STATUS IdeBusEntryPoint(
    IN EFI_HANDLE       ImageHandle,
    IN EFI_SYSTEM_TABLE *SystemTable )
{
    EFI_STATUS Status;
    EFI_EVENT  ExitBootServicesNotifyEvent;

    gIdeBusDriverBinding.DriverBindingHandle = NULL;
    gIdeBusDriverBinding.ImageHandle         = ImageHandle;

    InitAmiLib( ImageHandle, SystemTable );
    //
    //Register our ExitBootServices () callback function
    //  
    Status = pBS->CreateEvent(
        EFI_EVENT_SIGNAL_EXIT_BOOT_SERVICES,
        TPL_CALLBACK,
        IdeBusExitBootServices,
        NULL,
        &ExitBootServicesNotifyEvent
        );
    ASSERT_EFI_ERROR( Status );

    Status = pBS->LocateProtocol(
                    &gPlatformIdeProtocolGuid,
                    NULL,
                    &gPlatformIdeProtocol
                    );
    if (EFI_ERROR (Status)) {
        //
        // if EFI_ERROR then Assign Default values Instance to gPlatformIdeProtocol.
        //
        gPlatformIdeProtocol = (PLATFORM_IDE_PROTOCOL *)&gPlatformIdeProtocolInstance;
    }
    //
    // Assert when PLATFORM_IDE_PROTOCOL's revision is not supported 
    //
    ASSERT(!(gPlatformIdeProtocol->Revision > PLATFORM_IDE_PROTOCOL_SUPPORTED_REVISION))

    Status = pBS->InstallMultipleProtocolInterfaces(
        &gIdeBusDriverBinding.DriverBindingHandle,
        &gIdeBusDriverBindingProtocolGuid, &gIdeBusDriverBinding,
        &(gPlatformIdeProtocol->gComponentNameProtocolGuid), &gIdeBusControllerDriverName,
        NULL
        );

#ifdef Debug_Level_1
    EfiDebugPrint( -1, "IdeBusEntryPoint Exit Status %x\n", Status );
#endif

    return Status;
}

//<AMI_PHDR_START>
//---------------------------------------------------------------------------
//
// Procedure:	IdeBusSupported
//
// Description:	Checks whether IDE_PROTOCOL_INTERFACE is installed on the controller.
//				If 'yes', return SUCCESS else ERROR
//
// Input:
//	IN EFI_DRIVER_BINDING_PROTOCOL    *This,
//	IN EFI_HANDLE                     Controller,
//	IN EFI_DEVICE_PATH_PROTOCOL       *RemainingDevicePath
//
// Output:
//	EFI_STATUS
//
// Modified:
//
// Referrals: OpenProtocol CloseProtocol
//
// Notes:
//  Here is the control flow of this function:
// 1. If Devicepath is NULL, check "gEfiIdeControllerProtocolGuid" is installed by IdeController device driver,
// if yes, it is the IDE controller that this Bus will manage. Then return Success.
// 2. If Devicepath is valid, check if "gEfiIdeBusInitProtocolGuid" is already installed by this BUS driver,
// if yes, check whether it is OK to configure this device. if not installed goto step 1.
//
//---------------------------------------------------------------------------
//<AMI_PHDR_END>
EFI_STATUS IdeBusSupported(
    IN EFI_DRIVER_BINDING_PROTOCOL *This,
    IN EFI_HANDLE                  Controller,
    IN EFI_DEVICE_PATH_PROTOCOL    *RemainingDevicePath )
{
    EFI_STATUS                       Status;

    VOID                             *IdeControllerInterface = NULL ;
    ATAPI_DEVICE_PATH                *AtapiRemainingDevicePath = (ATAPI_DEVICE_PATH*) RemainingDevicePath;
    IDE_BUS_INIT_PROTOCOL            *IdeBusInitInterface;
    EFI_PCI_IO_PROTOCOL              *PciIO;
    UINT8 PciConfig[256];

#ifdef Debug_Level_1
    EfiDebugPrint( -1, "IdeBusSupported Entry\n" );
#endif

    //
    //Check for Valid ATAPI Device Path. If no return UNSUPPORTED
    //
    if ( !(AtapiRemainingDevicePath == NULL)) {

        //
        // RemainingDevicePath is not NULL and begins with the End of Device Path node, 
        // then the driver must not enumerate any of the children of Controller nor create any child device handle. 
        // Only the controller initialization should be performed. UEFI specification V 2.3.1, P. 10.1
        //
        if(isEndNode(RemainingDevicePath)) {
            return EFI_SUCCESS;
        }

        //
        // Check if the AtapiRemainingDevicePath is valid 8.3.4.1
        //
        if ( AtapiRemainingDevicePath->Header.Type != MESSAGING_DEVICE_PATH
             || AtapiRemainingDevicePath->Header.SubType != MSG_ATAPI_DP
             && NODE_LENGTH( &AtapiRemainingDevicePath->Header ) != ATAPI_DEVICE_PATH_LENGTH ) {
#ifdef Debug_Level_3
            EfiDebugPrint( -1, "AtapiRemainingDevicePath not Valid\n" );
#endif
            return EFI_UNSUPPORTED;
        }

        //
        //Now check whether it is OK to enumerate the specified device.
        //
        Status = pBS->OpenProtocol( Controller,
                                    &gEfiIdeBusInitProtocolGuid,
                                    (VOID**)&IdeBusInitInterface,
                                    This->DriverBindingHandle,
                                    Controller,
                                    EFI_OPEN_PROTOCOL_BY_DRIVER );

        if ( Status == EFI_SUCCESS || Status == EFI_ALREADY_STARTED ) {
            pBS->CloseProtocol(
                Controller,
                &gEfiIdeBusInitProtocolGuid,
                This->DriverBindingHandle,
                Controller
                );

            if ( AtapiRemainingDevicePath->PrimarySecondary == PRIMARY_CHANNEL && AtapiRemainingDevicePath->SlaveMaster == MASTER_DRIVE ) {
                if ( IdeBusInitInterface->IdeBusInitData[PRIMARY_CHANNEL][MASTER_DRIVE] >= DEVICE_DETECTION_FAILED ) {
                    return EFI_ALREADY_STARTED;
                }
            }

            if ( AtapiRemainingDevicePath->PrimarySecondary == PRIMARY_CHANNEL && AtapiRemainingDevicePath->SlaveMaster == SLAVE_DRIVE ) {
                if ( IdeBusInitInterface->IdeBusInitData[PRIMARY_CHANNEL][SLAVE_DRIVE] >= DEVICE_DETECTION_FAILED ) {
                    return EFI_ALREADY_STARTED;
                }
            }

            if ( AtapiRemainingDevicePath->PrimarySecondary == SECONDARY_CHANNEL && AtapiRemainingDevicePath->SlaveMaster == MASTER_DRIVE ) {
                if ( IdeBusInitInterface->IdeBusInitData[SECONDARY_CHANNEL][MASTER_DRIVE] >= DEVICE_DETECTION_FAILED ) {
                    return EFI_ALREADY_STARTED;
                }
            }

            if ( AtapiRemainingDevicePath->PrimarySecondary == SECONDARY_CHANNEL && AtapiRemainingDevicePath->SlaveMaster == SLAVE_DRIVE ) {
                if ( IdeBusInitInterface->IdeBusInitData[SECONDARY_CHANNEL][SLAVE_DRIVE] >= DEVICE_DETECTION_FAILED ) {
                    return EFI_ALREADY_STARTED;
                }
            }
        }
    }

    //
    //Check whether IDE_CONTROLLER_PROTOCOL  has been installed on this controller
    //
    Status = pBS->OpenProtocol( Controller,
                                &(gPlatformIdeProtocol->gIdeControllerProtocolGuid),
                                (VOID**)&IdeControllerInterface,
                                This->DriverBindingHandle,
                                Controller,
                                EFI_OPEN_PROTOCOL_BY_DRIVER );

#ifdef Debug_Level_3

    if ( EFI_ERROR( Status )) {
        if ( gPlatformIdeProtocol->EfiIdeProtocol )
            EfiDebugPrint( -1, "Error opening gEfiIdeControllerInitProtocolGuid\n" );
        else
            EfiDebugPrint( -1, "Error opening gEfiIdeControllerProtocolGuid\n" );
    }
#endif

    //
    //IDE_CONTROLLER_PROTOCOL will be opened by each device. So EFI_ALREADY_STARTED is not an error
    //
    if  ( !(Status == EFI_SUCCESS || Status == EFI_ALREADY_STARTED)) {
        return EFI_UNSUPPORTED;
    }

    //
    //Close IDE_CONTROLLER_PROTOCOL
    //
    pBS->CloseProtocol(
        Controller,
        &(gPlatformIdeProtocol->gIdeControllerProtocolGuid),
        This->DriverBindingHandle,
        Controller
        );

#ifdef Debug_Level_1
    EfiDebugPrint( -1, "IdeBusSupported Exit Success\n" );
#endif
    //
    // Check if Controller is in AHCI mode or not?
    //
    Status = pBS->OpenProtocol( Controller,
                                &gEfiPciIoProtocolGuid,
                                (VOID**)&PciIO,
                                This->DriverBindingHandle,
                                Controller,
                                EFI_OPEN_PROTOCOL_GET_PROTOCOL );

    if ( EFI_ERROR( Status )) {
        return EFI_UNSUPPORTED;
    }

    Status = PciIO->Pci.Read( PciIO,
                              EfiPciIoWidthUint8,
                              0,
                              sizeof (PciConfig),
                              PciConfig
                              );

    if ((PciConfig [IDE_SUB_CLASS_CODE] == SCC_AHCI_CONTROLLER) || (PciConfig [IDE_SUB_CLASS_CODE] == SCC_RAID_CONTROLLER)) {
        if ( !(gPlatformIdeProtocol->AhciCompatibleMode) )
            return EFI_UNSUPPORTED;
    }

    return EFI_SUCCESS;
}

//<AMI_PHDR_START>
//---------------------------------------------------------------------------
//
// Procedure:	IdeBusStart
//
// Description:	Installs IDE Block IO Protocol
//
// Input:
//	IN EFI_DRIVER_BINDING_PROTOCOL    *This,
//	IN EFI_HANDLE                     Controller,
//	IN EFI_DEVICE_PATH_PROTOCOL       *RemainingDevicePath
//
// Output:
//	EFI_STATUS
//
// Modified:
//
// Referrals: OpenProtocol CloseProtocol InstallProtocolInterface AllocatePool
//
// Notes:
//  Here is the control flow of this function:
// 1.  Check if "gEfiIdeBusInitProtocolGuid" is already installed. If not, install it "InstallBusInitProtocol".
// 2.  If Devicepath is valid, initialize so that only particular device will be detected and
//	   confgiured, else all devices will be detected and configured.
// 3.  check whether the device has not been already detected. If yes, skip it and go for next device
// 4.  IdeBusInterface is initialized for this device. Update Base address.
// 5.  Do the detection "DetectIdeDevice". Update the status in "IdeBusInitProtocol". If failure undo the process "IdeBusInterface".
// 6.  Repeat for all devices from step 3.
// 7.  Start the configuration process for devices which are detected successfully "DEVICE_DETECTED_SUCCESSFULLY".
// 8.  "ConfigureIdeDeviceAndController" will do the configuration.
// 9.  If above step is success, build Devicepath "CreateIdeDevicePath"
// 10. Create the Block_io_Protocol"InitIdeBlockIO". Install it only if Device is not Password protected.
// 11. Create the DISK_INFO_PROTOCOL "InitIdeDiskInfo". Install it only if Device is not Password protected.
// 12. Install a child device with the above three protocols.
// 13. Open "gEfiIdeControllerProtocolGuid" with the child handle.
// 14. Repeat from step 8 for the remaining devices.
//
//---------------------------------------------------------------------------
//<AMI_PHDR_END>
EFI_STATUS IdeBusStart(
    IN EFI_DRIVER_BINDING_PROTOCOL *This,
    IN EFI_HANDLE                  Controller,
    IN EFI_DEVICE_PATH_PROTOCOL    *RemainingDevicePath )
{
    EFI_STATUS                       Status;
    EFI_PCI_IO_PROTOCOL              *PciIO;

    IDE_BLK_IO_DEV                   *IdeBlockIoDev = NULL;
    VOID                             *IdeControllerInterface = NULL ;
    IDE_BUS_INIT_PROTOCOL            *IdeBusInitInterface;
    IDE_BUS_PROTOCOL                 *IdeBusInterface;
    UINT8 Enumeration_Process = ENUMERATE_ALL;
    ATAPI_DEVICE_PATH                *AtapiRemainingDevicePath = (ATAPI_DEVICE_PATH*)RemainingDevicePath;

    UINT8 Start_Channel = PRIMARY_CHANNEL;
    UINT8 End_Channel   = SECONDARY_CHANNEL;
    UINT8 Start_Device  = MASTER_DRIVE;
    UINT8 End_Device    = SLAVE_DRIVE;

    INT8 TotalDevice = 0;
    INT8 Current_Channel;
    INT8 Current_Device;
    UINT16                           SecurityStatus = 0;

#ifdef Debug_Level_1
    EfiDebugPrint( -1, "IdeBusStart Entry\n" );
#endif

    PROGRESS_CODE( DXE_IDE_BEGIN );

    //
    //Open IDE_CONTROLLER_PROTOCOL. If success or Already opened, It is OK to proceed.
    //
    Status = pBS->OpenProtocol( Controller,
                                &(gPlatformIdeProtocol->gIdeControllerProtocolGuid),
                                (VOID**)&IdeControllerInterface,
                                This->DriverBindingHandle,
                                Controller,
                                EFI_OPEN_PROTOCOL_BY_DRIVER );

    if  ( !(Status == EFI_SUCCESS || Status == EFI_ALREADY_STARTED)) {
        return EFI_DEVICE_ERROR;
    }

    //
    //Get the PciIO interface
    //
    Status = pBS->OpenProtocol( Controller,
                                &gEfiPciIoProtocolGuid,
                                (VOID**)&PciIO,
                                This->DriverBindingHandle,
                                Controller,
                                EFI_OPEN_PROTOCOL_GET_PROTOCOL );


    //
    //Check if IDE_BUS_INIT_PROTOCOL installed.
    //
    Status = pBS->OpenProtocol( Controller,
                                &gEfiIdeBusInitProtocolGuid,
                                (VOID**)&IdeBusInitInterface,
                                This->DriverBindingHandle,
                                Controller,
                                EFI_OPEN_PROTOCOL_BY_DRIVER );


    if  ( !(Status == EFI_SUCCESS || Status == EFI_ALREADY_STARTED)) {
        Status = pBS->AllocatePool( EfiBootServicesData,
                                    sizeof(IDE_BUS_INIT_PROTOCOL),
                                    (VOID**)&IdeBusInitInterface
                                    );

        if ( EFI_ERROR( Status )) {
            return EFI_OUT_OF_RESOURCES; 
        }
        Status = InstallBusInitProtocol( Controller, IdeBusInitInterface, IdeControllerInterface );

        if ( EFI_ERROR( Status )) {
            if ( Status == EFI_OUT_OF_RESOURCES) {
                return EFI_OUT_OF_RESOURCES;
            } else {
                return EFI_DEVICE_ERROR;
            }
        }
    }

    //
    //	Check if AtapiRemainingDevicePath is valid or not
    //
    if ( !(AtapiRemainingDevicePath == NULL)) {

        //
        // RemainingDevicePath is not NULL and begins with the End of Device Path node, 
        // then the driver must not enumerate any of the children of Controller nor create any child device handle. 
        // Only the controller initialization should be performed. UEFI specification V 2.3.1, P. 10.1
        //
        if(isEndNode(RemainingDevicePath)) {
            return EFI_SUCCESS;
        }

        //
        // Check if the AtapiRemainingDevicePath is valid 8.3.4.1
        //
        if ( AtapiRemainingDevicePath->Header.Type != MESSAGING_DEVICE_PATH
             || AtapiRemainingDevicePath->Header.SubType != MSG_ATAPI_DP
             && NODE_LENGTH( &AtapiRemainingDevicePath->Header ) != ATAPI_DEVICE_PATH_LENGTH ) {
#ifdef Debug_Level_3
            EfiDebugPrint( -1, "AtapiRemainingDevicePath not Valid\n" );
#endif
            return EFI_DEVICE_ERROR;
        }

        if ( AtapiRemainingDevicePath->PrimarySecondary == PRIMARY_CHANNEL
             && AtapiRemainingDevicePath->SlaveMaster == MASTER_DRIVE ) {
            Enumeration_Process = ENUMERATE_PRIMARY_MASTER;
        }

        if ( AtapiRemainingDevicePath->PrimarySecondary == PRIMARY_CHANNEL
             && AtapiRemainingDevicePath->SlaveMaster == SLAVE_DRIVE ) {
            Enumeration_Process = ENUMERATE_PRIMARY_SLAVE;
        }

        if ( AtapiRemainingDevicePath->PrimarySecondary == SECONDARY_CHANNEL
             && AtapiRemainingDevicePath->SlaveMaster == MASTER_DRIVE ) {
            Enumeration_Process = ENUMERATE_SECONDARY_MASTER;
        }

        if ( AtapiRemainingDevicePath->PrimarySecondary == SECONDARY_CHANNEL
             && AtapiRemainingDevicePath->SlaveMaster == SLAVE_DRIVE ) {
            Enumeration_Process = ENUMERATE_SECONDARY_SLAVE;
        }

        switch ( Enumeration_Process )
        {
        case ENUMERATE_PRIMARY_MASTER:
            Start_Channel = PRIMARY_CHANNEL;
            End_Channel   = PRIMARY_CHANNEL;
            Start_Device  = MASTER_DRIVE;
            End_Device    = MASTER_DRIVE;
            break;
        case ENUMERATE_PRIMARY_SLAVE:
            Start_Channel = PRIMARY_CHANNEL;
            End_Channel   = PRIMARY_CHANNEL;
            Start_Device  = SLAVE_DRIVE;
            End_Device    = SLAVE_DRIVE;
            break;
        case ENUMERATE_SECONDARY_MASTER:
            Start_Channel = SECONDARY_CHANNEL;
            End_Channel   = SECONDARY_CHANNEL;
            Start_Device  = MASTER_DRIVE;
            End_Device    = MASTER_DRIVE;
            break;
        case ENUMERATE_SECONDARY_SLAVE:
            Start_Channel = SECONDARY_CHANNEL;
            End_Channel   = SECONDARY_CHANNEL;
            Start_Device  = SLAVE_DRIVE;
            End_Device    = SLAVE_DRIVE;
            break;
        default:
            break;
        }
    }


#ifdef Debug_Level_3
            EfiDebugPrint( -1, "Enumerate = %x\n", Enumeration_Process );
#endif

    //---------------------------------------------------------------------------------------------------------
    //	Device Detection Begins
    //---------------------------------------------------------------------------------------------------------
    PROGRESS_CODE( DXE_IDE_DETECT );

    for ( Current_Channel = Start_Channel; Current_Channel <= End_Channel; Current_Channel++ )
    {

        if ( gPlatformIdeProtocol->EfiIdeProtocol ) {
            ( (EFI_IDE_CONTROLLER_INIT_PROTOCOL*)IdeControllerInterface )->NotifyPhase( (EFI_IDE_CONTROLLER_INIT_PROTOCOL*)IdeControllerInterface, EfiIdeBeforeChannelEnumeration, Current_Channel );
        }
        //
        // Calculate the Number of Devices to be detected in single Channel 
        //
        TotalDevice = ( End_Device - Start_Device ) + 1;

        if ( gPlatformIdeProtocol->MasterSlaveEnumeration ) {
            Current_Device = Start_Device;
        } else {
            Current_Device = End_Device;
        }

        while ( TotalDevice ) 
        {
            //
            // Check whether the given device is disabled by USER OR already processed
            //
            if ( IdeBusInitInterface->IdeBusInitData[Current_Channel][Current_Device] == DEVICE_DISABLED
                 || IdeBusInitInterface->IdeBusInitData[Current_Channel][Current_Device] == DEVICE_DETECTED_SUCCESSFULLY
                 || IdeBusInitInterface->IdeBusInitData[Current_Channel][Current_Device] == DEVICE_CONFIGURED_SUCCESSFULLY
                 || IdeBusInitInterface->IdeBusInitData[Current_Channel][Current_Device] == DEVICE_DETECTION_FAILED
                 || IdeBusInitInterface->IdeBusInitData[Current_Channel][Current_Device] == DEVICE_REMOVED ) {

                if ( gPlatformIdeProtocol->MasterSlaveEnumeration ) {
                    Current_Device++;
                } else {
                    Current_Device--;
                }
                TotalDevice--;
                continue;
            }

            //
            // Allocate memory for IDE_BUS_PROTOCOL
            //
            if ( gPlatformIdeProtocol->EfiIdeProtocol ) {
                IdeBlockIoDev = MallocZ( sizeof(IDE_BLK_IO_DEV));

                if ( !IdeBlockIoDev ) {
                    return EFI_OUT_OF_RESOURCES;
                }
                IdeBlockIoDev->Signature = IDE_BLK_IO_DEV_SIGNATURE;
                IdeBusInterface          = (IDE_BUS_PROTOCOL*)&(IdeBlockIoDev->BlkIo);
            } else {
                IdeBusInterface = MallocZ( sizeof(IDE_BUS_PROTOCOL));

                if ( !IdeBusInterface ) {
                    return EFI_OUT_OF_RESOURCES;
                }
            }

            //
            // Initialize the fields
            //

            if ( gPlatformIdeProtocol->EfiIdeProtocol ) { 
                IdeBusInterface->EfiIdeControllerInterface =(EFI_IDE_CONTROLLER_INIT_PROTOCOL*) IdeControllerInterface;
                IdeBusInterface->IdeControllerInterfaceHandle = Controller;
            } else {
                IdeBusInterface->IdeControllerInterface =(IDE_CONTROLLER_PROTOCOL*) IdeControllerInterface;
            }
            IdeBusInterface->IdeBusInitInterface  = IdeBusInitInterface;
            IdeBusInterface->PciIO                = PciIO;
            IdeBusInterface->IdeDevice.PciIO      = PciIO;
            IdeBusInterface->IdeDevice.Channel    = Current_Channel;
            IdeBusInterface->IdeDevice.Device     = Current_Device;
            IdeBusInterface->AtaReadWritePio      = AtaReadWritePio;
            IdeBusInterface->AtaPioDataIn         = AtaPioDataIn;
            IdeBusInterface->AtaPioDataOut        = AtaPioDataOut;
            IdeBusInterface->IdeNonDataCommand    = IdeNonDataCommandExp;
            IdeBusInterface->WaitForCmdCompletion = WaitForCmdCompletion;
            IdeBusInterface->GeneralAtapiCommandAndData = GeneralAtapiCommandAndData;
            Status = UpdateBaseAddress( IdeBusInterface );

            if ( Status == EFI_SUCCESS ) {
                Status = DetectIdeDevice( IdeBusInterface );
            }

            if ( EFI_ERROR( Status ) ) {
                //
                // Update IdeBusInitInterface
                //
                IdeBusInitInterface->IdeBusInitData[Current_Channel][Current_Device] = DEVICE_DETECTION_FAILED;
                if ( gPlatformIdeProtocol->EfiIdeProtocol )
                    pBS->FreePool( IdeBlockIoDev );
                else
                    pBS->FreePool( IdeBusInterface );
 
                if ( gPlatformIdeProtocol->MasterSlaveEnumeration ) {
                    Current_Device++;
                } else {
                    Current_Device--;
                }
                TotalDevice--;
                continue;
            } else {
                IdeBusInitInterface->IdeBusInitData[Current_Channel][Current_Device]  = DEVICE_DETECTED_SUCCESSFULLY;
                IdeBusInitInterface->pIdeBusProtocol[Current_Channel][Current_Device] = IdeBusInterface; // Save the Pointer
            }

            if ( gPlatformIdeProtocol->MasterSlaveEnumeration ) {
                Current_Device++;
            } else {
                Current_Device--;
            }
            TotalDevice--;
        }                                                               // Loop for Master/Slave
    }                                                                   // Loop for Primary/Secondary

    //---------------------------------------------------------------------------------------------------------
    //	Device Detection Ends
    //---------------------------------------------------------------------------------------------------------
    //	Configuration Starts
    //---------------------------------------------------------------------------------------------------------
    PROGRESS_CODE( DXE_IDE_ENABLE );

    for ( Current_Channel = Start_Channel; Current_Channel <= End_Channel; Current_Channel++ )
    {
        for ( Current_Device = Start_Device; Current_Device <= End_Device; Current_Device++ )
        {

            //  
            //Check whether the given device is detected successfully
            //
            if ( IdeBusInitInterface->IdeBusInitData[Current_Channel][Current_Device] == DEVICE_DETECTED_SUCCESSFULLY ) {
                IdeBusInterface = IdeBusInitInterface->pIdeBusProtocol[Current_Channel][Current_Device];

                Status = ConfigureIdeDeviceAndController( IdeBusInterface, IdeControllerInterface, IdeBusInitInterface );

                if ( EFI_ERROR( Status )) {
                    ERROR_CODE( DXE_IDE_DEVICE_FAILURE, EFI_ERROR_MAJOR );

                    if ( gPlatformIdeProtocol->EfiIdeProtocol )
                        pBS->FreePool( IdeBlockIoDev );
                    else
                        pBS->FreePool( IdeBusInterface );

                    IdeBusInitInterface->pIdeBusProtocol[Current_Channel][Current_Device] = NULL;
                    continue;
                }

                //
                //Device has been successfully detected and configured.
                //

                //
                //Create the Devicepath
                //  
                Status = CreateIdeDevicePath( This, Controller, IdeBusInitInterface, IdeBusInterface, RemainingDevicePath, Current_Channel, Current_Device );

                if ( EFI_ERROR( Status )) {
                    if ( gPlatformIdeProtocol->EfiIdeProtocol )
                        pBS->FreePool( IdeBlockIoDev );
                    else
                        pBS->FreePool( IdeBusInterface );
                    continue;
                }

                //
                //Initialize Block_IO Protocol
                //
                Status = InitIdeBlockIO( IdeBusInterface );

                if ( EFI_ERROR( Status )) {
                    if ( gPlatformIdeProtocol->EfiIdeProtocol )
                        pBS->FreePool( IdeBlockIoDev );
                    else
                        pBS->FreePool( IdeBusInterface );
                    continue;
                }

                //
                //Initialize IDE EFI_DISK_INFO_PROTOCOL
                //
                Status = InitIdeDiskInfo( IdeBusInterface );

                if ( EFI_ERROR( Status )) {
                    if ( gPlatformIdeProtocol->EfiIdeProtocol )
                        pBS->FreePool( IdeBlockIoDev );
                    else
                        pBS->FreePool( IdeBusInterface );
                    continue;
                }

                //
                //Install Devicepath
                //
                Status = pBS->InstallMultipleProtocolInterfaces(
                                            &(IdeBusInterface->IdeDeviceHandle),
                                            &gDevicePathProtocolGuid, IdeBusInterface->DevicePathProtocol,
                                            NULL );

                if ( EFI_ERROR( Status )) {
                    IdeBusInitInterface->IdeBusInitData[Current_Channel][Current_Device] = DEVICE_DETECTION_FAILED;
                    if ( gPlatformIdeProtocol->EfiIdeProtocol )
                        pBS->FreePool( IdeBlockIoDev );
                    else
                        pBS->FreePool( IdeBusInterface );
                    continue;
                }

                //
                //Open IdeControllerProtocol
                //
                Status = pBS->OpenProtocol( Controller,
                                            &(gPlatformIdeProtocol->gIdeControllerProtocolGuid),
                                            (VOID**)&IdeControllerInterface,
                                            This->DriverBindingHandle,
                                            IdeBusInterface->IdeDeviceHandle,
                                            EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER );


                //
                //Install other optional Protocols - Hdd Security
                //
                Status = pBS->LocateProtocol(
                                &gHddSecurityInitProtocolGuid,
                                 NULL,
                                 &HddSecurityInitProtocol
                                );

                if ( !EFI_ERROR( Status )) {
                    if ( HddSecurityInitProtocol != NULL ) {
                        HddSecurityInitProtocol->InstallSecurityInterface( IdeBusInterface, FALSE );
                    }
                } else {
                    //
                    // If Security Feature support is not enabled, always freeze lock the security feature
                    //
                    if ( IdeBusInterface->IdeDevice.IdentifyData.Command_Set_Supported_82 & 0x2 ) {
                        Status = IdeNonDataCommand( IdeBusInterface, 0, 0,
                                                    0, 0, 0,
                                                    IdeBusInterface->IdeDevice.Device << 4,
                                                    SECURITY_FREEZE_LOCK );
                        //
                        // if Device Configuration Overlay feature set supported then issue the
                        // Dev config Free lock command.
                        //
                        if ( IdeBusInterface->IdeDevice.IdentifyData.Command_Set_Supported_83 & 0x800 ) {
                            Status = IdeNonDataCommand( IdeBusInterface, DEV_CONFIG_FREEZE_LOCK_FEATURES, 0,
                                                        0, 0, 0,
                                                        IdeBusInterface->IdeDevice.Device << 4,
                                                        DEV_CONFIG_FREEZE_LOCK );
                        }
                        // Update the Identify device buffer
                        GetIdentifyData( IdeBusInterface, &(IdeBusInterface->IdeDevice));
                    }
                }

                //
                // Install other optional Protocols - OpalSecurity
                //

                Status = pBS->LocateProtocol (
                                    &gOpalSecInitProtocolGuid,
                                    NULL,
                                    &OpalSecInitProtocol
                                );

                if(!EFI_ERROR(Status)) {
                    if(OpalSecInitProtocol != NULL) {
                        OpalSecInitProtocol->InstallOpalSecurityInterface(IdeBusInterface, FALSE);
                    }
                }

                //
                //Install other optional Protocols - SMART
                //
                Status = pBS->LocateProtocol(
                                    &gHddSmartInitProtocolGuid,
                                    NULL,
                                    &HddSmartInitProtocol
                                    );

                if ( !EFI_ERROR( Status )) {
                    if ( HddSmartInitProtocol != NULL ) {
                        HddSmartInitProtocol->InitSMARTSupport( IdeBusInterface, FALSE );
                        //
                        //Get the updated IdentifyData
                        //
                        GetIdentifyData( IdeBusInterface, &(IdeBusInterface->IdeDevice));
                        if ( HddSmartInitProtocol->SmartDiagonasticFlag ) {
                            HddSmartInitProtocol->InstallSMARTInterface( IdeBusInterface, FALSE );
                        }
                    }
                }

                if ( gPlatformIdeProtocol->IdePwrManagementInterfaceSupport ) {
                    InstallIDEPowerMgmtInterface( IdeBusInterface );
                }

                if ( gPlatformIdeProtocol->HostProtectedAreaSupport ) {
                    InstallHPAInterface( IdeBusInterface );
                }

#ifdef Debug_Level_3
                PrintIdeDeviceInfo( IdeBusInterface );
#endif
            }                                               // DEVICE_CONFIGURED_SUCCESSFULLY

            //Before installing BlockIO and DiskInfo protocol, check whether the device has been
            //password protected. If yes, BlockIO and DiskInfo will not be installed.
            IdeBusInterface = IdeBusInitInterface->pIdeBusProtocol[Current_Channel][Current_Device];

            if ( IdeBusInitInterface->IdeBusInitData[Current_Channel][Current_Device] == DEVICE_CONFIGURED_SUCCESSFULLY ) {
                //
                //Check BlockIO has been installed or not.
                //
                Status = pBS->OpenProtocol( IdeBusInterface->IdeDeviceHandle,
                                            &gEfiBlockIoProtocolGuid,
                                            NULL,
                                            This->DriverBindingHandle,
                                            IdeBusInterface->IdeDeviceHandle,
                                            EFI_OPEN_PROTOCOL_TEST_PROTOCOL );

                if ( EFI_ERROR( Status )) {
                    //
                    //BLOCKIO not installed and device has been configured successfully
                    //  
                    Status = EFI_UNSUPPORTED;
                    Status = pBS->InstallMultipleProtocolInterfaces(
                                        &(IdeBusInterface->IdeDeviceHandle),
                                        &gEfiBlockIoProtocolGuid, (EFI_BLOCK_IO_PROTOCOL*)(IdeBusInterface->IdeBlkIo),
                                        &gEfiDiskInfoProtocolGuid, (EFI_DISK_INFO_PROTOCOL*)(IdeBusInterface->IdeDiskInfo),
                                        NULL );
                }                                                       // If BlockIO not Installed
            }                                                           // End of installing BlockIO and DiskInfo
        }                                                               // Loop for Master/Slave
    }                                                                   // Loop for Primary/Secondary

    //---------------------------------------------------------------------------------------------------------
    //	Configuration Ends
    //---------------------------------------------------------------------------------------------------------

    // Check HP Support and Ide Controller protocol to create an HP event
    if ( gPlatformIdeProtocol->IdeHPSupport == 1 && gPlatformIdeProtocol->EfiIdeProtocol == 0 ) {

        // 
        // Check whether already HP Event has been created and also HP is supported
        //  
        if ( IdeBusInitInterface->HPEvent == NULL && IdeBusInitInterface->HPMask ) {
            //
            // Create and Event
            //
            Status = pBS->CreateEvent( EFI_EVENT_TIMER | EFI_EVENT_NOTIFY_SIGNAL,
                                   TPL_CALLBACK,
                                   IdeHPTimer,
                                   IdeBusInitInterface,
                                   &(IdeBusInitInterface->HPEvent));

            if ( Status == EFI_SUCCESS ) {
                pBS->SetTimer( IdeBusInitInterface->HPEvent, TimerPeriodic, 20000000 ); // 2sec
            }
        }
    }

    Status = pBS->LocateProtocol (
                                &gAtaPassThruInitProtocolGuid,
                                NULL,
                                &AtaPassThruInitProtocol
                        );

    if(!EFI_ERROR(Status)) {
        if(AtaPassThruInitProtocol != NULL) {
            AtaPassThruInitProtocol->InstallAtaPassThru(Controller, FALSE);
        }
    }

    // SCSIPassThruAtapi install
    Status = pBS->LocateProtocol (
                                &gScsiPassThruAtapiInitProtocolGuid,
                                NULL,
                                &gScsiPassThruAtapiInitProtocol
                        );

    if(!EFI_ERROR(Status)) {
        if(gScsiPassThruAtapiInitProtocol != NULL) {
            gScsiPassThruAtapiInitProtocol->InstallScsiPassThruAtapi(Controller, FALSE);
        }
    }

    //
    // This will notify AMITSE to invoke the HDD password Screen
    //
    Status = pBS->InstallProtocolInterface(
        &Controller,
        &gHddSecurityEndProtocolGuid, EFI_NATIVE_INTERFACE, NULL
        );

#ifdef Debug_Level_1
    EfiDebugPrint( -1, "IdeBusStart Exit Success\n" );
#endif

    return EFI_SUCCESS;
}

//<AMI_PHDR_START>
//---------------------------------------------------------------------------
//
// Procedure:	IdeBusStop
//
// Description:	Uninstall all devices installed in start procedure.
//
// Input:
//	IN EFI_DRIVER_BINDING_PROTOCOL    *This,
//	IN EFI_HANDLE                     Controller,
//	IN EFI_DEVICE_PATH_PROTOCOL       *RemainingDevicePath
//
// Output:
//	EFI_STATUS
//
// Modified:
//
// Referrals: OpenProtocol CloseProtocol
//
// Notes:
//  Here is the control flow of this function:
// 1.  Check whether "gEfiIdeBusInitProtocolGuid" is installed on this controller. If not exit with error.
// 2.  If "NumberOfChildren" is zero, check wether all child devices have been stopped. If not exit with error.
//                      if all child devices have been stopped, then close "gEfiIdeControllerProtocolGuid" and "gEfiIdeBusInitProtocolGuid",
//		        uninstall "gEfiIdeBusInitProtocolGuid" and then exit with success.
// 3.  If "NumberOfChildren" is non-zero,	close "gEfiIdeControllerProtocolGuid" opened by the child device in start function.
//			uninstall all protocols installed on this child device in start function,
//			free up all resources allocated in start function. Repeat step	3 for all child devices and	return success at the end.
//
//---------------------------------------------------------------------------
//<AMI_PHDR_END>
EFI_STATUS IdeBusStop(
    IN EFI_DRIVER_BINDING_PROTOCOL *This,
    IN EFI_HANDLE                  Controller,
    IN UINTN                       NumberOfChildren,
    IN EFI_HANDLE                  *ChildHandleBuffer )
{
    IDE_BUS_INIT_PROTOCOL            *IdeBusInitInterface;
    IDE_BUS_PROTOCOL                 *IdeBusInterface = NULL;
    EFI_STATUS                       Status;
    IDE_BLK_IO_DEV                   *IdeBlockIoDev = NULL;
    VOID                             *IdeControllerInterface = NULL ;
 
    UINT8 Current_Channel                 = 0xff;
    UINT8 Current_Device                  = 0xff;
    UINT8 Index                           = 0;
    BOOLEAN                          Flag = TRUE;
    EFI_DEVICE_PATH_PROTOCOL         *DevicePath;

    //
    //Check if IDE_BUS_INIT_PROTOCOL is installed on the Controller.
    //
    Status = pBS->OpenProtocol( Controller,
                                &gEfiIdeBusInitProtocolGuid,
                                (VOID**)&IdeBusInitInterface,
                                This->DriverBindingHandle,
                                Controller,
                                EFI_OPEN_PROTOCOL_GET_PROTOCOL );

    if ( EFI_ERROR( Status )) {
        return EFI_DEVICE_ERROR;
    }

    //
    //Check if ChildHandleBuffer is valid
    //
    if ( NumberOfChildren ) {
        while ( NumberOfChildren )
        {
            Status = pBS->OpenProtocol(
                ChildHandleBuffer[Index],
                &gDevicePathProtocolGuid,
                (VOID**)&DevicePath,
                This->DriverBindingHandle,
                Controller,
                EFI_OPEN_PROTOCOL_GET_PROTOCOL );

            //Lookout for ATAPI device path
            //ACPI_DEVICE path, PCI Device path and then ATAPI device path will be the sequence
            do
            {
                if ((DevicePath->Type == MESSAGING_DEVICE_PATH) && (DevicePath->SubType == MSG_ATAPI_DP)) {
                    Current_Channel = ((ATAPI_DEVICE_PATH*)DevicePath)->PrimarySecondary;
                    Current_Device  = ((ATAPI_DEVICE_PATH*)DevicePath)->SlaveMaster;
                    break;
                } else {
                    DevicePath = NEXT_NODE( DevicePath );
                }
            } while ( DevicePath->Type != END_DEVICE_PATH );

            if ( Current_Channel == 0xff || Current_Device == 0xff ) {
                return EFI_DEVICE_ERROR;
            }

            //
            //Get the pointer to IDE_BUS_PROTOCOL
            //
            IdeBusInterface = IdeBusInitInterface->pIdeBusProtocol[Current_Channel][Current_Device];

            //
            //Close all the protocols opened by this Child Device
            //
            pBS->CloseProtocol(
                        Controller,
                        &(gPlatformIdeProtocol->gIdeControllerProtocolGuid),
                        This->DriverBindingHandle,
                        ChildHandleBuffer[Index] );

            //Before uninstalling BLOCKIO check whether it is installed or not
            Status = pBS->OpenProtocol( ChildHandleBuffer[Index],
                                        &gEfiBlockIoProtocolGuid,
                                        NULL,
                                        This->DriverBindingHandle,
                                        ChildHandleBuffer[Index],
                                        EFI_OPEN_PROTOCOL_TEST_PROTOCOL );

            if ( Status == EFI_SUCCESS ) {
                Status = pBS->UninstallMultipleProtocolInterfaces(
                                    ChildHandleBuffer[Index],
                                    &gEfiBlockIoProtocolGuid, (EFI_BLOCK_IO_PROTOCOL*)(IdeBusInterface->IdeBlkIo),
                                    &gEfiDiskInfoProtocolGuid, (EFI_DISK_INFO_PROTOCOL*)(IdeBusInterface->IdeDiskInfo),
                                    NULL );
            }

            Status = pBS->    UninstallMultipleProtocolInterfaces(
                ChildHandleBuffer[Index],
                &gDevicePathProtocolGuid, IdeBusInterface->DevicePathProtocol,
                NULL );

            if ( EFI_ERROR( Status )) {
                pBS->OpenProtocol( Controller,
                                   &(gPlatformIdeProtocol->gIdeControllerProtocolGuid),
                                   (VOID**)&IdeControllerInterface,
                                   This->DriverBindingHandle,
                                   ChildHandleBuffer[Index],
                                   EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER );

                return EFI_DEVICE_ERROR;
            }  else {
                //
                //Now free up all resources allocated.
                //
                if ( IdeBusInterface->IdeDevice.AtapiDevice != NULL ) {
                    pBS->FreePool( IdeBusInterface->IdeDevice.AtapiDevice->PacketBuffer );
                    pBS->FreePool( IdeBusInterface->IdeDevice.AtapiDevice->InquiryData );
                    pBS->FreePool( IdeBusInterface->IdeDevice.AtapiDevice );
                }

                //
                //Freeup resources allocated for component names
                //
                if ( IdeBusInterface->IdeDevice.UDeviceName != NULL ) {
                    pBS->FreePool( IdeBusInterface->IdeDevice.UDeviceName->Language );
                    pBS->FreePool( IdeBusInterface->IdeDevice.UDeviceName->UnicodeString );
                    pBS->FreePool( IdeBusInterface->IdeDevice.UDeviceName );
                }

                // Uninstall optional protocols

                //
                //Before uninstalling HDD security check whether it is installed or not
                //
                Status = pBS->OpenProtocol( ChildHandleBuffer[Index],
                                            &gHddSecurityInitProtocolGuid,
                                            (VOID**)&HddSecurityInitProtocol,
                                            This->DriverBindingHandle,
                                            ChildHandleBuffer[Index],
                                            EFI_OPEN_PROTOCOL_TEST_PROTOCOL );

                if ( !EFI_ERROR( Status )) {
                    if ( HddSecurityInitProtocol != NULL ) {
                        HddSecurityInitProtocol->StopSecurityModeSupport( IdeBusInterface, FALSE );
                    }
                }

                //
                //Before uninstalling Hdd Smart check whether it is installed or not
                //
                Status = pBS->OpenProtocol( ChildHandleBuffer[Index],
                                            &gHddSmartInitProtocolGuid,
                                            (VOID**)&HddSmartInitProtocol,
                                            This->DriverBindingHandle,
                                            ChildHandleBuffer[Index],
                                            EFI_OPEN_PROTOCOL_TEST_PROTOCOL );

                if ( !EFI_ERROR( Status )) {
                    if ( HddSmartInitProtocol != NULL ) {
                        if ( HddSmartInitProtocol->SmartDiagonasticFlag ) {
                            HddSmartInitProtocol->UnInstallSMARTInterface( IdeBusInterface, FALSE );
                        }
                    }
                }

                //
                //Before uninstalling OPAL security Interface check whether it is installed or not.
                //
                Status = pBS->OpenProtocol( ChildHandleBuffer[Index],
                                            &gOpalSecInitProtocolGuid,
                                            (VOID**)&OpalSecInitProtocol,
                                            This->DriverBindingHandle,
                                            ChildHandleBuffer[Index],
                                            EFI_OPEN_PROTOCOL_TEST_PROTOCOL );

                if ( !EFI_ERROR( Status )) {
                    if ( OpalSecInitProtocol != NULL ) {
                        OpalSecInitProtocol->UnInstallOpalSecurityInterface( IdeBusInterface, FALSE );
                    }
                }

	            if ( gPlatformIdeProtocol->IdePwrManagementInterfaceSupport ) {
	                StopIDEPowerMgmtInterface( IdeBusInterface );
	            }

	            if ( gPlatformIdeProtocol->HostProtectedAreaSupport ) {
	                StopHPAInterface( IdeBusInterface );
	            }

	            if ( gPlatformIdeProtocol->EfiIdeProtocol ) {
	                IdeBlockIoDev = IDE_BLOCK_IO_DEV_FROM_THIS( &(IdeBusInterface->IdeBlkIo));
                }
                pBS->FreePool( IdeBusInterface->IdeBlkIo->BlkIo.Media );
                pBS->FreePool( IdeBusInterface->IdeBlkIo );
                pBS->FreePool( IdeBusInterface->IdeDiskInfo );
                Current_Channel = IdeBusInterface->IdeDevice.Channel;
                Current_Device  = IdeBusInterface->IdeDevice.Device;
                IdeBusInitInterface->IdeBusInitData[Current_Channel][Current_Device] = DEVICE_IN_RESET_STATE;
                pBS->FreePool( IdeBusInterface->DevicePathProtocol );

	            if ( gPlatformIdeProtocol->EfiIdeProtocol )
	                pBS->FreePool( IdeBlockIoDev );
	            else
	                pBS->FreePool( IdeBusInterface );
            }
            NumberOfChildren--;
            Index++;
        }

        return EFI_SUCCESS;
    } else {
        //   
        //Check if IDE_BUS_INIT_PROTOCOL can be removed
        //
        for ( Current_Channel = PRIMARY_CHANNEL; Current_Channel <= SECONDARY_CHANNEL; Current_Channel++ )
        {
            for ( Current_Device = MASTER_DRIVE; Current_Device <= SLAVE_DRIVE; Current_Device++ )
            {
                if ( IdeBusInitInterface->IdeBusInitData[Current_Channel][Current_Device] == DEVICE_CONFIGURED_SUCCESSFULLY ) {
                    Flag = FALSE;
                }
            }
        }

        //
        // Can't uninstall IDE_BUS_INIT_PROTOCOL if any one of the IDE devices are in "CONFIGURED" state.
        //
        if ( Flag == TRUE ) {
            if ( gPlatformIdeProtocol->IdeHPSupport ) {

	            //
	            // Check whether already HP Event has been created and also HP is supported
	            //    
	            if ( IdeBusInitInterface->HPEvent != NULL ) {
	                pBS->CloseEvent( IdeBusInitInterface->HPEvent );
                }
            }
            //    
            //Close all the protocols opened in Start Function
            //
            Status = pBS->CloseProtocol( Controller,
                                         &(gPlatformIdeProtocol->gIdeControllerProtocolGuid),
                                         This->DriverBindingHandle,
                                         Controller );
            //
            // AtaPass Thru uninstall
            //
            Status = pBS->LocateProtocol (
                                &gAtaPassThruInitProtocolGuid,
                                NULL,
                                &AtaPassThruInitProtocol
                        );

            if(!EFI_ERROR(Status)) {
                 if(AtaPassThruInitProtocol != NULL) {
                     AtaPassThruInitProtocol->StopAtaPassThruSupport(Controller, FALSE);
                 }
             }
            //
            // ScsiPassThruAtapi uninstall
            //
            Status = pBS->LocateProtocol (
                                &gScsiPassThruAtapiInitProtocolGuid,
                                NULL,
                                &gScsiPassThruAtapiInitProtocol);

             if(!EFI_ERROR(Status)) {
                 if(gScsiPassThruAtapiInitProtocol != NULL) {
                     gScsiPassThruAtapiInitProtocol->StopScsiPassThruAtapiSupport(Controller, FALSE);
                 }
             }


            Status = pBS->CloseProtocol( Controller,
                                         &gEfiIdeBusInitProtocolGuid,
                                         This->DriverBindingHandle,
                                         Controller );

            Status = pBS->UninstallProtocolInterface( Controller,
                                                      &gEfiIdeBusInitProtocolGuid,
                                                      IdeBusInitInterface );

            if ( EFI_ERROR( Status ))  {
                Status = pBS->OpenProtocol( Controller,
                                            &gEfiIdeBusInitProtocolGuid,
                                            (VOID**)&IdeBusInitInterface,
                                            This->DriverBindingHandle,
                                            Controller,
                                            EFI_OPEN_PROTOCOL_BY_DRIVER );

                Status = pBS->OpenProtocol( Controller,
                                            &(gPlatformIdeProtocol->gIdeControllerProtocolGuid),
                                            (VOID**)&IdeControllerInterface,
                                            This->DriverBindingHandle,
                                            Controller,
                                            EFI_OPEN_PROTOCOL_BY_DRIVER );

                return EFI_DEVICE_ERROR;
            }

	        if ( gPlatformIdeProtocol->EfiIdeProtocol )
	            pBS->FreePool( IdeBlockIoDev );
	        else
	            pBS->FreePool( IdeBusInterface );

            if ( gDescriptorBuffer != NULL ) {
                pBS->FreePool( gDescriptorBuffer );
            }
            gDescriptorBuffer = NULL;
            return EFI_SUCCESS;
        } else {
            return EFI_DEVICE_ERROR;
        }
    }
}

//<AMI_PHDR_START>
//---------------------------------------------------------------------------
//
// Procedure:	InstallBusInitProtocol
//
// Description:	Installs BUS Init Protocol on the IDE controller Handle
//
// Input:
//	IN EFI_HANDLE                     Controller,
//	IDE_BUS_INIT_PROTOCOL			*IdeBusInitInterface;
//	IDE_CONTROLLER_PROTOCOL			*IdeControllerInterface
//
// Output:
//	EFI_STATUS
//
// Modified:
//
// Referrals: AllocatePool, InstallProtocolInterface, IdeGetControllerInfo
//
// Notes:
//  Here is the control flow of this function:
//	1. Call "IdeGetControllerInfo", to get channel information from IdeController driver.
//  2. Install "gEfiIdeBusInitProtocolGuid" on the IDE controller.
//
//---------------------------------------------------------------------------
//<AMI_PHDR_END>
EFI_STATUS InstallBusInitProtocol(
    IN EFI_HANDLE                Controller,
    IN OUT IDE_BUS_INIT_PROTOCOL *IdeBusInitInterface,
    IN VOID *IdeControllerInterfaceIn
    )
{
    CONTROLLER_INFO *ControllerInfo;
    EFI_IDE_CONTROLLER_INIT_PROTOCOL    *EfiIdeControllerInterface = NULL ;
    IDE_CONTROLLER_PROTOCOL             *IdeControllerInterface = NULL ;
    EFI_STATUS      Status;

    //
    // Initialize IdeControllerInterface
    //
    if ( gPlatformIdeProtocol->EfiIdeProtocol )
        EfiIdeControllerInterface = ( EFI_IDE_CONTROLLER_INIT_PROTOCOL *) IdeControllerInterfaceIn;
    else
        IdeControllerInterface = ( IDE_CONTROLLER_PROTOCOL *) IdeControllerInterfaceIn;

    //
    //Initialize the default Values
    //
    ZeroMemory( IdeBusInitInterface, sizeof(IDE_BUS_INIT_PROTOCOL));

    Status = pBS->AllocatePool( EfiBootServicesData,
                                sizeof(CONTROLLER_INFO),
                                (VOID**)&ControllerInfo
                                );

    if ( EFI_ERROR( Status )) {
        return Status;
    }

    ZeroMemory( ControllerInfo, sizeof(CONTROLLER_INFO));

    if ( gPlatformIdeProtocol->EfiIdeProtocol ) {
        ControllerInfo->Flags = 0; // ACOUSTIC_SUPPORT_DISABLE

        if ( gPlatformIdeProtocol->SBIdeSupport ) {
            Status = pBS->LocateProtocol(&gIdeSetupProtocolguid, NULL, &gIdeSetupProtocol);

            if ( gPlatformIdeProtocol->AcousticManagementSupport ) {  

                if (!EFI_ERROR(Status)) {

                    if(gIdeSetupProtocol->AcousticPwrMgmt)
                        ControllerInfo->Flags |= ACOUSTIC_SUPPORT_ENABLE;
                    else
                        ControllerInfo->Flags &= ~ACOUSTIC_SUPPORT_ENABLE;
                    ControllerInfo->Acoustic_Management_Level   = gIdeSetupProtocol->AcousticLevel;
                } else {
                    ControllerInfo->Flags &= ~ACOUSTIC_SUPPORT_ENABLE ;
                    ControllerInfo->Acoustic_Management_Level   = ACOUSTIC_LEVEL_BYPASS;
                }
            } //End of ACOUSTIC_MANAGEMENT_SUPPORT   
        } //End of SBIDE_SUPPORT

        if ( gPlatformIdeProtocol->HddPowerLossInS3 ) {
            ControllerInfo->Flags |= S3_RESUME_UNLOCK_HDD_PASSWORD;
        }

        ControllerInfo->PrimaryChannel        = PRIMARY_CHANNEL_ENABLE;
        ControllerInfo->PrimaryMasterDevice   = PRIMARY_MASTER_DRIVE_ENABLE;
        ControllerInfo->PrimarySlaveDevice    = PRIMARY_SLAVE_DRIVE_ENABLE;
        ControllerInfo->SecondaryChannel      = SECONDARY_CHANNEL_ENABLE;
        ControllerInfo->SecondaryMasterDevice = SECONDARY_MASTER_DRIVE_ENABLE;
        ControllerInfo->SecondarySlaveDevice  = SECONDARY_SLAVE_DRIVE_ENABLE;
        ControllerInfo->BusMasterEnable       = BUSMASTER_ENABLE;
        ControllerInfo->HPMask                = 0;           // Hot Plug Mask

    } else {
		IdeControllerInterface->IdeGetControllerInfo( Controller, ControllerInfo );
    }

    if ( ControllerInfo->PrimaryChannel == DEVICE_DISABLED ) {
        IdeBusInitInterface->IdeBusInitData[PRIMARY_CHANNEL][MASTER_DRIVE] = DEVICE_DISABLED;
        IdeBusInitInterface->IdeBusInitData[PRIMARY_CHANNEL][SLAVE_DRIVE]  = DEVICE_DISABLED;
    } else {
        IdeBusInitInterface->IdeBusInitData[PRIMARY_CHANNEL][MASTER_DRIVE] = ControllerInfo->PrimaryMasterDevice;
        IdeBusInitInterface->IdeBusInitData[PRIMARY_CHANNEL][SLAVE_DRIVE]  = ControllerInfo->PrimarySlaveDevice;
    }

    if ( ControllerInfo->SecondaryChannel == DEVICE_DISABLED ) {
        IdeBusInitInterface->IdeBusInitData[SECONDARY_CHANNEL][MASTER_DRIVE] = DEVICE_DISABLED;
        IdeBusInitInterface->IdeBusInitData[SECONDARY_CHANNEL][SLAVE_DRIVE]  = DEVICE_DISABLED;
    } else {
        IdeBusInitInterface->IdeBusInitData[SECONDARY_CHANNEL][MASTER_DRIVE] = ControllerInfo->SecondaryMasterDevice;
        IdeBusInitInterface->IdeBusInitData[SECONDARY_CHANNEL][SLAVE_DRIVE]  = ControllerInfo->SecondarySlaveDevice;
    }

    IdeBusInitInterface->BusMasterSelection        = ControllerInfo->BusMasterEnable;
    IdeBusInitInterface->HPMask                    = ControllerInfo->HPMask;
    if ( gPlatformIdeProtocol->EfiIdeProtocol )
        IdeBusInitInterface->EfiIdeControllerInterface = EfiIdeControllerInterface;
    else
        IdeBusInitInterface->IdeControllerInterface   	 = IdeControllerInterface;

    IdeBusInitInterface->Flags                     = ControllerInfo->Flags;
    IdeBusInitInterface->Acoustic_Management_Level = ControllerInfo->Acoustic_Management_Level;

    Status = pBS->FreePool( ControllerInfo );

    // Initialize PrevPortNum and PrevPortMultiplierPortNum for AtaPassThru to 0xFFFF

    IdeBusInitInterface->PrevPortNum = 0xffff;
    IdeBusInitInterface->PrevPortMultiplierPortNum = 0xffff;

    Status = pBS->InstallProtocolInterface(
        &Controller,
        &gEfiIdeBusInitProtocolGuid,
        EFI_NATIVE_INTERFACE,
        IdeBusInitInterface );

    if ((IdeBusInitInterface->BusMasterSelection) &&  gDescriptorBuffer == NULL ) {
        //Since the PRD table need to be aligned at 64KB to create maximum # of tables
        //allocate 128KB and use the 64KB aligned address,
        Status = pBS->AllocatePool( EfiBootServicesData,
                                    2 * 64 * 1024,
                                    (VOID**)&gDescriptorBuffer
                                    );

        if ( EFI_ERROR( Status )) {
            IdeBusInitInterface->BusMasterSelection = 0;
        }
    }

#ifdef Debug_Level_3
    EfiDebugPrint( -1, "Installed IDE_BUS_INIT_PROTOCOL\n" );
#endif

    return Status;
}

//<AMI_PHDR_START>
//---------------------------------------------------------------------------
//
// Procedure:	ConfigureIdeDeviceAndController
//
// Description:	PIO and DMA mode programming both on the Controller as well as on the Device is done
//
// Input:
//	IDE_BUS_INIT_PROTOCOL			*IdeBusInitInterface
//	IDE_CONTROLLER_PROTOCOL			*IdeControllerInterface
//	IDE_BUS_INIT_PROTOCOL			*IdeBusInitInterface
//
// Output:
//	EFI_STATUS
//
// Modified:
//
// Referrals: ConfigureIdeDevice, GetIdentifyData
//
// Notes:
//  Here is the control flow of this function:
// 1. Get the Best PIO and DMA mode supported by the device from Identify Data
// 2. Set the PIO and DMA mode in the IDE controller.
// 3. Configure the IDE device with the PIO and DMA mode.
// 4. Update the Identify Data.
// 5. Based on the IDE device select the proper Read/Write commands.
// 6. Construct a unicode string for the IDE device.
//
//---------------------------------------------------------------------------
//<AMI_PHDR_END>
EFI_STATUS ConfigureIdeDeviceAndController(
    IN IDE_BUS_PROTOCOL                 *IdeBusInterface,
    IN VOID              *IdeControllerInterfaceIn,
    IN IDE_BUS_INIT_PROTOCOL            *IdeBusInitInterface )
{
    EFI_STATUS              Status;
    UINT8                   Current_Channel = IdeBusInterface->IdeDevice.Channel;
    UINT8                   Current_Device  = IdeBusInterface->IdeDevice.Device;

    EFI_ATA_COLLECTIVE_MODE *SupportedModes = NULL;
    EFI_IDE_CONTROLLER_INIT_PROTOCOL       *EfiIdeControllerInterface = NULL ;
    IDE_CONTROLLER_PROTOCOL    *IdeControllerInterface = NULL ;


    if ( gPlatformIdeProtocol->EfiIdeProtocol )
        EfiIdeControllerInterface = (EFI_IDE_CONTROLLER_INIT_PROTOCOL*) IdeControllerInterfaceIn;
    else
        IdeControllerInterface = (IDE_CONTROLLER_PROTOCOL *) IdeControllerInterfaceIn;

    if ( gPlatformIdeProtocol->EfiIdeProtocol ) {
        GetIdentifyData( IdeBusInterface, &(IdeBusInterface->IdeDevice));
        Status = EfiIdeControllerInterface->SubmitData( EfiIdeControllerInterface, IdeBusInterface->IdeDevice.Channel,
                                                 IdeBusInterface->IdeDevice.Device, (EFI_IDENTIFY_DATA*)&(IdeBusInterface->IdeDevice.IdentifyData));

        if ( EFI_ERROR( Status )) {
            return Status;
        }

	    Status = EfiIdeControllerInterface->CalculateMode( EfiIdeControllerInterface, IdeBusInterface->IdeDevice.Channel,
                                                    IdeBusInterface->IdeDevice.Device, &SupportedModes );

    if ( EFI_ERROR( Status )) {
        return Status;
    }

	    Status = EfiIdeControllerInterface->SetTiming( EfiIdeControllerInterface, IdeBusInterface->IdeDevice.Channel,
                                                IdeBusInterface->IdeDevice.Device, SupportedModes );

        if ( EFI_ERROR( Status )) {
            return Status;
        }

	    IdeBusInterface->IdeDevice.PIOMode = 0xff;
	    IdeBusInterface->IdeDevice.SWDma   = 0xff;
	    IdeBusInterface->IdeDevice.MWDma   = 0xff;
	    IdeBusInterface->IdeDevice.UDma    = 0xff;

        if ( SupportedModes->PioMode.Valid ) {
            IdeBusInterface->IdeDevice.PIOMode = SupportedModes->PioMode.Mode;
        }

        if ( SupportedModes->SingleWordDmaMode.Valid ) {
            IdeBusInterface->IdeDevice.SWDma = SupportedModes->SingleWordDmaMode.Mode;
        }

        if ( SupportedModes->MultiWordDmaMode.Valid ) {
             IdeBusInterface->IdeDevice.MWDma = SupportedModes->MultiWordDmaMode.Mode;
        }

        if ( SupportedModes->UdmaMode.Valid ) {
            IdeBusInterface->IdeDevice.UDma = SupportedModes->UdmaMode.Mode;
        }

	    IdeBusInterface->IdeDevice.IORdy = ((EFI_IDENTIFY_DATA*)&(IdeBusInterface->IdeDevice.IdentifyData))->AtaData.capabilities & 0x800;

    } else {
        //    
        // Get the best PIO and DMA mode from the IDE device
        //    
	    IdeControllerInterface->GetbestPioDmaMode( &(IdeBusInterface->IdeDevice));

        //
        // Program PIO mode Timing in the controller
        //
	    IdeControllerInterface->IdeSetPioMode( &(IdeBusInterface->IdeDevice));

        // See if Bus Master has been enabled
	    IdeControllerInterface->IdeSetDmaMode( &(IdeBusInterface->IdeDevice)); 
    }

    //	Issue SET feature command to set the PIO and DMA mode
    Status = ConfigureIdeDevice( IdeBusInterface, IdeBusInitInterface );

    if ( EFI_ERROR( Status )) {
        return Status;
    } else {
        //
        //Get the updated IdentifyData
        //
        GetIdentifyData( IdeBusInterface, &(IdeBusInterface->IdeDevice));

        //
        //Check if UDMA and MWDMA are programmed successfully
        //    
        if ( IdeBusInterface->IdeDevice.UDma != 0xff ) {
            if ( !(ReturnMSBset((IdeBusInterface->IdeDevice.IdentifyData.UDMA_Mode_88 >> 8)) == IdeBusInterface->IdeDevice.UDma)) {
                IdeBusInterface->IdeDevice.UDma = ReturnMSBset((IdeBusInterface->IdeDevice.IdentifyData.UDMA_Mode_88 >> 8));
                if ( gPlatformIdeProtocol->EfiIdeProtocol ) {
                    SupportedModes->UdmaMode.Mode = IdeBusInterface->IdeDevice.UDma;
                    EfiIdeControllerInterface->SetTiming( EfiIdeControllerInterface, IdeBusInterface->IdeDevice.Channel,
                                                             IdeBusInterface->IdeDevice.Device, SupportedModes );
                } else {
                    IdeControllerInterface->IdeSetDmaMode( &(IdeBusInterface->IdeDevice));
                }
            }
        } else {
            if ( IdeBusInterface->IdeDevice.MWDma != 0xff ) {
                if ( !(ReturnMSBset( IdeBusInterface->IdeDevice.IdentifyData.MultiWord_DMA_63 >> 8 ) == IdeBusInterface->IdeDevice.MWDma)) {
                    IdeBusInterface->IdeDevice.MWDma = ReturnMSBset( (IdeBusInterface->IdeDevice.IdentifyData.MultiWord_DMA_63 >> 8));
                    if ( gPlatformIdeProtocol->EfiIdeProtocol ) {
                        SupportedModes->MultiWordDmaMode.Mode = IdeBusInterface->IdeDevice.MWDma;
                        EfiIdeControllerInterface-> SetTiming( EfiIdeControllerInterface, IdeBusInterface->IdeDevice.Channel,
                                                        IdeBusInterface->IdeDevice.Device, SupportedModes );
                    } else {
                        IdeControllerInterface->IdeSetDmaMode( &(IdeBusInterface->IdeDevice));
                    } 
                }
            }
        }

        //		Check for ATA
        if ( IdeBusInterface->IdeDevice.DeviceType == ATA ) {
            //			Update IDE Read/Write Command
            if  ((IdeBusInterface->IdeDevice.IdentifyData.Valid_Bits_59 & 0x100)
                 && (IdeBusInterface->IdeDevice.IdentifyData.Valid_Bits_59 & 0xff)) {  // Check if Multiple Read/Write
                if ( IdeBusInterface->IdeDevice.IdentifyData.Command_Set_Supported_83 & 0x400 ) {
                    //					48Bit LBA supported
                    IdeBusInterface->IdeDevice.ReadCommand  = READ_MULTIPLE_EXT;
                    IdeBusInterface->IdeDevice.WriteCommand = WRITE_MULTIPLE_EXT;
                } else {
                    IdeBusInterface->IdeDevice.ReadCommand  = READ_MULTIPLE;
                    IdeBusInterface->IdeDevice.WriteCommand = WRITE_MULTIPLE;
                }
            } else {                      // 1 Block = 1 Sector
                if ( IdeBusInterface->IdeDevice.IdentifyData.Command_Set_Supported_83 & 0x400 ) {
                    //					48Bit LBA supported
                    IdeBusInterface->IdeDevice.ReadCommand  = READ_SECTORS_EXT;
                    IdeBusInterface->IdeDevice.WriteCommand = WRITE_SECTORS_EXT;
                } else {
                    IdeBusInterface->IdeDevice.ReadCommand  = READ_SECTORS;
                    IdeBusInterface->IdeDevice.WriteCommand = WRITE_SECTORS;
                }
            }

            if ( DMACapable( IdeBusInterface )) {
                if ( gPlatformIdeProtocol->IdeBusMasterSupport ) {
                    IdeBusInterface->IdeDevice.ReadCommand  = READ_DMA;
                    IdeBusInterface->IdeDevice.WriteCommand = WRITE_DMA;

                    if ( IdeBusInterface->IdeDevice.IdentifyData.Command_Set_Supported_83 & 0x400 ) {
                    //
                    // 48Bit LBA supported
                    //
                        IdeBusInterface->IdeDevice.ReadCommand  = READ_DMA_EXT;
                        IdeBusInterface->IdeDevice.WriteCommand = WRITE_DMA_EXT;
	                }
 			    }
            }
        }    
        IdeBusInitInterface->IdeBusInitData[Current_Channel][Current_Device] = DEVICE_CONFIGURED_SUCCESSFULLY;
    }

    if ( gPlatformIdeProtocol->DisableSoftSetPrev || gPlatformIdeProtocol->ForceHddPasswordPrompt ) {

        //
        // Software settings preserved
        //
        if ((IdeBusInterface->IdeDevice.IdentifyData.Reserved_76_79[0] != 0xFFFF)
            && (IdeBusInterface->IdeDevice.IdentifyData.Reserved_76_79[2] & 0x0040)) {
            Status = IdeSetFeatureCommand( IdeBusInterface, DISABLE_SATA2_SOFTPREV, 6 );
            //
            // Get the updated IdentifyData
            //
            GetIdentifyData( IdeBusInterface, &(IdeBusInterface->IdeDevice));
        }
    }

    return EFI_SUCCESS;
}

//<AMI_PHDR_START>
//---------------------------------------------------------------------------
//
// Procedure:	InitIdeBlockIO
//
// Description:	Initializes IDE Block IO interface
//
// Input:
//
//	IDE_BUS_PROTOCOL				*IdeBusInterface,
//
// Output:
//	EFI_STATUS
//
// Modified:
//
// Referrals: AllocatePool, OpenProtocol, DetectAtapiMedia, AtapiInquiryData
//
// Notes:
//  Here is the control flow of this function:
//  1. Initialize EFI_BLOCK_IO_PROTOCOL Protocol.
//	2. In case of Removable devices, detect Media presence.
//
//---------------------------------------------------------------------------
//<AMI_PHDR_END>

EFI_STATUS InitIdeBlockIO(
    IN IDE_BUS_PROTOCOL *IdeBusInterface )
{
    EFI_STATUS            Status;
    EFI_BLOCK_IO_PROTOCOL *BlkIo;
    IDE_BLOCK_IO          *IdeBlkIo;
    EFI_BLOCK_IO_MEDIA    *BlkMedia;
    ATAPI_DEVICE          *AtapiDevice;
    UINT8                 *Data;
    UINT8                 *InquiryData;
    UINT16                InquiryDataSize;
    UINT8                 Current_Channel;
    UINT8                 Current_Device;
    UINT8                 bTemp;
    UINT16                OddType = 0;
    UINT8                 OddLoadingType =0xFF;
    UINT32                SectorSize = ATA_SECTOR_BYTES;

    Status = pBS->AllocatePool( EfiBootServicesData,
                                sizeof(IDE_BLOCK_IO),
                                (VOID**)&IdeBlkIo );

    if ( EFI_ERROR( Status )) {
        return Status;
    }


    BlkMedia = MallocZ( sizeof(EFI_BLOCK_IO_MEDIA));

    if ( !BlkMedia ) {
        pBS->FreePool( IdeBlkIo );
        return EFI_OUT_OF_RESOURCES;
    }

    //
    //Initialize the IdeBlkIo pointer in IDE_BUS_PROTOCOL (IdeBusInterface)
    //
    IdeBusInterface->IdeBlkIo = IdeBlkIo;

    //
    //Initialize the fields in IdeBlkIo (IDE_BLOCK_IO)
    //    
    IdeBlkIo->IdeBusInterface = IdeBusInterface;

    if ( IdeBusInterface->IdeDevice.DeviceType == ATA ) {
        //    
        //ATA
        //    
        BlkIo              = &(IdeBlkIo->BlkIo);
        //
        // UEFI2.3.1 Supports the BlockIo Revision 3
        //
        if(pST->Hdr.Revision >= 0x0002001F) {
            BlkIo->Revision    = EFI_BLOCK_IO_PROTOCOL_REVISION3;
        } else {
            BlkIo->Revision    = BLKIO_REVISION;
        }
        BlkIo->Media       = BlkMedia;
        BlkIo->Reset       = AtaReset;
        BlkIo->ReadBlocks  = AtaBlkRead;
        BlkIo->WriteBlocks = AtaBlkWrite;
        BlkIo->FlushBlocks = AtaBlkFlush;

        BlkMedia->MediaId        = 0;
        BlkMedia->RemovableMedia = (IdeBusInterface->IdeDevice.IdentifyData.General_Config_0 & 0x80) == 0x80 ? TRUE : FALSE;

        //Check if Hot plug supported for this device
        Current_Channel = IdeBusInterface->IdeDevice.Channel;
        Current_Device  = IdeBusInterface->IdeDevice.Device;
        bTemp           = Current_Channel == 0 ? 1 : 4;       // BIT MASK

        if ( Current_Device ) {
            bTemp <<= 1;
        }

        if ( bTemp & IdeBusInterface->IdeBusInitInterface->HPMask ) {
            BlkMedia->RemovableMedia = TRUE;
        }

        BlkMedia->MediaPresent     = TRUE;
        BlkMedia->LogicalPartition = FALSE;
        BlkMedia->ReadOnly         = FALSE;
        BlkMedia->WriteCaching     = FALSE;


        if((IdeBusInterface->IdeDevice.IdentifyData.Reserved_104_126[2] & BIT14) && // WORD 106 valid? - BIT 14 - 1
           (!(IdeBusInterface->IdeDevice.IdentifyData.Reserved_104_126[2] & BIT15)) && // WORD 106 valid? - BIT 15 - 0
           (IdeBusInterface->IdeDevice.IdentifyData.Reserved_104_126[2] & BIT12)) { // WORD 106 bit 12 - Sectorsize > 256 words
            // The sector size is in words 117-118.
            SectorSize = (UINT32)(IdeBusInterface->IdeDevice.IdentifyData.Reserved_104_126[13] + \
                                  (IdeBusInterface->IdeDevice.IdentifyData.Reserved_104_126[14] << 16)) * 2;
        }

        BlkMedia->BlockSize = SectorSize;

        //If BusMaster Support is Enabled for the device, IO Alignment should be DWORD

        if ( DMACapable( IdeBusInterface )) {
            BlkMedia->IoAlign = 4;
        } else {
            BlkMedia->IoAlign = 0;
        }

        if ( IdeBusInterface->IdeDevice.IdentifyData.Command_Set_Supported_83 & 0x400 ) {
            BlkMedia->LastBlock = IdeBusInterface->IdeDevice.IdentifyData.LBA_48 - 1;
        } else {
            BlkMedia->LastBlock = IdeBusInterface->IdeDevice.IdentifyData.Addressable_Sector_60 - 1;
        }

        if(pST->Hdr.Revision >= 0x0002001F) {

            BlkMedia->OptimalTransferLengthGranularity=BlkMedia->BlockSize;
            //
            // bit 14 of word 106 is set to one and bit 15 of word 106 is cleared to zero, 
            // then the contents of word 106 contain valid information . 
            // Otherwise, information is not valid in this word.
            //
            if ( (IdeBusInterface->IdeDevice.IdentifyData.Reserved_104_126[2] & 0xC000) == 0x4000 ) {
                //
                // If bit 13 of word 106 is set to one, then the device has more than one 
                // logical sector per physical sector and bits (3:0) of word 106 are valid
                //
                if ( IdeBusInterface->IdeDevice.IdentifyData.Reserved_104_126[2] & 0x2000 ) {
    
                    BlkMedia->LogicalBlocksPerPhysicalBlock = 1 << 
                                    (IdeBusInterface->IdeDevice.IdentifyData.Reserved_104_126[2] & 0xF);
    
                    //
                    // Bits 13:0 of word 209 indicate the Logical sector offset within the first physical 
                    // sector where the first logical sector is placed
                    //
                    BlkMedia->LowestAlignedLba =IdeBusInterface->IdeDevice.IdentifyData.Reserved_206_254[3] & 0x3FFF;
    
                } else {
                    //
                    // Default set the 1 logical blocks per PhysicalBlock
                    //
                    BlkMedia->LogicalBlocksPerPhysicalBlock=1;
    
                    //
                    // Default value set to 0 for Lowest Aligned LBA
                    //
                    BlkMedia->LowestAlignedLba=0;
                }
            } else {
                    //
                    // Default set the 1 logical blocks per PhysicalBlock
                    //
                    BlkMedia->LogicalBlocksPerPhysicalBlock=1;
                    //
                    // Default value set to 0 for Lowest Aligned LBA
                    //
                    BlkMedia->LowestAlignedLba=0;
            }
        }
    } else {
        //
        //If it is an ATAPI device, check whether it is a CDROM or not. Currently only CDROM/Direct access Devices are supported.
        //
        if ((IdeBusInterface->IdeDevice.IdentifyData.General_Config_0 & 0x1f00) == (CDROM_DEVICE << 8)
            || (IdeBusInterface->IdeDevice.IdentifyData.General_Config_0 & 0x1f00) == (DIRECT_ACCESS_DEVICE << 8)
            || (IdeBusInterface->IdeDevice.IdentifyData.General_Config_0 & 0x1f00) == (OPTICAL_MEMORY_DEVICE << 8)) {
            AtapiDevice = MallocZ( sizeof (ATAPI_DEVICE));

            if ( !AtapiDevice ) {
                return EFI_OUT_OF_RESOURCES;
            }

            IdeBusInterface->IdeDevice.AtapiDevice = AtapiDevice;

            Status = pBS->AllocatePool( EfiBootServicesData,
                                        16,
                                        (VOID**)&Data
                                        );

            if ( EFI_ERROR( Status )) {
                return Status;
            }

            AtapiDevice->PacketBuffer = Data;
            AtapiDevice->DeviceType   = (IdeBusInterface->IdeDevice.IdentifyData.General_Config_0 & 0x1f00) >> 8;
            AtapiDevice->PacketSize   = (IdeBusInterface->IdeDevice.IdentifyData.General_Config_0 & 3) == 1 ? 16 : 12;

            BlkIo              = &(IdeBlkIo->BlkIo);
            //
            // UEFI2.3.1 Supports the BlockIo Revision 3
            //
            if(pST->Hdr.Revision >= 0x0002001F) {
                BlkIo->Revision    = EFI_BLOCK_IO_PROTOCOL_REVISION3;
            } else {
                BlkIo->Revision    = BLKIO_REVISION;
            }
            BlkIo->Media       = BlkMedia;
            BlkIo->Reset       = AtapiReset;
            BlkIo->ReadBlocks  = AtapiBlkRead;
            BlkIo->WriteBlocks = AtapiBlkWrite;
            BlkIo->FlushBlocks = AtapiBlkFlush;
            //
            //Initialize with default value. Later on it will be updated if needed.
            //
            BlkMedia->BlockSize = CDROM_BLOCK_SIZE;


            //
            //Update Inquiry Data
            //
            Status = pBS->AllocatePool( EfiBootServicesData,
                                        INQUIRY_DATA_LENGTH,
                                        (VOID**)&InquiryData );

            if ( EFI_ERROR( Status )) {
                return Status;
            }
            InquiryDataSize = INQUIRY_DATA_LENGTH;
            AtapiInquiryData( IdeBusInterface, InquiryData, &InquiryDataSize );
            AtapiDevice->InquiryData     = InquiryData;
            AtapiDevice->InquiryDataSize = InquiryDataSize;

            //
            // Get the ATAPI drive Type information and save it ATAPI_DEVICE
            //
            Status = GetOddType( IdeBusInterface, &OddType );

            if ( !EFI_ERROR( Status )) {
                AtapiDevice->OddType = GetEnumOddType( OddType );
            }

            //
            // Get the ATAPI drive Loading information and save it ATAPI_DEVICE
            //
            Status = GetOddLoadingType( IdeBusInterface, &OddLoadingType );

            if ( !EFI_ERROR( Status )) {
                AtapiDevice->OddLoadingType = (ODD_LOADING_TYPE)OddLoadingType;
            } else {
                AtapiDevice->OddLoadingType = (ODD_LOADING_TYPE)0xFF;
            }

            BlkMedia->RemovableMedia   = (IdeBusInterface->IdeDevice.IdentifyData.General_Config_0 & 0x80) == 0x80 ? TRUE : FALSE;
            BlkMedia->LogicalPartition = FALSE;
            BlkMedia->WriteCaching     = FALSE;

            //
            //If BusMaster Support is Enabled for the device, IO Alignment should be DWORD
            //
            if ( DMACapable( IdeBusInterface )) {
                BlkMedia->IoAlign = 4;
            } else {
                BlkMedia->IoAlign = 0;
            }
        }
    }
    return EFI_SUCCESS;
}

//<AMI_PHDR_START>
//---------------------------------------------------------------------------
//
// Procedure:	GetEnumOddType
//
// Description:	Get the Enum value for ODD type found on profile
//
// Input:
//
//      UINT16      Oddtype
// Output:
//      ODD_TYPE    EnumValue
//
// Modified:
//
// Referrals:
//
// Notes:
//
//---------------------------------------------------------------------------
//<AMI_PHDR_END>
ODD_TYPE GetEnumOddType(
    UINT16 OddType )
{
    switch ( OddType )
    {
    case 1:
    case 3:
    case 4:
    case 5:
        return Obsolete;

    case 2:
        return Removabledisk;

    case 8:
        return CDROM;

    case 9:
        return CDR;

    case 0xa:
        return CDRW;

    case 0x10:
        return DVDROM;

    case 0x11:
        return DVDRSequentialrecording;

    case 0x12:
        return DVDRAM;

    case 0x13:
        return DVDRWRestrictedOverwrite;

    case 0x15:
        return DVDRWSequentialrecording;

    case 0x16:
        return DVDRDualLayerJumprecording;

    case 0x17:
        return DVDRWDualLayer;

    case 0x18:
        return DVDDownloaddiscrecording;

    case 0x1a:
        return DVDRW;

    case 0x1b:
        return DVDR;

    case 0x40:
        return BDROM;

    case 0x41:
        return BDRSequentialRecording;

    case 0x42:
        return BDRRandomRecordingMode;

    case 0x43:
        return BDRE;

    case 0x50:
        return HDDVDROM;

    case 0x51:
        return HDDVDR;

    case 0x52:
        return HDDVDRAM;

    case 0x53:
        return HDDVDRW;

    case 0x58:
        return HDDVDRDualLayer;

    case 0x5a:
        return HDDVDRWDualLayer;

    default:
        return UnknownType;
    }
}

//<AMI_PHDR_START>
//---------------------------------------------------------------------------
//
// Procedure:	InitIdeDiskInfo
//
// Description:	Initializes IDE DiskInfo Interface
//
// Input:
//
//	IDE_BUS_PROTOCOL		*IdeBusInterface,
//
// Output:
//	EFI_STATUS
//
// Modified:
//
// Referrals: AllocatePool OpenProtocol
//
// Notes:
//
//---------------------------------------------------------------------------
//<AMI_PHDR_END>

EFI_STATUS InitIdeDiskInfo(
    IN IDE_BUS_PROTOCOL *IdeBusInterface )
{
    EFI_STATUS    Status;
    IDE_DISK_INFO *IdeDiskInfo;

    Status = pBS->AllocatePool( EfiBootServicesData,
                                sizeof(IDE_DISK_INFO),
                                (VOID**)&IdeDiskInfo );

    if ( EFI_ERROR( Status )) {
        return Status;
    }

    //
    //Initialize the IdeBlkIo pointer in IDE_BUS_PROTOCOL (IdeBusInterface)
    //
    IdeBusInterface->IdeDiskInfo = IdeDiskInfo;

    //
    //Initialize the fields in IdeDiskInfo (IDE_DISK_INFO)
    //
    IdeDiskInfo->IdeBusInterface = IdeBusInterface;

    pBS->CopyMem( &(IdeDiskInfo->DiskInfo.Interface), &gEfiIdeDiskInfoProtocolGuid, sizeof (EFI_GUID));
    IdeDiskInfo->DiskInfo.Inquiry   = DiskInfoInquiry;
    IdeDiskInfo->DiskInfo.Identify  = DiskInfoIdentify;
    IdeDiskInfo->DiskInfo.SenseData = DiskInfoSenseData;
    IdeDiskInfo->DiskInfo.WhichIde  = DiskInfoWhichIDE;
    return EFI_SUCCESS;
}

//<AMI_PHDR_START>
//---------------------------------------------------------------------------
//
// Procedure:	CreateIdeDevicePath
//
// Description:	Creates a IDE device devicepath and adds it to IdeBusInterface
//
// Input:
//	IN EFI_DRIVER_BINDING_PROTOCOL  *This,
//	IN EFI_HANDLE                   Controller,
//	IDE_BUS_INIT_PROTOCOL			*IdeBusInitInterface;
//	IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath
//	UINT8							Current_Channel
//	UINT8							Current_Device
//
// Output:
//	EFI_STATUS
//
// Modified:
//
// Referrals: AllocatePool, OpenProtocol, IdeBusStart
//
// Notes:
//  Here is the control flow of this function:
//  1.  If Remaining Devicepath is not NULL, we have already verified that it is a
//			valid Atapi device path in IdeBusStart. So nothing to do. Just exit.
//	2.	Build a Atapi devicepath and a End devce path.
//	3.  Get the Devicepath for the IDE controller.
//	3.  Append Atapi devicepath to  IDE controller devicepath.
//
//---------------------------------------------------------------------------
//<AMI_PHDR_END>
EFI_STATUS CreateIdeDevicePath(
    IN EFI_DRIVER_BINDING_PROTOCOL  *This,
    IN EFI_HANDLE                   Controller,
    IDE_BUS_INIT_PROTOCOL           *IdeBusInitInterface,
    IDE_BUS_PROTOCOL                *IdeBusInterface,
    IN OUT EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath,
    IN UINT8                        Current_Channel,
    IN UINT8                        Current_Device )
{
    EFI_STATUS               Status;
    ATAPI_DEVICE_PATH        NewDevicePath;
    EFI_DEVICE_PATH_PROTOCOL *TempDevicePath;

    NewDevicePath.Header.Type    = MESSAGING_DEVICE_PATH;
    NewDevicePath.Header.SubType = MSG_ATAPI_DP;
    SET_NODE_LENGTH( &NewDevicePath.Header, ATAPI_DEVICE_PATH_LENGTH );
    NewDevicePath.PrimarySecondary = Current_Channel;
    NewDevicePath.SlaveMaster      = Current_Device;
    NewDevicePath.Lun              = 0;

    //
    //Append the Device Path
    //
    Status = pBS->OpenProtocol( Controller,
                                &gDevicePathProtocolGuid,
                                (VOID**)&TempDevicePath,
                                This->DriverBindingHandle,
                                Controller,
                                EFI_OPEN_PROTOCOL_GET_PROTOCOL );

    IdeBusInterface->DevicePathProtocol = DPAddNode( TempDevicePath, &NewDevicePath.Header );
    return EFI_SUCCESS;
}

//<AMI_PHDR_START>
//---------------------------------------------------------------------------
//
// Procedure:	ConfigureIdeDevice
//
// Description:	Issues SET FEATURE Command
//
// Input:
//		IDE_BUS_PROTOCOL			*IdeBusInterface,
//		IDE_BUS_INIT_PROTOCOL		*IdeBusInitInterface
//
// Output:
//	EFI_STATUS
//
// Modified:
//
// Referrals: ConfigureIdeDeviceAndController, IdeSetFeatureCommand
//
// Notes:
//  Here is the control flow of this function:
//  1. Issue Set feature commend to set PIO mode if needed.
//	2. Set Multiple Mode command for ATA devices if needed.
//  3. Issue Set feature commend to set UDMA/MWDMA. If it fails, disable Busmaster support.
//
//---------------------------------------------------------------------------
//<AMI_PHDR_END>

EFI_STATUS ConfigureIdeDevice(
    IN IDE_BUS_PROTOCOL      *IdeBusInterface,
    IN IDE_BUS_INIT_PROTOCOL *IdeBusInitInterface )
{
    EFI_STATUS               Status= EFI_SUCCESS;
    UINT8                    DMACapability;
    UINT8                    Data8;
    IO_REGS                  Regs = IdeBusInterface->IdeDevice.Regs;
    UINT16                   DeviceName[41];
    UINT16                   Index;

    EFI_UNICODE_STRING_TABLE *tempUnicodeTable;
    CHAR8                    Language[] = "Eng";

    //
    //Check if Device need spin-up
    //
    if ((IdeBusInterface->IdeDevice.IdentifyData.General_Config_0 & 4)
        && (IdeBusInterface->IdeDevice.IdentifyData.Special_Config_2 == SPIN_UP_REQUIRED1
            || IdeBusInterface->IdeDevice.IdentifyData.Special_Config_2 == SPIN_UP_REQUIRED2)) {
        Status = IdeSetFeatureCommand( IdeBusInterface, SET_DEVICE_SPINUP, 0 );

        if ( EFI_ERROR( Status )) {    
            //
            //Some HDD may take a long time to spin up. Wait for additional time
            //
            Status = WaitforBitClear( IdeBusInterface->PciIO, Regs.ControlBlock.AlternateStatusReg, BSY | DRQ, gPlatformIdeProtocol->PoweonBusyClearTimeout );
        }
        //
        //Get the Identify Command once more
        //
        GetIdentifyData( IdeBusInterface, &(IdeBusInterface->IdeDevice));
    }

    //
    //	Check if PIO mode needs to be programmed
    //    
    if ((IdeBusInterface->IdeDevice.IdentifyData.Valid_Bits_53 & 0x2) && (IdeBusInterface->IdeDevice.PIOMode != 0xff)) {
        Status = IdeSetFeatureCommand( IdeBusInterface, SET_TRANSFER_MODE, PIO_FLOW_CONTROL | IdeBusInterface->IdeDevice.PIOMode );
    }

    if ( EFI_ERROR( Status )) {
        return EFI_DEVICE_ERROR;
    }

    //
    //Issue Set Multiple Mode Command only for ATA device
    //
    if  ( IdeBusInterface->IdeDevice.DeviceType == ATA ) {
        Data8 = IdeBusInterface->IdeDevice.IdentifyData.Maximum_Sector_Multiple_Command_47 & 0xff;

        if ( Data8 & 0x2 ) {
            Data8 = 2;
        }

        if ( Data8 & 0x4 ) {
            Data8 = 0x4;
        }

        if ( Data8 & 0x8 ) {
            Data8 = 0x8;
        }

        if ( Data8 & 0x10 ) {
            Data8 = 0x10;
        }

        if ( Data8 & 0x20 ) {
            Data8 = 0x20;
        }

        if ( Data8 & 0x40 ) {
            Data8 = 0x40;
        }

        if ( Data8 & 0x80 ) {
            Data8 = 0x80;
        }

        if ( Data8 > 1 ) {
            Status = IdeNonDataCommand(
                IdeBusInterface,
                0,              // Features
                Data8,          // Sector Count
                0,              // LBA Low
                0,              // LBA Mid
                0,              // LBA High
                IdeBusInterface->IdeDevice.Device << 4, // Device
                SET_MULTIPLE_MODE );                     // Command
        }
    }

    //Check if Busmaster Enabled
    //Status = EFI_NOT_FOUND;
    //Check if  UDMA is supported
    if  ( IdeBusInterface->IdeDevice.UDma != 0xff ) {
        Status =     IdeSetFeatureCommand( IdeBusInterface, SET_TRANSFER_MODE, UDMA_MODE | IdeBusInterface->IdeDevice.UDma );
    } else {
        if ( IdeBusInterface->IdeDevice.MWDma != 0xff ) {
            Status = IdeSetFeatureCommand( IdeBusInterface, SET_TRANSFER_MODE, MWDMA_MODE | IdeBusInterface->IdeDevice.MWDma );
        }
    }

    if ( EFI_ERROR( Status )) {
        //
        //No DMA support
        //
        IdeBusInterface->IdeDevice.UDma  = 0xff;
        IdeBusInterface->IdeDevice.MWDma = 0xff;
    } else {
        //
        //Enable DMA capable bit
        //
        DMACapability = 0x20;

        if ( IdeBusInterface->IdeDevice.Device ) {
            DMACapability = 0x40;
        }

        if ( DMACapable( IdeBusInterface )) {
            IdeReadByte( IdeBusInterface->PciIO,
                         IdeBusInterface->IdeDevice.Regs.BusMasterBlock.BMStatusRegister,
                         &Data8 );
            Data8 |= DMACapability;
            IdeWriteByte( IdeBusInterface->PciIO,
                          IdeBusInterface->IdeDevice.Regs.BusMasterBlock.BMStatusRegister,
                          Data8 );
        }
    }

    //
    //Convert the Device string from Engligh to Unicode
    //
    IdeBusInterface->IdeDevice.UDeviceName = NULL;
	if ( gPlatformIdeProtocol->EfiIdeProtocol ) {
	    IdeBusInterface->ControllerNameTable = IdeBusInterface->IdeDevice.UDeviceName;
	} 

    for ( Index = 0; Index < 40; Index += 2 ) {

            DeviceName[Index]     = ((UINT8*)IdeBusInterface->IdeDevice.IdentifyData.Model_Number_27)[Index + 1];
            DeviceName[Index + 1] = ((UINT8*)IdeBusInterface->IdeDevice.IdentifyData.Model_Number_27)[Index];
    }

    for ( Index = 39; Index >= 0; Index-- ) {
        if ( DeviceName[Index] == 0x20 )
            continue;
        else 
            break;
    }

    DeviceName[Index + 1] = 0;        // Terminate string
    Index += 2;

    //
    //This is a patch to make it work for both in Aptio and Alaska
    //
    tempUnicodeTable = MallocZ( sizeof (EFI_UNICODE_STRING_TABLE) * 2 );

    Status = pBS->AllocatePool( EfiBootServicesData,
                                sizeof (Language),
                                (VOID**)&tempUnicodeTable[0].Language
                                );

    Status = pBS->AllocatePool( EfiBootServicesData,
                                Index * (sizeof (UINT16)),
                                (VOID**)&tempUnicodeTable[0].UnicodeString
                                );


    pBS->CopyMem( tempUnicodeTable[0].Language, &Language,  sizeof(Language));
    pBS->CopyMem( tempUnicodeTable[0].UnicodeString, DeviceName, Index * (sizeof (UINT16)));
    tempUnicodeTable[1].Language           = NULL;
    tempUnicodeTable[1].UnicodeString      = NULL;
    IdeBusInterface->IdeDevice.UDeviceName = tempUnicodeTable;
	if ( gPlatformIdeProtocol->EfiIdeProtocol ) {
	    IdeBusInterface->ControllerNameTable = IdeBusInterface->IdeDevice.UDeviceName;
	} 
    if ( gPlatformIdeProtocol->SBIdeSupport ) {
        InitMiscConfig(IdeBusInterface);
    }

	if ( gPlatformIdeProtocol->IdePowerManagementSupport ) {
	    Status = InitIDEPowerManagement( IdeBusInterface );
	}

    return EFI_SUCCESS;
}

//**********************************************************************
//<AMI_PHDR_START>
//
// Procedure:	InitMiscConfig
//
// Description:	Initialize misc IDE configurations.
//
// Input:
//	IN SATA_DEVICE_INTERFACE	*SataDevInterface	
//
// Output:
//	None
//
//<AMI_PHDR_END>
//**********************************************************************
VOID InitMiscConfig (
    IN IDE_BUS_PROTOCOL    *IdeBusInterface
)
{
    if ( gPlatformIdeProtocol->DiPMSupport ) {

        if(IdeBusInterface->IdeDevice.IdentifyData.Reserved_76_79[2] & \
                IDENTIFY_DiPM__SUPPORT) { // DiPM supported?
            //
            // Always disable DiPM in IDE mode
            //
            IdeSetFeatureCommand (IdeBusInterface, DiPM_DISABLE, DiPM_SUB_COMMAND);
        }
    }
    if ( gPlatformIdeProtocol->AcousticManagementSupport ) {
    	InitAcousticSupport (IdeBusInterface);
	}

}

//<AMI_PHDR_START>
//---------------------------------------------------------------------------
//
// Procedure:	InitAcousticSupport
//
// Description:	Initializes Acoustic Management Support functionality
//
// Input:
//		IDE_BUS_PROTOCOL			*IdeBusInterface,
//
// Output:
//	EFI_STATUS
//
// Modified:
//
// Referrals: IdeSetFeatureCommand
//
// Notes:
// 1. Check if the device support Acoustic management.
// 2. Check the desired state Vs the current state.
// 3. If both are equal nothing to do exit else program the desired level
//
//---------------------------------------------------------------------------
//<AMI_PHDR_END>
EFI_STATUS InitAcousticSupport(
    IN IDE_BUS_PROTOCOL *IdeBusInterface )
{
    UINT8 Data8;

    //
    //	Check if the device supports Acoustic Management
    //
    if  ( IdeBusInterface->IdeDevice.IdentifyData.Command_Set_Supported_83 & 0x200 ) {
        //
        //Check if Acoustic Level need to be enabled or Disabled
        //
        if ( IdeBusInterface->IdeBusInitInterface->Flags & ACOUSTIC_SUPPORT_ENABLE ) {
            Data8 = IdeBusInterface->IdeBusInitInterface->Acoustic_Management_Level;

            //
            // Do we need to program the recommended value
            //
			if ( Data8 == ACOUSTIC_LEVEL_BYPASS ) {
                //
                // Get the rcommended value
                //
				Data8 = (UINT8)(IdeBusInterface->IdeDevice.IdentifyData.Acoustic_Level_94 >> 8);
			}

				IdeSetFeatureCommand (IdeBusInterface, ACOUSTIC_MANAGEMENT_ENABLE, Data8);
		} else {
                //
                // If already disabled, nothing to do
                //
			if	(IdeBusInterface->IdeDevice.IdentifyData.Command_Set_Enabled_86 & 0x200) 			
				IdeSetFeatureCommand (IdeBusInterface, ACOUSTIC_MANAGEMENT_DISABLE, 0);
		}
	}
	return EFI_SUCCESS;
}


//<AMI_PHDR_START>
//---------------------------------------------------------------------------
//
// Procedure:	UpdateBaseAddress
//
// Description:	Updates Command and Control reg address.
//
// Input:
//	IDE_BUS_PROTOCOL			*IdeBusInterface;
//
// Output:
//	EFI_STATUS
//
// Modified:
//
// Referrals: IdeBusStart
//
// Notes:
//  Here is the control flow of this function:
//  1. Using PCI_IO_PROTOCOL, update the Command, control and Busmaster reg address.
//	Make use of Channel number while updating. Also check whether controller is running in Legacy/Native mode
//
//---------------------------------------------------------------------------
//<AMI_PHDR_END>

EFI_STATUS UpdateBaseAddress(
    IN IDE_BUS_PROTOCOL *IdeBusInterface )
{
    EFI_PCI_IO_PROTOCOL *PciIO;
    UINT8               PciConfig[0x40];
    UINT16              CommandReg;
    UINT16              ControlReg;
    UINT16              BusMasterReg;


    PciIO = IdeBusInterface->PciIO;
    PciIO->Pci.Read(
        PciIO,
        EfiPciIoWidthUint8,
        0,
        sizeof (PciConfig),
        PciConfig );

    if ((PciConfig [PROGRAMMING_INTERFACE_OFFSET] & (IdeBusInterface->IdeDevice.Channel == 0 ? 1 : 4))
        || (PciConfig [IDE_SUB_CLASS_CODE] == SCC_AHCI_CONTROLLER)
        || (PciConfig [IDE_SUB_CLASS_CODE] == SCC_RAID_CONTROLLER)) {
        //   
        //Native Mode Secondary
        //    
        if ( IdeBusInterface->IdeDevice.Channel ) {
            CommandReg   =    (*(UINT16*)(PciConfig + SECONDARY_COMMAND_BLOCK_OFFSET)) & 0xfffe;
            ControlReg   =   ((*(UINT16*)(PciConfig + SECONDARY_CONTROL_BLOCK_OFFSET)) & 0xfffe) + 2;
            BusMasterReg = ((*(UINT16*)(PciConfig + LEGACY_BUS_MASTER_OFFSET)) & 0xfffe) + 8;
        } else {  
            //
            // Native mode Primary
            //   
            CommandReg   =   (*(UINT16*)(PciConfig + PRIMARY_COMMAND_BLOCK_OFFSET)) & 0xfffe;
            ControlReg   =  ((*(UINT16*)(PciConfig + PRIMARY_CONTROL_BLOCK_OFFSET)) & 0xfffe) + 2;
            BusMasterReg = (*(UINT16*)(PciConfig + LEGACY_BUS_MASTER_OFFSET)) & 0xfffe;
        }
    } else {
        //
        //Legacy Mode Secondary
        //
        if ( IdeBusInterface->IdeDevice.Channel ) {
            CommandReg   = SECONDARY_COMMAND_BLOCK;
            ControlReg   = SECONDARY_CONTROL_BLOCK;
            BusMasterReg = (*(UINT16*)(PciConfig + LEGACY_BUS_MASTER_OFFSET) & 0xfffe) + 8;
        } else {      
            //
            //Legacy mode Primary
            //
            CommandReg   = PRIMARY_COMMAND_BLOCK;
            ControlReg   = PRIMARY_CONTROL_BLOCK;
            BusMasterReg = (*(UINT16*)(PciConfig + LEGACY_BUS_MASTER_OFFSET) & 0xfffe);
        }
    }

    //
    //	Validate the Address
    //
    if ( CommandReg == 0 || ControlReg == 0 ) {
        return EFI_DEVICE_ERROR;
    }

    if ( CommandReg == 0xfffe || ControlReg == 0xfffe ) {
        return EFI_DEVICE_ERROR;
    }

    //
    //Update the Command block registers
    //
    IdeBusInterface->IdeDevice.Regs.CommandBlock.DataReg        = CommandReg;
    IdeBusInterface->IdeDevice.Regs.CommandBlock.FeatureReg     = CommandReg + 1;
    IdeBusInterface->IdeDevice.Regs.CommandBlock.ErrorReg       = CommandReg + 1;
    IdeBusInterface->IdeDevice.Regs.CommandBlock.SectorCountReg = CommandReg + 2;
    IdeBusInterface->IdeDevice.Regs.CommandBlock.LBALowReg      = CommandReg + 3;
    IdeBusInterface->IdeDevice.Regs.CommandBlock.LBAMidReg      = CommandReg + 4;
    IdeBusInterface->IdeDevice.Regs.CommandBlock.LBAHighReg     = CommandReg + 5;
    IdeBusInterface->IdeDevice.Regs.CommandBlock.DeviceReg      = CommandReg + 6;
    IdeBusInterface->IdeDevice.Regs.CommandBlock.CommandReg     = CommandReg + 7;
    IdeBusInterface->IdeDevice.Regs.CommandBlock.StatusReg      = CommandReg + 7;

    //
    //Update the Control Block Register address
    //
    IdeBusInterface->IdeDevice.Regs.ControlBlock.DeviceControlReg   = ControlReg;
    IdeBusInterface->IdeDevice.Regs.ControlBlock.AlternateStatusReg = ControlReg;


    //
    //Update the Bus Master register address
    //
    IdeBusInterface->IdeDevice.Regs.BusMasterBlock.BMCommandRegister           = BusMasterReg;
    IdeBusInterface->IdeDevice.Regs.BusMasterBlock.BMStatusRegister            = BusMasterReg + 2;
    IdeBusInterface->IdeDevice.Regs.BusMasterBlock.BMDescriptorTablePointerReg = BusMasterReg + 4;

    return EFI_SUCCESS;
}

//<AMI_PHDR_START>
//---------------------------------------------------------------------------
//
// Procedure:	DMACapable
//
// Description:	Check if DMA is supported
//
// Input:
//	IN IDE_BUS_PROTOCOL				*IdeBusInterface,
//
// Output:
//		TRUE : DMA Capable
//
// Modified:
//
// Referrals:
//
// Notes:
//
//---------------------------------------------------------------------------
//<AMI_PHDR_END>
BOOLEAN DMACapable(
    IN IDE_BUS_PROTOCOL *IdeBusInterface )
{
    if ( IdeBusInterface->IdeDevice.DeviceType == ATAPI ) {
        //
        // For Atapi Devices check Bit 8 in Word 49 =  DMA	Supported or not
        //
        if ((IdeBusInterface->IdeDevice.IdentifyData.Capabilities_49 & 0x100) == 0 ) {
            return FALSE;
        }
    }

    if ((IdeBusInterface->IdeDevice.UDma != 0xff)
        || (IdeBusInterface->IdeDevice.MWDma != 0xff)) {
        return TRUE;
    } else {
        return FALSE;
    }
}

//<AMI_PHDR_START>
//---------------------------------------------------------------------------
//
// Procedure:	DiskInfoInquiry
//
// Description:
//
// Input:
//	IN EFI_DISK_INFO_PROTOCOL	*This,
//	IN OUT VOID					*InquiryData,
//	IN OUT UINT32				*InquiryDataSize
//
// Output:
//	EFI_STATUS
//
// Modified:
//
// Referrals: InitIdeDiskInfo
//
// Notes:
//	1. Check for Atapi Device. If not exit
//	2. COpy the Inquiry Data from AtapiDevice->InquiryData to the input pointer.
//
//---------------------------------------------------------------------------
//<AMI_PHDR_END>
EFI_STATUS DiskInfoInquiry(
    IN EFI_DISK_INFO_PROTOCOL *This,
    IN OUT VOID               *InquiryData,
    IN OUT UINT32             *InquiryDataSize )
{
    IDE_BUS_PROTOCOL *IdeBusInterface = ((IDE_BLOCK_IO*)This)->IdeBusInterface;
    ATAPI_DEVICE     *AtapiDevice     = IdeBusInterface->IdeDevice.AtapiDevice;


    //
    //	Check for ATAPI device. If not return EFI_NOT_FOUND
    //
    if ( IdeBusInterface->IdeDevice.DeviceType == ATA ) {
        return EFI_NOT_FOUND;               
    } else {
        if ( *InquiryDataSize < AtapiDevice->InquiryDataSize ) {
            *InquiryDataSize = AtapiDevice->InquiryDataSize;
            return EFI_BUFFER_TOO_SMALL;
        }

        if ( AtapiDevice->InquiryData != NULL ) {
            pBS->CopyMem( InquiryData, AtapiDevice->InquiryData, AtapiDevice->InquiryDataSize );
            *InquiryDataSize = AtapiDevice->InquiryDataSize;
            return EFI_SUCCESS;
        } else {
            return EFI_NOT_FOUND;
        }
    }
}

//<AMI_PHDR_START>
//---------------------------------------------------------------------------
//
// Procedure:	DiskInfoIdentify
//
// Description:	Return Identify Data
//
// Input:
//	EFI_DISK_INFO_PROTOCOL			*This,
//	IN OUT VOID						*IdentifyData,
//	IN OUT UINT32					*IdentifyDataSize
//
// Output:
//	EFI_STATUS
//
// Modified:
//
// Referrals: InitIdeDiskInfo
//
// Notes:
//	1. Return the Identify command data.
//
//---------------------------------------------------------------------------
//<AMI_PHDR_END>
EFI_STATUS DiskInfoIdentify(
    EFI_DISK_INFO_PROTOCOL *This,
    IN OUT VOID            *IdentifyData,
    IN OUT UINT32          *IdentifyDataSize )
{
    IDE_BUS_PROTOCOL *IdeBusInterface = ((IDE_BLOCK_IO*)This)->IdeBusInterface;

    if ( *IdentifyDataSize < sizeof (IDENTIFY_DATA)) {
        *IdentifyDataSize = sizeof (IDENTIFY_DATA);
        return EFI_BUFFER_TOO_SMALL;
    }

    pBS->CopyMem( IdentifyData, &(IdeBusInterface->IdeDevice.IdentifyData), sizeof (IDENTIFY_DATA));
    *IdentifyDataSize =  sizeof (IDENTIFY_DATA);
    return EFI_SUCCESS;
}

//<AMI_PHDR_START>
//---------------------------------------------------------------------------
//
// Procedure:	DiskInfoSenseData
//
// Description:	Return InfoSenseData.
//
// Input:
//	EFI_DISK_INFO_PROTOCOL          *This,
//	VOID						*SenseData,
//	UINT32						*SenseDataSize,
//	UINT8						*SenseDataNumber
//
// Output:
//	EFI_STATUS
//
// Modified:
//
// Referrals: InitIdeDiskInfo
//
// Notes:
//	1. Return the Sense data for the Atapi device.
//
//---------------------------------------------------------------------------
//<AMI_PHDR_END>
EFI_STATUS DiskInfoSenseData(
    IN EFI_DISK_INFO_PROTOCOL *This,
    OUT VOID                  *SenseData,
    OUT UINT32                *SenseDataSize,
    OUT UINT8                 *SenseDataNumber )
{
    return EFI_NOT_FOUND;
}

//<AMI_PHDR_START>
//---------------------------------------------------------------------------
//
// Procedure:	DiskInfoWhichIDE
//
// Description:	Returns whether the device is PM/PS/SM/SS
//
// Input:
//	IN EFI_DISK_INFO_PROTOCOL	*This,
//	OUT UINT32					*IdeChannel,
//	OUT UINT32					*IdeDevice
//
// Output:
//	EFI_STATUS
//
// Modified:
//
// Referrals: InitIdeDiskInfo
//
// Notes:
//	1. Return information about the Primary/Secondary channel and Master/Slave information.
//
//---------------------------------------------------------------------------
//<AMI_PHDR_END>

EFI_STATUS DiskInfoWhichIDE(
    IN EFI_DISK_INFO_PROTOCOL *This,
    OUT UINT32                *IdeChannel,
    OUT UINT32                *IdeDevice )
{
    IDE_BUS_PROTOCOL *IdeBusInterface = ((IDE_BLOCK_IO*)This)->IdeBusInterface;

    *IdeChannel = IdeBusInterface->IdeDevice.Channel;
    *IdeDevice  = IdeBusInterface->IdeDevice.Device;
    return EFI_SUCCESS;
}


//<AMI_PHDR_START>
//---------------------------------------------------------------------------
//
// Procedure:	IdeHPTimer
//
// Description:	Checks for any HP IDE device
//
// Input:
//	IN EFI_EVENT            Event,
//	IN VOID                         *Context
//
// Output:
//	EFI_STATUS
//
// Modified:
//
// Referrals:
//
// Notes:
//
//---------------------------------------------------------------------------
//<AMI_PHDR_END>
VOID IdeHPTimer(
    IN EFI_EVENT Event,
    IN VOID      *Context )
{
    EFI_STATUS                       Status;
    UINT8                            DeviceStatus;
    UINT8                            CurrentState;
    UINT8                            Current_Channel;
    UINT8                            Current_Device;
    IDE_BUS_INIT_PROTOCOL            *IdeBusInitInterface = (IDE_BUS_INIT_PROTOCOL*)Context;

    IDE_BUS_PROTOCOL                 *IdeBusInterface;
    IN IDE_CONTROLLER_PROTOCOL       *IdeControllerInterface = IdeBusInitInterface->IdeControllerInterface;

    IdeControllerInterface->HPCheckForDeviceChange( IdeControllerInterface->PciIO,
                                                    IdeBusInitInterface->HPMask,
                                                    &DeviceStatus );

    for ( Current_Channel = PRIMARY_CHANNEL; Current_Channel <= SECONDARY_CHANNEL; Current_Channel++ )
    {
        for ( Current_Device = MASTER_DRIVE; Current_Device <= SLAVE_DRIVE; Current_Device++ )
        {
            CurrentState    = IdeBusInitInterface->IdeBusInitData[Current_Channel][Current_Device];
            IdeBusInterface = IdeBusInitInterface->pIdeBusProtocol[Current_Channel][Current_Device];

            if ((CurrentState == DEVICE_CONFIGURED_SUCCESSFULLY) && ((DeviceStatus & 01) == 0)) {
                //
                //Handle Device Removal
                //
                    Status = pBS->DisconnectController( IdeControllerInterface->ControllerHandle, NULL, IdeBusInterface->IdeDeviceHandle );


                if ( Status == EFI_SUCCESS ) {
                    IdeBusInitInterface->IdeBusInitData[Current_Channel][Current_Device] = DEVICE_IN_RESET_STATE;
                }
            }

            if ((CurrentState != DEVICE_CONFIGURED_SUCCESSFULLY) && ((DeviceStatus & 01) == 1)) {
                //Handle device insertion
                //Force IdeBusStart to Enumerate this device.
                IdeBusInitInterface->IdeBusInitData[Current_Channel][Current_Device] = DEVICE_IN_RESET_STATE;
             
                pBS->ConnectController( IdeControllerInterface->ControllerHandle, NULL, NULL, TRUE );
            }
            DeviceStatus >>= 1;
        }
    }
}

//<AMI_PHDR_START>
//---------------------------------------------------------------------------
//
// Procedure:	CheckHPControllerPresence
//
// Description:	A quick check to see if ports are still decoded.
//
// Input:
//	IN IDE_BUS_PROTOCOL			*IdeBusInterface
//
// Output:
//	EFI_STATUS
//
// Modified:
//
// Referrals:
//
// Notes:
//
//---------------------------------------------------------------------------
//<AMI_PHDR_END>
EFI_STATUS CheckHPControllerPresence(
    IN IDE_BUS_PROTOCOL *IdeBusInterface )
{
    UINT8   Device = IdeBusInterface->IdeDevice.Device;
    IO_REGS Regs   = IdeBusInterface->IdeDevice.Regs;
    UINT8   Data8;

    //
    //Select the drive
    //
    IdeWriteByte( IdeBusInterface->PciIO, Regs.CommandBlock.DeviceReg, Device << 4 );

    //
    //Read the status Register
    //
    IdeReadByte( IdeBusInterface->PciIO, Regs.CommandBlock.StatusReg, &Data8 );

    if ( Data8 == 0xff ) {
        return EFI_NOT_FOUND;
    }

    if ( Data8 == 0x7f ) {
        return EFI_NOT_FOUND;
    }

    return EFI_SUCCESS;
}

                         // IDE_HP_SUPPORT
//---------------------------------------------------------------------------

#ifdef Debug_Level_3
//<AMI_PHDR_START>
//---------------------------------------------------------------------------
//
// Procedure:	PrintIdeDeviceInfo
//
// Description:	Prints Debug Level 3 Trace Messages
//
// Input:
//	IN IDE_BUS_PROTOCOL			*IdeBusInterface
//
// Output:
//	EFI_STATUS
//
// Modified:
//
// Referrals:
//
// Notes:
//
//---------------------------------------------------------------------------
//<AMI_PHDR_END>
void PrintIdeDeviceInfo(
    IDE_BUS_PROTOCOL *IdeBusInterface )
{
    UINT16 Data8;
    UINT16 *pIdentifyData;

    //		Print the Channel and Device Number
    EfiDebugPrint( -1, "-----------------IDE Device Info Start-----------------\n" );
    EfiDebugPrint( -1, "Channel   : %x   Device    : %x\n", IdeBusInterface->IdeDevice.Channel, IdeBusInterface->IdeDevice.Device );
    EfiDebugPrint( -1, "PIOMode   : %x   UDMAMode  : %x\n", IdeBusInterface->IdeDevice.PIOMode, IdeBusInterface->IdeDevice.UDma );
    EfiDebugPrint( -1, "SWDMAMode : %x   MWDMAMode : %x\n", IdeBusInterface->IdeDevice.SWDma,   IdeBusInterface->IdeDevice.MWDma );
    EfiDebugPrint( -1, "IORDY		: %x   \n",                  IdeBusInterface->IdeDevice.IORdy );
    pIdentifyData = (UINT16*) &(IdeBusInterface->IdeDevice.IdentifyData);

    for ( Data8 = 0; Data8 < 0xff; Data8 += 4 )
    {
        EfiDebugPrint( -1, "%X %X %X %X\n", pIdentifyData[Data8 + 0], pIdentifyData[Data8 + 1], pIdentifyData[Data8 + 2], pIdentifyData[Data8 + 3] );
    }
        EfiDebugPrint( -1, "-----------------IDE Device Info End-------------------\n" );
}

#endif          /* Debug_Level_3 */

//<AMI_PHDR_START>
//---------------------------------------------------------------------------
//
// Procedure:	CheckAhciMode
//
// Description:	Checks If the controller is in AHCI MODE.
//
// Input:
//	IDE_BUS_PROTOCOL			*IdeBusInterface;
//
// Output:
//	BOOLEAN                     TRUE  - AHCI Mode
//                              FALSE - IDE Mode
//
// Modified:
//
// Referrals:
//
// Notes:
//
//---------------------------------------------------------------------------
//<AMI_PHDR_END>
BOOLEAN CheckAhciMode(
    IN IDE_BUS_PROTOCOL *IdeBusInterface )
{
    EFI_PCI_IO_PROTOCOL *PciIO;
    UINT8               PciConfig[0x40];
    BOOLEAN             AhciFlag = FALSE;

    PciIO = IdeBusInterface->PciIO;
    PciIO->Pci.Read(
        PciIO,
        EfiPciIoWidthUint8,
        0,
        sizeof (PciConfig),
        PciConfig );

    AhciFlag = (BOOLEAN)((PciConfig [IDE_SUB_CLASS_CODE] & SCC_AHCI_CONTROLLER) ? TRUE : FALSE );

    return AhciFlag;
}

//<AMI_PHDR_START>
//---------------------------------------------------------------------------
//
// Procedure:	IssueFreezeLockCommand
//
// Description:	Issue the Freeze lock command.
//
// Input:
//	IDE_BUS_PROTOCOL			*IdeBusInterface;
//
// Output:
//
// Modified:
//
// Referrals:
//
// Notes:
//
//---------------------------------------------------------------------------
//<AMI_PHDR_END>
EFI_STATUS IssueFreezeLockCommand(
    IN IDE_BUS_PROTOCOL *IdeBusInterface )
{
    EFI_STATUS Status = EFI_SUCCESS;

    if ( IdeBusInterface->IdeDevice.IdentifyData.Command_Set_Supported_82 & 0x2 ) {
        Status = IdeNonDataCommand( IdeBusInterface, 0, 0,
                                    0, 0, 0,
                                    IdeBusInterface->IdeDevice.Device << 4,
                                    SECURITY_FREEZE_LOCK );
        //    
        //Update the Identify device buffer
        //
        GetIdentifyData( IdeBusInterface, &(IdeBusInterface->IdeDevice));
    }
    return Status;
}

//**********************************************************************
//**********************************************************************
//**                                                                  **
//**        (C)Copyright 1985-2012, American Megatrends, Inc.         **
//**                                                                  **
//**                       All Rights Reserved.                       **
//**                                                                  **
//**         5555 Oakbrook Pkwy, Suite 200, Norcross, GA 30093        **
//**                                                                  **
//**                       Phone: (770)-246-8600                      **
//**                                                                  **
//**********************************************************************
//**********************************************************************