2 This driver module produces IDE_CONTROLLER_INIT protocol for Sata Controllers.
4 Copyright (c) 2011, Intel Corporation. All rights reserved.<BR>
5 This program and the accompanying materials
6 are licensed and made available under the terms and conditions of the BSD License
7 which accompanies this distribution. The full text of the license may be found at
8 http://opensource.org/licenses/bsd-license.php
10 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
11 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
15 #include "SataController.h"
18 /// EFI_DRIVER_BINDING_PROTOCOL instance
20 EFI_DRIVER_BINDING_PROTOCOL gSataControllerDriverBinding
= {
21 SataControllerSupported
,
30 Read AHCI Operation register.
32 @param PciIo The PCI IO protocol instance.
33 @param Offset The operation register offset.
35 @return The register content read.
41 IN EFI_PCI_IO_PROTOCOL
*PciIo
,
47 ASSERT (PciIo
!= NULL
);
64 Write AHCI Operation register.
66 @param PciIo The PCI IO protocol instance.
67 @param Offset The operation register offset.
68 @param Data The data used to write down.
74 IN EFI_PCI_IO_PROTOCOL
*PciIo
,
79 ASSERT (PciIo
!= NULL
);
94 This function is used to calculate the best PIO mode supported by specific IDE device
96 @param IdentifyData The identify data of specific IDE device.
97 @param DisPioMode Disqualified PIO modes collection.
98 @param SelectedMode Available PIO modes collection.
100 @retval EFI_SUCCESS Best PIO modes are returned.
101 @retval EFI_UNSUPPORTED The device doesn't support PIO mode,
102 or all supported modes have been disqualified.
105 CalculateBestPioMode (
106 IN EFI_IDENTIFY_DATA
*IdentifyData
,
107 IN UINT16
*DisPioMode OPTIONAL
,
108 OUT UINT16
*SelectedMode
112 UINT16 AdvancedPioMode
;
115 UINT16 MinimumPioCycleTime
;
119 PioMode
= (UINT8
) (((ATA5_IDENTIFY_DATA
*) (&(IdentifyData
->AtaData
)))->pio_cycle_timing
>> 8);
122 // See whether Identify Data word 64 - 70 are valid
124 if ((IdentifyData
->AtaData
.field_validity
& 0x02) == 0x02) {
126 AdvancedPioMode
= IdentifyData
->AtaData
.advanced_pio_modes
;
127 DEBUG ((EFI_D_INFO
, "CalculateBestPioMode: AdvancedPioMode = %x\n", AdvancedPioMode
));
129 for (Index
= 0; Index
< 8; Index
++) {
130 if ((AdvancedPioMode
& 0x01) != 0) {
134 AdvancedPioMode
>>= 1;
138 // If Temp is modified, mean the advanced_pio_modes is not zero;
139 // if Temp is not modified, mean there is no advanced PIO mode supported,
140 // the best PIO Mode is the value in pio_cycle_timing.
143 AdvancedPioMode
= (UINT16
) (Temp
+ 3);
145 AdvancedPioMode
= PioMode
;
149 // Limit the PIO mode to at most PIO4.
151 PioMode
= (UINT16
) MIN (AdvancedPioMode
, 4);
153 MinimumPioCycleTime
= IdentifyData
->AtaData
.min_pio_cycle_time_with_flow_control
;
155 if (MinimumPioCycleTime
<= 120) {
156 PioMode
= (UINT16
) MIN (4, PioMode
);
157 } else if (MinimumPioCycleTime
<= 180) {
158 PioMode
= (UINT16
) MIN (3, PioMode
);
159 } else if (MinimumPioCycleTime
<= 240) {
160 PioMode
= (UINT16
) MIN (2, PioMode
);
166 // Degrade the PIO mode if the mode has been disqualified
168 if (DisPioMode
!= NULL
) {
169 if (*DisPioMode
< 2) {
170 return EFI_UNSUPPORTED
; // no mode below ATA_PIO_MODE_BELOW_2
173 if (PioMode
>= *DisPioMode
) {
174 PioMode
= (UINT16
) (*DisPioMode
- 1);
179 *SelectedMode
= 1; // ATA_PIO_MODE_BELOW_2;
181 *SelectedMode
= PioMode
; // ATA_PIO_MODE_2 to ATA_PIO_MODE_4;
186 // Identify Data word 64 - 70 are not valid
187 // Degrade the PIO mode if the mode has been disqualified
189 if (DisPioMode
!= NULL
) {
190 if (*DisPioMode
< 2) {
191 return EFI_UNSUPPORTED
; // no mode below ATA_PIO_MODE_BELOW_2
194 if (PioMode
== *DisPioMode
) {
200 *SelectedMode
= 1; // ATA_PIO_MODE_BELOW_2;
202 *SelectedMode
= 2; // ATA_PIO_MODE_2;
211 This function is used to calculate the best UDMA mode supported by specific IDE device
213 @param IdentifyData The identify data of specific IDE device.
214 @param DisUDmaMode Disqualified UDMA modes collection.
215 @param SelectedMode Available UDMA modes collection.
217 @retval EFI_SUCCESS Best UDMA modes are returned.
218 @retval EFI_UNSUPPORTED The device doesn't support UDMA mode,
219 or all supported modes have been disqualified.
222 CalculateBestUdmaMode (
223 IN EFI_IDENTIFY_DATA
*IdentifyData
,
224 IN UINT16
*DisUDmaMode OPTIONAL
,
225 OUT UINT16
*SelectedMode
229 UINT16 DeviceUDmaMode
;
234 // Check whether the WORD 88 (supported UltraDMA by drive) is valid
236 if ((IdentifyData
->AtaData
.field_validity
& 0x04) == 0x00) {
237 return EFI_UNSUPPORTED
;
240 DeviceUDmaMode
= IdentifyData
->AtaData
.ultra_dma_mode
;
241 DEBUG ((EFI_D_INFO
, "CalculateBestUdmaMode: DeviceUDmaMode = %x\n", DeviceUDmaMode
));
242 DeviceUDmaMode
&= 0x3f;
243 TempMode
= 0; // initialize it to UDMA-0
245 while ((DeviceUDmaMode
>>= 1) != 0) {
250 // Degrade the UDMA mode if the mode has been disqualified
252 if (DisUDmaMode
!= NULL
) {
253 if (*DisUDmaMode
== 0) {
255 return EFI_UNSUPPORTED
; // no mode below ATA_UDMA_MODE_0
258 if (TempMode
>= *DisUDmaMode
) {
259 TempMode
= (UINT16
) (*DisUDmaMode
- 1);
264 // Possible returned mode is between ATA_UDMA_MODE_0 and ATA_UDMA_MODE_5
266 *SelectedMode
= TempMode
;
272 The Entry Point of module. It follows the standard UEFI driver model.
274 @param[in] ImageHandle The firmware allocated handle for the EFI image.
275 @param[in] SystemTable A pointer to the EFI System Table.
277 @retval EFI_SUCCESS The entry point is executed successfully.
278 @retval other Some error occurs when executing this entry point.
283 InitializeSataControllerDriver (
284 IN EFI_HANDLE ImageHandle
,
285 IN EFI_SYSTEM_TABLE
*SystemTable
291 // Install driver model protocol(s).
293 Status
= EfiLibInstallDriverBindingComponentName2 (
296 &gSataControllerDriverBinding
,
298 &gSataControllerComponentName
,
299 &gSataControllerComponentName2
301 ASSERT_EFI_ERROR (Status
);
307 Supported function of Driver Binding protocol for this driver.
308 Test to see if this driver supports ControllerHandle.
310 @param This Protocol instance pointer.
311 @param Controller Handle of device to test.
312 @param RemainingDevicePath A pointer to the device path.
313 it should be ignored by device driver.
315 @retval EFI_SUCCESS This driver supports this device.
316 @retval EFI_ALREADY_STARTED This driver is already running on this device.
317 @retval other This driver does not support this device.
322 SataControllerSupported (
323 IN EFI_DRIVER_BINDING_PROTOCOL
*This
,
324 IN EFI_HANDLE Controller
,
325 IN EFI_DEVICE_PATH_PROTOCOL
*RemainingDevicePath
329 EFI_PCI_IO_PROTOCOL
*PciIo
;
333 // Attempt to open PCI I/O Protocol
335 Status
= gBS
->OpenProtocol (
337 &gEfiPciIoProtocolGuid
,
339 This
->DriverBindingHandle
,
341 EFI_OPEN_PROTOCOL_GET_PROTOCOL
343 if (EFI_ERROR (Status
)) {
348 // Now further check the PCI header: Base Class (offset 0x0B) and
349 // Sub Class (offset 0x0A). This controller should be an SATA controller
351 Status
= PciIo
->Pci
.Read (
354 PCI_CLASSCODE_OFFSET
,
355 sizeof (PciData
.Hdr
.ClassCode
),
356 PciData
.Hdr
.ClassCode
358 if (EFI_ERROR (Status
)) {
359 return EFI_UNSUPPORTED
;
362 if (IS_PCI_IDE (&PciData
) || IS_PCI_SATADPA (&PciData
)) {
366 return EFI_UNSUPPORTED
;
370 This routine is called right after the .Supported() called and
371 Start this driver on ControllerHandle.
373 @param This Protocol instance pointer.
374 @param Controller Handle of device to bind driver to.
375 @param RemainingDevicePath A pointer to the device path.
376 it should be ignored by device driver.
378 @retval EFI_SUCCESS This driver is added to this device.
379 @retval EFI_ALREADY_STARTED This driver is already running on this device.
380 @retval other Some error occurs when binding this driver to this device.
385 SataControllerStart (
386 IN EFI_DRIVER_BINDING_PROTOCOL
*This
,
387 IN EFI_HANDLE Controller
,
388 IN EFI_DEVICE_PATH_PROTOCOL
*RemainingDevicePath
392 EFI_PCI_IO_PROTOCOL
*PciIo
;
394 EFI_SATA_CONTROLLER_PRIVATE_DATA
*SataPrivateData
;
396 UINTN ChannelDeviceCount
;
398 DEBUG ((EFI_D_INFO
, "SataControllerStart START\n"));
400 SataPrivateData
= NULL
;
403 // Now test and open PCI I/O Protocol
405 Status
= gBS
->OpenProtocol (
407 &gEfiPciIoProtocolGuid
,
409 This
->DriverBindingHandle
,
411 EFI_OPEN_PROTOCOL_BY_DRIVER
413 if (EFI_ERROR (Status
)) {
414 DEBUG ((EFI_D_ERROR
, "SataControllerStart error return status = %r\n", Status
));
419 // Allocate Sata Private Data structure
421 SataPrivateData
= AllocateZeroPool (sizeof (EFI_SATA_CONTROLLER_PRIVATE_DATA
));
422 if (SataPrivateData
== NULL
) {
423 Status
= EFI_OUT_OF_RESOURCES
;
428 // Initialize Sata Private Data
430 SataPrivateData
->Signature
= SATA_CONTROLLER_SIGNATURE
;
431 SataPrivateData
->PciIo
= PciIo
;
432 SataPrivateData
->IdeInit
.GetChannelInfo
= IdeInitGetChannelInfo
;
433 SataPrivateData
->IdeInit
.NotifyPhase
= IdeInitNotifyPhase
;
434 SataPrivateData
->IdeInit
.SubmitData
= IdeInitSubmitData
;
435 SataPrivateData
->IdeInit
.DisqualifyMode
= IdeInitDisqualifyMode
;
436 SataPrivateData
->IdeInit
.CalculateMode
= IdeInitCalculateMode
;
437 SataPrivateData
->IdeInit
.SetTiming
= IdeInitSetTiming
;
438 SataPrivateData
->IdeInit
.EnumAll
= SATA_ENUMER_ALL
;
440 Status
= PciIo
->Pci
.Read (
443 PCI_CLASSCODE_OFFSET
,
444 sizeof (PciData
.Hdr
.ClassCode
),
445 PciData
.Hdr
.ClassCode
447 ASSERT_EFI_ERROR (Status
);
449 if (IS_PCI_IDE (&PciData
)) {
450 SataPrivateData
->IdeInit
.ChannelCount
= IDE_MAX_CHANNEL
;
451 SataPrivateData
->DeviceCount
= IDE_MAX_DEVICES
;
452 } else if (IS_PCI_SATADPA (&PciData
)) {
454 // Read Host Capability Register(CAP) to get Number of Ports(NPS) and Supports Port Multiplier(SPM)
455 // NPS is 0's based value indicating the maximum number of ports supported by the HBA silicon.
456 // A maximum of 32 ports can be supported. A value of '0h', indicating one port, is the minimum requirement.
458 Data32
= AhciReadReg (PciIo
, R_AHCI_CAP
);
459 SataPrivateData
->IdeInit
.ChannelCount
= (UINT8
) (Data32
& B_AHCI_CAP_NPS
+ 1);
460 SataPrivateData
->DeviceCount
= AHCI_MAX_DEVICES
;
461 if ((Data32
& B_AHCI_CAP_SPM
) == B_AHCI_CAP_SPM
) {
462 SataPrivateData
->DeviceCount
= AHCI_MULTI_MAX_DEVICES
;
466 ChannelDeviceCount
= (UINTN
) (SataPrivateData
->IdeInit
.ChannelCount
) * (UINTN
) (SataPrivateData
->DeviceCount
);
467 SataPrivateData
->DisqulifiedModes
= AllocateZeroPool ((sizeof (EFI_ATA_COLLECTIVE_MODE
)) * ChannelDeviceCount
);
468 if (SataPrivateData
->DisqulifiedModes
== NULL
) {
469 Status
= EFI_OUT_OF_RESOURCES
;
473 SataPrivateData
->IdentifyData
= AllocateZeroPool ((sizeof (EFI_IDENTIFY_DATA
)) * ChannelDeviceCount
);
474 if (SataPrivateData
->IdentifyData
== NULL
) {
475 Status
= EFI_OUT_OF_RESOURCES
;
479 SataPrivateData
->IdentifyValid
= AllocateZeroPool ((sizeof (BOOLEAN
)) * ChannelDeviceCount
);
480 if (SataPrivateData
->IdentifyValid
== NULL
) {
481 Status
= EFI_OUT_OF_RESOURCES
;
486 // Install IDE Controller Init Protocol to this instance
488 Status
= gBS
->InstallMultipleProtocolInterfaces (
490 &gEfiIdeControllerInitProtocolGuid
,
491 &(SataPrivateData
->IdeInit
),
496 if (EFI_ERROR (Status
)) {
500 &gEfiPciIoProtocolGuid
,
501 This
->DriverBindingHandle
,
504 if (SataPrivateData
!= NULL
) {
505 if (SataPrivateData
->DisqulifiedModes
!= NULL
) {
506 FreePool (SataPrivateData
->DisqulifiedModes
);
508 if (SataPrivateData
->IdentifyData
!= NULL
) {
509 FreePool (SataPrivateData
->IdentifyData
);
511 if (SataPrivateData
->IdentifyValid
!= NULL
) {
512 FreePool (SataPrivateData
->IdentifyValid
);
514 FreePool (SataPrivateData
);
518 DEBUG ((EFI_D_INFO
, "SataControllerStart END status = %r\n", Status
));
524 Stop this driver on ControllerHandle.
526 @param This Protocol instance pointer.
527 @param Controller Handle of device to stop driver on.
528 @param NumberOfChildren Not used.
529 @param ChildHandleBuffer Not used.
531 @retval EFI_SUCCESS This driver is removed from this device.
532 @retval other Some error occurs when removing this driver from this device.
538 IN EFI_DRIVER_BINDING_PROTOCOL
*This
,
539 IN EFI_HANDLE Controller
,
540 IN UINTN NumberOfChildren
,
541 IN EFI_HANDLE
*ChildHandleBuffer
545 EFI_IDE_CONTROLLER_INIT_PROTOCOL
*IdeInit
;
546 EFI_SATA_CONTROLLER_PRIVATE_DATA
*SataPrivateData
;
549 // Open the produced protocol
551 Status
= gBS
->OpenProtocol (
553 &gEfiIdeControllerInitProtocolGuid
,
555 This
->DriverBindingHandle
,
557 EFI_OPEN_PROTOCOL_GET_PROTOCOL
559 if (EFI_ERROR (Status
)) {
560 return EFI_UNSUPPORTED
;
563 SataPrivateData
= SATA_CONTROLLER_PRIVATE_DATA_FROM_THIS (IdeInit
);
564 ASSERT (SataPrivateData
!= NULL
);
567 // Uninstall the IDE Controller Init Protocol from this instance
569 Status
= gBS
->UninstallMultipleProtocolInterfaces (
571 &gEfiIdeControllerInitProtocolGuid
,
572 &(SataPrivateData
->IdeInit
),
575 if (EFI_ERROR (Status
)) {
579 if (SataPrivateData
!= NULL
) {
580 if (SataPrivateData
->DisqulifiedModes
!= NULL
) {
581 FreePool (SataPrivateData
->DisqulifiedModes
);
583 if (SataPrivateData
->IdentifyData
!= NULL
) {
584 FreePool (SataPrivateData
->IdentifyData
);
586 if (SataPrivateData
->IdentifyValid
!= NULL
) {
587 FreePool (SataPrivateData
->IdentifyValid
);
589 FreePool (SataPrivateData
);
593 // Close protocols opened by Sata Controller driver
595 return gBS
->CloseProtocol (
597 &gEfiPciIoProtocolGuid
,
598 This
->DriverBindingHandle
,
604 // Interface functions of IDE_CONTROLLER_INIT protocol
607 This function can be used to obtain information about a specified channel.
608 It's usually used by IDE Bus driver during enumeration process.
610 @param This the EFI_IDE_CONTROLLER_INIT_PROTOCOL instance.
611 @param Channel Channel number. Parallel ATA (PATA) controllers can support up to two channels.
612 Advanced Host Controller Interface (AHCI) Serial ATA (SATA) controllers
613 can support up to 32 channels, each of which can have up to 1 device.
614 In the presence of a multiplier, each channel can have 15 devices.
615 @param Enabled TRUE if the channel is enabled. If the channel is disabled,
616 then it will no be enumerated.
617 @param MaxDevices For Parallel ATA (PATA) controllers, this number will either be 1 or 2.
618 For Serial ATA (SATA) controllers, it always be 1,
619 but with a port multiplier, this number can be as large as 15.
621 @retval EFI_SUCCESS Success to get channel information.
622 @retval EFI_INVALID_PARAMETER Invalid channel id.
626 IdeInitGetChannelInfo (
627 IN EFI_IDE_CONTROLLER_INIT_PROTOCOL
*This
,
629 OUT BOOLEAN
*Enabled
,
630 OUT UINT8
*MaxDevices
633 EFI_SATA_CONTROLLER_PRIVATE_DATA
*SataPrivateData
;
634 SataPrivateData
= SATA_CONTROLLER_PRIVATE_DATA_FROM_THIS (This
);
635 ASSERT (SataPrivateData
!= NULL
);
637 if (Channel
< This
->ChannelCount
) {
639 *MaxDevices
= SataPrivateData
->DeviceCount
;
644 return EFI_INVALID_PARAMETER
;
648 This function is called by IdeBus driver before executing certain actions.
649 This allows IDE Controller Init to prepare for each action.
651 @param This The EFI_IDE_CONTROLLER_INIT_PROTOCOL instance.
652 @param Phase Phase indicator defined by IDE_CONTROLLER_INIT protocol.
653 @param Channel Channel number.
655 @retval EFI_SUCCESS Success operation.
660 IN EFI_IDE_CONTROLLER_INIT_PROTOCOL
*This
,
661 IN EFI_IDE_CONTROLLER_ENUM_PHASE Phase
,
669 This function is called by IdeBus driver to submit EFI_IDENTIFY_DATA data structure
670 obtained from IDE deivce. This structure is used to set IDE timing.
672 @param This The EFI_IDE_CONTROLLER_INIT_PROTOCOL instance.
673 @param Channel Channel number.
674 @param Device Device number.
675 @param IdentifyData A pointer to EFI_IDENTIFY_DATA data structure.
677 @retval EFI_SUCCESS The information is accepted without any errors.
678 @retval EFI_INVALID_PARAMETER Invalid channel id or device id.
683 IN EFI_IDE_CONTROLLER_INIT_PROTOCOL
*This
,
686 IN EFI_IDENTIFY_DATA
*IdentifyData
689 EFI_SATA_CONTROLLER_PRIVATE_DATA
*SataPrivateData
;
690 SataPrivateData
= SATA_CONTROLLER_PRIVATE_DATA_FROM_THIS (This
);
691 ASSERT (SataPrivateData
!= NULL
);
693 if ((Channel
>= This
->ChannelCount
) || (Device
>= SataPrivateData
->DeviceCount
)) {
694 return EFI_INVALID_PARAMETER
;
698 // Make a local copy of device's IdentifyData and mark the valid flag
700 if (IdentifyData
!= NULL
) {
702 &(SataPrivateData
->IdentifyData
[Channel
* Device
]),
704 sizeof (EFI_IDENTIFY_DATA
)
707 SataPrivateData
->IdentifyValid
[Channel
* Device
] = TRUE
;
709 SataPrivateData
->IdentifyValid
[Channel
* Device
] = FALSE
;
716 This function is called by IdeBus driver to disqualify unsupported operation
717 mode on specfic IDE device.
719 @param This The EFI_IDE_CONTROLLER_INIT_PROTOCOL instance.
720 @param Channel Channel number.
721 @param Device Device number.
722 @param BadModes The modes that the device does not support and that
723 should be disqualified.
725 @retval EFI_SUCCESS The modes were accepted without any errors.
726 @retval EFI_INVALID_PARAMETER Invalid channel id or device id.
730 IdeInitDisqualifyMode (
731 IN EFI_IDE_CONTROLLER_INIT_PROTOCOL
*This
,
734 IN EFI_ATA_COLLECTIVE_MODE
*BadModes
737 EFI_SATA_CONTROLLER_PRIVATE_DATA
*SataPrivateData
;
738 SataPrivateData
= SATA_CONTROLLER_PRIVATE_DATA_FROM_THIS (This
);
739 ASSERT (SataPrivateData
!= NULL
);
741 if ((Channel
>= This
->ChannelCount
) || (BadModes
== NULL
) || (Device
>= SataPrivateData
->DeviceCount
)) {
742 return EFI_INVALID_PARAMETER
;
746 // Record the disqualified modes per channel per device. From ATA/ATAPI spec,
747 // if a mode is not supported, the modes higher than it is also not supported.
750 &(SataPrivateData
->DisqulifiedModes
[Channel
* Device
]),
752 sizeof (EFI_ATA_COLLECTIVE_MODE
)
759 This function is called by IdeBus driver to calculate the best operation mode
760 supported by specific IDE device.
762 @param This The EFI_IDE_CONTROLLER_INIT_PROTOCOL instance.
763 @param Channel Channel number.
764 @param Device Device number.
765 @param SupportedModes The optimum modes for the device.
767 @retval EFI_SUCCESS Supported modes are returned.
768 @retval EFI_INVALID_PARAMETER Invalid channel id or device id.
769 @retval EFI_OUT_OF_RESOURCES Fail to allocate pool.
770 @retval EFI_NOT_READY Identify data of the device is not ready.
774 IdeInitCalculateMode (
775 IN EFI_IDE_CONTROLLER_INIT_PROTOCOL
*This
,
778 OUT EFI_ATA_COLLECTIVE_MODE
**SupportedModes
781 EFI_SATA_CONTROLLER_PRIVATE_DATA
*SataPrivateData
;
782 EFI_IDENTIFY_DATA
*IdentifyData
;
783 BOOLEAN IdentifyValid
;
784 EFI_ATA_COLLECTIVE_MODE
*DisqulifiedModes
;
788 SataPrivateData
= SATA_CONTROLLER_PRIVATE_DATA_FROM_THIS (This
);
789 ASSERT (SataPrivateData
!= NULL
);
791 if ((Channel
>= This
->ChannelCount
) || (SupportedModes
== NULL
) || (Device
>= SataPrivateData
->DeviceCount
)) {
792 return EFI_INVALID_PARAMETER
;
795 *SupportedModes
= AllocateZeroPool (sizeof (EFI_ATA_COLLECTIVE_MODE
));
796 if (*SupportedModes
== NULL
) {
797 return EFI_OUT_OF_RESOURCES
;
800 IdentifyData
= &(SataPrivateData
->IdentifyData
[Channel
* Device
]);
801 IdentifyValid
= SataPrivateData
->IdentifyValid
[Channel
* Device
];
802 DisqulifiedModes
= &(SataPrivateData
->DisqulifiedModes
[Channel
* Device
]);
805 // Make sure we've got the valid identify data of the device from SubmitData()
807 if (!IdentifyValid
) {
808 return EFI_NOT_READY
;
811 Status
= CalculateBestPioMode (
813 (DisqulifiedModes
->PioMode
.Valid
? ((UINT16
*) &(DisqulifiedModes
->PioMode
.Mode
)) : NULL
),
816 if (!EFI_ERROR (Status
)) {
817 (*SupportedModes
)->PioMode
.Valid
= TRUE
;
818 (*SupportedModes
)->PioMode
.Mode
= SelectedMode
;
821 (*SupportedModes
)->PioMode
.Valid
= FALSE
;
823 DEBUG ((EFI_D_INFO
, "IdeInitCalculateMode: PioMode = %x\n", (*SupportedModes
)->PioMode
.Mode
));
825 Status
= CalculateBestUdmaMode (
827 (DisqulifiedModes
->UdmaMode
.Valid
? ((UINT16
*) &(DisqulifiedModes
->UdmaMode
.Mode
)) : NULL
),
831 if (!EFI_ERROR (Status
)) {
832 (*SupportedModes
)->UdmaMode
.Valid
= TRUE
;
833 (*SupportedModes
)->UdmaMode
.Mode
= SelectedMode
;
836 (*SupportedModes
)->UdmaMode
.Valid
= FALSE
;
838 DEBUG ((EFI_D_INFO
, "IdeInitCalculateMode: UdmaMode = %x\n", (*SupportedModes
)->UdmaMode
.Mode
));
841 // The modes other than PIO and UDMA are not supported
847 This function is called by IdeBus driver to set appropriate timing on IDE
848 controller according supported operation mode.
850 @param This The EFI_IDE_CONTROLLER_INIT_PROTOCOL instance.
851 @param Channel Channel number.
852 @param Device Device number.
853 @param Modes The modes to set.
855 @retval EFI_SUCCESS Sucess operation.
860 IN EFI_IDE_CONTROLLER_INIT_PROTOCOL
*This
,
863 IN EFI_ATA_COLLECTIVE_MODE
*Modes