MdeModulePkg/Bus/Scsi/ScsiDiskDxe/ScsiDisk.c

   1 /** @file
   2   SCSI disk driver that layers on every SCSI IO protocol in the system.
   3
   4 Copyright (c) 2006 - 2010, 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
  16 #include "ScsiDisk.h"
  17
  18 EFI_DRIVER_BINDING_PROTOCOL gScsiDiskDriverBinding = {
  19   ScsiDiskDriverBindingSupported,
  20   ScsiDiskDriverBindingStart,
  21   ScsiDiskDriverBindingStop,
  22   0xa,
  23   NULL,
  24   NULL
  25 };
  26
  27 EFI_DISK_INFO_PROTOCOL gScsiDiskInfoProtocolTemplate = {
  28   EFI_DISK_INFO_SCSI_INTERFACE_GUID,
  29   ScsiDiskInfoInquiry,
  30   ScsiDiskInfoIdentify,
  31   ScsiDiskInfoSenseData,
  32   ScsiDiskInfoWhichIde
  33 };
  34
  35 /**
  36   The user Entry Point for module ScsiDisk.
  37
  38   The user code starts with this function.
  39
  40   @param  ImageHandle    The firmware allocated handle for the EFI image.
  41   @param  SystemTable    A pointer to the EFI System Table.
  42
  43   @retval EFI_SUCCESS       The entry point is executed successfully.
  44   @retval other             Some error occurs when executing this entry point.
  45
  46 **/
  47 EFI_STATUS
  48 EFIAPI
  49 InitializeScsiDisk(
  50   IN EFI_HANDLE           ImageHandle,
  51   IN EFI_SYSTEM_TABLE     *SystemTable
  52   )
  53 {
  54   EFI_STATUS              Status;
  55
  56   //
  57   // Install driver model protocol(s).
  58   //
  59   Status = EfiLibInstallDriverBindingComponentName2 (
  60              ImageHandle,
  61              SystemTable,
  62              &gScsiDiskDriverBinding,
  63              ImageHandle,
  64              &gScsiDiskComponentName,
  65              &gScsiDiskComponentName2
  66              );
  67   ASSERT_EFI_ERROR (Status);
  68
  69
  70   return Status;
  71 }
  72
  73 /**
  74   Test to see if this driver supports ControllerHandle.
  75
  76   This service is called by the EFI boot service ConnectController(). In order
  77   to make drivers as small as possible, there are a few calling restrictions for
  78   this service. ConnectController() must follow these calling restrictions.
  79   If any other agent wishes to call Supported() it must also follow these
  80   calling restrictions.
  81
  82   @param  This                Protocol instance pointer.
  83   @param  ControllerHandle    Handle of device to test
  84   @param  RemainingDevicePath Optional parameter use to pick a specific child
  85                               device to start.
  86
  87   @retval EFI_SUCCESS         This driver supports this device
  88   @retval EFI_ALREADY_STARTED This driver is already running on this device
  89   @retval other               This driver does not support this device
  90
  91 **/
  92 EFI_STATUS
  93 EFIAPI
  94 ScsiDiskDriverBindingSupported (
  95   IN EFI_DRIVER_BINDING_PROTOCOL  *This,
  96   IN EFI_HANDLE                   Controller,
  97   IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath   OPTIONAL
  98   )
  99 {
 100   EFI_STATUS            Status;
 101   EFI_SCSI_IO_PROTOCOL  *ScsiIo;
 102   UINT8                 DeviceType;
 103
 104   Status = gBS->OpenProtocol (
 105                   Controller,
 106                   &gEfiScsiIoProtocolGuid,
 107                   (VOID **) &ScsiIo,
 108                   This->DriverBindingHandle,
 109                   Controller,
 110                   EFI_OPEN_PROTOCOL_BY_DRIVER
 111                   );
 112   if (EFI_ERROR (Status)) {
 113     return Status;
 114   }
 115
 116   Status = ScsiIo->GetDeviceType (ScsiIo, &DeviceType);
 117   if (!EFI_ERROR (Status)) {
 118     if ((DeviceType == EFI_SCSI_TYPE_DISK) || (DeviceType == EFI_SCSI_TYPE_CDROM)) {
 119       Status = EFI_SUCCESS;
 120     } else {
 121       Status = EFI_UNSUPPORTED;
 122     }
 123   }
 124
 125   gBS->CloseProtocol (
 126          Controller,
 127          &gEfiScsiIoProtocolGuid,
 128          This->DriverBindingHandle,
 129          Controller
 130          );
 131   return Status;
 132 }
 133
 134
 135 /**
 136   Start this driver on ControllerHandle.
 137
 138   This service is called by the EFI boot service ConnectController(). In order
 139   to make drivers as small as possible, there are a few calling restrictions for
 140   this service. ConnectController() must follow these calling restrictions. If
 141   any other agent wishes to call Start() it must also follow these calling
 142   restrictions.
 143
 144   @param  This                 Protocol instance pointer.
 145   @param  ControllerHandle     Handle of device to bind driver to
 146   @param  RemainingDevicePath  Optional parameter use to pick a specific child
 147                                device to start.
 148
 149   @retval EFI_SUCCESS          This driver is added to ControllerHandle
 150   @retval EFI_ALREADY_STARTED  This driver is already running on ControllerHandle
 151   @retval other                This driver does not support this device
 152
 153 **/
 154 EFI_STATUS
 155 EFIAPI
 156 ScsiDiskDriverBindingStart (
 157   IN EFI_DRIVER_BINDING_PROTOCOL  *This,
 158   IN EFI_HANDLE                   Controller,
 159   IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath   OPTIONAL
 160   )
 161 {
 162   EFI_STATUS            Status;
 163   EFI_SCSI_IO_PROTOCOL  *ScsiIo;
 164   SCSI_DISK_DEV         *ScsiDiskDevice;
 165   BOOLEAN               Temp;
 166   UINT8                 Index;
 167   UINT8                 MaxRetry;
 168   BOOLEAN               NeedRetry;
 169
 170   ScsiDiskDevice = (SCSI_DISK_DEV *) AllocateZeroPool (sizeof (SCSI_DISK_DEV));
 171   if (ScsiDiskDevice == NULL) {
 172     return EFI_OUT_OF_RESOURCES;
 173   }
 174
 175   Status = gBS->OpenProtocol (
 176                   Controller,
 177                   &gEfiScsiIoProtocolGuid,
 178                   (VOID **) &ScsiIo,
 179                   This->DriverBindingHandle,
 180                   Controller,
 181                   EFI_OPEN_PROTOCOL_BY_DRIVER
 182                   );
 183   if (EFI_ERROR (Status)) {
 184     FreePool (ScsiDiskDevice);
 185     return Status;
 186   }
 187
 188   ScsiDiskDevice->Signature         = SCSI_DISK_DEV_SIGNATURE;
 189   ScsiDiskDevice->ScsiIo            = ScsiIo;
 190   ScsiDiskDevice->BlkIo.Media       = &ScsiDiskDevice->BlkIoMedia;
 191   ScsiDiskDevice->BlkIo.Reset       = ScsiDiskReset;
 192   ScsiDiskDevice->BlkIo.ReadBlocks  = ScsiDiskReadBlocks;
 193   ScsiDiskDevice->BlkIo.WriteBlocks = ScsiDiskWriteBlocks;
 194   ScsiDiskDevice->BlkIo.FlushBlocks = ScsiDiskFlushBlocks;
 195   ScsiDiskDevice->Handle            = Controller;
 196
 197   ScsiIo->GetDeviceType (ScsiIo, &(ScsiDiskDevice->DeviceType));
 198   switch (ScsiDiskDevice->DeviceType) {
 199   case EFI_SCSI_TYPE_DISK:
 200     ScsiDiskDevice->BlkIo.Media->BlockSize = 0x200;
 201     break;
 202
 203   case EFI_SCSI_TYPE_CDROM:
 204     ScsiDiskDevice->BlkIo.Media->BlockSize = 0x800;
 205     break;
 206   }
 207   //
 208   // The Sense Data Array's initial size is 6
 209   //
 210   ScsiDiskDevice->SenseDataNumber = 6;
 211   ScsiDiskDevice->SenseData = (EFI_SCSI_SENSE_DATA *) AllocateZeroPool (
 212                                  sizeof (EFI_SCSI_SENSE_DATA) * ScsiDiskDevice->SenseDataNumber
 213                                  );
 214   if (ScsiDiskDevice->SenseData == NULL) {
 215     gBS->CloseProtocol (
 216           Controller,
 217           &gEfiScsiIoProtocolGuid,
 218           This->DriverBindingHandle,
 219           Controller
 220           );
 221     FreePool (ScsiDiskDevice);
 222     return EFI_OUT_OF_RESOURCES;
 223   }
 224
 225   //
 226   // Retrieve device information
 227   //
 228   MaxRetry = 2;
 229   for (Index = 0; Index < MaxRetry; Index++) {
 230     Status = ScsiDiskInquiryDevice (ScsiDiskDevice, &NeedRetry);
 231     if (!EFI_ERROR (Status)) {
 232       break;
 233     }
 234
 235     if (!NeedRetry) {
 236       FreePool (ScsiDiskDevice->SenseData);
 237       gBS->CloseProtocol (
 238              Controller,
 239              &gEfiScsiIoProtocolGuid,
 240              This->DriverBindingHandle,
 241              Controller
 242              );
 243       FreePool (ScsiDiskDevice);
 244       return EFI_DEVICE_ERROR;
 245     }
 246   }
 247   //
 248   // The second parameter "TRUE" means must
 249   // retrieve media capacity
 250   //
 251   Status = ScsiDiskDetectMedia (ScsiDiskDevice, TRUE, &Temp);
 252   if (!EFI_ERROR (Status)) {
 253     //
 254     // Determine if Block IO should be produced on this controller handle
 255     //
 256     if (DetermineInstallBlockIo(Controller)) {
 257       InitializeInstallDiskInfo(ScsiDiskDevice, Controller);
 258       Status = gBS->InstallMultipleProtocolInterfaces (
 259                       &Controller,
 260                       &gEfiBlockIoProtocolGuid,
 261                       &ScsiDiskDevice->BlkIo,
 262                       &gEfiDiskInfoProtocolGuid,
 263                       &ScsiDiskDevice->DiskInfo,
 264                       NULL
 265                       );
 266       if (!EFI_ERROR(Status)) {
 267         ScsiDiskDevice->ControllerNameTable = NULL;
 268         AddUnicodeString2 (
 269           "eng",
 270           gScsiDiskComponentName.SupportedLanguages,
 271           &ScsiDiskDevice->ControllerNameTable,
 272           L"SCSI Disk Device",
 273           TRUE
 274           );
 275         AddUnicodeString2 (
 276           "en",
 277           gScsiDiskComponentName2.SupportedLanguages,
 278           &ScsiDiskDevice->ControllerNameTable,
 279           L"SCSI Disk Device",
 280           FALSE
 281           );
 282         return EFI_SUCCESS;
 283       }
 284     }
 285   }
 286
 287   gBS->FreePool (ScsiDiskDevice->SenseData);
 288   gBS->FreePool (ScsiDiskDevice);
 289   gBS->CloseProtocol (
 290          Controller,
 291          &gEfiScsiIoProtocolGuid,
 292          This->DriverBindingHandle,
 293          Controller
 294          );
 295   return Status;
 296
 297 }
 298
 299
 300 /**
 301   Stop this driver on ControllerHandle.
 302
 303   This service is called by the EFI boot service DisconnectController().
 304   In order to make drivers as small as possible, there are a few calling
 305   restrictions for this service. DisconnectController() must follow these
 306   calling restrictions. If any other agent wishes to call Stop() it must
 307   also follow these calling restrictions.
 308
 309   @param  This              Protocol instance pointer.
 310   @param  ControllerHandle  Handle of device to stop driver on
 311   @param  NumberOfChildren  Number of Handles in ChildHandleBuffer. If number of
 312                             children is zero stop the entire bus driver.
 313   @param  ChildHandleBuffer List of Child Handles to Stop.
 314
 315   @retval EFI_SUCCESS       This driver is removed ControllerHandle
 316   @retval other             This driver was not removed from this device
 317
 318 **/
 319 EFI_STATUS
 320 EFIAPI
 321 ScsiDiskDriverBindingStop (
 322   IN  EFI_DRIVER_BINDING_PROTOCOL     *This,
 323   IN  EFI_HANDLE                      Controller,
 324   IN  UINTN                           NumberOfChildren,
 325   IN  EFI_HANDLE                      *ChildHandleBuffer   OPTIONAL
 326   )
 327 {
 328   EFI_BLOCK_IO_PROTOCOL *BlkIo;
 329   SCSI_DISK_DEV         *ScsiDiskDevice;
 330   EFI_STATUS            Status;
 331
 332   Status = gBS->OpenProtocol (
 333                   Controller,
 334                   &gEfiBlockIoProtocolGuid,
 335                   (VOID **) &BlkIo,
 336                   This->DriverBindingHandle,
 337                   Controller,
 338                   EFI_OPEN_PROTOCOL_GET_PROTOCOL
 339                   );
 340   if (EFI_ERROR (Status)) {
 341     return Status;
 342   }
 343
 344   ScsiDiskDevice = SCSI_DISK_DEV_FROM_THIS (BlkIo);
 345   Status = gBS->UninstallMultipleProtocolInterfaces (
 346                   Controller,
 347                   &gEfiBlockIoProtocolGuid,
 348                   &ScsiDiskDevice->BlkIo,
 349                   &gEfiDiskInfoProtocolGuid,
 350                   &ScsiDiskDevice->DiskInfo,
 351                   NULL
 352                   );
 353   if (!EFI_ERROR (Status)) {
 354     gBS->CloseProtocol (
 355            Controller,
 356            &gEfiScsiIoProtocolGuid,
 357            This->DriverBindingHandle,
 358            Controller
 359            );
 360
 361     ReleaseScsiDiskDeviceResources (ScsiDiskDevice);
 362
 363     return EFI_SUCCESS;
 364   }
 365   //
 366   // errors met
 367   //
 368   return Status;
 369 }
 370
 371 /**
 372   Reset SCSI Disk.
 373
 374
 375   @param  This                 The pointer of EFI_BLOCK_IO_PROTOCOL
 376   @param  ExtendedVerification The flag about if extend verificate
 377
 378   @retval EFI_SUCCESS          The device was reset.
 379   @retval EFI_DEVICE_ERROR     The device is not functioning properly and could
 380                                not be reset.
 381   @return EFI_STATUS is returned from EFI_SCSI_IO_PROTOCOL.ResetDevice().
 382
 383 **/
 384 EFI_STATUS
 385 EFIAPI
 386 ScsiDiskReset (
 387   IN  EFI_BLOCK_IO_PROTOCOL   *This,
 388   IN  BOOLEAN                 ExtendedVerification
 389   )
 390 {
 391   EFI_TPL       OldTpl;
 392   SCSI_DISK_DEV *ScsiDiskDevice;
 393   EFI_STATUS    Status;
 394
 395   OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
 396
 397   ScsiDiskDevice  = SCSI_DISK_DEV_FROM_THIS (This);
 398
 399   Status          = ScsiDiskDevice->ScsiIo->ResetDevice (ScsiDiskDevice->ScsiIo);
 400
 401   if (!ExtendedVerification) {
 402     goto Done;
 403   }
 404
 405   Status = ScsiDiskDevice->ScsiIo->ResetBus (ScsiDiskDevice->ScsiIo);
 406
 407 Done:
 408   gBS->RestoreTPL (OldTpl);
 409   return Status;
 410 }
 411
 412 /**
 413   The function is to Read Block from SCSI Disk.
 414
 415   @param  This       The pointer of EFI_BLOCK_IO_PROTOCOL.
 416   @param  MediaId    The Id of Media detected
 417   @param  Lba        The logic block address
 418   @param  BufferSize The size of Buffer
 419   @param  Buffer     The buffer to fill the read out data
 420
 421   @retval EFI_SUCCESS           Successfully to read out block.
 422   @retval EFI_DEVICE_ERROR      Fail to detect media.
 423   @retval EFI_NO_MEDIA          Media is not present.
 424   @retval EFI_MEDIA_CHANGED     Media has changed.
 425   @retval EFI_BAD_BUFFER_SIZE   The Buffer was not a multiple of the block size of the device.
 426   @retval EFI_INVALID_PARAMETER Invalid parameter passed in.
 427
 428 **/
 429 EFI_STATUS
 430 EFIAPI
 431 ScsiDiskReadBlocks (
 432   IN  EFI_BLOCK_IO_PROTOCOL   *This,
 433   IN  UINT32                  MediaId,
 434   IN  EFI_LBA                 Lba,
 435   IN  UINTN                   BufferSize,
 436   OUT VOID                    *Buffer
 437   )
 438 {
 439   SCSI_DISK_DEV       *ScsiDiskDevice;
 440   EFI_BLOCK_IO_MEDIA  *Media;
 441   EFI_STATUS          Status;
 442   UINTN               BlockSize;
 443   UINTN               NumberOfBlocks;
 444   BOOLEAN             MediaChange;
 445   EFI_TPL             OldTpl;
 446
 447   MediaChange = FALSE;
 448   if (Buffer == NULL) {
 449     return EFI_INVALID_PARAMETER;
 450   }
 451
 452   if (BufferSize == 0) {
 453     return EFI_SUCCESS;
 454   }
 455
 456   OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
 457
 458   ScsiDiskDevice = SCSI_DISK_DEV_FROM_THIS (This);
 459
 460   if (!IS_DEVICE_FIXED(ScsiDiskDevice)) {
 461
 462     Status = ScsiDiskDetectMedia (ScsiDiskDevice, FALSE, &MediaChange);
 463     if (EFI_ERROR (Status)) {
 464       Status = EFI_DEVICE_ERROR;
 465       goto Done;
 466     }
 467
 468     if (MediaChange) {
 469       gBS->ReinstallProtocolInterface (
 470             ScsiDiskDevice->Handle,
 471             &gEfiBlockIoProtocolGuid,
 472             &ScsiDiskDevice->BlkIo,
 473             &ScsiDiskDevice->BlkIo
 474             );
 475     }
 476   }
 477   //
 478   // Get the intrinsic block size
 479   //
 480   Media           = ScsiDiskDevice->BlkIo.Media;
 481   BlockSize       = Media->BlockSize;
 482
 483   NumberOfBlocks  = BufferSize / BlockSize;
 484
 485   if (!(Media->MediaPresent)) {
 486     Status = EFI_NO_MEDIA;
 487     goto Done;
 488   }
 489
 490   if (MediaId != Media->MediaId) {
 491     Status = EFI_MEDIA_CHANGED;
 492     goto Done;
 493   }
 494
 495   if (BufferSize % BlockSize != 0) {
 496     Status = EFI_BAD_BUFFER_SIZE;
 497     goto Done;
 498   }
 499
 500   if (Lba > Media->LastBlock) {
 501     Status = EFI_INVALID_PARAMETER;
 502     goto Done;
 503   }
 504
 505   if ((Lba + NumberOfBlocks - 1) > Media->LastBlock) {
 506     Status = EFI_INVALID_PARAMETER;
 507     goto Done;
 508   }
 509
 510   if ((Media->IoAlign > 1) && (((UINTN) Buffer & (Media->IoAlign - 1)) != 0)) {
 511     Status = EFI_INVALID_PARAMETER;
 512     goto Done;
 513   }
 514
 515   //
 516   // If all the parameters are valid, then perform read sectors command
 517   // to transfer data from device to host.
 518   //
 519   Status = ScsiDiskReadSectors (ScsiDiskDevice, Buffer, Lba, NumberOfBlocks);
 520
 521 Done:
 522   gBS->RestoreTPL (OldTpl);
 523   return Status;
 524 }
 525
 526 /**
 527   The function is to Write Block to SCSI Disk.
 528
 529   @param  This       The pointer of EFI_BLOCK_IO_PROTOCOL
 530   @param  MediaId    The Id of Media detected
 531   @param  Lba        The logic block address
 532   @param  BufferSize The size of Buffer
 533   @param  Buffer     The buffer to fill the read out data
 534
 535   @retval EFI_SUCCESS           Successfully to read out block.
 536   @retval EFI_WRITE_PROTECTED   The device can not be written to.
 537   @retval EFI_DEVICE_ERROR      Fail to detect media.
 538   @retval EFI_NO_MEDIA          Media is not present.
 539   @retval EFI_MEDIA_CHNAGED     Media has changed.
 540   @retval EFI_BAD_BUFFER_SIZE   The Buffer was not a multiple of the block size of the device.
 541   @retval EFI_INVALID_PARAMETER Invalid parameter passed in.
 542
 543 **/
 544 EFI_STATUS
 545 EFIAPI
 546 ScsiDiskWriteBlocks (
 547   IN  EFI_BLOCK_IO_PROTOCOL   *This,
 548   IN  UINT32                  MediaId,
 549   IN  EFI_LBA                 Lba,
 550   IN  UINTN                   BufferSize,
 551   IN  VOID                    *Buffer
 552   )
 553 {
 554   SCSI_DISK_DEV       *ScsiDiskDevice;
 555   EFI_BLOCK_IO_MEDIA  *Media;
 556   EFI_STATUS          Status;
 557   UINTN               BlockSize;
 558   UINTN               NumberOfBlocks;
 559   BOOLEAN             MediaChange;
 560   EFI_TPL             OldTpl;
 561
 562   MediaChange = FALSE;
 563   if (Buffer == NULL) {
 564     return EFI_INVALID_PARAMETER;
 565   }
 566
 567   if (BufferSize == 0) {
 568     return EFI_SUCCESS;
 569   }
 570
 571   OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
 572
 573   ScsiDiskDevice = SCSI_DISK_DEV_FROM_THIS (This);
 574
 575   if (!IS_DEVICE_FIXED(ScsiDiskDevice)) {
 576
 577     Status = ScsiDiskDetectMedia (ScsiDiskDevice, FALSE, &MediaChange);
 578     if (EFI_ERROR (Status)) {
 579       Status = EFI_DEVICE_ERROR;
 580       goto Done;
 581     }
 582
 583     if (MediaChange) {
 584       gBS->ReinstallProtocolInterface (
 585             ScsiDiskDevice->Handle,
 586             &gEfiBlockIoProtocolGuid,
 587             &ScsiDiskDevice->BlkIo,
 588             &ScsiDiskDevice->BlkIo
 589             );
 590     }
 591   }
 592   //
 593   // Get the intrinsic block size
 594   //
 595   Media           = ScsiDiskDevice->BlkIo.Media;
 596   BlockSize       = Media->BlockSize;
 597
 598   NumberOfBlocks  = BufferSize / BlockSize;
 599
 600   if (!(Media->MediaPresent)) {
 601     Status = EFI_NO_MEDIA;
 602     goto Done;
 603   }
 604
 605   if (MediaId != Media->MediaId) {
 606     Status = EFI_MEDIA_CHANGED;
 607     goto Done;
 608   }
 609
 610   if (BufferSize % BlockSize != 0) {
 611     Status = EFI_BAD_BUFFER_SIZE;
 612     goto Done;
 613   }
 614
 615   if (Lba > Media->LastBlock) {
 616     Status = EFI_INVALID_PARAMETER;
 617     goto Done;
 618   }
 619
 620   if ((Lba + NumberOfBlocks - 1) > Media->LastBlock) {
 621     Status = EFI_INVALID_PARAMETER;
 622     goto Done;
 623   }
 624
 625   if ((Media->IoAlign > 1) && (((UINTN) Buffer & (Media->IoAlign - 1)) != 0)) {
 626     Status = EFI_INVALID_PARAMETER;
 627     goto Done;
 628   }
 629   //
 630   // if all the parameters are valid, then perform read sectors command
 631   // to transfer data from device to host.
 632   //
 633   Status = ScsiDiskWriteSectors (ScsiDiskDevice, Buffer, Lba, NumberOfBlocks);
 634
 635 Done:
 636   gBS->RestoreTPL (OldTpl);
 637   return Status;
 638 }
 639
 640 /**
 641   Flush Block to Disk.
 642
 643   EFI_SUCCESS is returned directly.
 644
 645   @param  This              The pointer of EFI_BLOCK_IO_PROTOCOL
 646
 647   @retval EFI_SUCCESS       All outstanding data was written to the device
 648
 649 **/
 650 EFI_STATUS
 651 EFIAPI
 652 ScsiDiskFlushBlocks (
 653   IN  EFI_BLOCK_IO_PROTOCOL   *This
 654   )
 655 {
 656   //
 657   // return directly
 658   //
 659   return EFI_SUCCESS;
 660 }
 661
 662
 663 /**
 664   Detect Device and read out capacity ,if error occurs, parse the sense key.
 665
 666   @param  ScsiDiskDevice    The pointer of SCSI_DISK_DEV
 667   @param  MustReadCapacity  The flag about reading device capacity
 668   @param  MediaChange       The pointer of flag indicates if media has changed
 669
 670   @retval EFI_DEVICE_ERROR  Indicates that error occurs
 671   @retval EFI_SUCCESS       Successfully to detect media
 672
 673 **/
 674 EFI_STATUS
 675 ScsiDiskDetectMedia (
 676   IN   SCSI_DISK_DEV   *ScsiDiskDevice,
 677   IN   BOOLEAN         MustReadCapacity,
 678   OUT  BOOLEAN         *MediaChange
 679   )
 680 {
 681   EFI_STATUS          Status;
 682   EFI_STATUS          ReadCapacityStatus;
 683   EFI_SCSI_SENSE_DATA *SenseData;
 684   UINTN               NumberOfSenseKeys;
 685   BOOLEAN             NeedRetry;
 686   BOOLEAN             NeedReadCapacity;
 687   UINT8               Index;
 688   UINT8               MaxRetry;
 689   EFI_BLOCK_IO_MEDIA  OldMedia;
 690   UINTN               Action;
 691
 692   Status              = EFI_SUCCESS;
 693   ReadCapacityStatus  = EFI_SUCCESS;
 694   SenseData           = NULL;
 695   NumberOfSenseKeys   = 0;
 696   NeedReadCapacity    = FALSE;
 697   CopyMem (&OldMedia, ScsiDiskDevice->BlkIo.Media, sizeof (OldMedia));
 698   *MediaChange        = FALSE;
 699   MaxRetry            = 3;
 700
 701   for (Index = 0; Index < MaxRetry; Index++) {
 702     Status = ScsiDiskTestUnitReady (
 703               ScsiDiskDevice,
 704               &NeedRetry,
 705               &SenseData,
 706               &NumberOfSenseKeys
 707               );
 708     if (!EFI_ERROR (Status)) {
 709       break;
 710     }
 711
 712     if (!NeedRetry) {
 713       return Status;
 714     }
 715   }
 716
 717   if ((Index == MaxRetry) && EFI_ERROR (Status)) {
 718     return EFI_DEVICE_ERROR;
 719   }
 720
 721   Status = DetectMediaParsingSenseKeys (
 722             ScsiDiskDevice,
 723             SenseData,
 724             NumberOfSenseKeys,
 725             &Action
 726             );
 727   if (EFI_ERROR (Status)) {
 728     return Status;
 729   }
 730   //
 731   // ACTION_NO_ACTION: need not read capacity
 732   // other action code: need read capacity
 733   //
 734   if (Action == ACTION_NO_ACTION) {
 735     NeedReadCapacity = FALSE;
 736   } else {
 737     NeedReadCapacity = TRUE;
 738   }
 739
 740   //
 741   // either NeedReadCapacity is TRUE, or MustReadCapacity is TRUE,
 742   // retrieve capacity via Read Capacity command
 743   //
 744   if (NeedReadCapacity || MustReadCapacity) {
 745     //
 746     // retrieve media information
 747     //
 748     MaxRetry = 3;
 749     for (Index = 0; Index < MaxRetry; Index++) {
 750
 751       ReadCapacityStatus = ScsiDiskReadCapacity (
 752                             ScsiDiskDevice,
 753                             &NeedRetry,
 754                             &SenseData,
 755                             &NumberOfSenseKeys
 756                             );
 757       if (EFI_ERROR (ReadCapacityStatus) && !NeedRetry) {
 758         return EFI_DEVICE_ERROR;
 759       }
 760       //
 761       // analyze sense key to action
 762       //
 763       Status = DetectMediaParsingSenseKeys (
 764                 ScsiDiskDevice,
 765                 SenseData,
 766                 NumberOfSenseKeys,
 767                 &Action
 768                 );
 769       //
 770       // if Status is error, it may indicate crisis error,
 771       // so return without retry.
 772       //
 773       if (EFI_ERROR (Status)) {
 774         return Status;
 775       }
 776
 777       switch (Action) {
 778       case ACTION_NO_ACTION:
 779         //
 780         // no retry
 781         //
 782         Index = MaxRetry;
 783         break;
 784
 785       case ACTION_RETRY_COMMAND_LATER:
 786         //
 787         // retry the ReadCapacity later and continuously, until the condition
 788         // no longer emerges.
 789         // stall time is 100000us, or say 0.1 second.
 790         //
 791         gBS->Stall (100000);
 792         Index = 0;
 793         break;
 794
 795       default:
 796         //
 797         // other cases, just retry the command
 798         //
 799         break;
 800       }
 801     }
 802
 803     if ((Index == MaxRetry) && EFI_ERROR (ReadCapacityStatus)) {
 804       return EFI_DEVICE_ERROR;
 805     }
 806   }
 807
 808   if (ScsiDiskDevice->BlkIo.Media->MediaId != OldMedia.MediaId) {
 809     //
 810     // Media change information got from the device
 811     //
 812     *MediaChange = TRUE;
 813   }
 814
 815   if (ScsiDiskDevice->BlkIo.Media->ReadOnly != OldMedia.ReadOnly) {
 816     *MediaChange = TRUE;
 817     ScsiDiskDevice->BlkIo.Media->MediaId += 1;
 818   }
 819
 820   if (ScsiDiskDevice->BlkIo.Media->BlockSize != OldMedia.BlockSize) {
 821     *MediaChange = TRUE;
 822     ScsiDiskDevice->BlkIo.Media->MediaId += 1;
 823   }
 824
 825   if (ScsiDiskDevice->BlkIo.Media->LastBlock != OldMedia.LastBlock) {
 826     *MediaChange = TRUE;
 827     ScsiDiskDevice->BlkIo.Media->MediaId += 1;
 828   }
 829
 830   if (ScsiDiskDevice->BlkIo.Media->MediaPresent != OldMedia.MediaPresent) {
 831     if (ScsiDiskDevice->BlkIo.Media->MediaPresent) {
 832       //
 833       // when change from no media to media present, reset the MediaId to 1.
 834       //
 835       ScsiDiskDevice->BlkIo.Media->MediaId = 1;
 836     } else {
 837       //
 838       // when no media, reset the MediaId to zero.
 839       //
 840       ScsiDiskDevice->BlkIo.Media->MediaId = 0;
 841     }
 842
 843     *MediaChange = TRUE;
 844   }
 845
 846   return EFI_SUCCESS;
 847 }
 848
 849
 850 /**
 851   Send out Inquiry command to Device.
 852
 853   @param  ScsiDiskDevice  The pointer of SCSI_DISK_DEV
 854   @param  NeedRetry       Indicates if needs try again when error happens
 855
 856   @retval  EFI_DEVICE_ERROR  Indicates that error occurs
 857   @retval  EFI_SUCCESS       Successfully to detect media
 858
 859 **/
 860 EFI_STATUS
 861 ScsiDiskInquiryDevice (
 862   IN OUT  SCSI_DISK_DEV   *ScsiDiskDevice,
 863      OUT  BOOLEAN         *NeedRetry
 864   )
 865 {
 866   UINT32              InquiryDataLength;
 867   UINT8               SenseDataLength;
 868   UINT8               HostAdapterStatus;
 869   UINT8               TargetStatus;
 870   EFI_SCSI_SENSE_DATA *SenseDataArray;
 871   UINTN               NumberOfSenseKeys;
 872   EFI_STATUS          Status;
 873   UINT8               MaxRetry;
 874   UINT8               Index;
 875
 876   InquiryDataLength = sizeof (EFI_SCSI_INQUIRY_DATA);
 877   SenseDataLength   = 0;
 878
 879   Status = ScsiInquiryCommand (
 880             ScsiDiskDevice->ScsiIo,
 881             EFI_TIMER_PERIOD_SECONDS (1),
 882             NULL,
 883             &SenseDataLength,
 884             &HostAdapterStatus,
 885             &TargetStatus,
 886             (VOID *) &(ScsiDiskDevice->InquiryData),
 887             &InquiryDataLength,
 888             FALSE
 889             );
 890     //
 891     // no need to check HostAdapterStatus and TargetStatus
 892     //
 893   if ((Status == EFI_SUCCESS) || (Status == EFI_WARN_BUFFER_TOO_SMALL)) {
 894      ParseInquiryData (ScsiDiskDevice);
 895      return EFI_SUCCESS;
 896
 897    } else if (Status == EFI_NOT_READY) {
 898      *NeedRetry = TRUE;
 899      return EFI_DEVICE_ERROR;
 900
 901    } else if ((Status == EFI_INVALID_PARAMETER) || (Status == EFI_UNSUPPORTED)) {
 902      *NeedRetry = FALSE;
 903      return EFI_DEVICE_ERROR;
 904    }
 905    //
 906    // go ahead to check HostAdapterStatus and TargetStatus
 907    // (EFI_TIMEOUT, EFI_DEVICE_ERROR)
 908    //
 909
 910    Status = CheckHostAdapterStatus (HostAdapterStatus);
 911    if ((Status == EFI_TIMEOUT) || (Status == EFI_NOT_READY)) {
 912      *NeedRetry = TRUE;
 913      return EFI_DEVICE_ERROR;
 914    } else if (Status == EFI_DEVICE_ERROR) {
 915       //
 916       // reset the scsi channel
 917       //
 918     ScsiDiskDevice->ScsiIo->ResetBus (ScsiDiskDevice->ScsiIo);
 919     *NeedRetry = FALSE;
 920     return EFI_DEVICE_ERROR;
 921   }
 922
 923   Status = CheckTargetStatus (TargetStatus);
 924   if (Status == EFI_NOT_READY) {
 925     //
 926     // reset the scsi device
 927     //
 928     ScsiDiskDevice->ScsiIo->ResetDevice (ScsiDiskDevice->ScsiIo);
 929     *NeedRetry = TRUE;
 930     return EFI_DEVICE_ERROR;
 931
 932   } else if (Status == EFI_DEVICE_ERROR) {
 933     *NeedRetry = FALSE;
 934     return EFI_DEVICE_ERROR;
 935   }
 936
 937   //
 938   // if goes here, meant ScsiInquiryCommand() failed.
 939   // if ScsiDiskRequestSenseKeys() succeeds at last,
 940   // better retry ScsiInquiryCommand(). (by setting *NeedRetry = TRUE)
 941   //
 942   MaxRetry = 3;
 943   for (Index = 0; Index < MaxRetry; Index++) {
 944     Status = ScsiDiskRequestSenseKeys (
 945               ScsiDiskDevice,
 946               NeedRetry,
 947               &SenseDataArray,
 948               &NumberOfSenseKeys,
 949               TRUE
 950               );
 951     if (!EFI_ERROR (Status)) {
 952       *NeedRetry = TRUE;
 953       return EFI_DEVICE_ERROR;
 954     }
 955
 956     if (!*NeedRetry) {
 957       return EFI_DEVICE_ERROR;
 958     }
 959   }
 960   //
 961   // ScsiDiskRequestSenseKeys() failed after several rounds of retry.
 962   // set *NeedRetry = FALSE to avoid the outside caller try again.
 963   //
 964   *NeedRetry = FALSE;
 965   return EFI_DEVICE_ERROR;
 966 }
 967
 968 /**
 969   To test device.
 970
 971   When Test Unit Ready command succeeds, retrieve Sense Keys via Request Sense;
 972   When Test Unit Ready command encounters any error caused by host adapter or
 973   target, return error without retrieving Sense Keys.
 974
 975   @param  ScsiDiskDevice     The pointer of SCSI_DISK_DEV
 976   @param  NeedRetry          The pointer of flag indicates try again
 977   @param  SenseDataArray     The pointer of an array of sense data
 978   @param  NumberOfSenseKeys  The pointer of the number of sense data array
 979
 980   @retval EFI_DEVICE_ERROR   Indicates that error occurs
 981   @retval EFI_SUCCESS        Successfully to test unit
 982
 983 **/
 984 EFI_STATUS
 985 ScsiDiskTestUnitReady (
 986   IN  SCSI_DISK_DEV         *ScsiDiskDevice,
 987   OUT BOOLEAN               *NeedRetry,
 988   OUT EFI_SCSI_SENSE_DATA   **SenseDataArray,
 989   OUT UINTN                 *NumberOfSenseKeys
 990   )
 991 {
 992   EFI_STATUS  Status;
 993   UINT8       SenseDataLength;
 994   UINT8       HostAdapterStatus;
 995   UINT8       TargetStatus;
 996   UINT8       Index;
 997   UINT8       MaxRetry;
 998
 999   SenseDataLength     = 0;
1000   *NumberOfSenseKeys  = 0;
1001
1002   //
1003   // Parameter 3 and 4: do not require sense data, retrieve it when needed.
1004   //
1005   Status = ScsiTestUnitReadyCommand (
1006             ScsiDiskDevice->ScsiIo,
1007             EFI_TIMER_PERIOD_SECONDS (1),
1008             NULL,
1009             &SenseDataLength,
1010             &HostAdapterStatus,
1011             &TargetStatus
1012             );
1013   //
1014   // no need to check HostAdapterStatus and TargetStatus
1015   //
1016   if (Status == EFI_NOT_READY) {
1017     *NeedRetry = TRUE;
1018     return EFI_DEVICE_ERROR;
1019
1020   } else if ((Status == EFI_INVALID_PARAMETER) || (Status == EFI_UNSUPPORTED)) {
1021     *NeedRetry = FALSE;
1022     return EFI_DEVICE_ERROR;
1023   }
1024   //
1025   // go ahead to check HostAdapterStatus and TargetStatus(in case of EFI_DEVICE_ERROR)
1026   //
1027
1028   Status = CheckHostAdapterStatus (HostAdapterStatus);
1029   if ((Status == EFI_TIMEOUT) || (Status == EFI_NOT_READY)) {
1030     *NeedRetry = TRUE;
1031     return EFI_DEVICE_ERROR;
1032
1033   } else if (Status == EFI_DEVICE_ERROR) {
1034     //
1035     // reset the scsi channel
1036     //
1037     ScsiDiskDevice->ScsiIo->ResetBus (ScsiDiskDevice->ScsiIo);
1038     *NeedRetry = FALSE;
1039     return EFI_DEVICE_ERROR;
1040   }
1041
1042   Status = CheckTargetStatus (TargetStatus);
1043   if (Status == EFI_NOT_READY) {
1044     //
1045     // reset the scsi device
1046     //
1047     ScsiDiskDevice->ScsiIo->ResetDevice (ScsiDiskDevice->ScsiIo);
1048     *NeedRetry = TRUE;
1049     return EFI_DEVICE_ERROR;
1050
1051   } else if (Status == EFI_DEVICE_ERROR) {
1052     *NeedRetry = FALSE;
1053     return EFI_DEVICE_ERROR;
1054   }
1055
1056   MaxRetry = 3;
1057   for (Index = 0; Index < MaxRetry; Index++) {
1058     Status = ScsiDiskRequestSenseKeys (
1059               ScsiDiskDevice,
1060               NeedRetry,
1061               SenseDataArray,
1062               NumberOfSenseKeys,
1063               FALSE
1064               );
1065     if (!EFI_ERROR (Status)) {
1066       return EFI_SUCCESS;
1067     }
1068
1069     if (!*NeedRetry) {
1070       return EFI_DEVICE_ERROR;
1071     }
1072   }
1073   //
1074   // ScsiDiskRequestSenseKeys() failed after several rounds of retry.
1075   // set *NeedRetry = FALSE to avoid the outside caller try again.
1076   //
1077   *NeedRetry = FALSE;
1078   return EFI_DEVICE_ERROR;
1079 }
1080
1081 /**
1082   Parsing Sense Keys which got from request sense command.
1083
1084   @param  ScsiDiskDevice     The pointer of SCSI_DISK_DEV
1085   @param  SenseData          The pointer of EFI_SCSI_SENSE_DATA
1086   @param  NumberOfSenseKeys  The number of sense key
1087   @param  Action             The pointer of action which indicates what is need to do next
1088
1089   @retval EFI_DEVICE_ERROR   Indicates that error occurs
1090   @retval EFI_SUCCESS        Successfully to complete the parsing
1091
1092 **/
1093 EFI_STATUS
1094 DetectMediaParsingSenseKeys (
1095   OUT  SCSI_DISK_DEV           *ScsiDiskDevice,
1096   IN   EFI_SCSI_SENSE_DATA     *SenseData,
1097   IN   UINTN                   NumberOfSenseKeys,
1098   OUT  UINTN                   *Action
1099   )
1100 {
1101   BOOLEAN RetryLater;
1102
1103   //
1104   // Default is to read capacity, unless..
1105   //
1106   *Action = ACTION_READ_CAPACITY;
1107
1108   if (NumberOfSenseKeys == 0) {
1109     *Action = ACTION_NO_ACTION;
1110     return EFI_SUCCESS;
1111   }
1112
1113   if (!ScsiDiskHaveSenseKey (SenseData, NumberOfSenseKeys)) {
1114     //
1115     // No Sense Key returned from last submitted command
1116     //
1117     *Action = ACTION_NO_ACTION;
1118     return EFI_SUCCESS;
1119   }
1120
1121   if (ScsiDiskIsNoMedia (SenseData, NumberOfSenseKeys)) {
1122     ScsiDiskDevice->BlkIo.Media->MediaPresent = FALSE;
1123     ScsiDiskDevice->BlkIo.Media->LastBlock    = 0;
1124     *Action = ACTION_NO_ACTION;
1125     return EFI_SUCCESS;
1126   }
1127
1128   if (ScsiDiskIsMediaChange (SenseData, NumberOfSenseKeys)) {
1129     ScsiDiskDevice->BlkIo.Media->MediaId++;
1130     return EFI_SUCCESS;
1131   }
1132
1133   if (ScsiDiskIsMediaError (SenseData, NumberOfSenseKeys)) {
1134     ScsiDiskDevice->BlkIo.Media->MediaPresent = FALSE;
1135     ScsiDiskDevice->BlkIo.Media->LastBlock    = 0;
1136     return EFI_DEVICE_ERROR;
1137   }
1138
1139   if (ScsiDiskIsHardwareError (SenseData, NumberOfSenseKeys)) {
1140     return EFI_DEVICE_ERROR;
1141   }
1142
1143   if (!ScsiDiskIsDriveReady (SenseData, NumberOfSenseKeys, &RetryLater)) {
1144     if (RetryLater) {
1145       *Action = ACTION_RETRY_COMMAND_LATER;
1146       return EFI_SUCCESS;
1147     }
1148
1149     return EFI_DEVICE_ERROR;
1150   }
1151
1152   return EFI_SUCCESS;
1153 }
1154
1155
1156 /**
1157   Send read capacity command to device and get the device parameter.
1158
1159   @param  ScsiDiskDevice     The pointer of SCSI_DISK_DEV
1160   @param  NeedRetry          The pointer of flag indicates if need a retry
1161   @param  SenseDataArray     The pointer of an array of sense data
1162   @param  NumberOfSenseKeys  The number of sense key
1163
1164   @retval EFI_DEVICE_ERROR   Indicates that error occurs
1165   @retval EFI_SUCCESS        Successfully to read capacity
1166
1167 **/
1168 EFI_STATUS
1169 ScsiDiskReadCapacity (
1170   IN  OUT  SCSI_DISK_DEV           *ScsiDiskDevice,
1171       OUT  BOOLEAN                 *NeedRetry,
1172       OUT  EFI_SCSI_SENSE_DATA     **SenseDataArray,
1173       OUT  UINTN                   *NumberOfSenseKeys
1174   )
1175 {
1176   UINT8                         HostAdapterStatus;
1177   UINT8                         TargetStatus;
1178   EFI_STATUS                    CommandStatus;
1179   EFI_STATUS                    Status;
1180   UINT8                         Index;
1181   UINT8                         MaxRetry;
1182   UINT8                         SenseDataLength;
1183   UINT8                         ScsiVersion;
1184   UINT32                        DataLength10;
1185   UINT32                        DataLength16;
1186   EFI_SCSI_DISK_CAPACITY_DATA   CapacityData10;
1187   EFI_SCSI_DISK_CAPACITY_DATA16 CapacityData16;
1188
1189
1190   SenseDataLength       = 0;
1191   DataLength10          = sizeof (EFI_SCSI_DISK_CAPACITY_DATA);
1192   DataLength16          = sizeof (EFI_SCSI_DISK_CAPACITY_DATA16);
1193   ZeroMem (&CapacityData10, sizeof (EFI_SCSI_DISK_CAPACITY_DATA));
1194   ZeroMem (&CapacityData16, sizeof (EFI_SCSI_DISK_CAPACITY_DATA16));
1195
1196   *NumberOfSenseKeys  = 0;
1197   *NeedRetry          = FALSE;
1198   ScsiVersion         = (UINT8)(ScsiDiskDevice->InquiryData.Version & 0x03);
1199
1200   if (ScsiVersion < SCSI_COMMAND_VERSION_3) {
1201     //
1202     // submit Read Capacity(10) Command. in this call,not request sense data
1203     //
1204     CommandStatus = ScsiReadCapacityCommand (
1205                       ScsiDiskDevice->ScsiIo,
1206                       EFI_TIMER_PERIOD_SECONDS(1),
1207                       NULL,
1208                       &SenseDataLength,
1209                       &HostAdapterStatus,
1210                       &TargetStatus,
1211                       (VOID *) &CapacityData10,
1212                       &DataLength10,
1213                       FALSE
1214                       );
1215     } else {
1216       //
1217       // submit Read Capacity(16) Command to get parameter LogicalBlocksPerPhysicalBlock
1218       // and LowestAlignedLba
1219       //
1220       CommandStatus = ScsiReadCapacity16Command (
1221                         ScsiDiskDevice->ScsiIo,
1222                         EFI_TIMER_PERIOD_SECONDS (1),
1223                         NULL,
1224                         &SenseDataLength,
1225                         &HostAdapterStatus,
1226                         &TargetStatus,
1227                         (VOID *) &CapacityData16,
1228                         &DataLength16,
1229                         FALSE
1230                         );
1231     }
1232     //
1233     // no need to check HostAdapterStatus and TargetStatus
1234     //
1235    if (CommandStatus == EFI_SUCCESS) {
1236      GetMediaInfo (ScsiDiskDevice, &CapacityData10,&CapacityData16);
1237      return EFI_SUCCESS;
1238
1239    } else if (CommandStatus == EFI_NOT_READY) {
1240      *NeedRetry = TRUE;
1241      return EFI_DEVICE_ERROR;
1242
1243    } else if ((CommandStatus == EFI_INVALID_PARAMETER) || (CommandStatus == EFI_UNSUPPORTED)) {
1244      *NeedRetry = FALSE;
1245      return EFI_DEVICE_ERROR;
1246    }
1247    //
1248    // go ahead to check HostAdapterStatus and TargetStatus
1249    // (EFI_TIMEOUT, EFI_DEVICE_ERROR, EFI_WARN_BUFFER_TOO_SMALL)
1250    //
1251
1252    Status = CheckHostAdapterStatus (HostAdapterStatus);
1253    if ((Status == EFI_TIMEOUT) || (Status == EFI_NOT_READY)) {
1254      *NeedRetry = TRUE;
1255      return EFI_DEVICE_ERROR;
1256
1257    } else if (Status == EFI_DEVICE_ERROR) {
1258     //
1259     // reset the scsi channel
1260     //
1261     ScsiDiskDevice->ScsiIo->ResetBus (ScsiDiskDevice->ScsiIo);
1262     *NeedRetry = FALSE;
1263     return EFI_DEVICE_ERROR;
1264   }
1265
1266   Status = CheckTargetStatus (TargetStatus);
1267   if (Status == EFI_NOT_READY) {
1268     //
1269     // reset the scsi device
1270     //
1271     ScsiDiskDevice->ScsiIo->ResetDevice (ScsiDiskDevice->ScsiIo);
1272     *NeedRetry = TRUE;
1273     return EFI_DEVICE_ERROR;
1274
1275   } else if (Status == EFI_DEVICE_ERROR) {
1276     *NeedRetry = FALSE;
1277     return EFI_DEVICE_ERROR;
1278   }
1279
1280   //
1281   // if goes here, meant ScsiReadCapacityCommand() failed.
1282   // if ScsiDiskRequestSenseKeys() succeeds at last,
1283   // better retry ScsiReadCapacityCommand(). (by setting *NeedRetry = TRUE)
1284   //
1285   MaxRetry = 3;
1286   for (Index = 0; Index < MaxRetry; Index++) {
1287
1288     Status = ScsiDiskRequestSenseKeys (
1289               ScsiDiskDevice,
1290               NeedRetry,
1291               SenseDataArray,
1292               NumberOfSenseKeys,
1293               TRUE
1294               );
1295     if (!EFI_ERROR (Status)) {
1296       *NeedRetry = TRUE;
1297       return EFI_DEVICE_ERROR;
1298     }
1299
1300     if (!*NeedRetry) {
1301       return EFI_DEVICE_ERROR;
1302     }
1303   }
1304   //
1305   // ScsiDiskRequestSenseKeys() failed after several rounds of retry.
1306   // set *NeedRetry = FALSE to avoid the outside caller try again.
1307   //
1308   *NeedRetry = FALSE;
1309   return EFI_DEVICE_ERROR;
1310 }
1311
1312 /**
1313   Check the HostAdapter status and re-interpret it in EFI_STATUS.
1314
1315   @param  HostAdapterStatus  Host Adapter status
1316
1317   @retval  EFI_SUCCESS       Host adapter is OK.
1318   @retval  EFI_TIMEOUT       Timeout.
1319   @retval  EFI_NOT_READY     Adapter NOT ready.
1320   @retval  EFI_DEVICE_ERROR  Adapter device error.
1321
1322 **/
1323 EFI_STATUS
1324 CheckHostAdapterStatus (
1325   IN UINT8   HostAdapterStatus
1326   )
1327 {
1328   switch (HostAdapterStatus) {
1329   case EFI_EXT_SCSI_STATUS_HOST_ADAPTER_OK:
1330     return EFI_SUCCESS;
1331
1332   case EFI_EXT_SCSI_STATUS_HOST_ADAPTER_SELECTION_TIMEOUT:
1333   case EFI_EXT_SCSI_STATUS_HOST_ADAPTER_TIMEOUT:
1334   case EFI_EXT_SCSI_STATUS_HOST_ADAPTER_TIMEOUT_COMMAND:
1335     return EFI_TIMEOUT;
1336
1337   case EFI_EXT_SCSI_STATUS_HOST_ADAPTER_MESSAGE_REJECT:
1338   case EFI_EXT_SCSI_STATUS_HOST_ADAPTER_PARITY_ERROR:
1339   case EFI_EXT_SCSI_STATUS_HOST_ADAPTER_REQUEST_SENSE_FAILED:
1340   case EFI_EXT_SCSI_STATUS_HOST_ADAPTER_DATA_OVERRUN_UNDERRUN:
1341   case EFI_EXT_SCSI_STATUS_HOST_ADAPTER_BUS_RESET:
1342     return EFI_NOT_READY;
1343
1344   case EFI_EXT_SCSI_STATUS_HOST_ADAPTER_BUS_FREE:
1345   case EFI_EXT_SCSI_STATUS_HOST_ADAPTER_PHASE_ERROR:
1346     return EFI_DEVICE_ERROR;
1347
1348   default:
1349     return EFI_SUCCESS;
1350   }
1351 }
1352
1353
1354 /**
1355   Check the target status and re-interpret it in EFI_STATUS.
1356
1357   @param  TargetStatus  Target status
1358
1359   @retval EFI_NOT_READY       Device is NOT ready.
1360   @retval EFI_DEVICE_ERROR
1361   @retval EFI_SUCCESS
1362
1363 **/
1364 EFI_STATUS
1365 CheckTargetStatus (
1366   IN  UINT8   TargetStatus
1367   )
1368 {
1369   switch (TargetStatus) {
1370   case EFI_EXT_SCSI_STATUS_TARGET_GOOD:
1371   case EFI_EXT_SCSI_STATUS_TARGET_CHECK_CONDITION:
1372   case EFI_EXT_SCSI_STATUS_TARGET_CONDITION_MET:
1373     return EFI_SUCCESS;
1374
1375   case EFI_EXT_SCSI_STATUS_TARGET_INTERMEDIATE:
1376   case EFI_EXT_SCSI_STATUS_TARGET_INTERMEDIATE_CONDITION_MET:
1377   case EFI_EXT_SCSI_STATUS_TARGET_BUSY:
1378   case EFI_EXT_SCSI_STATUS_TARGET_TASK_SET_FULL:
1379     return EFI_NOT_READY;
1380
1381   case EFI_EXT_SCSI_STATUS_TARGET_RESERVATION_CONFLICT:
1382     return EFI_DEVICE_ERROR;
1383     break;
1384
1385   default:
1386     return EFI_SUCCESS;
1387   }
1388 }
1389
1390
1391 /**
1392   Retrieve all sense keys from the device.
1393
1394   When encountering error during the process, if retrieve sense keys before
1395   error encountered, it returns the sense keys with return status set to EFI_SUCCESS,
1396   and NeedRetry set to FALSE; otherwize, return the proper return status.
1397
1398   @param  ScsiDiskDevice     The pointer of SCSI_DISK_DEV
1399   @param  NeedRetry          The pointer of flag indicates if need a retry
1400   @param  SenseDataArray     The pointer of an array of sense data
1401   @param  NumberOfSenseKeys  The number of sense key
1402   @param  AskResetIfError    The flag indicates if need reset when error occurs
1403
1404   @retval EFI_DEVICE_ERROR   Indicates that error occurs
1405   @retval EFI_SUCCESS        Successfully to request sense key
1406
1407 **/
1408 EFI_STATUS
1409 ScsiDiskRequestSenseKeys (
1410   IN  OUT  SCSI_DISK_DEV           *ScsiDiskDevice,
1411       OUT  BOOLEAN                 *NeedRetry,
1412       OUT  EFI_SCSI_SENSE_DATA     **SenseDataArray,
1413       OUT  UINTN                   *NumberOfSenseKeys,
1414   IN       BOOLEAN                 AskResetIfError
1415   )
1416 {
1417   EFI_SCSI_SENSE_DATA *PtrSenseData;
1418   UINT8               SenseDataLength;
1419   BOOLEAN             SenseReq;
1420   EFI_STATUS          Status;
1421   EFI_STATUS          FallStatus;
1422   UINT8               HostAdapterStatus;
1423   UINT8               TargetStatus;
1424
1425   FallStatus      = EFI_SUCCESS;
1426   SenseDataLength = sizeof (EFI_SCSI_SENSE_DATA);
1427
1428   ZeroMem (
1429     ScsiDiskDevice->SenseData,
1430     sizeof (EFI_SCSI_SENSE_DATA) * (ScsiDiskDevice->SenseDataNumber)
1431     );
1432
1433   *NumberOfSenseKeys  = 0;
1434   *SenseDataArray     = ScsiDiskDevice->SenseData;
1435   PtrSenseData        = ScsiDiskDevice->SenseData;
1436
1437   for (SenseReq = TRUE; SenseReq;) {
1438     Status = ScsiRequestSenseCommand (
1439               ScsiDiskDevice->ScsiIo,
1440               EFI_TIMER_PERIOD_SECONDS (2),
1441               PtrSenseData,
1442               &SenseDataLength,
1443               &HostAdapterStatus,
1444               &TargetStatus
1445               );
1446      if ((Status == EFI_SUCCESS) || (Status == EFI_WARN_BUFFER_TOO_SMALL)) {
1447         FallStatus = EFI_SUCCESS;
1448
1449      } else if ((Status == EFI_TIMEOUT) || (Status == EFI_NOT_READY)) {
1450        *NeedRetry  = TRUE;
1451        FallStatus  = EFI_DEVICE_ERROR;
1452
1453      } else if ((Status == EFI_INVALID_PARAMETER) || (Status == EFI_UNSUPPORTED)) {
1454        *NeedRetry  = FALSE;
1455        FallStatus  = EFI_DEVICE_ERROR;
1456
1457      } else if (Status == EFI_DEVICE_ERROR) {
1458         if (AskResetIfError) {
1459           ScsiDiskDevice->ScsiIo->ResetDevice (ScsiDiskDevice->ScsiIo);
1460         }
1461
1462         FallStatus = EFI_DEVICE_ERROR;
1463     }
1464
1465     if (EFI_ERROR (FallStatus)) {
1466       if (*NumberOfSenseKeys != 0) {
1467         *NeedRetry = FALSE;
1468         return EFI_SUCCESS;
1469       } else {
1470         return EFI_DEVICE_ERROR;
1471       }
1472     }
1473
1474     (*NumberOfSenseKeys) += 1;
1475
1476     //
1477     // no more sense key or number of sense keys exceeds predefined,
1478     // skip the loop.
1479     //
1480     if ((PtrSenseData->Sense_Key == EFI_SCSI_SK_NO_SENSE) ||
1481         (*NumberOfSenseKeys == ScsiDiskDevice->SenseDataNumber)) {
1482       SenseReq = FALSE;
1483     }
1484     PtrSenseData += 1;
1485   }
1486   return EFI_SUCCESS;
1487 }
1488
1489
1490 /**
1491   Get information from media read capacity command.
1492
1493   @param  ScsiDiskDevice  The pointer of SCSI_DISK_DEV
1494   @param  Capacity10      The pointer of EFI_SCSI_DISK_CAPACITY_DATA
1495   @param  Capacity16      The pointer of EFI_SCSI_DISK_CAPACITY_DATA16
1496
1497 **/
1498 VOID
1499 GetMediaInfo (
1500   IN OUT SCSI_DISK_DEV                  *ScsiDiskDevice,
1501   IN     EFI_SCSI_DISK_CAPACITY_DATA    *Capacity10,
1502   IN     EFI_SCSI_DISK_CAPACITY_DATA16  *Capacity16
1503   )
1504 {
1505   UINT8       ScsiVersion;
1506   UINT8       *Ptr;
1507
1508   ScsiVersion    = (UINT8)(ScsiDiskDevice->InquiryData.Version & 0x03);
1509   ScsiDiskDevice->BlkIo.Media->LowestAlignedLba               = 0;
1510   ScsiDiskDevice->BlkIo.Media->LogicalBlocksPerPhysicalBlock  = 1;
1511
1512
1513   if (ScsiVersion < SCSI_COMMAND_VERSION_3) {
1514     ScsiDiskDevice->BlkIo.Media->LastBlock =  (Capacity10->LastLba3 << 24) |
1515                                               (Capacity10->LastLba2 << 16) |
1516                                               (Capacity10->LastLba1 << 8)  |
1517                                                Capacity10->LastLba0;
1518
1519     ScsiDiskDevice->BlkIo.Media->BlockSize = (Capacity10->BlockSize3 << 24) |
1520                                              (Capacity10->BlockSize2 << 16) |
1521                                              (Capacity10->BlockSize1 << 8)  |
1522                                               Capacity10->BlockSize0;
1523     ScsiDiskDevice->BlkIo.Revision = EFI_BLOCK_IO_PROTOCOL_REVISION;
1524   } else {
1525
1526     Ptr = (UINT8*)&ScsiDiskDevice->BlkIo.Media->LastBlock;
1527     *Ptr++ = Capacity16->LastLba0;
1528     *Ptr++ = Capacity16->LastLba1;
1529     *Ptr++ = Capacity16->LastLba2;
1530     *Ptr++ = Capacity16->LastLba3;
1531     *Ptr++ = Capacity16->LastLba4;
1532     *Ptr++ = Capacity16->LastLba5;
1533     *Ptr++ = Capacity16->LastLba6;
1534     *Ptr   = Capacity16->LastLba7;
1535
1536     ScsiDiskDevice->BlkIo.Media->BlockSize = (Capacity16->BlockSize3 << 24) |
1537                                              (Capacity16->BlockSize2 << 16) |
1538                                              (Capacity16->BlockSize1 << 8)  |
1539                                               Capacity16->BlockSize0;
1540
1541     ScsiDiskDevice->BlkIo.Media->LowestAlignedLba = (Capacity16->LowestAlignLogic2 << 8)|(Capacity16->LowestAlignLogic1);
1542     ScsiDiskDevice->BlkIo.Media->LogicalBlocksPerPhysicalBlock  = Capacity16->LogicPerPhysical;
1543     ScsiDiskDevice->BlkIo.Revision = EFI_BLOCK_IO_PROTOCOL_REVISION2;
1544   }
1545
1546
1547   ScsiDiskDevice->BlkIo.Media->MediaPresent = TRUE;
1548
1549   if (ScsiDiskDevice->DeviceType == EFI_SCSI_TYPE_DISK) {
1550     ScsiDiskDevice->BlkIo.Media->BlockSize = 0x200;
1551   }
1552
1553   if (ScsiDiskDevice->DeviceType == EFI_SCSI_TYPE_CDROM) {
1554     ScsiDiskDevice->BlkIo.Media->BlockSize = 0x800;
1555   }
1556 }
1557
1558 /**
1559   Parse Inquiry data.
1560
1561   @param  ScsiDiskDevice  The pointer of SCSI_DISK_DEV
1562
1563 **/
1564 VOID
1565 ParseInquiryData (
1566   IN OUT SCSI_DISK_DEV   *ScsiDiskDevice
1567   )
1568 {
1569   ScsiDiskDevice->FixedDevice               = (BOOLEAN) ((ScsiDiskDevice->InquiryData.Rmb == 1) ? 0 : 1);
1570   ScsiDiskDevice->BlkIoMedia.RemovableMedia = (BOOLEAN) (!ScsiDiskDevice->FixedDevice);
1571 }
1572
1573 /**
1574   Read sector from SCSI Disk.
1575
1576   @param  ScsiDiskDevice  The pointer of SCSI_DISK_DEV
1577   @param  Buffer          The buffer to fill in the read out data
1578   @param  Lba             Logic block address
1579   @param  NumberOfBlocks  The number of blocks to read
1580
1581   @retval EFI_DEVICE_ERROR  Indicates a device error.
1582   @retval EFI_SUCCESS       Operation is successful.
1583
1584 **/
1585 EFI_STATUS
1586 ScsiDiskReadSectors (
1587   IN   SCSI_DISK_DEV     *ScsiDiskDevice,
1588   OUT  VOID              *Buffer,
1589   IN   EFI_LBA           Lba,
1590   IN   UINTN             NumberOfBlocks
1591   )
1592 {
1593   UINTN               BlocksRemaining;
1594   UINT32              Lba32;
1595   UINT8               *PtrBuffer;
1596   UINT32              BlockSize;
1597   UINT32              ByteCount;
1598   UINT32              MaxBlock;
1599   UINT32              SectorCount;
1600   UINT64              Timeout;
1601   EFI_STATUS          Status;
1602   UINT8               Index;
1603   UINT8               MaxRetry;
1604   BOOLEAN             NeedRetry;
1605   EFI_SCSI_SENSE_DATA *SenseData;
1606   UINTN               NumberOfSenseKeys;
1607
1608   SenseData         = NULL;
1609   NumberOfSenseKeys = 0;
1610
1611   Status            = EFI_SUCCESS;
1612
1613   BlocksRemaining   = NumberOfBlocks;
1614   BlockSize         = ScsiDiskDevice->BlkIo.Media->BlockSize;
1615   //
1616   // limit the data bytes that can be transferred by one Read(10) Command
1617   //
1618   MaxBlock  = 65536;
1619
1620   PtrBuffer = Buffer;
1621   Lba32     = (UINT32) Lba;
1622
1623   while (BlocksRemaining > 0) {
1624
1625     if (BlocksRemaining <= MaxBlock) {
1626
1627       SectorCount = (UINT16) BlocksRemaining;
1628     } else {
1629
1630       SectorCount = MaxBlock;
1631     }
1632
1633     ByteCount = SectorCount * BlockSize;
1634     Timeout   = EFI_TIMER_PERIOD_SECONDS (2);
1635
1636     MaxRetry  = 2;
1637     for (Index = 0; Index < MaxRetry; Index++) {
1638
1639       Status = ScsiDiskRead10 (
1640                 ScsiDiskDevice,
1641                 &NeedRetry,
1642                 &SenseData,
1643                 &NumberOfSenseKeys,
1644                 Timeout,
1645                 PtrBuffer,
1646                 &ByteCount,
1647                 Lba32,
1648                 SectorCount
1649                 );
1650       if (!EFI_ERROR (Status)) {
1651         break;
1652       }
1653
1654       if (!NeedRetry) {
1655         return EFI_DEVICE_ERROR;
1656       }
1657
1658     }
1659
1660     if ((Index == MaxRetry) && (Status != EFI_SUCCESS)) {
1661       return EFI_DEVICE_ERROR;
1662     }
1663
1664     //
1665     // actual transferred sectors
1666     //
1667     SectorCount = ByteCount / BlockSize;
1668
1669     Lba32 += SectorCount;
1670     PtrBuffer = PtrBuffer + SectorCount * BlockSize;
1671     BlocksRemaining -= SectorCount;
1672   }
1673
1674   return EFI_SUCCESS;
1675 }
1676
1677 /**
1678   Write sector to SCSI Disk.
1679
1680   @param  ScsiDiskDevice  The pointer of SCSI_DISK_DEV
1681   @param  Buffer          The buffer of data to be written into SCSI Disk
1682   @param  Lba             Logic block address
1683   @param  NumberOfBlocks  The number of blocks to read
1684
1685   @retval EFI_DEVICE_ERROR  Indicates a device error.
1686   @retval EFI_SUCCESS       Operation is successful.
1687
1688 **/
1689 EFI_STATUS
1690 ScsiDiskWriteSectors (
1691   IN  SCSI_DISK_DEV     *ScsiDiskDevice,
1692   IN  VOID              *Buffer,
1693   IN  EFI_LBA           Lba,
1694   IN  UINTN             NumberOfBlocks
1695   )
1696 {
1697   UINTN               BlocksRemaining;
1698   UINT32              Lba32;
1699   UINT8               *PtrBuffer;
1700   UINT32              BlockSize;
1701   UINT32              ByteCount;
1702   UINT32              MaxBlock;
1703   UINT32              SectorCount;
1704   UINT64              Timeout;
1705   EFI_STATUS          Status;
1706   UINT8               Index;
1707   UINT8               MaxRetry;
1708   BOOLEAN             NeedRetry;
1709   EFI_SCSI_SENSE_DATA *SenseData;
1710   UINTN               NumberOfSenseKeys;
1711
1712   SenseData         = NULL;
1713   NumberOfSenseKeys = 0;
1714
1715   Status            = EFI_SUCCESS;
1716
1717   BlocksRemaining   = NumberOfBlocks;
1718   BlockSize         = ScsiDiskDevice->BlkIo.Media->BlockSize;
1719   //
1720   // limit the data bytes that can be transferred by one Write(10) Command
1721   //
1722   MaxBlock  = 65536;
1723
1724   PtrBuffer = Buffer;
1725   Lba32     = (UINT32) Lba;
1726
1727   while (BlocksRemaining > 0) {
1728
1729     if (BlocksRemaining <= MaxBlock) {
1730
1731       SectorCount = (UINT16) BlocksRemaining;
1732     } else {
1733
1734       SectorCount = MaxBlock;
1735     }
1736
1737     ByteCount = SectorCount * BlockSize;
1738     Timeout   = EFI_TIMER_PERIOD_SECONDS (2);
1739     MaxRetry  = 2;
1740     for (Index = 0; Index < MaxRetry; Index++) {
1741       Status = ScsiDiskWrite10 (
1742                 ScsiDiskDevice,
1743                 &NeedRetry,
1744                 &SenseData,
1745                 &NumberOfSenseKeys,
1746                 Timeout,
1747                 PtrBuffer,
1748                 &ByteCount,
1749                 Lba32,
1750                 SectorCount
1751                 );
1752       if (!EFI_ERROR (Status)) {
1753         break;
1754       }
1755
1756       if (!NeedRetry) {
1757         return EFI_DEVICE_ERROR;
1758       }
1759     }
1760
1761     if ((Index == MaxRetry) && (Status != EFI_SUCCESS)) {
1762       return EFI_DEVICE_ERROR;
1763     }
1764     //
1765     // actual transferred sectors
1766     //
1767     SectorCount = ByteCount / BlockSize;
1768
1769     Lba32 += SectorCount;
1770     PtrBuffer = PtrBuffer + SectorCount * BlockSize;
1771     BlocksRemaining -= SectorCount;
1772   }
1773
1774   return EFI_SUCCESS;
1775 }
1776
1777
1778 /**
1779   Submit Read command.
1780
1781   @param  ScsiDiskDevice     The pointer of ScsiDiskDevice
1782   @param  NeedRetry          The pointer of flag indicates if needs retry if error happens
1783   @param  SenseDataArray     NOT used yet in this function
1784   @param  NumberOfSenseKeys  The number of sense key
1785   @param  Timeout            The time to complete the command
1786   @param  DataBuffer         The buffer to fill with the read out data
1787   @param  DataLength         The length of buffer
1788   @param  StartLba           The start logic block address
1789   @param  SectorSize         The size of sector
1790
1791   @return  EFI_STATUS is returned by calling ScsiRead10Command().
1792 **/
1793 EFI_STATUS
1794 ScsiDiskRead10 (
1795   IN     SCSI_DISK_DEV         *ScsiDiskDevice,
1796      OUT BOOLEAN               *NeedRetry,
1797      OUT EFI_SCSI_SENSE_DATA   **SenseDataArray,   OPTIONAL
1798      OUT UINTN                 *NumberOfSenseKeys,
1799   IN     UINT64                Timeout,
1800      OUT UINT8                 *DataBuffer,
1801   IN OUT UINT32                *DataLength,
1802   IN     UINT32                StartLba,
1803   IN     UINT32                SectorSize
1804   )
1805 {
1806   UINT8       SenseDataLength;
1807   EFI_STATUS  Status;
1808   UINT8       HostAdapterStatus;
1809   UINT8       TargetStatus;
1810
1811   *NeedRetry          = FALSE;
1812   *NumberOfSenseKeys  = 0;
1813   SenseDataLength     = 0;
1814   Status = ScsiRead10Command (
1815             ScsiDiskDevice->ScsiIo,
1816             Timeout,
1817             NULL,
1818             &SenseDataLength,
1819             &HostAdapterStatus,
1820             &TargetStatus,
1821             DataBuffer,
1822             DataLength,
1823             StartLba,
1824             SectorSize
1825             );
1826   return Status;
1827 }
1828
1829
1830 /**
1831   Submit Write Command.
1832
1833   @param  ScsiDiskDevice     The pointer of ScsiDiskDevice
1834   @param  NeedRetry          The pointer of flag indicates if needs retry if error happens
1835   @param  SenseDataArray     NOT used yet in this function
1836   @param  NumberOfSenseKeys  The number of sense key
1837   @param  Timeout            The time to complete the command
1838   @param  DataBuffer         The buffer to fill with the read out data
1839   @param  DataLength         The length of buffer
1840   @param  StartLba           The start logic block address
1841   @param  SectorSize         The size of sector
1842
1843   @return  EFI_STATUS is returned by calling ScsiWrite10Command().
1844
1845 **/
1846 EFI_STATUS
1847 ScsiDiskWrite10 (
1848   IN     SCSI_DISK_DEV         *ScsiDiskDevice,
1849      OUT BOOLEAN               *NeedRetry,
1850      OUT EFI_SCSI_SENSE_DATA   **SenseDataArray,   OPTIONAL
1851      OUT UINTN                 *NumberOfSenseKeys,
1852   IN     UINT64                Timeout,
1853   IN     UINT8                 *DataBuffer,
1854   IN OUT UINT32                *DataLength,
1855   IN     UINT32                StartLba,
1856   IN     UINT32                SectorSize
1857   )
1858 {
1859   EFI_STATUS  Status;
1860   UINT8       SenseDataLength;
1861   UINT8       HostAdapterStatus;
1862   UINT8       TargetStatus;
1863
1864   *NeedRetry          = FALSE;
1865   *NumberOfSenseKeys  = 0;
1866   SenseDataLength     = 0;
1867   Status = ScsiWrite10Command (
1868             ScsiDiskDevice->ScsiIo,
1869             Timeout,
1870             NULL,
1871             &SenseDataLength,
1872             &HostAdapterStatus,
1873             &TargetStatus,
1874             DataBuffer,
1875             DataLength,
1876             StartLba,
1877             SectorSize
1878             );
1879   return Status;
1880 }
1881
1882
1883 /**
1884   Check sense key to find if media presents.
1885
1886   @param  SenseData   The pointer of EFI_SCSI_SENSE_DATA
1887   @param  SenseCounts The number of sense key
1888
1889   @retval TRUE    NOT any media
1890   @retval FALSE   Media presents
1891 **/
1892 BOOLEAN
1893 ScsiDiskIsNoMedia (
1894   IN  EFI_SCSI_SENSE_DATA   *SenseData,
1895   IN  UINTN                 SenseCounts
1896   )
1897 {
1898   EFI_SCSI_SENSE_DATA *SensePtr;
1899   UINTN               Index;
1900   BOOLEAN             IsNoMedia;
1901
1902   IsNoMedia = FALSE;
1903   SensePtr  = SenseData;
1904
1905   for (Index = 0; Index < SenseCounts; Index++) {
1906     //
1907     // Sense Key is EFI_SCSI_SK_NOT_READY (0x2),
1908     // Additional Sense Code is ASC_NO_MEDIA (0x3A)
1909     //
1910     if ((SensePtr->Sense_Key == EFI_SCSI_SK_NOT_READY) &&
1911         (SensePtr->Addnl_Sense_Code == EFI_SCSI_ASC_NO_MEDIA)) {
1912       IsNoMedia = TRUE;
1913     }
1914     SensePtr++;
1915   }
1916
1917   return IsNoMedia;
1918 }
1919
1920
1921 /**
1922   Parse sense key.
1923
1924   @param  SenseData    The pointer of EFI_SCSI_SENSE_DATA
1925   @param  SenseCounts  The number of sense key
1926
1927   @retval TRUE   Error
1928   @retval FALSE  NOT error
1929
1930 **/
1931 BOOLEAN
1932 ScsiDiskIsMediaError (
1933   IN  EFI_SCSI_SENSE_DATA   *SenseData,
1934   IN  UINTN                 SenseCounts
1935   )
1936 {
1937   EFI_SCSI_SENSE_DATA *SensePtr;
1938   UINTN               Index;
1939   BOOLEAN             IsError;
1940
1941   IsError   = FALSE;
1942   SensePtr  = SenseData;
1943
1944   for (Index = 0; Index < SenseCounts; Index++) {
1945
1946     switch (SensePtr->Sense_Key) {
1947
1948     case EFI_SCSI_SK_MEDIUM_ERROR:
1949       //
1950       // Sense Key is EFI_SCSI_SK_MEDIUM_ERROR (0x3)
1951       //
1952       switch (SensePtr->Addnl_Sense_Code) {
1953
1954       //
1955       // fall through
1956       //
1957       case EFI_SCSI_ASC_MEDIA_ERR1:
1958
1959       //
1960       // fall through
1961       //
1962       case EFI_SCSI_ASC_MEDIA_ERR2:
1963
1964       //
1965       // fall through
1966       //
1967       case EFI_SCSI_ASC_MEDIA_ERR3:
1968       case EFI_SCSI_ASC_MEDIA_ERR4:
1969         IsError = TRUE;
1970         break;
1971
1972       default:
1973         break;
1974       }
1975
1976       break;
1977
1978     case EFI_SCSI_SK_NOT_READY:
1979       //
1980       // Sense Key is EFI_SCSI_SK_NOT_READY (0x2)
1981       //
1982       switch (SensePtr->Addnl_Sense_Code) {
1983       //
1984       // Additional Sense Code is ASC_MEDIA_UPSIDE_DOWN (0x6)
1985       //
1986       case EFI_SCSI_ASC_MEDIA_UPSIDE_DOWN:
1987         IsError = TRUE;
1988         break;
1989
1990       default:
1991         break;
1992       }
1993       break;
1994
1995     default:
1996       break;
1997     }
1998
1999     SensePtr++;
2000   }
2001
2002   return IsError;
2003 }
2004
2005
2006 /**
2007   Check sense key to find if hardware error happens.
2008
2009   @param  SenseData     The pointer of EFI_SCSI_SENSE_DATA
2010   @param  SenseCounts   The number of sense key
2011
2012   @retval TRUE  Hardware error exits.
2013   @retval FALSE NO error.
2014
2015 **/
2016 BOOLEAN
2017 ScsiDiskIsHardwareError (
2018   IN  EFI_SCSI_SENSE_DATA   *SenseData,
2019   IN  UINTN                 SenseCounts
2020   )
2021 {
2022   EFI_SCSI_SENSE_DATA *SensePtr;
2023   UINTN               Index;
2024   BOOLEAN             IsError;
2025
2026   IsError   = FALSE;
2027   SensePtr  = SenseData;
2028
2029   for (Index = 0; Index < SenseCounts; Index++) {
2030
2031     //
2032     // Sense Key is EFI_SCSI_SK_HARDWARE_ERROR (0x4)
2033     //
2034     if (SensePtr->Sense_Key == EFI_SCSI_SK_HARDWARE_ERROR) {
2035       IsError = TRUE;
2036     }
2037
2038     SensePtr++;
2039   }
2040
2041   return IsError;
2042 }
2043
2044
2045 /**
2046   Check sense key to find if media has changed.
2047
2048   @param  SenseData    The pointer of EFI_SCSI_SENSE_DATA
2049   @param  SenseCounts  The number of sense key
2050
2051   @retval TRUE   Media is changed.
2052   @retval FALSE  Media is NOT changed.
2053 **/
2054 BOOLEAN
2055 ScsiDiskIsMediaChange (
2056   IN  EFI_SCSI_SENSE_DATA   *SenseData,
2057   IN  UINTN                 SenseCounts
2058   )
2059 {
2060   EFI_SCSI_SENSE_DATA *SensePtr;
2061   UINTN               Index;
2062   BOOLEAN             IsMediaChanged;
2063
2064   IsMediaChanged  = FALSE;
2065   SensePtr        = SenseData;
2066
2067   for (Index = 0; Index < SenseCounts; Index++) {
2068     //
2069     // Sense Key is EFI_SCSI_SK_UNIT_ATTENTION (0x6),
2070     // Additional sense code is EFI_SCSI_ASC_MEDIA_CHANGE (0x28)
2071     //
2072     if ((SensePtr->Sense_Key == EFI_SCSI_SK_UNIT_ATTENTION) &&
2073         (SensePtr->Addnl_Sense_Code == EFI_SCSI_ASC_MEDIA_CHANGE)) {
2074       IsMediaChanged = TRUE;
2075     }
2076
2077     SensePtr++;
2078   }
2079
2080   return IsMediaChanged;
2081 }
2082
2083 /**
2084   Check sense key to find if reset happens.
2085
2086   @param  SenseData    The pointer of EFI_SCSI_SENSE_DATA
2087   @param  SenseCounts  The number of sense key
2088
2089   @retval TRUE  It is reset before.
2090   @retval FALSE It is NOT reset before.
2091
2092 **/
2093 BOOLEAN
2094 ScsiDiskIsResetBefore (
2095   IN  EFI_SCSI_SENSE_DATA   *SenseData,
2096   IN  UINTN                 SenseCounts
2097   )
2098 {
2099   EFI_SCSI_SENSE_DATA *SensePtr;
2100   UINTN               Index;
2101   BOOLEAN             IsResetBefore;
2102
2103   IsResetBefore = FALSE;
2104   SensePtr      = SenseData;
2105
2106   for (Index = 0; Index < SenseCounts; Index++) {
2107
2108     //
2109     // Sense Key is EFI_SCSI_SK_UNIT_ATTENTION (0x6)
2110     // Additional Sense Code is EFI_SCSI_ASC_RESET (0x29)
2111     //
2112     if ((SensePtr->Sense_Key == EFI_SCSI_SK_UNIT_ATTENTION) &&
2113         (SensePtr->Addnl_Sense_Code == EFI_SCSI_ASC_RESET)) {
2114       IsResetBefore = TRUE;
2115     }
2116
2117     SensePtr++;
2118   }
2119
2120   return IsResetBefore;
2121 }
2122
2123 /**
2124   Check sense key to find if the drive is ready.
2125
2126   @param  SenseData    The pointer of EFI_SCSI_SENSE_DATA
2127   @param  SenseCounts  The number of sense key
2128   @param  RetryLater   The flag means if need a retry
2129
2130   @retval TRUE  Drive is ready.
2131   @retval FALSE Drive is NOT ready.
2132
2133 **/
2134 BOOLEAN
2135 ScsiDiskIsDriveReady (
2136   IN  EFI_SCSI_SENSE_DATA   *SenseData,
2137   IN  UINTN                 SenseCounts,
2138   OUT BOOLEAN               *RetryLater
2139   )
2140 {
2141   EFI_SCSI_SENSE_DATA *SensePtr;
2142   UINTN               Index;
2143   BOOLEAN             IsReady;
2144
2145   IsReady     = TRUE;
2146   *RetryLater = FALSE;
2147   SensePtr    = SenseData;
2148
2149   for (Index = 0; Index < SenseCounts; Index++) {
2150
2151     switch (SensePtr->Sense_Key) {
2152
2153     case EFI_SCSI_SK_NOT_READY:
2154       //
2155       // Sense Key is EFI_SCSI_SK_NOT_READY (0x2)
2156       //
2157       switch (SensePtr->Addnl_Sense_Code) {
2158       case EFI_SCSI_ASC_NOT_READY:
2159         //
2160         // Additional Sense Code is EFI_SCSI_ASC_NOT_READY (0x4)
2161         //
2162         switch (SensePtr->Addnl_Sense_Code_Qualifier) {
2163         case EFI_SCSI_ASCQ_IN_PROGRESS:
2164           //
2165           // Additional Sense Code Qualifier is
2166           // EFI_SCSI_ASCQ_IN_PROGRESS (0x1)
2167           //
2168           IsReady     = FALSE;
2169           *RetryLater = TRUE;
2170           break;
2171
2172         default:
2173           IsReady     = FALSE;
2174           *RetryLater = FALSE;
2175           break;
2176         }
2177         break;
2178
2179       default:
2180         break;
2181       }
2182       break;
2183
2184     default:
2185       break;
2186     }
2187
2188     SensePtr++;
2189   }
2190
2191   return IsReady;
2192 }
2193
2194 /**
2195   Check sense key to find if it has sense key.
2196
2197   @param  SenseData   - The pointer of EFI_SCSI_SENSE_DATA
2198   @param  SenseCounts - The number of sense key
2199
2200   @retval TRUE  It has sense key.
2201   @retval FALSE It has NOT any sense key.
2202
2203 **/
2204 BOOLEAN
2205 ScsiDiskHaveSenseKey (
2206   IN  EFI_SCSI_SENSE_DATA   *SenseData,
2207   IN  UINTN                 SenseCounts
2208   )
2209 {
2210   EFI_SCSI_SENSE_DATA *SensePtr;
2211   UINTN               Index;
2212   BOOLEAN             HaveSenseKey;
2213
2214   if (SenseCounts == 0) {
2215     HaveSenseKey = FALSE;
2216   } else {
2217     HaveSenseKey = TRUE;
2218   }
2219
2220   SensePtr = SenseData;
2221
2222   for (Index = 0; Index < SenseCounts; Index++) {
2223
2224     //
2225     // Sense Key is SK_NO_SENSE (0x0)
2226     //
2227     if ((SensePtr->Sense_Key == EFI_SCSI_SK_NO_SENSE) &&
2228         (Index == 0)) {
2229       HaveSenseKey = FALSE;
2230     }
2231
2232     SensePtr++;
2233   }
2234
2235   return HaveSenseKey;
2236 }
2237
2238 /**
2239   Release resource about disk device.
2240
2241   @param  ScsiDiskDevice  The pointer of SCSI_DISK_DEV
2242
2243 **/
2244 VOID
2245 ReleaseScsiDiskDeviceResources (
2246   IN  SCSI_DISK_DEV   *ScsiDiskDevice
2247   )
2248 {
2249   if (ScsiDiskDevice == NULL) {
2250     return ;
2251   }
2252
2253   if (ScsiDiskDevice->SenseData != NULL) {
2254     FreePool (ScsiDiskDevice->SenseData);
2255     ScsiDiskDevice->SenseData = NULL;
2256   }
2257
2258   if (ScsiDiskDevice->ControllerNameTable != NULL) {
2259     FreeUnicodeStringTable (ScsiDiskDevice->ControllerNameTable);
2260     ScsiDiskDevice->ControllerNameTable = NULL;
2261   }
2262
2263   FreePool (ScsiDiskDevice);
2264
2265   ScsiDiskDevice = NULL;
2266 }
2267
2268 /**
2269   Determine if Block Io should be produced.
2270
2271
2272   @param  ChildHandle  Child Handle to retrieve Parent information.
2273
2274   @retval  TRUE    Should produce Block Io.
2275   @retval  FALSE   Should not produce Block Io.
2276
2277 **/
2278 BOOLEAN
2279 DetermineInstallBlockIo (
2280   IN  EFI_HANDLE      ChildHandle
2281   )
2282 {
2283   EFI_SCSI_PASS_THRU_PROTOCOL           *ScsiPassThru;
2284   EFI_EXT_SCSI_PASS_THRU_PROTOCOL       *ExtScsiPassThru;
2285
2286   //
2287   // Firstly, check if ExtScsiPassThru Protocol parent handle exists. If existence,
2288   // check its attribute, logic or physical.
2289   //
2290   ExtScsiPassThru = (EFI_EXT_SCSI_PASS_THRU_PROTOCOL *)GetParentProtocol (&gEfiExtScsiPassThruProtocolGuid, ChildHandle);
2291   if (ExtScsiPassThru != NULL) {
2292     if ((ExtScsiPassThru->Mode->Attributes & EFI_SCSI_PASS_THRU_ATTRIBUTES_LOGICAL) != 0) {
2293       return TRUE;
2294     }
2295   }
2296
2297   //
2298   // Secondly, check if ScsiPassThru Protocol parent handle exists. If existence,
2299   // check its attribute, logic or physical.
2300   //
2301   ScsiPassThru = (EFI_SCSI_PASS_THRU_PROTOCOL *)GetParentProtocol (&gEfiScsiPassThruProtocolGuid, ChildHandle);
2302   if (ScsiPassThru != NULL) {
2303     if ((ScsiPassThru->Mode->Attributes & EFI_SCSI_PASS_THRU_ATTRIBUTES_LOGICAL) != 0) {
2304       return TRUE;
2305     }
2306   }
2307
2308   return FALSE;
2309 }
2310
2311 /**
2312   Search protocol database and check to see if the protocol
2313   specified by ProtocolGuid is present on a ControllerHandle and opened by
2314   ChildHandle with an attribute of EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER.
2315   If the ControllerHandle is found, then the protocol specified by ProtocolGuid
2316   will be opened on it.
2317
2318
2319   @param  ProtocolGuid   ProtocolGuid pointer.
2320   @param  ChildHandle    Child Handle to retrieve Parent information.
2321
2322 **/
2323 VOID *
2324 EFIAPI
2325 GetParentProtocol (
2326   IN  EFI_GUID                          *ProtocolGuid,
2327   IN  EFI_HANDLE                        ChildHandle
2328   )
2329 {
2330   UINTN                                 Index;
2331   UINTN                                 HandleCount;
2332   VOID                                  *Interface;
2333   EFI_STATUS                            Status;
2334   EFI_HANDLE                            *HandleBuffer;
2335
2336   //
2337   // Retrieve the list of all handles from the handle database
2338   //
2339   Status = gBS->LocateHandleBuffer (
2340                   ByProtocol,
2341                   ProtocolGuid,
2342                   NULL,
2343                   &HandleCount,
2344                   &HandleBuffer
2345                   );
2346
2347   if (EFI_ERROR (Status)) {
2348     return NULL;
2349   }
2350
2351   //
2352   // Iterate to find who is parent handle that is opened with ProtocolGuid by ChildHandle
2353   //
2354   for (Index = 0; Index < HandleCount; Index++) {
2355     Status = EfiTestChildHandle (HandleBuffer[Index], ChildHandle, ProtocolGuid);
2356     if (!EFI_ERROR (Status)) {
2357       Status = gBS->HandleProtocol (HandleBuffer[Index], ProtocolGuid, (VOID **)&Interface);
2358       if (!EFI_ERROR (Status)) {
2359         gBS->FreePool (HandleBuffer);
2360         return Interface;
2361       }
2362     }
2363   }
2364
2365   gBS->FreePool (HandleBuffer);
2366   return NULL;
2367 }
2368
2369 /**
2370   Provides inquiry information for the controller type.
2371
2372   This function is used by the IDE bus driver to get inquiry data.  Data format
2373   of Identify data is defined by the Interface GUID.
2374
2375   @param[in]      This              Pointer to the EFI_DISK_INFO_PROTOCOL instance.
2376   @param[in, out] InquiryData       Pointer to a buffer for the inquiry data.
2377   @param[in, out] InquiryDataSize   Pointer to the value for the inquiry data size.
2378
2379   @retval EFI_SUCCESS            The command was accepted without any errors.
2380   @retval EFI_NOT_FOUND          Device does not support this data class
2381   @retval EFI_DEVICE_ERROR       Error reading InquiryData from device
2382   @retval EFI_BUFFER_TOO_SMALL   InquiryDataSize not big enough
2383
2384 **/
2385 EFI_STATUS
2386 EFIAPI
2387 ScsiDiskInfoInquiry (
2388   IN     EFI_DISK_INFO_PROTOCOL   *This,
2389   IN OUT VOID                     *InquiryData,
2390   IN OUT UINT32                   *InquiryDataSize
2391   )
2392 {
2393   EFI_STATUS      Status;
2394   SCSI_DISK_DEV   *ScsiDiskDevice;
2395
2396   ScsiDiskDevice  = SCSI_DISK_DEV_FROM_DISKINFO (This);
2397
2398   Status = EFI_BUFFER_TOO_SMALL;
2399   if (*InquiryDataSize >= sizeof (ScsiDiskDevice->InquiryData)) {
2400     Status = EFI_SUCCESS;
2401     CopyMem (InquiryData, &ScsiDiskDevice->InquiryData, sizeof (ScsiDiskDevice->InquiryData));
2402   }
2403   *InquiryDataSize = sizeof (ScsiDiskDevice->InquiryData);
2404   return Status;
2405 }
2406
2407
2408 /**
2409   Provides identify information for the controller type.
2410
2411   This function is used by the IDE bus driver to get identify data.  Data format
2412   of Identify data is defined by the Interface GUID.
2413
2414   @param[in]      This              Pointer to the EFI_DISK_INFO_PROTOCOL
2415                                     instance.
2416   @param[in, out] IdentifyData      Pointer to a buffer for the identify data.
2417   @param[in, out] IdentifyDataSize  Pointer to the value for the identify data
2418                                     size.
2419
2420   @retval EFI_SUCCESS            The command was accepted without any errors.
2421   @retval EFI_NOT_FOUND          Device does not support this data class
2422   @retval EFI_DEVICE_ERROR       Error reading IdentifyData from device
2423   @retval EFI_BUFFER_TOO_SMALL   IdentifyDataSize not big enough
2424
2425 **/
2426 EFI_STATUS
2427 EFIAPI
2428 ScsiDiskInfoIdentify (
2429   IN     EFI_DISK_INFO_PROTOCOL   *This,
2430   IN OUT VOID                     *IdentifyData,
2431   IN OUT UINT32                   *IdentifyDataSize
2432   )
2433 {
2434   EFI_STATUS      Status;
2435   SCSI_DISK_DEV   *ScsiDiskDevice;
2436
2437   if (CompareGuid (&This->Interface, &gEfiDiskInfoScsiInterfaceGuid)) {
2438     //
2439     // Physical SCSI bus does not support this data class.
2440     //
2441     return EFI_NOT_FOUND;
2442   }
2443
2444   ScsiDiskDevice  = SCSI_DISK_DEV_FROM_DISKINFO (This);
2445
2446   Status = EFI_BUFFER_TOO_SMALL;
2447   if (*IdentifyDataSize >= sizeof (ScsiDiskDevice->IdentifyData)) {
2448     Status = EFI_SUCCESS;
2449     CopyMem (IdentifyData, &ScsiDiskDevice->IdentifyData, sizeof (ScsiDiskDevice->IdentifyData));
2450   }
2451   *IdentifyDataSize = sizeof (ScsiDiskDevice->IdentifyData);
2452   return Status;
2453 }
2454
2455 /**
2456   Provides sense data information for the controller type.
2457
2458   This function is used by the IDE bus driver to get sense data.
2459   Data format of Sense data is defined by the Interface GUID.
2460
2461   @param[in]      This              Pointer to the EFI_DISK_INFO_PROTOCOL instance.
2462   @param[in, out] SenseData         Pointer to the SenseData.
2463   @param[in, out] SenseDataSize     Size of SenseData in bytes.
2464   @param[out]     SenseDataNumber   Pointer to the value for the sense data size.
2465
2466   @retval EFI_SUCCESS            The command was accepted without any errors.
2467   @retval EFI_NOT_FOUND          Device does not support this data class.
2468   @retval EFI_DEVICE_ERROR       Error reading SenseData from device.
2469   @retval EFI_BUFFER_TOO_SMALL   SenseDataSize not big enough.
2470
2471 **/
2472 EFI_STATUS
2473 EFIAPI
2474 ScsiDiskInfoSenseData (
2475   IN     EFI_DISK_INFO_PROTOCOL   *This,
2476   IN OUT VOID                     *SenseData,
2477   IN OUT UINT32                   *SenseDataSize,
2478   OUT    UINT8                    *SenseDataNumber
2479   )
2480 {
2481   return EFI_NOT_FOUND;
2482 }
2483
2484
2485 /**
2486   This function is used by the IDE bus driver to get controller information.
2487
2488   @param[in]  This         Pointer to the EFI_DISK_INFO_PROTOCOL instance.
2489   @param[out] IdeChannel   Pointer to the Ide Channel number.  Primary or secondary.
2490   @param[out] IdeDevice    Pointer to the Ide Device number.  Master or slave.
2491
2492   @retval EFI_SUCCESS       IdeChannel and IdeDevice are valid.
2493   @retval EFI_UNSUPPORTED   This is not an IDE device.
2494
2495 **/
2496 EFI_STATUS
2497 EFIAPI
2498 ScsiDiskInfoWhichIde (
2499   IN  EFI_DISK_INFO_PROTOCOL   *This,
2500   OUT UINT32                   *IdeChannel,
2501   OUT UINT32                   *IdeDevice
2502   )
2503 {
2504   SCSI_DISK_DEV   *ScsiDiskDevice;
2505
2506   if (CompareGuid (&This->Interface, &gEfiDiskInfoScsiInterfaceGuid)) {
2507     //
2508     // This is not an IDE physical device.
2509     //
2510     return EFI_UNSUPPORTED;
2511   }
2512
2513   ScsiDiskDevice  = SCSI_DISK_DEV_FROM_DISKINFO (This);
2514   *IdeChannel     = ScsiDiskDevice->Channel;
2515   *IdeDevice      = ScsiDiskDevice->Device;
2516
2517   return EFI_SUCCESS;
2518 }
2519
2520
2521 /**
2522   Issues ATA IDENTIFY DEVICE command to identify ATAPI device.
2523
2524   This function tries to fill 512-byte ATAPI_IDENTIFY_DATA for ATAPI device to
2525   implement Identify() interface for DiskInfo protocol. The ATA command is sent
2526   via SCSI Request Packet.
2527
2528   @param  ScsiDiskDevice  The pointer of SCSI_DISK_DEV
2529
2530   @retval EFI_SUCCESS     The ATAPI device identify data were retrieved successfully.
2531   @retval others          Some error occurred during the identification that ATAPI device.
2532
2533 **/
2534 EFI_STATUS
2535 AtapiIdentifyDevice (
2536   IN OUT SCSI_DISK_DEV   *ScsiDiskDevice
2537   )
2538 {
2539   EFI_SCSI_IO_SCSI_REQUEST_PACKET CommandPacket;
2540   UINT8                           Cdb[6];
2541
2542   //
2543   // Initialize SCSI REQUEST_PACKET and 6-byte Cdb
2544   //
2545   ZeroMem (&CommandPacket, sizeof (CommandPacket));
2546   ZeroMem (Cdb, sizeof (Cdb));
2547
2548   Cdb[0] = ATA_CMD_IDENTIFY_DEVICE;
2549   CommandPacket.Timeout = EFI_TIMER_PERIOD_SECONDS (1);
2550   CommandPacket.Cdb = Cdb;
2551   CommandPacket.CdbLength = sizeof (Cdb);
2552   CommandPacket.InDataBuffer = &ScsiDiskDevice->IdentifyData;
2553   CommandPacket.InTransferLength = sizeof (ScsiDiskDevice->IdentifyData);
2554
2555   return ScsiDiskDevice->ScsiIo->ExecuteScsiCommand (ScsiDiskDevice->ScsiIo, &CommandPacket, NULL);
2556 }
2557
2558
2559 /**
2560   Initialize the installation of DiskInfo protocol.
2561
2562   This function prepares for the installation of DiskInfo protocol on the child handle.
2563   By default, it installs DiskInfo protocol with SCSI interface GUID. If it further
2564   detects that the physical device is an ATAPI/AHCI device, it then updates interface GUID
2565   to be IDE/AHCI interface GUID.
2566
2567   @param  ScsiDiskDevice  The pointer of SCSI_DISK_DEV.
2568   @param  ChildHandle     Child handle to install DiskInfo protocol.
2569
2570 **/
2571 VOID
2572 InitializeInstallDiskInfo (
2573   IN  SCSI_DISK_DEV   *ScsiDiskDevice,
2574   IN  EFI_HANDLE      ChildHandle
2575   )
2576 {
2577   EFI_STATUS                Status;
2578   EFI_DEVICE_PATH_PROTOCOL  *DevicePathNode;
2579   EFI_DEVICE_PATH_PROTOCOL  *ChildDevicePathNode;
2580   ATAPI_DEVICE_PATH         *AtapiDevicePath;
2581   SATA_DEVICE_PATH          *SataDevicePath;
2582   UINTN                     IdentifyRetry;
2583
2584   Status = gBS->HandleProtocol (ChildHandle, &gEfiDevicePathProtocolGuid, (VOID **) &DevicePathNode);
2585   //
2586   // Device Path protocol must be installed on the device handle.
2587   //
2588   ASSERT_EFI_ERROR (Status);
2589   //
2590   // Copy the DiskInfo protocol template.
2591   //
2592   CopyMem (&ScsiDiskDevice->DiskInfo, &gScsiDiskInfoProtocolTemplate, sizeof (gScsiDiskInfoProtocolTemplate));
2593
2594   while (!IsDevicePathEnd (DevicePathNode)) {
2595     ChildDevicePathNode = NextDevicePathNode (DevicePathNode);
2596     if ((DevicePathType (DevicePathNode) == HARDWARE_DEVICE_PATH) &&
2597         (DevicePathSubType (DevicePathNode) == HW_PCI_DP) &&
2598         (DevicePathType (ChildDevicePathNode) == MESSAGING_DEVICE_PATH) &&
2599        ((DevicePathSubType (ChildDevicePathNode) == MSG_ATAPI_DP) ||
2600         (DevicePathSubType (ChildDevicePathNode) == MSG_SATA_DP))) {
2601
2602       IdentifyRetry = 3;
2603       do {
2604         //
2605         // Issue ATA Identify Device Command via SCSI command, which is required to publish DiskInfo protocol
2606         // with IDE/AHCI interface GUID.
2607         //
2608         Status = AtapiIdentifyDevice (ScsiDiskDevice);
2609         if (!EFI_ERROR (Status)) {
2610           if (DevicePathSubType(ChildDevicePathNode) == MSG_ATAPI_DP) {
2611             //
2612             // We find the valid ATAPI device path
2613             //
2614             AtapiDevicePath = (ATAPI_DEVICE_PATH *) ChildDevicePathNode;
2615             ScsiDiskDevice->Channel = AtapiDevicePath->PrimarySecondary;
2616             ScsiDiskDevice->Device = AtapiDevicePath->SlaveMaster;
2617             //
2618             // Update the DiskInfo.Interface to IDE interface GUID for the physical ATAPI device.
2619             //
2620             CopyGuid (&ScsiDiskDevice->DiskInfo.Interface, &gEfiDiskInfoIdeInterfaceGuid);
2621           } else {
2622             //
2623             // We find the valid SATA device path
2624             //
2625             SataDevicePath = (SATA_DEVICE_PATH *) ChildDevicePathNode;
2626             ScsiDiskDevice->Channel = SataDevicePath->HBAPortNumber;
2627             ScsiDiskDevice->Device = SataDevicePath->PortMultiplierPortNumber;
2628             //
2629             // Update the DiskInfo.Interface to AHCI interface GUID for the physical AHCI device.
2630             //
2631             CopyGuid (&ScsiDiskDevice->DiskInfo.Interface, &gEfiDiskInfoAhciInterfaceGuid);
2632           }
2633           return;
2634         }
2635       } while (--IdentifyRetry > 0);
2636     }
2637     DevicePathNode = ChildDevicePathNode;
2638   }
2639
2640   return;
2641 }