OvmfPkg/SataControllerDxe/SataController.c

   1 /** @file
   2   This driver module produces IDE_CONTROLLER_INIT protocol for Sata Controllers.
   3
   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
   9
  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.
  12
  13 **/
  14
  15 #include "SataController.h"
  16
  17 ///
  18 /// EFI_DRIVER_BINDING_PROTOCOL instance
  19 ///
  20 EFI_DRIVER_BINDING_PROTOCOL gSataControllerDriverBinding = {
  21   SataControllerSupported,
  22   SataControllerStart,
  23   SataControllerStop,
  24   0xa,
  25   NULL,
  26   NULL
  27 };
  28
  29 /**
  30   Read AHCI Operation register.
  31
  32   @param PciIo      The PCI IO protocol instance.
  33   @param Offset     The operation register offset.
  34
  35   @return The register content read.
  36
  37 **/
  38 UINT32
  39 EFIAPI
  40 AhciReadReg (
  41   IN EFI_PCI_IO_PROTOCOL    *PciIo,
  42   IN UINT32                 Offset
  43   )
  44 {
  45   UINT32    Data;
  46
  47   ASSERT (PciIo != NULL);
  48
  49   Data = 0;
  50
  51   PciIo->Mem.Read (
  52                PciIo,
  53                EfiPciIoWidthUint32,
  54                AHCI_BAR_INDEX,
  55                (UINT64) Offset,
  56                1,
  57                &Data
  58                );
  59
  60   return Data;
  61 }
  62
  63 /**
  64   Write AHCI Operation register.
  65
  66   @param PciIo      The PCI IO protocol instance.
  67   @param Offset     The operation register offset.
  68   @param Data       The data used to write down.
  69
  70 **/
  71 VOID
  72 EFIAPI
  73 AhciWriteReg (
  74   IN EFI_PCI_IO_PROTOCOL    *PciIo,
  75   IN UINT32                 Offset,
  76   IN UINT32                 Data
  77   )
  78 {
  79   ASSERT (PciIo != NULL);
  80
  81   PciIo->Mem.Write (
  82                PciIo,
  83                EfiPciIoWidthUint32,
  84                AHCI_BAR_INDEX,
  85                (UINT64) Offset,
  86                1,
  87                &Data
  88                );
  89
  90   return;
  91 }
  92
  93 /**
  94   This function is used to calculate the best PIO mode supported by specific IDE device
  95
  96   @param IdentifyData   The identify data of specific IDE device.
  97   @param DisPioMode     Disqualified PIO modes collection.
  98   @param SelectedMode   Available PIO modes collection.
  99
 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.
 103 **/
 104 EFI_STATUS
 105 CalculateBestPioMode (
 106   IN EFI_IDENTIFY_DATA  *IdentifyData,
 107   IN UINT16             *DisPioMode OPTIONAL,
 108   OUT UINT16            *SelectedMode
 109   )
 110 {
 111   UINT16    PioMode;
 112   UINT16    AdvancedPioMode;
 113   UINT16    Temp;
 114   UINT16    Index;
 115   UINT16    MinimumPioCycleTime;
 116
 117   Temp = 0xff;
 118
 119   PioMode = (UINT8) (((ATA5_IDENTIFY_DATA *) (&(IdentifyData->AtaData)))->pio_cycle_timing >> 8);
 120
 121   //
 122   // See whether Identify Data word 64 - 70 are valid
 123   //
 124   if ((IdentifyData->AtaData.field_validity & 0x02) == 0x02) {
 125
 126     AdvancedPioMode = IdentifyData->AtaData.advanced_pio_modes;
 127     DEBUG ((EFI_D_INFO, "CalculateBestPioMode: AdvancedPioMode = %x\n", AdvancedPioMode));
 128
 129     for (Index = 0; Index < 8; Index++) {
 130       if ((AdvancedPioMode & 0x01) != 0) {
 131         Temp = Index;
 132       }
 133
 134       AdvancedPioMode >>= 1;
 135     }
 136
 137     //
 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.
 141     //
 142     if (Temp != 0xff) {
 143       AdvancedPioMode = (UINT16) (Temp + 3);
 144     } else {
 145       AdvancedPioMode = PioMode;
 146     }
 147
 148     //
 149     // Limit the PIO mode to at most PIO4.
 150     //
 151     PioMode = (UINT16) MIN (AdvancedPioMode, 4);
 152
 153     MinimumPioCycleTime = IdentifyData->AtaData.min_pio_cycle_time_with_flow_control;
 154
 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);
 161     } else {
 162       PioMode = 0;
 163     }
 164
 165     //
 166     // Degrade the PIO mode if the mode has been disqualified
 167     //
 168     if (DisPioMode != NULL) {
 169       if (*DisPioMode < 2) {
 170         return EFI_UNSUPPORTED; // no mode below ATA_PIO_MODE_BELOW_2
 171       }
 172
 173       if (PioMode >= *DisPioMode) {
 174         PioMode = (UINT16) (*DisPioMode - 1);
 175       }
 176     }
 177
 178     if (PioMode < 2) {
 179       *SelectedMode = 1;        // ATA_PIO_MODE_BELOW_2;
 180     } else {
 181       *SelectedMode = PioMode;  // ATA_PIO_MODE_2 to ATA_PIO_MODE_4;
 182     }
 183
 184   } else {
 185     //
 186     // Identify Data word 64 - 70 are not valid
 187     // Degrade the PIO mode if the mode has been disqualified
 188     //
 189     if (DisPioMode != NULL) {
 190       if (*DisPioMode < 2) {
 191         return EFI_UNSUPPORTED; // no mode below ATA_PIO_MODE_BELOW_2
 192       }
 193
 194       if (PioMode == *DisPioMode) {
 195         PioMode--;
 196       }
 197     }
 198
 199     if (PioMode < 2) {
 200       *SelectedMode = 1;        // ATA_PIO_MODE_BELOW_2;
 201     } else {
 202       *SelectedMode = 2;        // ATA_PIO_MODE_2;
 203     }
 204
 205   }
 206
 207   return EFI_SUCCESS;
 208 }
 209
 210 /**
 211   This function is used to calculate the best UDMA mode supported by specific IDE device
 212
 213   @param IdentifyData   The identify data of specific IDE device.
 214   @param DisUDmaMode     Disqualified UDMA modes collection.
 215   @param SelectedMode   Available UDMA modes collection.
 216
 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.
 220 **/
 221 EFI_STATUS
 222 CalculateBestUdmaMode (
 223   IN EFI_IDENTIFY_DATA  *IdentifyData,
 224   IN UINT16             *DisUDmaMode OPTIONAL,
 225   OUT UINT16            *SelectedMode
 226   )
 227 {
 228   UINT16    TempMode;
 229   UINT16    DeviceUDmaMode;
 230
 231   DeviceUDmaMode = 0;
 232
 233   //
 234   // Check whether the WORD 88 (supported UltraDMA by drive) is valid
 235   //
 236   if ((IdentifyData->AtaData.field_validity & 0x04) == 0x00) {
 237     return EFI_UNSUPPORTED;
 238   }
 239
 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
 244
 245   while ((DeviceUDmaMode >>= 1) != 0) {
 246     TempMode++;
 247   }
 248
 249   //
 250   // Degrade the UDMA mode if the mode has been disqualified
 251   //
 252   if (DisUDmaMode != NULL) {
 253     if (*DisUDmaMode == 0) {
 254       *SelectedMode = 0;
 255       return EFI_UNSUPPORTED;   // no mode below ATA_UDMA_MODE_0
 256     }
 257
 258     if (TempMode >= *DisUDmaMode) {
 259       TempMode = (UINT16) (*DisUDmaMode - 1);
 260     }
 261   }
 262
 263   //
 264   // Possible returned mode is between ATA_UDMA_MODE_0 and ATA_UDMA_MODE_5
 265   //
 266   *SelectedMode = TempMode;
 267
 268   return EFI_SUCCESS;
 269 }
 270
 271 /**
 272   The Entry Point of module. It follows the standard UEFI driver model.
 273
 274   @param[in] ImageHandle    The firmware allocated handle for the EFI image.
 275   @param[in] SystemTable    A pointer to the EFI System Table.
 276
 277   @retval EFI_SUCCESS   The entry point is executed successfully.
 278   @retval other         Some error occurs when executing this entry point.
 279
 280 **/
 281 EFI_STATUS
 282 EFIAPI
 283 InitializeSataControllerDriver (
 284   IN EFI_HANDLE         ImageHandle,
 285   IN EFI_SYSTEM_TABLE   *SystemTable
 286   )
 287 {
 288   EFI_STATUS    Status;
 289
 290   //
 291   // Install driver model protocol(s).
 292   //
 293   Status = EfiLibInstallDriverBindingComponentName2 (
 294              ImageHandle,
 295              SystemTable,
 296              &gSataControllerDriverBinding,
 297              ImageHandle,
 298              &gSataControllerComponentName,
 299              &gSataControllerComponentName2
 300              );
 301   ASSERT_EFI_ERROR (Status);
 302
 303   return Status;
 304 }
 305
 306 /**
 307   Supported function of Driver Binding protocol for this driver.
 308   Test to see if this driver supports ControllerHandle.
 309
 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.
 314
 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.
 318
 319 **/
 320 EFI_STATUS
 321 EFIAPI
 322 SataControllerSupported (
 323   IN EFI_DRIVER_BINDING_PROTOCOL    *This,
 324   IN EFI_HANDLE                     Controller,
 325   IN EFI_DEVICE_PATH_PROTOCOL       *RemainingDevicePath
 326   )
 327 {
 328   EFI_STATUS            Status;
 329   EFI_PCI_IO_PROTOCOL   *PciIo;
 330   PCI_TYPE00            PciData;
 331
 332   //
 333   // Attempt to open PCI I/O Protocol
 334   //
 335   Status = gBS->OpenProtocol (
 336                   Controller,
 337                   &gEfiPciIoProtocolGuid,
 338                   (VOID **) &PciIo,
 339                   This->DriverBindingHandle,
 340                   Controller,
 341                   EFI_OPEN_PROTOCOL_GET_PROTOCOL
 342                   );
 343   if (EFI_ERROR (Status)) {
 344     return Status;
 345   }
 346
 347   //
 348   // Now further check the PCI header: Base Class (offset 0x0B) and
 349   // Sub Class (offset 0x0A). This controller should be an SATA controller
 350   //
 351   Status = PciIo->Pci.Read (
 352                         PciIo,
 353                         EfiPciIoWidthUint8,
 354                         PCI_CLASSCODE_OFFSET,
 355                         sizeof (PciData.Hdr.ClassCode),
 356                         PciData.Hdr.ClassCode
 357                         );
 358   if (EFI_ERROR (Status)) {
 359     return EFI_UNSUPPORTED;
 360   }
 361
 362   if (IS_PCI_IDE (&PciData) || IS_PCI_SATADPA (&PciData)) {
 363     return EFI_SUCCESS;
 364   }
 365
 366   return EFI_UNSUPPORTED;
 367 }
 368
 369 /**
 370   This routine is called right after the .Supported() called and
 371   Start this driver on ControllerHandle.
 372
 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.
 377
 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.
 381
 382 **/
 383 EFI_STATUS
 384 EFIAPI
 385 SataControllerStart (
 386   IN EFI_DRIVER_BINDING_PROTOCOL    *This,
 387   IN EFI_HANDLE                     Controller,
 388   IN EFI_DEVICE_PATH_PROTOCOL       *RemainingDevicePath
 389   )
 390 {
 391   UINTN                             BailLogMask;
 392   EFI_STATUS                        Status;
 393   EFI_PCI_IO_PROTOCOL               *PciIo;
 394   UINT64                            OriginalPciAttributes;
 395   PCI_TYPE00                        PciData;
 396   EFI_SATA_CONTROLLER_PRIVATE_DATA  *SataPrivateData;
 397   UINT32                            Data32;
 398   UINTN                             ChannelDeviceCount;
 399
 400   DEBUG ((EFI_D_INFO, "SataControllerStart START\n"));
 401
 402   BailLogMask = DEBUG_ERROR;
 403   SataPrivateData = NULL;
 404
 405   //
 406   // Now test and open PCI I/O Protocol
 407   //
 408   Status = gBS->OpenProtocol (
 409                   Controller,
 410                   &gEfiPciIoProtocolGuid,
 411                   (VOID **) &PciIo,
 412                   This->DriverBindingHandle,
 413                   Controller,
 414                   EFI_OPEN_PROTOCOL_BY_DRIVER
 415                   );
 416   if (EFI_ERROR (Status)) {
 417     if (Status == EFI_ALREADY_STARTED) {
 418       //
 419       // This is an expected condition for OpenProtocol() / BY_DRIVER, in a
 420       // DriverBindingStart() member function; degrade the log mask to
 421       // DEBUG_INFO.
 422       //
 423       BailLogMask = DEBUG_INFO;
 424     }
 425     goto Bail;
 426   }
 427
 428   //
 429   // Save original PCI attributes, and enable IO space access, memory space
 430   // access, and Bus Master (DMA).
 431   //
 432   Status = PciIo->Attributes (PciIo, EfiPciIoAttributeOperationGet, 0,
 433                     &OriginalPciAttributes);
 434   if (EFI_ERROR (Status)) {
 435     goto ClosePciIo;
 436   }
 437   Status = PciIo->Attributes (PciIo, EfiPciIoAttributeOperationEnable,
 438                     EFI_PCI_DEVICE_ENABLE, NULL);
 439   if (EFI_ERROR (Status)) {
 440     goto ClosePciIo;
 441   }
 442
 443   //
 444   // Allocate Sata Private Data structure
 445   //
 446   SataPrivateData = AllocateZeroPool (sizeof (EFI_SATA_CONTROLLER_PRIVATE_DATA));
 447   if (SataPrivateData == NULL) {
 448     Status = EFI_OUT_OF_RESOURCES;
 449     goto RestorePciAttributes;
 450   }
 451
 452   //
 453   // Initialize Sata Private Data
 454   //
 455   SataPrivateData->Signature = SATA_CONTROLLER_SIGNATURE;
 456   SataPrivateData->PciIo = PciIo;
 457   SataPrivateData->OriginalPciAttributes = OriginalPciAttributes;
 458   SataPrivateData->IdeInit.GetChannelInfo = IdeInitGetChannelInfo;
 459   SataPrivateData->IdeInit.NotifyPhase = IdeInitNotifyPhase;
 460   SataPrivateData->IdeInit.SubmitData = IdeInitSubmitData;
 461   SataPrivateData->IdeInit.DisqualifyMode = IdeInitDisqualifyMode;
 462   SataPrivateData->IdeInit.CalculateMode = IdeInitCalculateMode;
 463   SataPrivateData->IdeInit.SetTiming = IdeInitSetTiming;
 464   SataPrivateData->IdeInit.EnumAll = SATA_ENUMER_ALL;
 465
 466   Status = PciIo->Pci.Read (
 467                         PciIo,
 468                         EfiPciIoWidthUint8,
 469                         PCI_CLASSCODE_OFFSET,
 470                         sizeof (PciData.Hdr.ClassCode),
 471                         PciData.Hdr.ClassCode
 472                         );
 473   if (EFI_ERROR (Status)) {
 474     goto FreeSataPrivateData;
 475   }
 476
 477   if (IS_PCI_IDE (&PciData)) {
 478     SataPrivateData->IdeInit.ChannelCount = IDE_MAX_CHANNEL;
 479     SataPrivateData->DeviceCount = IDE_MAX_DEVICES;
 480   } else if (IS_PCI_SATADPA (&PciData)) {
 481     //
 482     // Read Host Capability Register(CAP) to get Number of Ports(NPS) and Supports Port Multiplier(SPM)
 483     //   NPS is 0's based value indicating the maximum number of ports supported by the HBA silicon.
 484     //   A maximum of 32 ports can be supported. A value of '0h', indicating one port, is the minimum requirement.
 485     //
 486     Data32 = AhciReadReg (PciIo, R_AHCI_CAP);
 487     SataPrivateData->IdeInit.ChannelCount = (UINT8) ((Data32 & B_AHCI_CAP_NPS) + 1);
 488     SataPrivateData->DeviceCount = AHCI_MAX_DEVICES;
 489     if ((Data32 & B_AHCI_CAP_SPM) == B_AHCI_CAP_SPM) {
 490       SataPrivateData->DeviceCount = AHCI_MULTI_MAX_DEVICES;
 491     }
 492   }
 493
 494   ChannelDeviceCount = (UINTN) (SataPrivateData->IdeInit.ChannelCount) * (UINTN) (SataPrivateData->DeviceCount);
 495   SataPrivateData->DisqualifiedModes = AllocateZeroPool ((sizeof (EFI_ATA_COLLECTIVE_MODE)) * ChannelDeviceCount);
 496   if (SataPrivateData->DisqualifiedModes == NULL) {
 497     Status = EFI_OUT_OF_RESOURCES;
 498     goto FreeSataPrivateData;
 499   }
 500
 501   SataPrivateData->IdentifyData = AllocateZeroPool ((sizeof (EFI_IDENTIFY_DATA)) * ChannelDeviceCount);
 502   if (SataPrivateData->IdentifyData == NULL) {
 503     Status = EFI_OUT_OF_RESOURCES;
 504     goto FreeDisqualifiedModes;
 505   }
 506
 507   SataPrivateData->IdentifyValid = AllocateZeroPool ((sizeof (BOOLEAN)) * ChannelDeviceCount);
 508   if (SataPrivateData->IdentifyValid == NULL) {
 509     Status = EFI_OUT_OF_RESOURCES;
 510     goto FreeIdentifyData;
 511   }
 512
 513   //
 514   // Install IDE Controller Init Protocol to this instance
 515   //
 516   Status = gBS->InstallMultipleProtocolInterfaces (
 517                   &Controller,
 518                   &gEfiIdeControllerInitProtocolGuid,
 519                   &(SataPrivateData->IdeInit),
 520                   NULL
 521                   );
 522
 523   if (EFI_ERROR (Status)) {
 524     goto FreeIdentifyValid;
 525   }
 526
 527   DEBUG ((EFI_D_INFO, "SataControllerStart END status = %r\n", Status));
 528   return Status;
 529
 530 FreeIdentifyValid:
 531   FreePool (SataPrivateData->IdentifyValid);
 532
 533 FreeIdentifyData:
 534   FreePool (SataPrivateData->IdentifyData);
 535
 536 FreeDisqualifiedModes:
 537   FreePool (SataPrivateData->DisqualifiedModes);
 538
 539 FreeSataPrivateData:
 540   FreePool (SataPrivateData);
 541
 542 RestorePciAttributes:
 543   PciIo->Attributes (PciIo, EfiPciIoAttributeOperationSet,
 544            OriginalPciAttributes, NULL);
 545
 546 ClosePciIo:
 547   gBS->CloseProtocol (
 548          Controller,
 549          &gEfiPciIoProtocolGuid,
 550          This->DriverBindingHandle,
 551          Controller
 552          );
 553
 554 Bail:
 555   DEBUG ((BailLogMask, "SataControllerStart error return status = %r\n",
 556     Status));
 557   return Status;
 558 }
 559
 560 /**
 561   Stop this driver on ControllerHandle.
 562
 563   @param This               Protocol instance pointer.
 564   @param Controller         Handle of device to stop driver on.
 565   @param NumberOfChildren   Not used.
 566   @param ChildHandleBuffer  Not used.
 567
 568   @retval EFI_SUCCESS   This driver is removed from this device.
 569   @retval other         Some error occurs when removing this driver from this device.
 570
 571 **/
 572 EFI_STATUS
 573 EFIAPI
 574 SataControllerStop (
 575   IN EFI_DRIVER_BINDING_PROTOCOL    *This,
 576   IN EFI_HANDLE                     Controller,
 577   IN UINTN                          NumberOfChildren,
 578   IN EFI_HANDLE                     *ChildHandleBuffer
 579   )
 580 {
 581   EFI_STATUS                        Status;
 582   EFI_IDE_CONTROLLER_INIT_PROTOCOL  *IdeInit;
 583   EFI_SATA_CONTROLLER_PRIVATE_DATA  *SataPrivateData;
 584   EFI_PCI_IO_PROTOCOL               *PciIo;
 585   UINT64                            OriginalPciAttributes;
 586
 587   //
 588   // Open the produced protocol
 589   //
 590   Status = gBS->OpenProtocol (
 591                   Controller,
 592                   &gEfiIdeControllerInitProtocolGuid,
 593                   (VOID **) &IdeInit,
 594                   This->DriverBindingHandle,
 595                   Controller,
 596                   EFI_OPEN_PROTOCOL_GET_PROTOCOL
 597                   );
 598   if (EFI_ERROR (Status)) {
 599     return EFI_UNSUPPORTED;
 600   }
 601
 602   SataPrivateData = SATA_CONTROLLER_PRIVATE_DATA_FROM_THIS (IdeInit);
 603   ASSERT (SataPrivateData != NULL);
 604
 605   PciIo                 = SataPrivateData->PciIo;
 606   OriginalPciAttributes = SataPrivateData->OriginalPciAttributes;
 607
 608   //
 609   // Uninstall the IDE Controller Init Protocol from this instance
 610   //
 611   Status = gBS->UninstallMultipleProtocolInterfaces (
 612                   Controller,
 613                   &gEfiIdeControllerInitProtocolGuid,
 614                   &(SataPrivateData->IdeInit),
 615                   NULL
 616                   );
 617   if (EFI_ERROR (Status)) {
 618     return Status;
 619   }
 620
 621   if (SataPrivateData->DisqualifiedModes != NULL) {
 622     FreePool (SataPrivateData->DisqualifiedModes);
 623   }
 624   if (SataPrivateData->IdentifyData != NULL) {
 625     FreePool (SataPrivateData->IdentifyData);
 626   }
 627   if (SataPrivateData->IdentifyValid != NULL) {
 628     FreePool (SataPrivateData->IdentifyValid);
 629   }
 630   FreePool (SataPrivateData);
 631
 632   //
 633   // Restore original PCI attributes
 634   //
 635   PciIo->Attributes (
 636            PciIo,
 637            EfiPciIoAttributeOperationSet,
 638            OriginalPciAttributes,
 639            NULL
 640            );
 641
 642   //
 643   // Close protocols opened by Sata Controller driver
 644   //
 645   return gBS->CloseProtocol (
 646                 Controller,
 647                 &gEfiPciIoProtocolGuid,
 648                 This->DriverBindingHandle,
 649                 Controller
 650                 );
 651 }
 652
 653 /**
 654   Calculate the flat array subscript of a (Channel, Device) pair.
 655
 656   @param[in] SataPrivateData  The private data structure corresponding to the
 657                               SATA controller that attaches the device for
 658                               which the flat array subscript is being
 659                               calculated.
 660
 661   @param[in] Channel          The channel (ie. port) number on the SATA
 662                               controller that the device is attached to.
 663
 664   @param[in] Device           The device number on the channel.
 665
 666   @return  The flat array subscript suitable for indexing DisqualifiedModes,
 667            IdentifyData, and IdentifyValid.
 668 **/
 669 STATIC
 670 UINTN
 671 FlatDeviceIndex (
 672   IN CONST EFI_SATA_CONTROLLER_PRIVATE_DATA  *SataPrivateData,
 673   IN UINTN                                   Channel,
 674   IN UINTN                                   Device
 675   )
 676 {
 677   ASSERT (SataPrivateData != NULL);
 678   ASSERT (Channel < SataPrivateData->IdeInit.ChannelCount);
 679   ASSERT (Device < SataPrivateData->DeviceCount);
 680
 681   return Channel * SataPrivateData->DeviceCount + Device;
 682 }
 683
 684 //
 685 // Interface functions of IDE_CONTROLLER_INIT protocol
 686 //
 687 /**
 688   Returns the information about the specified IDE channel.
 689
 690   This function can be used to obtain information about a particular IDE channel.
 691   The driver entity uses this information during the enumeration process.
 692
 693   If Enabled is set to FALSE, the driver entity will not scan the channel. Note
 694   that it will not prevent an operating system driver from scanning the channel.
 695
 696   For most of today's controllers, MaxDevices will either be 1 or 2. For SATA
 697   controllers, this value will always be 1. SATA configurations can contain SATA
 698   port multipliers. SATA port multipliers behave like SATA bridges and can support
 699   up to 16 devices on the other side. If a SATA port out of the IDE controller
 700   is connected to a port multiplier, MaxDevices will be set to the number of SATA
 701   devices that the port multiplier supports. Because today's port multipliers
 702   support up to fifteen SATA devices, this number can be as large as fifteen. The IDE
 703   bus driver is required to scan for the presence of port multipliers behind an SATA
 704   controller and enumerate up to MaxDevices number of devices behind the port
 705   multiplier.
 706
 707   In this context, the devices behind a port multiplier constitute a channel.
 708
 709   @param[in]  This         The pointer to the EFI_IDE_CONTROLLER_INIT_PROTOCOL instance.
 710   @param[in]  Channel      Zero-based channel number.
 711   @param[out] Enabled      TRUE if this channel is enabled.  Disabled channels
 712                            are not scanned to see if any devices are present.
 713   @param[out] MaxDevices   The maximum number of IDE devices that the bus driver
 714                            can expect on this channel.  For the ATA/ATAPI
 715                            specification, version 6, this number will either be
 716                            one or two. For Serial ATA (SATA) configurations with a
 717                            port multiplier, this number can be as large as fifteen.
 718
 719   @retval EFI_SUCCESS             Information was returned without any errors.
 720   @retval EFI_INVALID_PARAMETER   Channel is invalid (Channel >= ChannelCount).
 721
 722 **/
 723 EFI_STATUS
 724 EFIAPI
 725 IdeInitGetChannelInfo (
 726   IN EFI_IDE_CONTROLLER_INIT_PROTOCOL   *This,
 727   IN UINT8                              Channel,
 728   OUT BOOLEAN                           *Enabled,
 729   OUT UINT8                             *MaxDevices
 730   )
 731 {
 732   EFI_SATA_CONTROLLER_PRIVATE_DATA  *SataPrivateData;
 733   SataPrivateData = SATA_CONTROLLER_PRIVATE_DATA_FROM_THIS (This);
 734   ASSERT (SataPrivateData != NULL);
 735
 736   if (Channel < This->ChannelCount) {
 737     *Enabled = TRUE;
 738     *MaxDevices = SataPrivateData->DeviceCount;
 739     return EFI_SUCCESS;
 740   }
 741
 742   *Enabled = FALSE;
 743   return EFI_INVALID_PARAMETER;
 744 }
 745
 746 /**
 747   The notifications from the driver entity that it is about to enter a certain
 748   phase of the IDE channel enumeration process.
 749
 750   This function can be used to notify the IDE controller driver to perform
 751   specific actions, including any chipset-specific initialization, so that the
 752   chipset is ready to enter the next phase. Seven notification points are defined
 753   at this time.
 754
 755   More synchronization points may be added as required in the future.
 756
 757   @param[in] This      The pointer to the EFI_IDE_CONTROLLER_INIT_PROTOCOL instance.
 758   @param[in] Phase     The phase during enumeration.
 759   @param[in] Channel   Zero-based channel number.
 760
 761   @retval EFI_SUCCESS             The notification was accepted without any errors.
 762   @retval EFI_UNSUPPORTED         Phase is not supported.
 763   @retval EFI_INVALID_PARAMETER   Channel is invalid (Channel >= ChannelCount).
 764   @retval EFI_NOT_READY           This phase cannot be entered at this time; for
 765                                   example, an attempt was made to enter a Phase
 766                                   without having entered one or more previous
 767                                   Phase.
 768
 769 **/
 770 EFI_STATUS
 771 EFIAPI
 772 IdeInitNotifyPhase (
 773   IN EFI_IDE_CONTROLLER_INIT_PROTOCOL   *This,
 774   IN EFI_IDE_CONTROLLER_ENUM_PHASE      Phase,
 775   IN UINT8                              Channel
 776   )
 777 {
 778   return EFI_SUCCESS;
 779 }
 780
 781 /**
 782   Submits the device information to the IDE controller driver.
 783
 784   This function is used by the driver entity to pass detailed information about
 785   a particular device to the IDE controller driver. The driver entity obtains
 786   this information by issuing an ATA or ATAPI IDENTIFY_DEVICE command. IdentifyData
 787   is the pointer to the response data buffer. The IdentifyData buffer is owned
 788   by the driver entity, and the IDE controller driver must make a local copy
 789   of the entire buffer or parts of the buffer as needed. The original IdentifyData
 790   buffer pointer may not be valid when
 791
 792     - EFI_IDE_CONTROLLER_INIT_PROTOCOL.CalculateMode() or
 793     - EFI_IDE_CONTROLLER_INIT_PROTOCOL.DisqualifyMode() is called at a later point.
 794
 795   The IDE controller driver may consult various fields of EFI_IDENTIFY_DATA to
 796   compute the optimum mode for the device. These fields are not limited to the
 797   timing information. For example, an implementation of the IDE controller driver
 798   may examine the vendor and type/mode field to match known bad drives.
 799
 800   The driver entity may submit drive information in any order, as long as it
 801   submits information for all the devices belonging to the enumeration group
 802   before EFI_IDE_CONTROLLER_INIT_PROTOCOL.CalculateMode() is called for any device
 803   in that enumeration group. If a device is absent, EFI_IDE_CONTROLLER_INIT_PROTOCOL.SubmitData()
 804   should be called with IdentifyData set to NULL.  The IDE controller driver may
 805   not have any other mechanism to know whether a device is present or not. Therefore,
 806   setting IdentifyData to NULL does not constitute an error condition.
 807   EFI_IDE_CONTROLLER_INIT_PROTOCOL.SubmitData() can be called only once for a
 808   given (Channel, Device) pair.
 809
 810   @param[in] This           A pointer to the EFI_IDE_CONTROLLER_INIT_PROTOCOL instance.
 811   @param[in] Channel        Zero-based channel number.
 812   @param[in] Device         Zero-based device number on the Channel.
 813   @param[in] IdentifyData   The device's response to the ATA IDENTIFY_DEVICE command.
 814
 815   @retval EFI_SUCCESS             The information was accepted without any errors.
 816   @retval EFI_INVALID_PARAMETER   Channel is invalid (Channel >= ChannelCount).
 817   @retval EFI_INVALID_PARAMETER   Device is invalid.
 818
 819 **/
 820 EFI_STATUS
 821 EFIAPI
 822 IdeInitSubmitData (
 823   IN EFI_IDE_CONTROLLER_INIT_PROTOCOL   *This,
 824   IN UINT8                              Channel,
 825   IN UINT8                              Device,
 826   IN EFI_IDENTIFY_DATA                  *IdentifyData
 827   )
 828 {
 829   EFI_SATA_CONTROLLER_PRIVATE_DATA  *SataPrivateData;
 830   UINTN                             DeviceIndex;
 831
 832   SataPrivateData = SATA_CONTROLLER_PRIVATE_DATA_FROM_THIS (This);
 833   ASSERT (SataPrivateData != NULL);
 834
 835   if ((Channel >= This->ChannelCount) || (Device >= SataPrivateData->DeviceCount)) {
 836     return EFI_INVALID_PARAMETER;
 837   }
 838
 839   DeviceIndex = FlatDeviceIndex (SataPrivateData, Channel, Device);
 840
 841   //
 842   // Make a local copy of device's IdentifyData and mark the valid flag
 843   //
 844   if (IdentifyData != NULL) {
 845     CopyMem (
 846       &(SataPrivateData->IdentifyData[DeviceIndex]),
 847       IdentifyData,
 848       sizeof (EFI_IDENTIFY_DATA)
 849       );
 850
 851     SataPrivateData->IdentifyValid[DeviceIndex] = TRUE;
 852   } else {
 853     SataPrivateData->IdentifyValid[DeviceIndex] = FALSE;
 854   }
 855
 856   return EFI_SUCCESS;
 857 }
 858
 859 /**
 860   Disqualifies specific modes for an IDE device.
 861
 862   This function allows the driver entity or other drivers (such as platform
 863   drivers) to reject certain timing modes and request the IDE controller driver
 864   to recalculate modes. This function allows the driver entity and the IDE
 865   controller driver to negotiate the timings on a per-device basis. This function
 866   is useful in the case of drives that lie about their capabilities. An example
 867   is when the IDE device fails to accept the timing modes that are calculated
 868   by the IDE controller driver based on the response to the Identify Drive command.
 869
 870   If the driver entity does not want to limit the ATA timing modes and leave that
 871   decision to the IDE controller driver, it can either not call this function for
 872   the given device or call this function and set the Valid flag to FALSE for all
 873   modes that are listed in EFI_ATA_COLLECTIVE_MODE.
 874
 875   The driver entity may disqualify modes for a device in any order and any number
 876   of times.
 877
 878   This function can be called multiple times to invalidate multiple modes of the
 879   same type (e.g., Programmed Input/Output [PIO] modes 3 and 4). See the ATA/ATAPI
 880   specification for more information on PIO modes.
 881
 882   For Serial ATA (SATA) controllers, this member function can be used to disqualify
 883   a higher transfer rate mode on a given channel. For example, a platform driver
 884   may inform the IDE controller driver to not use second-generation (Gen2) speeds
 885   for a certain SATA drive.
 886
 887   @param[in] This       The pointer to the EFI_IDE_CONTROLLER_INIT_PROTOCOL instance.
 888   @param[in] Channel    The zero-based channel number.
 889   @param[in] Device     The zero-based device number on the Channel.
 890   @param[in] BadModes   The modes that the device does not support and that
 891                         should be disqualified.
 892
 893   @retval EFI_SUCCESS             The modes were accepted without any errors.
 894   @retval EFI_INVALID_PARAMETER   Channel is invalid (Channel >= ChannelCount).
 895   @retval EFI_INVALID_PARAMETER   Device is invalid.
 896   @retval EFI_INVALID_PARAMETER   IdentifyData is NULL.
 897
 898 **/
 899 EFI_STATUS
 900 EFIAPI
 901 IdeInitDisqualifyMode (
 902   IN EFI_IDE_CONTROLLER_INIT_PROTOCOL   *This,
 903   IN UINT8                              Channel,
 904   IN UINT8                              Device,
 905   IN EFI_ATA_COLLECTIVE_MODE            *BadModes
 906   )
 907 {
 908   EFI_SATA_CONTROLLER_PRIVATE_DATA  *SataPrivateData;
 909   UINTN                             DeviceIndex;
 910
 911   SataPrivateData = SATA_CONTROLLER_PRIVATE_DATA_FROM_THIS (This);
 912   ASSERT (SataPrivateData != NULL);
 913
 914   if ((Channel >= This->ChannelCount) || (BadModes == NULL) || (Device >= SataPrivateData->DeviceCount)) {
 915     return EFI_INVALID_PARAMETER;
 916   }
 917
 918   DeviceIndex = FlatDeviceIndex (SataPrivateData, Channel, Device);
 919
 920   //
 921   // Record the disqualified modes per channel per device. From ATA/ATAPI spec,
 922   // if a mode is not supported, the modes higher than it is also not supported.
 923   //
 924   CopyMem (
 925     &(SataPrivateData->DisqualifiedModes[DeviceIndex]),
 926     BadModes,
 927     sizeof (EFI_ATA_COLLECTIVE_MODE)
 928     );
 929
 930   return EFI_SUCCESS;
 931 }
 932
 933 /**
 934   Returns the information about the optimum modes for the specified IDE device.
 935
 936   This function is used by the driver entity to obtain the optimum ATA modes for
 937   a specific device.  The IDE controller driver takes into account the following
 938   while calculating the mode:
 939     - The IdentifyData inputs to EFI_IDE_CONTROLLER_INIT_PROTOCOL.SubmitData()
 940     - The BadModes inputs to EFI_IDE_CONTROLLER_INIT_PROTOCOL.DisqualifyMode()
 941
 942   The driver entity is required to call EFI_IDE_CONTROLLER_INIT_PROTOCOL.SubmitData()
 943   for all the devices that belong to an enumeration group before calling
 944   EFI_IDE_CONTROLLER_INIT_PROTOCOL.CalculateMode() for any device in the same group.
 945
 946   The IDE controller driver will use controller- and possibly platform-specific
 947   algorithms to arrive at SupportedModes.  The IDE controller may base its
 948   decision on user preferences and other considerations as well. This function
 949   may be called multiple times because the driver entity may renegotiate the mode
 950   with the IDE controller driver using EFI_IDE_CONTROLLER_INIT_PROTOCOL.DisqualifyMode().
 951
 952   The driver entity may collect timing information for various devices in any
 953   order. The driver entity is responsible for making sure that all the dependencies
 954   are satisfied. For example, the SupportedModes information for device A that
 955   was previously returned may become stale after a call to
 956   EFI_IDE_CONTROLLER_INIT_PROTOCOL.DisqualifyMode() for device B.
 957
 958   The buffer SupportedModes is allocated by the callee because the caller does
 959   not necessarily know the size of the buffer. The type EFI_ATA_COLLECTIVE_MODE
 960   is defined in a way that allows for future extensibility and can be of variable
 961   length. This memory pool should be deallocated by the caller when it is no
 962   longer necessary.
 963
 964   The IDE controller driver for a Serial ATA (SATA) controller can use this
 965   member function to force a lower speed (first-generation [Gen1] speeds on a
 966   second-generation [Gen2]-capable hardware).  The IDE controller driver can
 967   also allow the driver entity to stay with the speed that has been negotiated
 968   by the physical layer.
 969
 970   @param[in]  This             The pointer to the EFI_IDE_CONTROLLER_INIT_PROTOCOL instance.
 971   @param[in]  Channel          A zero-based channel number.
 972   @param[in]  Device           A zero-based device number on the Channel.
 973   @param[out] SupportedModes   The optimum modes for the device.
 974
 975   @retval EFI_SUCCESS             SupportedModes was returned.
 976   @retval EFI_INVALID_PARAMETER   Channel is invalid (Channel >= ChannelCount).
 977   @retval EFI_INVALID_PARAMETER   Device is invalid.
 978   @retval EFI_INVALID_PARAMETER   SupportedModes is NULL.
 979   @retval EFI_NOT_READY           Modes cannot be calculated due to a lack of
 980                                   data.  This error may happen if
 981                                   EFI_IDE_CONTROLLER_INIT_PROTOCOL.SubmitData()
 982                                   and EFI_IDE_CONTROLLER_INIT_PROTOCOL.DisqualifyData()
 983                                   were not called for at least one drive in the
 984                                   same enumeration group.
 985
 986 **/
 987 EFI_STATUS
 988 EFIAPI
 989 IdeInitCalculateMode (
 990   IN EFI_IDE_CONTROLLER_INIT_PROTOCOL   *This,
 991   IN UINT8                              Channel,
 992   IN UINT8                              Device,
 993   OUT EFI_ATA_COLLECTIVE_MODE           **SupportedModes
 994   )
 995 {
 996   EFI_SATA_CONTROLLER_PRIVATE_DATA  *SataPrivateData;
 997   EFI_IDENTIFY_DATA                 *IdentifyData;
 998   BOOLEAN                           IdentifyValid;
 999   EFI_ATA_COLLECTIVE_MODE           *DisqualifiedModes;
1000   UINT16                            SelectedMode;
1001   EFI_STATUS                        Status;
1002   UINTN                             DeviceIndex;
1003
1004   SataPrivateData = SATA_CONTROLLER_PRIVATE_DATA_FROM_THIS (This);
1005   ASSERT (SataPrivateData != NULL);
1006
1007   if ((Channel >= This->ChannelCount) || (SupportedModes == NULL) || (Device >= SataPrivateData->DeviceCount)) {
1008     return EFI_INVALID_PARAMETER;
1009   }
1010
1011   *SupportedModes = AllocateZeroPool (sizeof (EFI_ATA_COLLECTIVE_MODE));
1012   if (*SupportedModes == NULL) {
1013     ASSERT (*SupportedModes != NULL);
1014     return EFI_OUT_OF_RESOURCES;
1015   }
1016
1017   DeviceIndex = FlatDeviceIndex (SataPrivateData, Channel, Device);
1018
1019   IdentifyData = &(SataPrivateData->IdentifyData[DeviceIndex]);
1020   IdentifyValid = SataPrivateData->IdentifyValid[DeviceIndex];
1021   DisqualifiedModes = &(SataPrivateData->DisqualifiedModes[DeviceIndex]);
1022
1023   //
1024   // Make sure we've got the valid identify data of the device from SubmitData()
1025   //
1026   if (!IdentifyValid) {
1027     FreePool (*SupportedModes);
1028     return EFI_NOT_READY;
1029   }
1030
1031   Status = CalculateBestPioMode (
1032             IdentifyData,
1033             (DisqualifiedModes->PioMode.Valid ? ((UINT16 *) &(DisqualifiedModes->PioMode.Mode)) : NULL),
1034             &SelectedMode
1035             );
1036   if (!EFI_ERROR (Status)) {
1037     (*SupportedModes)->PioMode.Valid = TRUE;
1038     (*SupportedModes)->PioMode.Mode = SelectedMode;
1039
1040   } else {
1041     (*SupportedModes)->PioMode.Valid = FALSE;
1042   }
1043   DEBUG ((EFI_D_INFO, "IdeInitCalculateMode: PioMode = %x\n", (*SupportedModes)->PioMode.Mode));
1044
1045   Status = CalculateBestUdmaMode (
1046             IdentifyData,
1047             (DisqualifiedModes->UdmaMode.Valid ? ((UINT16 *) &(DisqualifiedModes->UdmaMode.Mode)) : NULL),
1048             &SelectedMode
1049             );
1050
1051   if (!EFI_ERROR (Status)) {
1052     (*SupportedModes)->UdmaMode.Valid = TRUE;
1053     (*SupportedModes)->UdmaMode.Mode  = SelectedMode;
1054
1055   } else {
1056     (*SupportedModes)->UdmaMode.Valid = FALSE;
1057   }
1058   DEBUG ((EFI_D_INFO, "IdeInitCalculateMode: UdmaMode = %x\n", (*SupportedModes)->UdmaMode.Mode));
1059
1060   //
1061   // The modes other than PIO and UDMA are not supported
1062   //
1063   return EFI_SUCCESS;
1064 }
1065
1066 /**
1067   Commands the IDE controller driver to program the IDE controller hardware
1068   so that the specified device can operate at the specified mode.
1069
1070   This function is used by the driver entity to instruct the IDE controller
1071   driver to program the IDE controller hardware to the specified modes. This
1072   function can be called only once for a particular device. For a Serial ATA
1073   (SATA) Advanced Host Controller Interface (AHCI) controller, no controller-
1074   specific programming may be required.
1075
1076   @param[in] This      Pointer to the EFI_IDE_CONTROLLER_INIT_PROTOCOL instance.
1077   @param[in] Channel   Zero-based channel number.
1078   @param[in] Device    Zero-based device number on the Channel.
1079   @param[in] Modes     The modes to set.
1080
1081   @retval EFI_SUCCESS             The command was accepted without any errors.
1082   @retval EFI_INVALID_PARAMETER   Channel is invalid (Channel >= ChannelCount).
1083   @retval EFI_INVALID_PARAMETER   Device is invalid.
1084   @retval EFI_NOT_READY           Modes cannot be set at this time due to lack of data.
1085   @retval EFI_DEVICE_ERROR        Modes cannot be set due to hardware failure.
1086                                   The driver entity should not use this device.
1087
1088 **/
1089 EFI_STATUS
1090 EFIAPI
1091 IdeInitSetTiming (
1092   IN EFI_IDE_CONTROLLER_INIT_PROTOCOL   *This,
1093   IN UINT8                              Channel,
1094   IN UINT8                              Device,
1095   IN EFI_ATA_COLLECTIVE_MODE            *Modes
1096   )
1097 {
1098   return EFI_SUCCESS;
1099 }