EdkModulePkg/Bus/Pci/IdeBus/Dxe/idebus.c

   1 /** @file
   2   Copyright (c) 2006 - 2007 Intel Corporation. <BR>
   3   All rights reserved. This program and the accompanying materials
   4   are licensed and made available under the terms and conditions of the BSD License
   5   which accompanies this distribution.  The full text of the license may be found at
   6   http://opensource.org/licenses/bsd-license.php
   7
   8   THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
   9   WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  10
  11   @par Revision Reference:
  12   This module is modified from DXE\IDE module for Ide Contriller Init support
  13
  14 **/
  15
  16 #include "idebus.h"
  17
  18 #define PCI_CLASS_MASS_STORAGE  0x01
  19 #define PCI_SUB_CLASS_IDE       0x01
  20
  21
  22 //
  23 // IDE Bus Driver Binding Protocol Instance
  24 //
  25 EFI_DRIVER_BINDING_PROTOCOL gIDEBusDriverBinding = {
  26   IDEBusDriverBindingSupported,
  27   IDEBusDriverBindingStart,
  28   IDEBusDriverBindingStop,
  29   0xa,
  30   NULL,
  31   NULL
  32 };
  33
  34 //
  35 // ***********************************************************************************
  36 // IDEBusDriverBindingSupported
  37 // ***********************************************************************************
  38 //
  39 /**
  40   Register Driver Binding protocol for this driver.
  41
  42   @param[in] This   -- A pointer to the EFI_DRIVER_BINDING_PROTOCOL instance.
  43   @param[in] ControllerHandle    -- The handle of the controller to test.
  44   @param[in] RemainingDevicePath -- A pointer to the remaining portion of a device path.
  45
  46   @retval  EFI_SUCCESS Driver loaded.
  47   @retval  other Driver not loaded.
  48
  49 **/
  50 EFI_STATUS
  51 EFIAPI
  52 IDEBusDriverBindingSupported (
  53   IN EFI_DRIVER_BINDING_PROTOCOL  *This,
  54   IN EFI_HANDLE                   Controller,
  55   IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath
  56   )
  57 // TODO:    Controller - add argument and description to function comment
  58 // TODO:    EFI_UNSUPPORTED - add return value to function comment
  59 {
  60   EFI_STATUS                        Status;
  61   EFI_DEVICE_PATH_PROTOCOL          *ParentDevicePath;
  62   EFI_DEV_PATH                      *Node;
  63   EFI_IDE_CONTROLLER_INIT_PROTOCOL  *IdeInit;
  64
  65   if (RemainingDevicePath != NULL) {
  66     Node = (EFI_DEV_PATH *) RemainingDevicePath;
  67     if (Node->DevPath.Type != MESSAGING_DEVICE_PATH ||
  68         Node->DevPath.SubType != MSG_ATAPI_DP ||
  69         DevicePathNodeLength(&Node->DevPath) != sizeof(ATAPI_DEVICE_PATH)) {
  70       return EFI_UNSUPPORTED;
  71     }
  72   }
  73
  74   //
  75   // Open the IO Abstraction(s) needed to perform the supported test
  76   //
  77   Status = gBS->OpenProtocol (
  78                   Controller,
  79                   &gEfiDevicePathProtocolGuid,
  80                   (VOID **) &ParentDevicePath,
  81                   This->DriverBindingHandle,
  82                   Controller,
  83                   EFI_OPEN_PROTOCOL_BY_DRIVER
  84                   );
  85   if (Status == EFI_ALREADY_STARTED) {
  86     return EFI_SUCCESS;
  87   }
  88
  89   if (EFI_ERROR (Status)) {
  90     return Status;
  91   }
  92
  93   //
  94   // Close protocol, don't use device path protocol in the .Support() function
  95   //
  96   gBS->CloseProtocol (
  97         Controller,
  98         &gEfiDevicePathProtocolGuid,
  99         This->DriverBindingHandle,
 100         Controller
 101         );
 102
 103   //
 104   // Verify the Ide Controller Init Protocol, which installed by the
 105   // IdeController module.
 106   // Note 1: PciIo protocol has been opened BY_DRIVER by ide_init, so We can't
 107   //         open BY_DRIVER here) That's why we don't check pciio protocol
 108   // Note 2: ide_init driver check ide controller's pci config space, so we dont
 109   //         check here any more to save code size
 110   //
 111   Status = gBS->OpenProtocol (
 112                   Controller,
 113                   &gEfiIdeControllerInitProtocolGuid,
 114                   (VOID **) &IdeInit,
 115                   This->DriverBindingHandle,
 116                   Controller,
 117                   EFI_OPEN_PROTOCOL_BY_DRIVER
 118                   );
 119
 120   if (Status == EFI_ALREADY_STARTED) {
 121     return EFI_SUCCESS;
 122   }
 123
 124   //
 125   // If protocols were opened normally, closed it
 126   //
 127   gBS->CloseProtocol (
 128         Controller,
 129         &gEfiIdeControllerInitProtocolGuid,
 130         This->DriverBindingHandle,
 131         Controller
 132         );
 133
 134   return Status;
 135 }
 136
 137 //
 138 // ***********************************************************************************
 139 // IDEBusDriverBindingStart
 140 // ***********************************************************************************
 141 //
 142 /**
 143   Start this driver on Controller by detecting all disks and installing
 144   BlockIo protocol on them.
 145
 146   @param  This Protocol instance pointer.
 147   @param  Controller Handle of device to bind driver to.
 148   @param  RemainingDevicePath Not used, always produce all possible children.
 149
 150   @retval  EFI_SUCCESS This driver is added to ControllerHandle.
 151   @retval  EFI_ALREADY_STARTED This driver is already running on ControllerHandle.
 152   @retval  other This driver does not support this device.
 153
 154 **/
 155 EFI_STATUS
 156 EFIAPI
 157 IDEBusDriverBindingStart (
 158   IN EFI_DRIVER_BINDING_PROTOCOL  *This,
 159   IN EFI_HANDLE                   Controller,
 160   IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath
 161   )
 162 {
 163   EFI_STATUS                        Status;
 164   EFI_STATUS                        SavedStatus;
 165   EFI_PCI_IO_PROTOCOL               *PciIo;
 166   EFI_DEVICE_PATH_PROTOCOL          *ParentDevicePath;
 167   EFI_DEV_PATH                      *Node;
 168   UINT8                             IdeChannel;
 169   UINT8                             BeginningIdeChannel;
 170   UINT8                             EndIdeChannel;
 171   UINT8                             IdeDevice;
 172   UINT8                             BeginningIdeDevice;
 173   UINT8                             EndIdeDevice;
 174   IDE_BLK_IO_DEV                    *IdeBlkIoDevice[IdeMaxChannel][IdeMaxDevice];
 175   IDE_BLK_IO_DEV                    *IdeBlkIoDevicePtr;
 176   IDE_REGISTERS_BASE_ADDR           IdeRegsBaseAddr[IdeMaxChannel];
 177   ATA_TRANSFER_MODE                 TransferMode;
 178   ATA_DRIVE_PARMS                   DriveParameters;
 179   EFI_DEV_PATH                      NewNode;
 180   UINT8                             ConfigurationOptions;
 181   UINT16                            CommandBlockBaseAddr;
 182   UINT16                            ControlBlockBaseAddr;
 183   UINTN                             DataSize;
 184   IDE_BUS_DRIVER_PRIVATE_DATA       *IdeBusDriverPrivateData;
 185
 186   //
 187   // Local variables declaration for IdeControllerInit support
 188   //
 189   EFI_IDE_CONTROLLER_INIT_PROTOCOL  *IdeInit;
 190   BOOLEAN                           EnumAll;
 191   BOOLEAN                           ChannelEnabled;
 192   UINT8                             MaxDevices;
 193   EFI_IDENTIFY_DATA                 IdentifyData;
 194   EFI_ATA_COLLECTIVE_MODE           *SupportedModes;
 195
 196   IdeBusDriverPrivateData = NULL;
 197   SupportedModes          = NULL;
 198
 199   //
 200   // Perform IdeBus initialization
 201   //
 202   Status = gBS->OpenProtocol (
 203                   Controller,
 204                   &gEfiDevicePathProtocolGuid,
 205                   (VOID **) &ParentDevicePath,
 206                   This->DriverBindingHandle,
 207                   Controller,
 208                   EFI_OPEN_PROTOCOL_BY_DRIVER
 209                   );
 210   if ((EFI_ERROR (Status)) && (Status != EFI_ALREADY_STARTED)) {
 211     return Status;
 212   }
 213
 214   //
 215   // Now open the IDE_CONTROLLER_INIT protocol. Step7.1
 216   //
 217   Status = gBS->OpenProtocol (
 218                   Controller,
 219                   &gEfiIdeControllerInitProtocolGuid,
 220                   (VOID **) &IdeInit,
 221                   This->DriverBindingHandle,
 222                   Controller,
 223                   EFI_OPEN_PROTOCOL_BY_DRIVER
 224                   );
 225
 226   //
 227   // The following OpenProtocol function with _GET_PROTOCOL attribute and
 228   // will not return EFI_ALREADY_STARTED, so save it for now
 229   //
 230   SavedStatus = Status;
 231
 232   if ((EFI_ERROR (Status)) && (Status != EFI_ALREADY_STARTED)) {
 233     DEBUG ((EFI_D_ERROR, "Open Init, Status=%x", Status));
 234     //
 235     // open protocol is not SUCCESS or not ALREADY_STARTED, error exit
 236     //
 237     goto ErrorExit;
 238   }
 239
 240   //
 241   // Save Enumall. Step7.2
 242   //
 243   EnumAll       = IdeInit->EnumAll;
 244
 245   //
 246   // Consume PCI I/O protocol. Note that the OpenProtocol with _GET_PROTOCOL
 247   // attribute will not return EFI_ALREADY_STARTED
 248   //
 249   Status = gBS->OpenProtocol (
 250                   Controller,
 251                   &gEfiPciIoProtocolGuid,
 252                   (VOID **) &PciIo,
 253                   This->DriverBindingHandle,
 254                   Controller,
 255                   EFI_OPEN_PROTOCOL_GET_PROTOCOL
 256                   );
 257   if (EFI_ERROR (Status)) {
 258     DEBUG ((EFI_D_ERROR, "Open PciIo, Status=%x", Status));
 259     goto ErrorExit;
 260   }
 261
 262   //
 263   // We must check EFI_ALREADY_STARTED because many ATAPI devices are removable
 264   //
 265   if (SavedStatus != EFI_ALREADY_STARTED) {
 266     IdeBusDriverPrivateData = AllocatePool (sizeof (IDE_BUS_DRIVER_PRIVATE_DATA));
 267     if (IdeBusDriverPrivateData == NULL) {
 268       Status = EFI_OUT_OF_RESOURCES;
 269       goto ErrorExit;
 270     }
 271
 272     ZeroMem (IdeBusDriverPrivateData, sizeof (IDE_BUS_DRIVER_PRIVATE_DATA));
 273     Status = gBS->InstallMultipleProtocolInterfaces (
 274                     &Controller,
 275                     &gEfiCallerIdGuid,
 276                     IdeBusDriverPrivateData,
 277                     NULL
 278                     );
 279     if (EFI_ERROR (Status)) {
 280       goto ErrorExit;
 281     }
 282
 283   } else {
 284     Status = gBS->OpenProtocol (
 285                     Controller,
 286                     &gEfiCallerIdGuid,
 287                     (VOID **) &IdeBusDriverPrivateData,
 288                     This->DriverBindingHandle,
 289                     Controller,
 290                     EFI_OPEN_PROTOCOL_GET_PROTOCOL
 291                     );
 292     if (EFI_ERROR (Status)) {
 293       IdeBusDriverPrivateData = NULL;
 294       goto ErrorExit;
 295     }
 296   }
 297
 298   Status = PciIo->Attributes (
 299                     PciIo,
 300                     EfiPciIoAttributeOperationEnable,
 301                     EFI_PCI_DEVICE_ENABLE,
 302                     NULL
 303                     );
 304   if (EFI_ERROR (Status)) {
 305     goto ErrorExit;
 306   }
 307
 308   //
 309   // Read the environment variable that contains the IDEBus Driver's
 310   // Config options that were set by the Driver Configuration Protocol
 311   //
 312   DataSize = sizeof (ConfigurationOptions);
 313   Status = gRT->GetVariable (
 314                   (CHAR16 *) L"Configuration",
 315                   &gEfiCallerIdGuid,
 316                   NULL,
 317                   &DataSize,
 318                   &ConfigurationOptions
 319                   );
 320   if (EFI_ERROR (Status)) {
 321     ConfigurationOptions = 0x0f;
 322   }
 323
 324   if (EnumAll) {
 325     //
 326     // If IdeInit->EnumAll is TRUE, must enumerate all IDE device anyway
 327     //
 328     BeginningIdeChannel = IdePrimary;
 329     EndIdeChannel       = IdeSecondary;
 330     BeginningIdeDevice  = IdeMaster;
 331     EndIdeDevice        = IdeSlave;
 332   } else if (RemainingDevicePath == NULL) {
 333     //
 334     // RemainingDevicePath is NULL, scan IDE bus for each device;
 335     //
 336     BeginningIdeChannel = IdePrimary;
 337     EndIdeChannel       = IdeSecondary;
 338     BeginningIdeDevice  = IdeMaster;
 339     //
 340     // default, may be redefined by IdeInit
 341     //
 342     EndIdeDevice = IdeSlave;
 343   } else {
 344     //
 345     // RemainingDevicePath is not NULL, only scan the specified device.
 346     //
 347     Node                = (EFI_DEV_PATH *) RemainingDevicePath;
 348     BeginningIdeChannel = Node->Atapi.PrimarySecondary;
 349     EndIdeChannel       = BeginningIdeChannel;
 350     BeginningIdeDevice  = Node->Atapi.SlaveMaster;
 351     EndIdeDevice        = BeginningIdeDevice;
 352   }
 353
 354   //
 355   // Obtain IDE IO port registers' base addresses
 356   //
 357   Status = GetIdeRegistersBaseAddr (PciIo, IdeRegsBaseAddr);
 358   if (EFI_ERROR (Status)) {
 359     goto ErrorExit;
 360   }
 361
 362   //
 363   // Report status code: begin IdeBus initialization
 364   //
 365   REPORT_STATUS_CODE_WITH_DEVICE_PATH (
 366     EFI_PROGRESS_CODE,
 367     (EFI_IO_BUS_ATA_ATAPI | EFI_IOB_PC_RESET),
 368     ParentDevicePath
 369     );
 370
 371   //
 372   // Strictly follow the enumeration based on IDE_CONTROLLER_INIT protocol
 373   //
 374   for (IdeChannel = BeginningIdeChannel; IdeChannel <= EndIdeChannel; IdeChannel++) {
 375
 376     IdeInit->NotifyPhase (IdeInit, EfiIdeBeforeChannelEnumeration, IdeChannel);
 377
 378     //
 379     // now obtain channel information fron IdeControllerInit protocol. Step9
 380     //
 381     Status = IdeInit->GetChannelInfo (
 382                         IdeInit,
 383                         IdeChannel,
 384                         &ChannelEnabled,
 385                         &MaxDevices
 386                         );
 387     if (EFI_ERROR (Status)) {
 388       DEBUG ((EFI_D_ERROR, "[GetChannel, Status=%x]", Status));
 389       continue;
 390     }
 391
 392     if (!ChannelEnabled) {
 393       continue;
 394     }
 395
 396     EndIdeDevice = (UINT8) EFI_MIN ((MaxDevices - 1), EndIdeDevice);
 397
 398     //
 399     // Now inform the IDE Controller Init Module. Sept10
 400     //
 401     IdeInit->NotifyPhase (IdeInit, EfiIdeBeforeChannelReset, IdeChannel);
 402
 403     //
 404     // No reset channel function implemented. Sept11
 405     //
 406     IdeInit->NotifyPhase (IdeInit, EfiIdeAfterChannelReset, IdeChannel);
 407
 408     //
 409     // Step13
 410     //
 411     IdeInit->NotifyPhase (
 412               IdeInit,
 413               EfiIdeBusBeforeDevicePresenceDetection,
 414               IdeChannel
 415               );
 416
 417     //
 418     // Prepare to detect IDE device of this channel
 419     //
 420     InitializeIDEChannelData ();
 421
 422     //
 423     // -- 1st inner loop --- Master/Slave ------------  Step14
 424     //
 425     for (IdeDevice = BeginningIdeDevice; IdeDevice <= EndIdeDevice; IdeDevice++) {
 426       //
 427       // Check whether the configuration options allow this device
 428       //
 429       if (!(ConfigurationOptions & (1 << (IdeChannel * 2 + IdeDevice)))) {
 430         continue;
 431       }
 432
 433       //
 434       // The device has been scanned in another Start(), No need to scan it again
 435       // for perf optimization.
 436       //
 437       if (IdeBusDriverPrivateData->HaveScannedDevice[IdeChannel * 2 + IdeDevice]) {
 438         continue;
 439       }
 440
 441       //
 442       // create child handle for the detected device.
 443       //
 444       IdeBlkIoDevice[IdeChannel][IdeDevice] = AllocatePool (sizeof (IDE_BLK_IO_DEV));
 445       if (IdeBlkIoDevice[IdeChannel][IdeDevice] == NULL) {
 446         continue;
 447       }
 448
 449       IdeBlkIoDevicePtr = IdeBlkIoDevice[IdeChannel][IdeDevice];
 450
 451       ZeroMem (IdeBlkIoDevicePtr, sizeof (IDE_BLK_IO_DEV));
 452
 453       IdeBlkIoDevicePtr->Signature  = IDE_BLK_IO_DEV_SIGNATURE;
 454       IdeBlkIoDevicePtr->Channel    = (EFI_IDE_CHANNEL) IdeChannel;
 455       IdeBlkIoDevicePtr->Device     = (EFI_IDE_DEVICE) IdeDevice;
 456
 457       //
 458       // initialize Block IO interface's Media pointer
 459       //
 460       IdeBlkIoDevicePtr->BlkIo.Media = &IdeBlkIoDevicePtr->BlkMedia;
 461
 462       //
 463       // Initialize IDE IO port addresses, including Command Block registers
 464       // and Control Block registers
 465       //
 466       IdeBlkIoDevicePtr->IoPort = AllocatePool (sizeof (IDE_BASE_REGISTERS));
 467       if (IdeBlkIoDevicePtr->IoPort == NULL) {
 468         continue;
 469       }
 470
 471       ZeroMem (IdeBlkIoDevicePtr->IoPort, sizeof (IDE_BASE_REGISTERS));
 472       CommandBlockBaseAddr = IdeRegsBaseAddr[IdeChannel].CommandBlockBaseAddr;
 473       ControlBlockBaseAddr = IdeRegsBaseAddr[IdeChannel].ControlBlockBaseAddr;
 474
 475       IdeBlkIoDevicePtr->IoPort->Data = CommandBlockBaseAddr;
 476       (*(UINT16 *) &IdeBlkIoDevicePtr->IoPort->Reg1) = (UINT16) (CommandBlockBaseAddr + 0x01);
 477       IdeBlkIoDevicePtr->IoPort->SectorCount = (UINT16) (CommandBlockBaseAddr + 0x02);
 478       IdeBlkIoDevicePtr->IoPort->SectorNumber = (UINT16) (CommandBlockBaseAddr + 0x03);
 479       IdeBlkIoDevicePtr->IoPort->CylinderLsb = (UINT16) (CommandBlockBaseAddr + 0x04);
 480       IdeBlkIoDevicePtr->IoPort->CylinderMsb = (UINT16) (CommandBlockBaseAddr + 0x05);
 481       IdeBlkIoDevicePtr->IoPort->Head = (UINT16) (CommandBlockBaseAddr + 0x06);
 482       (*(UINT16 *) &IdeBlkIoDevicePtr->IoPort->Reg) = (UINT16) (CommandBlockBaseAddr + 0x07);
 483
 484       (*(UINT16 *) &IdeBlkIoDevicePtr->IoPort->Alt) = ControlBlockBaseAddr;
 485       IdeBlkIoDevicePtr->IoPort->DriveAddress = (UINT16) (ControlBlockBaseAddr + 0x01);
 486
 487       IdeBlkIoDevicePtr->IoPort->MasterSlave = (UINT16) ((IdeDevice == IdeMaster) ? 1 : 0);
 488
 489       IdeBlkIoDevicePtr->PciIo = PciIo;
 490       IdeBlkIoDevicePtr->IdeBusDriverPrivateData = IdeBusDriverPrivateData;
 491       IdeBlkIoDevicePtr->IoPort->BusMasterBaseAddr = IdeRegsBaseAddr[IdeChannel].BusMasterBaseAddr;
 492
 493       //
 494       // Report Status code: is about to detect IDE drive
 495       //
 496       REPORT_STATUS_CODE_EX (
 497         EFI_PROGRESS_CODE,
 498         (EFI_IO_BUS_ATA_ATAPI | EFI_P_PC_PRESENCE_DETECT),
 499         0,
 500         &gEfiCallerIdGuid,
 501         NULL,
 502         NULL,
 503         0
 504       );
 505
 506       //
 507       // Discover device, now!
 508       //
 509       PERF_START (0, "DiscoverIdeDevice", "IDE", 0);
 510       Status = DiscoverIdeDevice (IdeBlkIoDevicePtr);
 511       PERF_END (0, "DiscoverIdeDevice", "IDE", 0);
 512
 513       IdeBusDriverPrivateData->HaveScannedDevice[IdeChannel * 2 + IdeDevice]  = TRUE;
 514       IdeBusDriverPrivateData->DeviceProcessed[IdeChannel * 2 + IdeDevice]    = FALSE;
 515
 516       if (!EFI_ERROR (Status)) {
 517         //
 518         // Set Device Path
 519         //
 520         ZeroMem (&NewNode, sizeof (NewNode));
 521         NewNode.DevPath.Type    = MESSAGING_DEVICE_PATH;
 522         NewNode.DevPath.SubType = MSG_ATAPI_DP;
 523         SetDevicePathNodeLength (&NewNode.DevPath, sizeof (ATAPI_DEVICE_PATH));
 524
 525         NewNode.Atapi.PrimarySecondary  = (UINT8) IdeBlkIoDevicePtr->Channel;
 526         NewNode.Atapi.SlaveMaster       = (UINT8) IdeBlkIoDevicePtr->Device;
 527         NewNode.Atapi.Lun               = IdeBlkIoDevicePtr->Lun;
 528         IdeBlkIoDevicePtr->DevicePath = AppendDevicePathNode (
 529                                           ParentDevicePath,
 530                                           &NewNode.DevPath
 531                                           );
 532         if (IdeBlkIoDevicePtr->DevicePath == NULL) {
 533           ReleaseIdeResources (IdeBlkIoDevicePtr);
 534           continue;
 535         }
 536
 537         //
 538         // Submit identify data to IDE controller init driver
 539         //
 540         CopyMem (&IdentifyData, IdeBlkIoDevicePtr->pIdData, sizeof (IdentifyData));
 541         IdeBusDriverPrivateData->DeviceFound[IdeChannel * 2 + IdeDevice] = TRUE;
 542         IdeInit->SubmitData (IdeInit, IdeChannel, IdeDevice, &IdentifyData);
 543       } else {
 544         //
 545         // Device detection failed
 546         //
 547         IdeBusDriverPrivateData->DeviceFound[IdeChannel * 2 + IdeDevice] = FALSE;
 548         IdeInit->SubmitData (IdeInit, IdeChannel, IdeDevice, NULL);
 549         ReleaseIdeResources (IdeBlkIoDevicePtr);
 550         IdeBlkIoDevicePtr = NULL;
 551       }
 552       //
 553       // end of 1st inner loop ---
 554       //
 555     }
 556     //
 557     // end of 1st outer loop =========
 558     //
 559   }
 560
 561   //
 562   // = 2nd outer loop == Primary/Secondary =================
 563   //
 564   for (IdeChannel = BeginningIdeChannel; IdeChannel <= EndIdeChannel; IdeChannel++) {
 565
 566     //
 567     // -- 2nd inner loop --- Master/Slave --------
 568     //
 569     for (IdeDevice = BeginningIdeDevice; IdeDevice <= EndIdeDevice; IdeDevice++) {
 570
 571       if (IdeBusDriverPrivateData->DeviceProcessed[IdeChannel * 2 + IdeDevice]) {
 572         continue;
 573       }
 574
 575       if (!IdeBusDriverPrivateData->DeviceFound[IdeChannel * 2 + IdeDevice]) {
 576         continue;
 577       }
 578
 579       Status = IdeInit->CalculateMode (
 580                           IdeInit,
 581                           IdeChannel,
 582                           IdeDevice,
 583                           &SupportedModes
 584                           );
 585       if (EFI_ERROR (Status)) {
 586         DEBUG ((EFI_D_ERROR, "[bStStp20S=%x]", Status));
 587         continue;
 588       }
 589
 590       IdeBlkIoDevicePtr = IdeBlkIoDevice[IdeChannel][IdeDevice];
 591
 592       //
 593       // Set best supported PIO mode on this IDE device
 594       //
 595       if (SupportedModes->PioMode.Mode <= ATA_PIO_MODE_2) {
 596         TransferMode.ModeCategory = ATA_MODE_CATEGORY_DEFAULT_PIO;
 597       } else {
 598         TransferMode.ModeCategory = ATA_MODE_CATEGORY_FLOW_PIO;
 599       }
 600
 601       TransferMode.ModeNumber = (UINT8) (SupportedModes->PioMode.Mode);
 602
 603       if (SupportedModes->ExtModeCount == 0){
 604         Status                  = SetDeviceTransferMode (IdeBlkIoDevicePtr, &TransferMode);
 605
 606         if (EFI_ERROR (Status)) {
 607           IdeBusDriverPrivateData->DeviceFound[IdeChannel * 2 + IdeDevice] = FALSE;
 608           ReleaseIdeResources (IdeBlkIoDevicePtr);
 609           IdeBlkIoDevicePtr = NULL;
 610           continue;
 611         }
 612       }
 613
 614       //
 615       // Set supported DMA mode on this IDE device. Note that UDMA & MDMA cann't
 616       // be set together. Only one DMA mode can be set to a device. If setting
 617       // DMA mode operation fails, we can continue moving on because we only use
 618       // PIO mode at boot time. DMA modes are used by certain kind of OS booting
 619       //
 620       if (SupportedModes->UdmaMode.Valid) {
 621
 622         TransferMode.ModeCategory = ATA_MODE_CATEGORY_UDMA;
 623         TransferMode.ModeNumber   = (UINT8) (SupportedModes->UdmaMode.Mode);
 624         Status                    = SetDeviceTransferMode (IdeBlkIoDevicePtr, &TransferMode);
 625
 626         if (EFI_ERROR (Status)) {
 627           IdeBusDriverPrivateData->DeviceFound[IdeChannel * 2 + IdeDevice] = FALSE;
 628           ReleaseIdeResources (IdeBlkIoDevicePtr);
 629           IdeBlkIoDevicePtr = NULL;
 630           continue;
 631         }
 632         //
 633         // Record Udma Mode
 634         //
 635         IdeBlkIoDevicePtr->UdmaMode.Valid = TRUE;
 636         IdeBlkIoDevicePtr->UdmaMode.Mode  = SupportedModes->UdmaMode.Mode;
 637         EnableInterrupt (IdeBlkIoDevicePtr);
 638       } else if (SupportedModes->MultiWordDmaMode.Valid) {
 639
 640         TransferMode.ModeCategory = ATA_MODE_CATEGORY_MDMA;
 641         TransferMode.ModeNumber   = (UINT8) SupportedModes->MultiWordDmaMode.Mode;
 642         Status                    = SetDeviceTransferMode (IdeBlkIoDevicePtr, &TransferMode);
 643
 644         if (EFI_ERROR (Status)) {
 645           IdeBusDriverPrivateData->DeviceFound[IdeChannel * 2 + IdeDevice] = FALSE;
 646           ReleaseIdeResources (IdeBlkIoDevicePtr);
 647           IdeBlkIoDevicePtr = NULL;
 648           continue;
 649         }
 650
 651         EnableInterrupt (IdeBlkIoDevicePtr);
 652       }
 653       //
 654       // Init driver parameters
 655       //
 656       DriveParameters.Sector          = (UINT8) IdeBlkIoDevicePtr->pIdData->AtaData.sectors_per_track;
 657       DriveParameters.Heads           = (UINT8) (IdeBlkIoDevicePtr->pIdData->AtaData.heads - 1);
 658       DriveParameters.MultipleSector  = (UINT8) IdeBlkIoDevicePtr->pIdData->AtaData.multi_sector_cmd_max_sct_cnt;
 659       //
 660       // Set Parameters for the device:
 661       // 1) Init
 662       // 2) Establish the block count for READ/WRITE MULTIPLE (EXT) command
 663       //
 664       if ((IdeBlkIoDevicePtr->Type == IdeHardDisk) || (IdeBlkIoDevicePtr->Type == Ide48bitAddressingHardDisk)) {
 665         Status = SetDriveParameters (IdeBlkIoDevicePtr, &DriveParameters);
 666       }
 667
 668       //
 669       // Record PIO mode used in private data
 670       //
 671       IdeBlkIoDevicePtr->PioMode = (ATA_PIO_MODE) SupportedModes->PioMode.Mode;
 672
 673       //
 674       // Set IDE controller Timing Blocks in the PCI Configuration Space
 675       //
 676       IdeInit->SetTiming (IdeInit, IdeChannel, IdeDevice, SupportedModes);
 677
 678       //
 679       // Add Component Name for the IDE/ATAPI device that was discovered.
 680       //
 681       IdeBlkIoDevicePtr->ControllerNameTable = NULL;
 682       ADD_NAME (IdeBlkIoDevicePtr);
 683
 684       Status = gBS->InstallMultipleProtocolInterfaces (
 685                       &IdeBlkIoDevicePtr->Handle,
 686                       &gEfiDevicePathProtocolGuid,
 687                       IdeBlkIoDevicePtr->DevicePath,
 688                       &gEfiBlockIoProtocolGuid,
 689                       &IdeBlkIoDevicePtr->BlkIo,
 690                       &gEfiDiskInfoProtocolGuid,
 691                       &IdeBlkIoDevicePtr->DiskInfo,
 692                       NULL
 693                       );
 694
 695       if (EFI_ERROR (Status)) {
 696         ReleaseIdeResources (IdeBlkIoDevicePtr);
 697       }
 698
 699       gBS->OpenProtocol (
 700             Controller,
 701             &gEfiPciIoProtocolGuid,
 702             (VOID **) &PciIo,
 703             This->DriverBindingHandle,
 704             IdeBlkIoDevicePtr->Handle,
 705             EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
 706             );
 707
 708       IdeBusDriverPrivateData->DeviceProcessed[IdeChannel * 2 + IdeDevice] = TRUE;
 709
 710       //
 711       // Report status code: device eanbled!
 712       //
 713       REPORT_STATUS_CODE_WITH_DEVICE_PATH (
 714         EFI_PROGRESS_CODE,
 715         (EFI_IO_BUS_ATA_ATAPI | EFI_P_PC_ENABLE),
 716         IdeBlkIoDevicePtr->DevicePath
 717         );
 718
 719       //
 720       // Create event to clear pending IDE interrupt
 721       //
 722       Status = gBS->CreateEvent (
 723                       EFI_EVENT_SIGNAL_EXIT_BOOT_SERVICES,
 724                       EFI_TPL_NOTIFY,
 725                       ClearInterrupt,
 726                       IdeBlkIoDevicePtr,
 727                       &IdeBlkIoDevicePtr->ExitBootServiceEvent
 728                       );
 729
 730       //
 731       // end of 2nd inner loop ----
 732       //
 733     }
 734     //
 735     // end of 2nd outer loop ==========
 736     //
 737   }
 738
 739   //
 740   // All configurations done! Notify IdeController to do post initialization
 741   // work such as saving IDE controller PCI settings for S3 resume
 742   //
 743   IdeInit->NotifyPhase (IdeInit, EfiIdeBusPhaseMaximum, 0);
 744
 745   if (SupportedModes != NULL) {
 746     gBS->FreePool (SupportedModes);
 747   }
 748
 749   PERF_START (0, "Finish IDE detection", "IDE", 1);
 750   PERF_END (0, "Finish IDE detection", "IDE", 0);
 751
 752   return EFI_SUCCESS;
 753
 754 ErrorExit:
 755
 756   //
 757   // Report error code: controller error
 758   //
 759   REPORT_STATUS_CODE_WITH_DEVICE_PATH (
 760     EFI_ERROR_CODE | EFI_ERROR_MINOR,
 761     (EFI_IO_BUS_ATA_ATAPI | EFI_IOB_EC_CONTROLLER_ERROR),
 762     ParentDevicePath
 763     );
 764
 765   gBS->CloseProtocol (
 766         Controller,
 767         &gEfiIdeControllerInitProtocolGuid,
 768         This->DriverBindingHandle,
 769         Controller
 770         );
 771
 772   gBS->UninstallMultipleProtocolInterfaces (
 773         Controller,
 774         &gEfiCallerIdGuid,
 775         IdeBusDriverPrivateData,
 776         NULL
 777         );
 778
 779   if (IdeBusDriverPrivateData != NULL) {
 780     gBS->FreePool (IdeBusDriverPrivateData);
 781   }
 782
 783   if (SupportedModes != NULL) {
 784     gBS->FreePool (SupportedModes);
 785   }
 786
 787   gBS->CloseProtocol (
 788         Controller,
 789         &gEfiPciIoProtocolGuid,
 790         This->DriverBindingHandle,
 791         Controller
 792         );
 793
 794   gBS->CloseProtocol (
 795         Controller,
 796         &gEfiDevicePathProtocolGuid,
 797         This->DriverBindingHandle,
 798         Controller
 799         );
 800
 801   return Status;
 802
 803 }
 804
 805 //
 806 // ***********************************************************************************
 807 // IDEBusDriverBindingStop
 808 // ***********************************************************************************
 809 //
 810 /**
 811   Stop this driver on Controller Handle.
 812
 813   @param  This Protocol instance pointer.
 814   @param  DeviceHandle Handle of device to stop driver on
 815   @param  NumberOfChildren Not used
 816   @param  ChildHandleBuffer Not used
 817
 818   @retval  EFI_SUCCESS This driver is removed DeviceHandle
 819   @retval  other This driver was not removed from this device
 820
 821 **/
 822 EFI_STATUS
 823 EFIAPI
 824 IDEBusDriverBindingStop (
 825   IN  EFI_DRIVER_BINDING_PROTOCOL     *This,
 826   IN  EFI_HANDLE                      Controller,
 827   IN  UINTN                           NumberOfChildren,
 828   IN  EFI_HANDLE                      *ChildHandleBuffer
 829   )
 830 // TODO:    Controller - add argument and description to function comment
 831 // TODO:    EFI_DEVICE_ERROR - add return value to function comment
 832 {
 833   EFI_STATUS                  Status;
 834   EFI_PCI_IO_PROTOCOL         *PciIo;
 835   BOOLEAN                     AllChildrenStopped;
 836   UINTN                       Index;
 837   IDE_BUS_DRIVER_PRIVATE_DATA *IdeBusDriverPrivateData;
 838
 839   IdeBusDriverPrivateData = NULL;
 840
 841   if (NumberOfChildren == 0) {
 842
 843     Status = gBS->OpenProtocol (
 844                     Controller,
 845                     &gEfiPciIoProtocolGuid,
 846                     (VOID **) &PciIo,
 847                     This->DriverBindingHandle,
 848                     Controller,
 849                     EFI_OPEN_PROTOCOL_GET_PROTOCOL
 850                     );
 851     if (!EFI_ERROR (Status)) {
 852       PciIo->Attributes (
 853               PciIo,
 854               EfiPciIoAttributeOperationDisable,
 855               EFI_PCI_IO_ATTRIBUTE_IDE_PRIMARY_IO | EFI_PCI_IO_ATTRIBUTE_IDE_SECONDARY_IO | EFI_PCI_DEVICE_ENABLE,
 856               NULL
 857               );
 858     }
 859
 860     gBS->OpenProtocol (
 861           Controller,
 862           &gEfiCallerIdGuid,
 863           (VOID **) &IdeBusDriverPrivateData,
 864           This->DriverBindingHandle,
 865           Controller,
 866           EFI_OPEN_PROTOCOL_GET_PROTOCOL
 867           );
 868
 869     gBS->UninstallMultipleProtocolInterfaces (
 870           Controller,
 871           &gEfiCallerIdGuid,
 872           IdeBusDriverPrivateData,
 873           NULL
 874           );
 875
 876     if (IdeBusDriverPrivateData != NULL) {
 877       gBS->FreePool (IdeBusDriverPrivateData);
 878     }
 879     //
 880     // Close the bus driver
 881     //
 882     gBS->CloseProtocol (
 883           Controller,
 884           &gEfiIdeControllerInitProtocolGuid,
 885           This->DriverBindingHandle,
 886           Controller
 887           );
 888     gBS->CloseProtocol (
 889           Controller,
 890           &gEfiPciIoProtocolGuid,
 891           This->DriverBindingHandle,
 892           Controller
 893           );
 894     gBS->CloseProtocol (
 895           Controller,
 896           &gEfiDevicePathProtocolGuid,
 897           This->DriverBindingHandle,
 898           Controller
 899           );
 900
 901     return EFI_SUCCESS;
 902   }
 903
 904   AllChildrenStopped = TRUE;
 905
 906   for (Index = 0; Index < NumberOfChildren; Index++) {
 907
 908     Status = DeRegisterIdeDevice (This, Controller, ChildHandleBuffer[Index]);
 909
 910     if (EFI_ERROR (Status)) {
 911       AllChildrenStopped = FALSE;
 912     }
 913   }
 914
 915   if (!AllChildrenStopped) {
 916     return EFI_DEVICE_ERROR;
 917   }
 918
 919   return EFI_SUCCESS;
 920 }
 921
 922 //
 923 // ***********************************************************************************
 924 // DeRegisterIdeDevice
 925 // ***********************************************************************************
 926 //
 927 /**
 928   Deregister an IDE device and free resources
 929
 930   @param  This Protocol instance pointer.
 931   @param  Controller Ide device handle
 932   @param  Handle Handle of device to deregister driver on
 933
 934   @return EFI_STATUS
 935
 936 **/
 937 EFI_STATUS
 938 DeRegisterIdeDevice (
 939   IN  EFI_DRIVER_BINDING_PROTOCOL    *This,
 940   IN  EFI_HANDLE                     Controller,
 941   IN  EFI_HANDLE                     Handle
 942   )
 943 // TODO:    EFI_SUCCESS - add return value to function comment
 944 {
 945   EFI_STATUS            Status;
 946   EFI_BLOCK_IO_PROTOCOL *BlkIo;
 947   IDE_BLK_IO_DEV        *IdeBlkIoDevice;
 948   EFI_PCI_IO_PROTOCOL   *PciIo;
 949   UINTN                 Index;
 950
 951   Status = gBS->OpenProtocol (
 952                   Handle,
 953                   &gEfiBlockIoProtocolGuid,
 954                   (VOID **) &BlkIo,
 955                   This->DriverBindingHandle,
 956                   Controller,
 957                   EFI_OPEN_PROTOCOL_GET_PROTOCOL
 958                   );
 959   if (EFI_ERROR (Status)) {
 960     return Status;
 961   }
 962
 963   IdeBlkIoDevice = IDE_BLOCK_IO_DEV_FROM_THIS (BlkIo);
 964
 965   //
 966   // Report Status code: Device disabled
 967   //
 968   REPORT_STATUS_CODE_WITH_DEVICE_PATH (
 969     EFI_PROGRESS_CODE,
 970     (EFI_IO_BUS_ATA_ATAPI | EFI_P_PC_DISABLE),
 971     IdeBlkIoDevice->DevicePath
 972     );
 973
 974   //
 975   // Close the child handle
 976   //
 977   Status = gBS->CloseProtocol (
 978                   Controller,
 979                   &gEfiPciIoProtocolGuid,
 980                   This->DriverBindingHandle,
 981                   Handle
 982                   );
 983
 984   Status = gBS->UninstallMultipleProtocolInterfaces (
 985                   Handle,
 986                   &gEfiDevicePathProtocolGuid,
 987                   IdeBlkIoDevice->DevicePath,
 988                   &gEfiBlockIoProtocolGuid,
 989                   &IdeBlkIoDevice->BlkIo,
 990                   &gEfiDiskInfoProtocolGuid,
 991                   &IdeBlkIoDevice->DiskInfo,
 992                   NULL
 993                   );
 994
 995   if (EFI_ERROR (Status)) {
 996     gBS->OpenProtocol (
 997           Controller,
 998           &gEfiPciIoProtocolGuid,
 999           (VOID **) &PciIo,
1000           This->DriverBindingHandle,
1001           Handle,
1002           EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
1003           );
1004     return Status;
1005   }
1006
1007   //
1008   // Release allocated resources
1009   //
1010   Index = IdeBlkIoDevice->Channel * 2 + IdeBlkIoDevice->Device;
1011   IdeBlkIoDevice->IdeBusDriverPrivateData->HaveScannedDevice[Index] = FALSE;
1012
1013   ReleaseIdeResources (IdeBlkIoDevice);
1014
1015   return EFI_SUCCESS;
1016 }
1017
1018 //
1019 // ***********************************************************************************
1020 // IDEBlkIoReset
1021 // ***********************************************************************************
1022 //
1023 /**
1024   TODO:    This - add argument and description to function comment
1025   TODO:    ExtendedVerification - add argument and description to function comment
1026   TODO:    EFI_DEVICE_ERROR - add return value to function comment
1027
1028 **/
1029 EFI_STATUS
1030 EFIAPI
1031 IDEBlkIoReset (
1032   IN  EFI_BLOCK_IO_PROTOCOL   *This,
1033   IN  BOOLEAN                 ExtendedVerification
1034   )
1035 {
1036   IDE_BLK_IO_DEV  *IdeBlkIoDevice;
1037   EFI_STATUS      Status;
1038   EFI_TPL         OldTpl;
1039
1040   OldTpl = gBS->RaiseTPL (EFI_TPL_CALLBACK);
1041
1042   IdeBlkIoDevice = IDE_BLOCK_IO_DEV_FROM_THIS (This);
1043   //
1044   // Requery IDE IO resources in case of the switch of native and legacy modes
1045   //
1046   ReassignIdeResources (IdeBlkIoDevice);
1047
1048   //
1049   // for ATA device, using ATA reset method
1050   //
1051   if (IdeBlkIoDevice->Type == IdeHardDisk ||
1052       IdeBlkIoDevice->Type == Ide48bitAddressingHardDisk) {
1053     Status = AtaSoftReset (IdeBlkIoDevice);
1054     goto Done;
1055   }
1056
1057   if (IdeBlkIoDevice->Type == IdeUnknown) {
1058     Status = EFI_DEVICE_ERROR;
1059     goto Done;
1060   }
1061
1062   //
1063   // for ATAPI device, using ATAPI reset method
1064   //
1065   Status = AtapiSoftReset (IdeBlkIoDevice);
1066   if (ExtendedVerification) {
1067     Status = AtaSoftReset (IdeBlkIoDevice);
1068   }
1069
1070 Done:
1071   gBS->RestoreTPL (OldTpl);
1072   return Status;
1073 }
1074
1075 /**
1076   Read data from block io device
1077
1078   @param  This Protocol instance pointer.
1079   @param  MediaId The media ID of the device
1080   @param  LBA Starting LBA address to read data
1081   @param  BufferSize The size of data to be read
1082   @param  Buffer Caller supplied buffer to save data
1083
1084   @return read data status
1085
1086 **/
1087 EFI_STATUS
1088 EFIAPI
1089 IDEBlkIoReadBlocks (
1090   IN  EFI_BLOCK_IO_PROTOCOL   *This,
1091   IN  UINT32                  MediaId,
1092   IN  EFI_LBA                 LBA,
1093   IN  UINTN                   BufferSize,
1094   OUT VOID                    *Buffer
1095   )
1096 // TODO:    EFI_DEVICE_ERROR - add return value to function comment
1097 {
1098   IDE_BLK_IO_DEV  *IdeBlkIoDevice;
1099   EFI_STATUS      Status;
1100   EFI_TPL         OldTpl;
1101
1102   OldTpl = gBS->RaiseTPL (EFI_TPL_CALLBACK);
1103
1104   IdeBlkIoDevice = IDE_BLOCK_IO_DEV_FROM_THIS (This);
1105
1106   //
1107   // Requery IDE IO resources in case of the switch of native and legacy modes
1108   //
1109   ReassignIdeResources (IdeBlkIoDevice);
1110
1111   //
1112   // For ATA compatible device, use ATA read block's mechanism
1113   //
1114   if (IdeBlkIoDevice->Type == IdeHardDisk ||
1115       IdeBlkIoDevice->Type == Ide48bitAddressingHardDisk) {
1116     Status = AtaBlkIoReadBlocks (
1117             IdeBlkIoDevice,
1118             MediaId,
1119             LBA,
1120             BufferSize,
1121             Buffer
1122             );
1123     goto Done;
1124   }
1125
1126   if (IdeBlkIoDevice->Type == IdeUnknown) {
1127     Status = EFI_DEVICE_ERROR;
1128     goto Done;
1129   }
1130
1131   //
1132   // for ATAPI device, using ATAPI read block's mechanism
1133   //
1134   Status = AtapiBlkIoReadBlocks (
1135           IdeBlkIoDevice,
1136           MediaId,
1137           LBA,
1138           BufferSize,
1139           Buffer
1140           );
1141
1142 Done:
1143   gBS->RestoreTPL (OldTpl);
1144
1145   return Status;
1146 }
1147
1148 /**
1149   Write data to block io device
1150
1151   @param  This Protocol instance pointer.
1152   @param  MediaId The media ID of the device
1153   @param  LBA Starting LBA address to write data
1154   @param  BufferSize The size of data to be written
1155   @param  Buffer Caller supplied buffer to save data
1156
1157   @return write data status
1158
1159 **/
1160 EFI_STATUS
1161 EFIAPI
1162 IDEBlkIoWriteBlocks (
1163   IN  EFI_BLOCK_IO_PROTOCOL   *This,
1164   IN  UINT32                  MediaId,
1165   IN  EFI_LBA                 LBA,
1166   IN  UINTN                   BufferSize,
1167   IN  VOID                    *Buffer
1168   )
1169 // TODO:    EFI_DEVICE_ERROR - add return value to function comment
1170 {
1171   IDE_BLK_IO_DEV  *IdeBlkIoDevice;
1172   EFI_STATUS      Status;
1173   EFI_TPL         OldTpl;
1174
1175   OldTpl = gBS->RaiseTPL (EFI_TPL_CALLBACK);
1176
1177   IdeBlkIoDevice = IDE_BLOCK_IO_DEV_FROM_THIS (This);
1178   //
1179   // Requery IDE IO resources in case of the switch of native and legacy modes
1180   //
1181   ReassignIdeResources (IdeBlkIoDevice);
1182
1183   //
1184   // for ATA device, using ATA write block's mechanism
1185   //
1186   if (IdeBlkIoDevice->Type == IdeHardDisk ||
1187       IdeBlkIoDevice->Type == Ide48bitAddressingHardDisk) {
1188
1189     Status = AtaBlkIoWriteBlocks (
1190             IdeBlkIoDevice,
1191             MediaId,
1192             LBA,
1193             BufferSize,
1194             Buffer
1195             );
1196     goto Done;
1197   }
1198
1199   if (IdeBlkIoDevice->Type == IdeUnknown) {
1200     Status = EFI_DEVICE_ERROR;
1201     goto Done;
1202   }
1203
1204   //
1205   // for ATAPI device, using ATAPI write block's mechanism
1206   //
1207   Status = AtapiBlkIoWriteBlocks (
1208           IdeBlkIoDevice,
1209           MediaId,
1210           LBA,
1211           BufferSize,
1212           Buffer
1213           );
1214
1215 Done:
1216   gBS->RestoreTPL (OldTpl);
1217   return Status;
1218 }
1219
1220 //
1221 // ***********************************************************************************
1222 // IDEBlkIoFlushBlocks
1223 // ***********************************************************************************
1224 //
1225 /**
1226   TODO:    This - add argument and description to function comment
1227   TODO:    EFI_SUCCESS - add return value to function comment
1228 **/
1229 EFI_STATUS
1230 EFIAPI
1231 IDEBlkIoFlushBlocks (
1232   IN  EFI_BLOCK_IO_PROTOCOL   *This
1233   )
1234 {
1235   //
1236   // return directly
1237   //
1238   return EFI_SUCCESS;
1239 }
1240
1241 /**
1242   Return the results of the Inquiry command to a drive in InquiryData.
1243   Data format of Inquiry data is defined by the Interface GUID.
1244
1245   @param  This Protocol instance pointer.
1246   @param  InquiryData Results of Inquiry command to device
1247   @param  InquiryDataSize Size of InquiryData in bytes.
1248
1249   @retval  EFI_SUCCESS InquiryData valid
1250   @retval  EFI_NOT_FOUND Device does not support this data class
1251   @retval  EFI_DEVICE_ERROR Error reading InquiryData from device
1252   @retval  EFI_BUFFER_TOO_SMALL IntquiryDataSize not big enough
1253
1254 **/
1255 EFI_STATUS
1256 EFIAPI
1257 IDEDiskInfoInquiry (
1258   IN     EFI_DISK_INFO_PROTOCOL   *This,
1259   IN OUT VOID                     *InquiryData,
1260   IN OUT UINT32                   *InquiryDataSize
1261   )
1262 {
1263   IDE_BLK_IO_DEV  *IdeBlkIoDevice;
1264
1265   IdeBlkIoDevice = IDE_BLOCK_IO_DEV_FROM_DISK_INFO_THIS (This);
1266
1267   if (*InquiryDataSize < sizeof (INQUIRY_DATA)) {
1268     *InquiryDataSize = sizeof (INQUIRY_DATA);
1269     return EFI_BUFFER_TOO_SMALL;
1270   }
1271
1272   if (IdeBlkIoDevice->pInquiryData == NULL) {
1273     return EFI_NOT_FOUND;
1274   }
1275
1276   gBS->CopyMem (InquiryData, IdeBlkIoDevice->pInquiryData, sizeof (INQUIRY_DATA));
1277   *InquiryDataSize = sizeof (INQUIRY_DATA);
1278
1279   return EFI_SUCCESS;
1280 }
1281
1282 /**
1283   Return the results of the Identify command to a drive in IdentifyData.
1284   Data format of Identify data is defined by the Interface GUID.
1285
1286   @param  This Protocol instance pointer.
1287   @param  IdentifyData Results of Identify command to device
1288   @param  IdentifyDataSize Size of IdentifyData in bytes.
1289
1290   @retval  EFI_SUCCESS IdentifyData valid
1291   @retval  EFI_NOT_FOUND Device does not support this data class
1292   @retval  EFI_DEVICE_ERROR Error reading IdentifyData from device
1293   @retval  EFI_BUFFER_TOO_SMALL IdentifyDataSize not big enough
1294
1295 **/
1296 EFI_STATUS
1297 EFIAPI
1298 IDEDiskInfoIdentify (
1299   IN     EFI_DISK_INFO_PROTOCOL   *This,
1300   IN OUT VOID                     *IdentifyData,
1301   IN OUT UINT32                   *IdentifyDataSize
1302   )
1303 {
1304   IDE_BLK_IO_DEV  *IdeBlkIoDevice;
1305
1306   IdeBlkIoDevice = IDE_BLOCK_IO_DEV_FROM_DISK_INFO_THIS (This);
1307
1308   if (*IdentifyDataSize < sizeof (EFI_IDENTIFY_DATA)) {
1309     *IdentifyDataSize = sizeof (EFI_IDENTIFY_DATA);
1310     return EFI_BUFFER_TOO_SMALL;
1311   }
1312
1313   if (IdeBlkIoDevice->pIdData == NULL) {
1314     return EFI_NOT_FOUND;
1315   }
1316
1317   gBS->CopyMem (IdentifyData, IdeBlkIoDevice->pIdData, sizeof (EFI_IDENTIFY_DATA));
1318   *IdentifyDataSize = sizeof (EFI_IDENTIFY_DATA);
1319
1320   return EFI_SUCCESS;
1321 }
1322
1323 /**
1324   Return the results of the Request Sense command to a drive in SenseData.
1325   Data format of Sense data is defined by the Interface GUID.
1326
1327   @param  This Protocol instance pointer.
1328   @param  SenseData Results of Request Sense command to device
1329   @param  SenseDataSize Size of SenseData in bytes.
1330   @param  SenseDataNumber Type of SenseData
1331
1332   @retval  EFI_SUCCESS InquiryData valid
1333   @retval  EFI_NOT_FOUND Device does not support this data class
1334   @retval  EFI_DEVICE_ERROR Error reading InquiryData from device
1335   @retval  EFI_BUFFER_TOO_SMALL SenseDataSize not big enough
1336
1337 **/
1338 EFI_STATUS
1339 EFIAPI
1340 IDEDiskInfoSenseData (
1341   IN     EFI_DISK_INFO_PROTOCOL   *This,
1342   IN OUT VOID                     *SenseData,
1343   IN OUT UINT32                   *SenseDataSize,
1344   OUT    UINT8                    *SenseDataNumber
1345   )
1346 {
1347   return EFI_NOT_FOUND;
1348 }
1349
1350 /**
1351   Return the results of the Request Sense command to a drive in SenseData.
1352   Data format of Sense data is defined by the Interface GUID.
1353
1354   @param  This Protocol instance pointer.
1355   @param  IdeChannel Primary or Secondary
1356   @param  IdeDevice Master or Slave
1357
1358   @retval  EFI_SUCCESS IdeChannel and IdeDevice are valid
1359   @retval  EFI_UNSUPPORTED This is not an IDE device
1360
1361 **/
1362 EFI_STATUS
1363 EFIAPI
1364 IDEDiskInfoWhichIde (
1365   IN  EFI_DISK_INFO_PROTOCOL   *This,
1366   OUT UINT32                   *IdeChannel,
1367   OUT UINT32                   *IdeDevice
1368   )
1369 {
1370   IDE_BLK_IO_DEV  *IdeBlkIoDevice;
1371
1372   IdeBlkIoDevice  = IDE_BLOCK_IO_DEV_FROM_DISK_INFO_THIS (This);
1373   *IdeChannel     = IdeBlkIoDevice->Channel;
1374   *IdeDevice      = IdeBlkIoDevice->Device;
1375
1376   return EFI_SUCCESS;
1377 }