mirror of
https://github.com/CloverHackyColor/CloverBootloader.git
synced 2024-12-05 13:33:33 +01:00
560 lines
24 KiB
C
560 lines
24 KiB
C
|
/** @file
|
||
|
This file declares EFI IDE Controller Init Protocol
|
||
|
|
||
|
The EFI_IDE_CONTROLLER_INIT_PROTOCOL provides the chipset-specific information
|
||
|
to the driver entity. This protocol is mandatory for IDE controllers if the
|
||
|
IDE devices behind the controller are to be enumerated by a driver entity.
|
||
|
|
||
|
There can only be one instance of EFI_IDE_CONTROLLER_INIT_PROTOCOL for each IDE
|
||
|
controller in a system. It is installed on the handle that corresponds to the
|
||
|
IDE controller. A driver entity that wishes to manage an IDE bus and possibly
|
||
|
IDE devices in a system will have to retrieve the EFI_IDE_CONTROLLER_INIT_PROTOCOL
|
||
|
instance that is associated with the controller to be managed.
|
||
|
|
||
|
A device handle for an IDE controller must contain an EFI_DEVICE_PATH_PROTOCOL.
|
||
|
|
||
|
Copyright (c) 2007 - 2018, Intel Corporation. All rights reserved.<BR>
|
||
|
SPDX-License-Identifier: BSD-2-Clause-Patent
|
||
|
|
||
|
@par Revision Reference:
|
||
|
This Protocol is defined in UEFI Platform Initialization Specification 1.2
|
||
|
Volume 5: Standards.
|
||
|
|
||
|
**/
|
||
|
|
||
|
#ifndef _EFI_IDE_CONTROLLER_INIT_PROTOCOL_H_
|
||
|
#define _EFI_IDE_CONTROLLER_INIT_PROTOCOL_H_
|
||
|
|
||
|
#include <IndustryStandard/Atapi.h>
|
||
|
|
||
|
///
|
||
|
/// Global ID for the EFI_IDE_CONTROLLER_INIT_PROTOCOL.
|
||
|
///
|
||
|
#define EFI_IDE_CONTROLLER_INIT_PROTOCOL_GUID \
|
||
|
{ \
|
||
|
0xa1e37052, 0x80d9, 0x4e65, {0xa3, 0x17, 0x3e, 0x9a, 0x55, 0xc4, 0x3e, 0xc9 } \
|
||
|
}
|
||
|
|
||
|
///
|
||
|
/// Forward declaration for EFI_IDE_CONTROLLER_INIT_PROTOCOL.
|
||
|
///
|
||
|
typedef struct _EFI_IDE_CONTROLLER_INIT_PROTOCOL EFI_IDE_CONTROLLER_INIT_PROTOCOL;
|
||
|
|
||
|
///
|
||
|
/// The phase of the IDE Controller enumeration.
|
||
|
///
|
||
|
typedef enum {
|
||
|
///
|
||
|
/// The driver entity is about to begin enumerating the devices
|
||
|
/// behind the specified channel. This notification can be used to
|
||
|
/// perform any chipset-specific programming.
|
||
|
///
|
||
|
EfiIdeBeforeChannelEnumeration,
|
||
|
///
|
||
|
/// The driver entity has completed enumerating the devices
|
||
|
/// behind the specified channel. This notification can be used to
|
||
|
/// perform any chipset-specific programming.
|
||
|
///
|
||
|
EfiIdeAfterChannelEnumeration,
|
||
|
///
|
||
|
/// The driver entity is about to reset the devices behind the
|
||
|
/// specified channel. This notification can be used to perform any
|
||
|
/// chipset-specific programming.
|
||
|
///
|
||
|
EfiIdeBeforeChannelReset,
|
||
|
///
|
||
|
/// The driver entity has completed resetting the devices behind
|
||
|
/// the specified channel. This notification can be used to perform
|
||
|
/// any chipset-specific programming.
|
||
|
///
|
||
|
EfiIdeAfterChannelReset,
|
||
|
///
|
||
|
/// The driver entity is about to detect the presence of devices
|
||
|
/// behind the specified channel. This notification can be used to
|
||
|
/// set up the bus signals to default levels or for implementing
|
||
|
/// predelays.
|
||
|
///
|
||
|
EfiIdeBusBeforeDevicePresenceDetection,
|
||
|
///
|
||
|
/// The driver entity is done with detecting the presence of
|
||
|
/// devices behind the specified channel. This notification can be
|
||
|
/// used to perform any chipset-specific programming.
|
||
|
///
|
||
|
EfiIdeBusAfterDevicePresenceDetection,
|
||
|
///
|
||
|
/// The IDE bus is requesting the IDE controller driver to
|
||
|
/// reprogram the IDE controller hardware and thereby reset all
|
||
|
/// the mode and timing settings to default settings.
|
||
|
///
|
||
|
EfiIdeResetMode,
|
||
|
EfiIdeBusPhaseMaximum
|
||
|
} EFI_IDE_CONTROLLER_ENUM_PHASE;
|
||
|
|
||
|
///
|
||
|
/// This extended mode describes the SATA physical protocol.
|
||
|
/// SATA physical layers can operate at different speeds.
|
||
|
/// These speeds are defined below. Various PATA protocols
|
||
|
/// and associated modes are not applicable to SATA devices.
|
||
|
///
|
||
|
typedef enum {
|
||
|
EfiAtaSataTransferProtocol
|
||
|
} EFI_ATA_EXT_TRANSFER_PROTOCOL;
|
||
|
|
||
|
///
|
||
|
/// Automatically detects the optimum SATA speed.
|
||
|
///
|
||
|
#define EFI_SATA_AUTO_SPEED 0
|
||
|
|
||
|
///
|
||
|
/// Indicates a first-generation (Gen1) SATA speed.
|
||
|
///
|
||
|
#define EFI_SATA_GEN1_SPEED 1
|
||
|
|
||
|
///
|
||
|
/// Indicates a second-generation (Gen2) SATA speed.
|
||
|
///
|
||
|
#define EFI_SATA_GEN2_SPEED 2
|
||
|
|
||
|
///
|
||
|
/// EFI_ATA_MODE structure.
|
||
|
///
|
||
|
typedef struct {
|
||
|
BOOLEAN Valid; ///< TRUE if Mode is valid.
|
||
|
UINT32 Mode; ///< The actual ATA mode. This field is not a bit map.
|
||
|
} EFI_ATA_MODE;
|
||
|
|
||
|
///
|
||
|
/// EFI_ATA_EXTENDED_MODE structure
|
||
|
///
|
||
|
typedef struct {
|
||
|
///
|
||
|
/// An enumeration defining various transfer protocols other than the protocols
|
||
|
/// that exist at the time this specification was developed (i.e., PIO, single
|
||
|
/// word DMA, multiword DMA, and UDMA). Each transfer protocol is associated
|
||
|
/// with a mode. The various transfer protocols are defined by the ATA/ATAPI
|
||
|
/// specification. This enumeration makes the interface extensible because we
|
||
|
/// can support new transport protocols beyond UDMA. Type EFI_ATA_EXT_TRANSFER_PROTOCOL
|
||
|
/// is defined below.
|
||
|
///
|
||
|
EFI_ATA_EXT_TRANSFER_PROTOCOL TransferProtocol;
|
||
|
///
|
||
|
/// The mode for operating the transfer protocol that is identified by TransferProtocol.
|
||
|
///
|
||
|
UINT32 Mode;
|
||
|
} EFI_ATA_EXTENDED_MODE;
|
||
|
|
||
|
///
|
||
|
/// EFI_ATA_COLLECTIVE_MODE structure.
|
||
|
///
|
||
|
typedef struct {
|
||
|
///
|
||
|
/// This field specifies the PIO mode. PIO modes are defined in the ATA/ATAPI
|
||
|
/// specification. The ATA/ATAPI specification defines the enumeration. In
|
||
|
/// other words, a value of 1 in this field means PIO mode 1. The actual meaning
|
||
|
/// of PIO mode 1 is governed by the ATA/ATAPI specification. Type EFI_ATA_MODE
|
||
|
/// is defined below.
|
||
|
///
|
||
|
EFI_ATA_MODE PioMode;
|
||
|
///
|
||
|
/// This field specifies the single word DMA mode. Single word DMA modes are defined
|
||
|
/// in the ATA/ATAPI specification, versions 1 and 2. Single word DMA support was
|
||
|
/// obsoleted in the ATA/ATAPI specification, version 3. Therefore, most devices and
|
||
|
/// controllers will not support this transfer mode. The ATA/ATAPI specification defines
|
||
|
/// the enumeration. In other words, a value of 1 in this field means single word DMA
|
||
|
/// mode 1. The actual meaning of single word DMA mode 1 is governed by the ATA/
|
||
|
/// ATAPI specification.
|
||
|
///
|
||
|
EFI_ATA_MODE SingleWordDmaMode;
|
||
|
///
|
||
|
/// This field specifies the multiword DMA mode. Various multiword DMA modes are
|
||
|
/// defined in the ATA/ATAPI specification. A value of 1 in this field means multiword
|
||
|
/// DMA mode 1. The actual meaning of multiword DMA mode 1 is governed by the
|
||
|
/// ATA/ATAPI specification.
|
||
|
///
|
||
|
EFI_ATA_MODE MultiWordDmaMode;
|
||
|
///
|
||
|
/// This field specifies the ultra DMA (UDMA) mode. UDMA modes are defined in the
|
||
|
/// ATA/ATAPI specification. A value of 1 in this field means UDMA mode 1. The
|
||
|
/// actual meaning of UDMA mode 1 is governed by the ATA/ATAPI specification.
|
||
|
///
|
||
|
EFI_ATA_MODE UdmaMode;
|
||
|
///
|
||
|
/// The number of extended-mode bitmap entries. Extended modes describe transfer
|
||
|
/// protocols beyond PIO, single word DMA, multiword DMA, and UDMA. This field
|
||
|
/// can be zero and provides extensibility.
|
||
|
///
|
||
|
UINT32 ExtModeCount;
|
||
|
///
|
||
|
/// ExtModeCount number of entries. Each entry represents a transfer protocol other
|
||
|
/// than the ones defined above (i.e., PIO, single word DMA, multiword DMA, and
|
||
|
/// UDMA). This field is defined for extensibility. At this time, only one extended
|
||
|
/// transfer protocol is defined to cover SATA transfers. Type
|
||
|
/// EFI_ATA_EXTENDED_MODE is defined below.
|
||
|
///
|
||
|
EFI_ATA_EXTENDED_MODE ExtMode[1];
|
||
|
} EFI_ATA_COLLECTIVE_MODE;
|
||
|
|
||
|
///
|
||
|
/// EFI_ATA_IDENTIFY_DATA & EFI_ATAPI_IDENTIFY_DATA structure
|
||
|
///
|
||
|
/// The definition of these two structures is not part of the protocol
|
||
|
/// definition because the ATA/ATAPI Specification controls the definition
|
||
|
/// of all the fields. The ATA/ATAPI Specification can obsolete old fields
|
||
|
/// or redefine existing fields.
|
||
|
typedef ATA_IDENTIFY_DATA EFI_ATA_IDENTIFY_DATA;
|
||
|
typedef ATAPI_IDENTIFY_DATA EFI_ATAPI_IDENTIFY_DATA;
|
||
|
|
||
|
///
|
||
|
/// This flag indicates whether the IDENTIFY data is a response from an ATA device
|
||
|
/// (EFI_ATA_IDENTIFY_DATA) or response from an ATAPI device
|
||
|
/// (EFI_ATAPI_IDENTIFY_DATA). According to the ATA/ATAPI specification,
|
||
|
/// EFI_IDENTIFY_DATA is for an ATA device if bit 15 of the Config field is zero.
|
||
|
/// The Config field is common to both EFI_ATA_IDENTIFY_DATA and
|
||
|
/// EFI_ATAPI_IDENTIFY_DATA.
|
||
|
///
|
||
|
#define EFI_ATAPI_DEVICE_IDENTIFY_DATA 0x8000
|
||
|
|
||
|
///
|
||
|
/// EFI_IDENTIFY_DATA structure.
|
||
|
///
|
||
|
typedef union {
|
||
|
///
|
||
|
/// The data that is returned by an ATA device upon successful completion
|
||
|
/// of the ATA IDENTIFY_DEVICE command.
|
||
|
///
|
||
|
EFI_ATA_IDENTIFY_DATA AtaData;
|
||
|
///
|
||
|
/// The data that is returned by an ATAPI device upon successful completion
|
||
|
/// of the ATA IDENTIFY_PACKET_DEVICE command.
|
||
|
///
|
||
|
EFI_ATAPI_IDENTIFY_DATA AtapiData;
|
||
|
} EFI_IDENTIFY_DATA;
|
||
|
|
||
|
/**
|
||
|
Returns the information about the specified IDE channel.
|
||
|
|
||
|
This function can be used to obtain information about a particular IDE channel.
|
||
|
The driver entity uses this information during the enumeration process.
|
||
|
|
||
|
If Enabled is set to FALSE, the driver entity will not scan the channel. Note
|
||
|
that it will not prevent an operating system driver from scanning the channel.
|
||
|
|
||
|
For most of today's controllers, MaxDevices will either be 1 or 2. For SATA
|
||
|
controllers, this value will always be 1. SATA configurations can contain SATA
|
||
|
port multipliers. SATA port multipliers behave like SATA bridges and can support
|
||
|
up to 16 devices on the other side. If a SATA port out of the IDE controller
|
||
|
is connected to a port multiplier, MaxDevices will be set to the number of SATA
|
||
|
devices that the port multiplier supports. Because today's port multipliers
|
||
|
support up to fifteen SATA devices, this number can be as large as fifteen. The IDE
|
||
|
bus driver is required to scan for the presence of port multipliers behind an SATA
|
||
|
controller and enumerate up to MaxDevices number of devices behind the port
|
||
|
multiplier.
|
||
|
|
||
|
In this context, the devices behind a port multiplier constitute a channel.
|
||
|
|
||
|
@param[in] This The pointer to the EFI_IDE_CONTROLLER_INIT_PROTOCOL instance.
|
||
|
@param[in] Channel Zero-based channel number.
|
||
|
@param[out] Enabled TRUE if this channel is enabled. Disabled channels
|
||
|
are not scanned to see if any devices are present.
|
||
|
@param[out] MaxDevices The maximum number of IDE devices that the bus driver
|
||
|
can expect on this channel. For the ATA/ATAPI
|
||
|
specification, version 6, this number will either be
|
||
|
one or two. For Serial ATA (SATA) configurations with a
|
||
|
port multiplier, this number can be as large as fifteen.
|
||
|
|
||
|
@retval EFI_SUCCESS Information was returned without any errors.
|
||
|
@retval EFI_INVALID_PARAMETER Channel is invalid (Channel >= ChannelCount).
|
||
|
|
||
|
**/
|
||
|
typedef
|
||
|
EFI_STATUS
|
||
|
(EFIAPI *EFI_IDE_CONTROLLER_GET_CHANNEL_INFO)(
|
||
|
IN EFI_IDE_CONTROLLER_INIT_PROTOCOL *This,
|
||
|
IN UINT8 Channel,
|
||
|
OUT BOOLEAN *Enabled,
|
||
|
OUT UINT8 *MaxDevices
|
||
|
);
|
||
|
|
||
|
/**
|
||
|
The notifications from the driver entity that it is about to enter a certain
|
||
|
phase of the IDE channel enumeration process.
|
||
|
|
||
|
This function can be used to notify the IDE controller driver to perform
|
||
|
specific actions, including any chipset-specific initialization, so that the
|
||
|
chipset is ready to enter the next phase. Seven notification points are defined
|
||
|
at this time.
|
||
|
|
||
|
More synchronization points may be added as required in the future.
|
||
|
|
||
|
@param[in] This The pointer to the EFI_IDE_CONTROLLER_INIT_PROTOCOL instance.
|
||
|
@param[in] Phase The phase during enumeration.
|
||
|
@param[in] Channel Zero-based channel number.
|
||
|
|
||
|
@retval EFI_SUCCESS The notification was accepted without any errors.
|
||
|
@retval EFI_UNSUPPORTED Phase is not supported.
|
||
|
@retval EFI_INVALID_PARAMETER Channel is invalid (Channel >= ChannelCount).
|
||
|
@retval EFI_NOT_READY This phase cannot be entered at this time; for
|
||
|
example, an attempt was made to enter a Phase
|
||
|
without having entered one or more previous
|
||
|
Phase.
|
||
|
|
||
|
**/
|
||
|
typedef
|
||
|
EFI_STATUS
|
||
|
(EFIAPI *EFI_IDE_CONTROLLER_NOTIFY_PHASE)(
|
||
|
IN EFI_IDE_CONTROLLER_INIT_PROTOCOL *This,
|
||
|
IN EFI_IDE_CONTROLLER_ENUM_PHASE Phase,
|
||
|
IN UINT8 Channel
|
||
|
);
|
||
|
|
||
|
/**
|
||
|
Submits the device information to the IDE controller driver.
|
||
|
|
||
|
This function is used by the driver entity to pass detailed information about
|
||
|
a particular device to the IDE controller driver. The driver entity obtains
|
||
|
this information by issuing an ATA or ATAPI IDENTIFY_DEVICE command. IdentifyData
|
||
|
is the pointer to the response data buffer. The IdentifyData buffer is owned
|
||
|
by the driver entity, and the IDE controller driver must make a local copy
|
||
|
of the entire buffer or parts of the buffer as needed. The original IdentifyData
|
||
|
buffer pointer may not be valid when
|
||
|
|
||
|
- EFI_IDE_CONTROLLER_INIT_PROTOCOL.CalculateMode() or
|
||
|
- EFI_IDE_CONTROLLER_INIT_PROTOCOL.DisqualifyMode() is called at a later point.
|
||
|
|
||
|
The IDE controller driver may consult various fields of EFI_IDENTIFY_DATA to
|
||
|
compute the optimum mode for the device. These fields are not limited to the
|
||
|
timing information. For example, an implementation of the IDE controller driver
|
||
|
may examine the vendor and type/mode field to match known bad drives.
|
||
|
|
||
|
The driver entity may submit drive information in any order, as long as it
|
||
|
submits information for all the devices belonging to the enumeration group
|
||
|
before EFI_IDE_CONTROLLER_INIT_PROTOCOL.CalculateMode() is called for any device
|
||
|
in that enumeration group. If a device is absent, EFI_IDE_CONTROLLER_INIT_PROTOCOL.SubmitData()
|
||
|
should be called with IdentifyData set to NULL. The IDE controller driver may
|
||
|
not have any other mechanism to know whether a device is present or not. Therefore,
|
||
|
setting IdentifyData to NULL does not constitute an error condition.
|
||
|
EFI_IDE_CONTROLLER_INIT_PROTOCOL.SubmitData() can be called only once for a
|
||
|
given (Channel, Device) pair.
|
||
|
|
||
|
@param[in] This A pointer to the EFI_IDE_CONTROLLER_INIT_PROTOCOL instance.
|
||
|
@param[in] Channel Zero-based channel number.
|
||
|
@param[in] Device Zero-based device number on the Channel.
|
||
|
@param[in] IdentifyData The device's response to the ATA IDENTIFY_DEVICE command.
|
||
|
|
||
|
@retval EFI_SUCCESS The information was accepted without any errors.
|
||
|
@retval EFI_INVALID_PARAMETER Channel is invalid (Channel >= ChannelCount).
|
||
|
@retval EFI_INVALID_PARAMETER Device is invalid.
|
||
|
|
||
|
**/
|
||
|
typedef
|
||
|
EFI_STATUS
|
||
|
(EFIAPI *EFI_IDE_CONTROLLER_SUBMIT_DATA)(
|
||
|
IN EFI_IDE_CONTROLLER_INIT_PROTOCOL *This,
|
||
|
IN UINT8 Channel,
|
||
|
IN UINT8 Device,
|
||
|
IN EFI_IDENTIFY_DATA *IdentifyData
|
||
|
);
|
||
|
|
||
|
/**
|
||
|
Disqualifies specific modes for an IDE device.
|
||
|
|
||
|
This function allows the driver entity or other drivers (such as platform
|
||
|
drivers) to reject certain timing modes and request the IDE controller driver
|
||
|
to recalculate modes. This function allows the driver entity and the IDE
|
||
|
controller driver to negotiate the timings on a per-device basis. This function
|
||
|
is useful in the case of drives that lie about their capabilities. An example
|
||
|
is when the IDE device fails to accept the timing modes that are calculated
|
||
|
by the IDE controller driver based on the response to the Identify Drive command.
|
||
|
|
||
|
If the driver entity does not want to limit the ATA timing modes and leave that
|
||
|
decision to the IDE controller driver, it can either not call this function for
|
||
|
the given device or call this function and set the Valid flag to FALSE for all
|
||
|
modes that are listed in EFI_ATA_COLLECTIVE_MODE.
|
||
|
|
||
|
The driver entity may disqualify modes for a device in any order and any number
|
||
|
of times.
|
||
|
|
||
|
This function can be called multiple times to invalidate multiple modes of the
|
||
|
same type (e.g., Programmed Input/Output [PIO] modes 3 and 4). See the ATA/ATAPI
|
||
|
specification for more information on PIO modes.
|
||
|
|
||
|
For Serial ATA (SATA) controllers, this member function can be used to disqualify
|
||
|
a higher transfer rate mode on a given channel. For example, a platform driver
|
||
|
may inform the IDE controller driver to not use second-generation (Gen2) speeds
|
||
|
for a certain SATA drive.
|
||
|
|
||
|
@param[in] This The pointer to the EFI_IDE_CONTROLLER_INIT_PROTOCOL instance.
|
||
|
@param[in] Channel The zero-based channel number.
|
||
|
@param[in] Device The zero-based device number on the Channel.
|
||
|
@param[in] BadModes The modes that the device does not support and that
|
||
|
should be disqualified.
|
||
|
|
||
|
@retval EFI_SUCCESS The modes were accepted without any errors.
|
||
|
@retval EFI_INVALID_PARAMETER Channel is invalid (Channel >= ChannelCount).
|
||
|
@retval EFI_INVALID_PARAMETER Device is invalid.
|
||
|
@retval EFI_INVALID_PARAMETER IdentifyData is NULL.
|
||
|
|
||
|
**/
|
||
|
typedef
|
||
|
EFI_STATUS
|
||
|
(EFIAPI *EFI_IDE_CONTROLLER_DISQUALIFY_MODE)(
|
||
|
IN EFI_IDE_CONTROLLER_INIT_PROTOCOL *This,
|
||
|
IN UINT8 Channel,
|
||
|
IN UINT8 Device,
|
||
|
IN EFI_ATA_COLLECTIVE_MODE *BadModes
|
||
|
);
|
||
|
|
||
|
/**
|
||
|
Returns the information about the optimum modes for the specified IDE device.
|
||
|
|
||
|
This function is used by the driver entity to obtain the optimum ATA modes for
|
||
|
a specific device. The IDE controller driver takes into account the following
|
||
|
while calculating the mode:
|
||
|
- The IdentifyData inputs to EFI_IDE_CONTROLLER_INIT_PROTOCOL.SubmitData()
|
||
|
- The BadModes inputs to EFI_IDE_CONTROLLER_INIT_PROTOCOL.DisqualifyMode()
|
||
|
|
||
|
The driver entity is required to call EFI_IDE_CONTROLLER_INIT_PROTOCOL.SubmitData()
|
||
|
for all the devices that belong to an enumeration group before calling
|
||
|
EFI_IDE_CONTROLLER_INIT_PROTOCOL.CalculateMode() for any device in the same group.
|
||
|
|
||
|
The IDE controller driver will use controller- and possibly platform-specific
|
||
|
algorithms to arrive at SupportedModes. The IDE controller may base its
|
||
|
decision on user preferences and other considerations as well. This function
|
||
|
may be called multiple times because the driver entity may renegotiate the mode
|
||
|
with the IDE controller driver using EFI_IDE_CONTROLLER_INIT_PROTOCOL.DisqualifyMode().
|
||
|
|
||
|
The driver entity may collect timing information for various devices in any
|
||
|
order. The driver entity is responsible for making sure that all the dependencies
|
||
|
are satisfied. For example, the SupportedModes information for device A that
|
||
|
was previously returned may become stale after a call to
|
||
|
EFI_IDE_CONTROLLER_INIT_PROTOCOL.DisqualifyMode() for device B.
|
||
|
|
||
|
The buffer SupportedModes is allocated by the callee because the caller does
|
||
|
not necessarily know the size of the buffer. The type EFI_ATA_COLLECTIVE_MODE
|
||
|
is defined in a way that allows for future extensibility and can be of variable
|
||
|
length. This memory pool should be deallocated by the caller when it is no
|
||
|
longer necessary.
|
||
|
|
||
|
The IDE controller driver for a Serial ATA (SATA) controller can use this
|
||
|
member function to force a lower speed (first-generation [Gen1] speeds on a
|
||
|
second-generation [Gen2]-capable hardware). The IDE controller driver can
|
||
|
also allow the driver entity to stay with the speed that has been negotiated
|
||
|
by the physical layer.
|
||
|
|
||
|
@param[in] This The pointer to the EFI_IDE_CONTROLLER_INIT_PROTOCOL instance.
|
||
|
@param[in] Channel A zero-based channel number.
|
||
|
@param[in] Device A zero-based device number on the Channel.
|
||
|
@param[out] SupportedModes The optimum modes for the device.
|
||
|
|
||
|
@retval EFI_SUCCESS SupportedModes was returned.
|
||
|
@retval EFI_INVALID_PARAMETER Channel is invalid (Channel >= ChannelCount).
|
||
|
@retval EFI_INVALID_PARAMETER Device is invalid.
|
||
|
@retval EFI_INVALID_PARAMETER SupportedModes is NULL.
|
||
|
@retval EFI_NOT_READY Modes cannot be calculated due to a lack of
|
||
|
data. This error may happen if
|
||
|
EFI_IDE_CONTROLLER_INIT_PROTOCOL.SubmitData()
|
||
|
and EFI_IDE_CONTROLLER_INIT_PROTOCOL.DisqualifyData()
|
||
|
were not called for at least one drive in the
|
||
|
same enumeration group.
|
||
|
|
||
|
**/
|
||
|
typedef
|
||
|
EFI_STATUS
|
||
|
(EFIAPI *EFI_IDE_CONTROLLER_CALCULATE_MODE)(
|
||
|
IN EFI_IDE_CONTROLLER_INIT_PROTOCOL *This,
|
||
|
IN UINT8 Channel,
|
||
|
IN UINT8 Device,
|
||
|
OUT EFI_ATA_COLLECTIVE_MODE **SupportedModes
|
||
|
);
|
||
|
|
||
|
/**
|
||
|
Commands the IDE controller driver to program the IDE controller hardware
|
||
|
so that the specified device can operate at the specified mode.
|
||
|
|
||
|
This function is used by the driver entity to instruct the IDE controller
|
||
|
driver to program the IDE controller hardware to the specified modes. This
|
||
|
function can be called only once for a particular device. For a Serial ATA
|
||
|
(SATA) Advanced Host Controller Interface (AHCI) controller, no controller-
|
||
|
specific programming may be required.
|
||
|
|
||
|
@param[in] This Pointer to the EFI_IDE_CONTROLLER_INIT_PROTOCOL instance.
|
||
|
@param[in] Channel Zero-based channel number.
|
||
|
@param[in] Device Zero-based device number on the Channel.
|
||
|
@param[in] Modes The modes to set.
|
||
|
|
||
|
@retval EFI_SUCCESS The command was accepted without any errors.
|
||
|
@retval EFI_INVALID_PARAMETER Channel is invalid (Channel >= ChannelCount).
|
||
|
@retval EFI_INVALID_PARAMETER Device is invalid.
|
||
|
@retval EFI_NOT_READY Modes cannot be set at this time due to lack of data.
|
||
|
@retval EFI_DEVICE_ERROR Modes cannot be set due to hardware failure.
|
||
|
The driver entity should not use this device.
|
||
|
|
||
|
**/
|
||
|
typedef
|
||
|
EFI_STATUS
|
||
|
(EFIAPI *EFI_IDE_CONTROLLER_SET_TIMING)(
|
||
|
IN EFI_IDE_CONTROLLER_INIT_PROTOCOL *This,
|
||
|
IN UINT8 Channel,
|
||
|
IN UINT8 Device,
|
||
|
IN EFI_ATA_COLLECTIVE_MODE *Modes
|
||
|
);
|
||
|
|
||
|
///
|
||
|
/// Provides the basic interfaces to abstract an IDE controller.
|
||
|
///
|
||
|
struct _EFI_IDE_CONTROLLER_INIT_PROTOCOL {
|
||
|
///
|
||
|
/// Returns the information about a specific channel.
|
||
|
///
|
||
|
EFI_IDE_CONTROLLER_GET_CHANNEL_INFO GetChannelInfo;
|
||
|
|
||
|
///
|
||
|
/// The notification that the driver entity is about to enter the
|
||
|
/// specified phase during the enumeration process.
|
||
|
///
|
||
|
EFI_IDE_CONTROLLER_NOTIFY_PHASE NotifyPhase;
|
||
|
|
||
|
///
|
||
|
/// Submits the Drive Identify data that was returned by the device.
|
||
|
///
|
||
|
EFI_IDE_CONTROLLER_SUBMIT_DATA SubmitData;
|
||
|
|
||
|
///
|
||
|
/// Submits information about modes that should be disqualified. The specified
|
||
|
/// IDE device does not support these modes and these modes should not be
|
||
|
/// returned by EFI_IDE_CONTROLLER_INIT_PROTOCOL.CalculateMode()
|
||
|
///
|
||
|
EFI_IDE_CONTROLLER_DISQUALIFY_MODE DisqualifyMode;
|
||
|
|
||
|
///
|
||
|
/// Calculates and returns the optimum mode for a particular IDE device.
|
||
|
///
|
||
|
EFI_IDE_CONTROLLER_CALCULATE_MODE CalculateMode;
|
||
|
|
||
|
///
|
||
|
/// Programs the IDE controller hardware to the default timing or per the modes
|
||
|
/// that were returned by the last call to EFI_IDE_CONTROLLER_INIT_PROTOCOL.CalculateMode().
|
||
|
///
|
||
|
EFI_IDE_CONTROLLER_SET_TIMING SetTiming;
|
||
|
|
||
|
///
|
||
|
/// Set to TRUE if the enumeration group includes all the channels that are
|
||
|
/// produced by this controller. Set to FALSE if an enumeration group consists of
|
||
|
/// only one channel.
|
||
|
///
|
||
|
BOOLEAN EnumAll;
|
||
|
|
||
|
///
|
||
|
/// The number of channels that are produced by this controller. Parallel ATA
|
||
|
/// (PATA) controllers can support up to two channels. Advanced Host Controller
|
||
|
/// Interface (AHCI) Serial ATA (SATA) controllers can support up to 32 channels,
|
||
|
/// each of which can have up to one device. In the presence of a multiplier,
|
||
|
/// each channel can have fifteen devices.
|
||
|
///
|
||
|
UINT8 ChannelCount;
|
||
|
};
|
||
|
|
||
|
extern EFI_GUID gEfiIdeControllerInitProtocolGuid;
|
||
|
|
||
|
#endif
|