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 - 2009, Intel Corporation. <BR>
   5 All rights reserved. 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  Capacity        The pointer of EFI_SCSI_DISK_CAPACITY_DATA
1495
1496 **/
1497 VOID
1498 GetMediaInfo (
1499   IN  OUT  SCSI_DISK_DEV          *ScsiDiskDevice,
1500   EFI_SCSI_DISK_CAPACITY_DATA     *Capacity10,
1501   EFI_SCSI_DISK_CAPACITY_DATA16   *Capacity16
1502   )
1503 {
1504   UINT8       ScsiVersion;
1505   UINT8       *Ptr;
1506
1507   ScsiVersion    = (UINT8)(ScsiDiskDevice->InquiryData.Version & 0x03);
1508   ScsiDiskDevice->BlkIo.Media->LowestAlignedLba               = 0;
1509   ScsiDiskDevice->BlkIo.Media->LogicalBlocksPerPhysicalBlock  = 1;
1510
1511
1512   if (ScsiVersion < SCSI_COMMAND_VERSION_3) {
1513     ScsiDiskDevice->BlkIo.Media->LastBlock =  (Capacity10->LastLba3 << 24) |
1514                                               (Capacity10->LastLba2 << 16) |
1515                                               (Capacity10->LastLba1 << 8)  |
1516                                                Capacity10->LastLba0;
1517
1518     ScsiDiskDevice->BlkIo.Media->BlockSize = (Capacity10->BlockSize3 << 24) |
1519                                              (Capacity10->BlockSize2 << 16) |
1520                                              (Capacity10->BlockSize1 << 8)  |
1521                                               Capacity10->BlockSize0;
1522     ScsiDiskDevice->BlkIo.Revision = EFI_BLOCK_IO_PROTOCOL_REVISION;
1523   } else {
1524
1525     Ptr = (UINT8*)&ScsiDiskDevice->BlkIo.Media->LastBlock;
1526     *Ptr++ = Capacity16->LastLba0;
1527     *Ptr++ = Capacity16->LastLba1;
1528     *Ptr++ = Capacity16->LastLba2;
1529     *Ptr++ = Capacity16->LastLba3;
1530     *Ptr++ = Capacity16->LastLba4;
1531     *Ptr++ = Capacity16->LastLba5;
1532     *Ptr++ = Capacity16->LastLba6;
1533     *Ptr   = Capacity16->LastLba7;
1534
1535     ScsiDiskDevice->BlkIo.Media->BlockSize = (Capacity16->BlockSize3 << 24) |
1536                                              (Capacity16->BlockSize2 << 16) |
1537                                              (Capacity16->BlockSize1 << 8)  |
1538                                               Capacity16->BlockSize0;
1539
1540     ScsiDiskDevice->BlkIo.Media->LowestAlignedLba = (Capacity16->LowestAlignLogic2 << 8)|(Capacity16->LowestAlignLogic1);
1541     ScsiDiskDevice->BlkIo.Media->LogicalBlocksPerPhysicalBlock  = Capacity16->LogicPerPhysical;
1542     ScsiDiskDevice->BlkIo.Revision = EFI_BLOCK_IO_PROTOCOL_REVISION2;
1543   }
1544
1545
1546   ScsiDiskDevice->BlkIo.Media->MediaPresent = TRUE;
1547
1548   if (ScsiDiskDevice->DeviceType == EFI_SCSI_TYPE_DISK) {
1549     ScsiDiskDevice->BlkIo.Media->BlockSize = 0x200;
1550   }
1551
1552   if (ScsiDiskDevice->DeviceType == EFI_SCSI_TYPE_CDROM) {
1553     ScsiDiskDevice->BlkIo.Media->BlockSize = 0x800;
1554   }
1555 }
1556
1557 /**
1558   Parse Inquiry data.
1559
1560   @param  ScsiDiskDevice  The pointer of SCSI_DISK_DEV
1561
1562 **/
1563 VOID
1564 ParseInquiryData (
1565   IN OUT SCSI_DISK_DEV   *ScsiDiskDevice
1566   )
1567 {
1568   ScsiDiskDevice->FixedDevice               = (BOOLEAN) ((ScsiDiskDevice->InquiryData.Rmb == 1) ? 0 : 1);
1569   ScsiDiskDevice->BlkIoMedia.RemovableMedia = (BOOLEAN) (!ScsiDiskDevice->FixedDevice);
1570 }
1571
1572 /**
1573   Read sector from SCSI Disk.
1574
1575   @param  ScsiDiskDevice  The pointer of SCSI_DISK_DEV
1576   @param  Buffer          The buffer to fill in the read out data
1577   @param  Lba             Logic block address
1578   @param  NumberOfBlocks  The number of blocks to read
1579
1580   @retval EFI_DEVICE_ERROR  Indicates a device error.
1581   @retval EFI_SUCCESS       Operation is successful.
1582
1583 **/
1584 EFI_STATUS
1585 ScsiDiskReadSectors (
1586   IN   SCSI_DISK_DEV     *ScsiDiskDevice,
1587   OUT  VOID              *Buffer,
1588   IN   EFI_LBA           Lba,
1589   IN   UINTN             NumberOfBlocks
1590   )
1591 {
1592   UINTN               BlocksRemaining;
1593   UINT32              Lba32;
1594   UINT8               *PtrBuffer;
1595   UINT32              BlockSize;
1596   UINT32              ByteCount;
1597   UINT32              MaxBlock;
1598   UINT32              SectorCount;
1599   UINT64              Timeout;
1600   EFI_STATUS          Status;
1601   UINT8               Index;
1602   UINT8               MaxRetry;
1603   BOOLEAN             NeedRetry;
1604   EFI_SCSI_SENSE_DATA *SenseData;
1605   UINTN               NumberOfSenseKeys;
1606
1607   SenseData         = NULL;
1608   NumberOfSenseKeys = 0;
1609
1610   Status            = EFI_SUCCESS;
1611
1612   BlocksRemaining   = NumberOfBlocks;
1613   BlockSize         = ScsiDiskDevice->BlkIo.Media->BlockSize;
1614   //
1615   // limit the data bytes that can be transferred by one Read(10) Command
1616   //
1617   MaxBlock  = 65536;
1618
1619   PtrBuffer = Buffer;
1620   Lba32     = (UINT32) Lba;
1621
1622   while (BlocksRemaining > 0) {
1623
1624     if (BlocksRemaining <= MaxBlock) {
1625
1626       SectorCount = (UINT16) BlocksRemaining;
1627     } else {
1628
1629       SectorCount = MaxBlock;
1630     }
1631
1632     ByteCount = SectorCount * BlockSize;
1633     Timeout   = EFI_TIMER_PERIOD_SECONDS (2);
1634
1635     MaxRetry  = 2;
1636     for (Index = 0; Index < MaxRetry; Index++) {
1637
1638       Status = ScsiDiskRead10 (
1639                 ScsiDiskDevice,
1640                 &NeedRetry,
1641                 &SenseData,
1642                 &NumberOfSenseKeys,
1643                 Timeout,
1644                 PtrBuffer,
1645                 &ByteCount,
1646                 Lba32,
1647                 SectorCount
1648                 );
1649       if (!EFI_ERROR (Status)) {
1650         break;
1651       }
1652
1653       if (!NeedRetry) {
1654         return EFI_DEVICE_ERROR;
1655       }
1656
1657     }
1658
1659     if ((Index == MaxRetry) && (Status != EFI_SUCCESS)) {
1660       return EFI_DEVICE_ERROR;
1661     }
1662
1663     //
1664     // actual transferred sectors
1665     //
1666     SectorCount = ByteCount / BlockSize;
1667
1668     Lba32 += SectorCount;
1669     PtrBuffer = PtrBuffer + SectorCount * BlockSize;
1670     BlocksRemaining -= SectorCount;
1671   }
1672
1673   return EFI_SUCCESS;
1674 }
1675
1676 /**
1677   Write sector to SCSI Disk.
1678
1679   @param  ScsiDiskDevice  The pointer of SCSI_DISK_DEV
1680   @param  Buffer          The buffer of data to be written into SCSI Disk
1681   @param  Lba             Logic block address
1682   @param  NumberOfBlocks  The number of blocks to read
1683
1684   @retval EFI_DEVICE_ERROR  Indicates a device error.
1685   @retval EFI_SUCCESS       Operation is successful.
1686
1687 **/
1688 EFI_STATUS
1689 ScsiDiskWriteSectors (
1690   IN  SCSI_DISK_DEV     *ScsiDiskDevice,
1691   IN  VOID              *Buffer,
1692   IN  EFI_LBA           Lba,
1693   IN  UINTN             NumberOfBlocks
1694   )
1695 {
1696   UINTN               BlocksRemaining;
1697   UINT32              Lba32;
1698   UINT8               *PtrBuffer;
1699   UINT32              BlockSize;
1700   UINT32              ByteCount;
1701   UINT32              MaxBlock;
1702   UINT32              SectorCount;
1703   UINT64              Timeout;
1704   EFI_STATUS          Status;
1705   UINT8               Index;
1706   UINT8               MaxRetry;
1707   BOOLEAN             NeedRetry;
1708   EFI_SCSI_SENSE_DATA *SenseData;
1709   UINTN               NumberOfSenseKeys;
1710
1711   SenseData         = NULL;
1712   NumberOfSenseKeys = 0;
1713
1714   Status            = EFI_SUCCESS;
1715
1716   BlocksRemaining   = NumberOfBlocks;
1717   BlockSize         = ScsiDiskDevice->BlkIo.Media->BlockSize;
1718   //
1719   // limit the data bytes that can be transferred by one Write(10) Command
1720   //
1721   MaxBlock  = 65536;
1722
1723   PtrBuffer = Buffer;
1724   Lba32     = (UINT32) Lba;
1725
1726   while (BlocksRemaining > 0) {
1727
1728     if (BlocksRemaining <= MaxBlock) {
1729
1730       SectorCount = (UINT16) BlocksRemaining;
1731     } else {
1732
1733       SectorCount = MaxBlock;
1734     }
1735
1736     ByteCount = SectorCount * BlockSize;
1737     Timeout   = EFI_TIMER_PERIOD_SECONDS (2);
1738     MaxRetry  = 2;
1739     for (Index = 0; Index < MaxRetry; Index++) {
1740       Status = ScsiDiskWrite10 (
1741                 ScsiDiskDevice,
1742                 &NeedRetry,
1743                 &SenseData,
1744                 &NumberOfSenseKeys,
1745                 Timeout,
1746                 PtrBuffer,
1747                 &ByteCount,
1748                 Lba32,
1749                 SectorCount
1750                 );
1751       if (!EFI_ERROR (Status)) {
1752         break;
1753       }
1754
1755       if (!NeedRetry) {
1756         return EFI_DEVICE_ERROR;
1757       }
1758     }
1759
1760     if ((Index == MaxRetry) && (Status != EFI_SUCCESS)) {
1761       return EFI_DEVICE_ERROR;
1762     }
1763     //
1764     // actual transferred sectors
1765     //
1766     SectorCount = ByteCount / BlockSize;
1767
1768     Lba32 += SectorCount;
1769     PtrBuffer = PtrBuffer + SectorCount * BlockSize;
1770     BlocksRemaining -= SectorCount;
1771   }
1772
1773   return EFI_SUCCESS;
1774 }
1775
1776
1777 /**
1778   Submit Read command.
1779
1780   @param  ScsiDiskDevice     The pointer of ScsiDiskDevice
1781   @param  NeedRetry          The pointer of flag indicates if needs retry if error happens
1782   @param  SenseDataArray     NOT used yet in this function
1783   @param  NumberOfSenseKeys  The number of sense key
1784   @param  Timeout            The time to complete the command
1785   @param  DataBuffer         The buffer to fill with the read out data
1786   @param  DataLength         The length of buffer
1787   @param  StartLba           The start logic block address
1788   @param  SectorSize         The size of sector
1789
1790   @return  EFI_STATUS is returned by calling ScsiRead10Command().
1791 **/
1792 EFI_STATUS
1793 ScsiDiskRead10 (
1794   IN     SCSI_DISK_DEV         *ScsiDiskDevice,
1795      OUT BOOLEAN               *NeedRetry,
1796      OUT EFI_SCSI_SENSE_DATA   **SenseDataArray,   OPTIONAL
1797      OUT UINTN                 *NumberOfSenseKeys,
1798   IN     UINT64                Timeout,
1799      OUT UINT8                 *DataBuffer,
1800   IN OUT UINT32                *DataLength,
1801   IN     UINT32                StartLba,
1802   IN     UINT32                SectorSize
1803   )
1804 {
1805   UINT8       SenseDataLength;
1806   EFI_STATUS  Status;
1807   UINT8       HostAdapterStatus;
1808   UINT8       TargetStatus;
1809
1810   *NeedRetry          = FALSE;
1811   *NumberOfSenseKeys  = 0;
1812   SenseDataLength     = 0;
1813   Status = ScsiRead10Command (
1814             ScsiDiskDevice->ScsiIo,
1815             Timeout,
1816             NULL,
1817             &SenseDataLength,
1818             &HostAdapterStatus,
1819             &TargetStatus,
1820             DataBuffer,
1821             DataLength,
1822             StartLba,
1823             SectorSize
1824             );
1825   return Status;
1826 }
1827
1828
1829 /**
1830   Submit Write Command.
1831
1832   @param  ScsiDiskDevice     The pointer of ScsiDiskDevice
1833   @param  NeedRetry          The pointer of flag indicates if needs retry if error happens
1834   @param  SenseDataArray     NOT used yet in this function
1835   @param  NumberOfSenseKeys  The number of sense key
1836   @param  Timeout            The time to complete the command
1837   @param  DataBuffer         The buffer to fill with the read out data
1838   @param  DataLength         The length of buffer
1839   @param  StartLba           The start logic block address
1840   @param  SectorSize         The size of sector
1841
1842   @return  EFI_STATUS is returned by calling ScsiWrite10Command().
1843
1844 **/
1845 EFI_STATUS
1846 ScsiDiskWrite10 (
1847   IN     SCSI_DISK_DEV         *ScsiDiskDevice,
1848      OUT BOOLEAN               *NeedRetry,
1849      OUT EFI_SCSI_SENSE_DATA   **SenseDataArray,   OPTIONAL
1850      OUT UINTN                 *NumberOfSenseKeys,
1851   IN     UINT64                Timeout,
1852   IN     UINT8                 *DataBuffer,
1853   IN OUT UINT32                *DataLength,
1854   IN     UINT32                StartLba,
1855   IN     UINT32                SectorSize
1856   )
1857 {
1858   EFI_STATUS  Status;
1859   UINT8       SenseDataLength;
1860   UINT8       HostAdapterStatus;
1861   UINT8       TargetStatus;
1862
1863   *NeedRetry          = FALSE;
1864   *NumberOfSenseKeys  = 0;
1865   SenseDataLength     = 0;
1866   Status = ScsiWrite10Command (
1867             ScsiDiskDevice->ScsiIo,
1868             Timeout,
1869             NULL,
1870             &SenseDataLength,
1871             &HostAdapterStatus,
1872             &TargetStatus,
1873             DataBuffer,
1874             DataLength,
1875             StartLba,
1876             SectorSize
1877             );
1878   return Status;
1879 }
1880
1881
1882 /**
1883   Check sense key to find if media presents.
1884
1885   @param  SenseData   The pointer of EFI_SCSI_SENSE_DATA
1886   @param  SenseCounts The number of sense key
1887
1888   @retval TRUE    NOT any media
1889   @retval FALSE   Media presents
1890 **/
1891 BOOLEAN
1892 ScsiDiskIsNoMedia (
1893   IN  EFI_SCSI_SENSE_DATA   *SenseData,
1894   IN  UINTN                 SenseCounts
1895   )
1896 {
1897   EFI_SCSI_SENSE_DATA *SensePtr;
1898   UINTN               Index;
1899   BOOLEAN             IsNoMedia;
1900
1901   IsNoMedia = FALSE;
1902   SensePtr  = SenseData;
1903
1904   for (Index = 0; Index < SenseCounts; Index++) {
1905     //
1906     // Sense Key is EFI_SCSI_SK_NOT_READY (0x2),
1907     // Additional Sense Code is ASC_NO_MEDIA (0x3A)
1908     //
1909     if ((SensePtr->Sense_Key == EFI_SCSI_SK_NOT_READY) &&
1910         (SensePtr->Addnl_Sense_Code == EFI_SCSI_ASC_NO_MEDIA)) {
1911       IsNoMedia = TRUE;
1912     }
1913     SensePtr++;
1914   }
1915
1916   return IsNoMedia;
1917 }
1918
1919
1920 /**
1921   Parse sense key.
1922
1923   @param  SenseData    The pointer of EFI_SCSI_SENSE_DATA
1924   @param  SenseCounts  The number of sense key
1925
1926   @retval TRUE   Error
1927   @retval FALSE  NOT error
1928
1929 **/
1930 BOOLEAN
1931 ScsiDiskIsMediaError (
1932   IN  EFI_SCSI_SENSE_DATA   *SenseData,
1933   IN  UINTN                 SenseCounts
1934   )
1935 {
1936   EFI_SCSI_SENSE_DATA *SensePtr;
1937   UINTN               Index;
1938   BOOLEAN             IsError;
1939
1940   IsError   = FALSE;
1941   SensePtr  = SenseData;
1942
1943   for (Index = 0; Index < SenseCounts; Index++) {
1944
1945     switch (SensePtr->Sense_Key) {
1946
1947     case EFI_SCSI_SK_MEDIUM_ERROR:
1948       //
1949       // Sense Key is EFI_SCSI_SK_MEDIUM_ERROR (0x3)
1950       //
1951       switch (SensePtr->Addnl_Sense_Code) {
1952
1953       //
1954       // fall through
1955       //
1956       case EFI_SCSI_ASC_MEDIA_ERR1:
1957
1958       //
1959       // fall through
1960       //
1961       case EFI_SCSI_ASC_MEDIA_ERR2:
1962
1963       //
1964       // fall through
1965       //
1966       case EFI_SCSI_ASC_MEDIA_ERR3:
1967       case EFI_SCSI_ASC_MEDIA_ERR4:
1968         IsError = TRUE;
1969         break;
1970
1971       default:
1972         break;
1973       }
1974
1975       break;
1976
1977     case EFI_SCSI_SK_NOT_READY:
1978       //
1979       // Sense Key is EFI_SCSI_SK_NOT_READY (0x2)
1980       //
1981       switch (SensePtr->Addnl_Sense_Code) {
1982       //
1983       // Additional Sense Code is ASC_MEDIA_UPSIDE_DOWN (0x6)
1984       //
1985       case EFI_SCSI_ASC_MEDIA_UPSIDE_DOWN:
1986         IsError = TRUE;
1987         break;
1988
1989       default:
1990         break;
1991       }
1992       break;
1993
1994     default:
1995       break;
1996     }
1997
1998     SensePtr++;
1999   }
2000
2001   return IsError;
2002 }
2003
2004
2005 /**
2006   Check sense key to find if hardware error happens.
2007
2008   @param  SenseData     The pointer of EFI_SCSI_SENSE_DATA
2009   @param  SenseCounts   The number of sense key
2010
2011   @retval TRUE  Hardware error exits.
2012   @retval FALSE NO error.
2013
2014 **/
2015 BOOLEAN
2016 ScsiDiskIsHardwareError (
2017   IN  EFI_SCSI_SENSE_DATA   *SenseData,
2018   IN  UINTN                 SenseCounts
2019   )
2020 {
2021   EFI_SCSI_SENSE_DATA *SensePtr;
2022   UINTN               Index;
2023   BOOLEAN             IsError;
2024
2025   IsError   = FALSE;
2026   SensePtr  = SenseData;
2027
2028   for (Index = 0; Index < SenseCounts; Index++) {
2029
2030     //
2031     // Sense Key is EFI_SCSI_SK_HARDWARE_ERROR (0x4)
2032     //
2033     if (SensePtr->Sense_Key == EFI_SCSI_SK_HARDWARE_ERROR) {
2034       IsError = TRUE;
2035     }
2036
2037     SensePtr++;
2038   }
2039
2040   return IsError;
2041 }
2042
2043
2044 /**
2045   Check sense key to find if media has changed.
2046
2047   @param  SenseData    The pointer of EFI_SCSI_SENSE_DATA
2048   @param  SenseCounts  The number of sense key
2049
2050   @retval TRUE   Media is changed.
2051   @retval FALSE  Media is NOT changed.
2052 **/
2053 BOOLEAN
2054 ScsiDiskIsMediaChange (
2055   IN  EFI_SCSI_SENSE_DATA   *SenseData,
2056   IN  UINTN                 SenseCounts
2057   )
2058 {
2059   EFI_SCSI_SENSE_DATA *SensePtr;
2060   UINTN               Index;
2061   BOOLEAN             IsMediaChanged;
2062
2063   IsMediaChanged  = FALSE;
2064   SensePtr        = SenseData;
2065
2066   for (Index = 0; Index < SenseCounts; Index++) {
2067     //
2068     // Sense Key is EFI_SCSI_SK_UNIT_ATTENTION (0x6),
2069     // Additional sense code is EFI_SCSI_ASC_MEDIA_CHANGE (0x28)
2070     //
2071     if ((SensePtr->Sense_Key == EFI_SCSI_SK_UNIT_ATTENTION) &&
2072         (SensePtr->Addnl_Sense_Code == EFI_SCSI_ASC_MEDIA_CHANGE)) {
2073       IsMediaChanged = TRUE;
2074     }
2075
2076     SensePtr++;
2077   }
2078
2079   return IsMediaChanged;
2080 }
2081
2082 /**
2083   Check sense key to find if reset happens.
2084
2085   @param  SenseData    The pointer of EFI_SCSI_SENSE_DATA
2086   @param  SenseCounts  The number of sense key
2087
2088   @retval TRUE  It is reset before.
2089   @retval FALSE It is NOT reset before.
2090
2091 **/
2092 BOOLEAN
2093 ScsiDiskIsResetBefore (
2094   IN  EFI_SCSI_SENSE_DATA   *SenseData,
2095   IN  UINTN                 SenseCounts
2096   )
2097 {
2098   EFI_SCSI_SENSE_DATA *SensePtr;
2099   UINTN               Index;
2100   BOOLEAN             IsResetBefore;
2101
2102   IsResetBefore = FALSE;
2103   SensePtr      = SenseData;
2104
2105   for (Index = 0; Index < SenseCounts; Index++) {
2106
2107     //
2108     // Sense Key is EFI_SCSI_SK_UNIT_ATTENTION (0x6)
2109     // Additional Sense Code is EFI_SCSI_ASC_RESET (0x29)
2110     //
2111     if ((SensePtr->Sense_Key == EFI_SCSI_SK_UNIT_ATTENTION) &&
2112         (SensePtr->Addnl_Sense_Code == EFI_SCSI_ASC_RESET)) {
2113       IsResetBefore = TRUE;
2114     }
2115
2116     SensePtr++;
2117   }
2118
2119   return IsResetBefore;
2120 }
2121
2122 /**
2123   Check sense key to find if the drive is ready.
2124
2125   @param  SenseData    The pointer of EFI_SCSI_SENSE_DATA
2126   @param  SenseCounts  The number of sense key
2127   @param  RetryLater   The flag means if need a retry
2128
2129   @retval TRUE  Drive is ready.
2130   @retval FALSE Drive is NOT ready.
2131
2132 **/
2133 BOOLEAN
2134 ScsiDiskIsDriveReady (
2135   IN  EFI_SCSI_SENSE_DATA   *SenseData,
2136   IN  UINTN                 SenseCounts,
2137   OUT BOOLEAN               *RetryLater
2138   )
2139 {
2140   EFI_SCSI_SENSE_DATA *SensePtr;
2141   UINTN               Index;
2142   BOOLEAN             IsReady;
2143
2144   IsReady     = TRUE;
2145   *RetryLater = FALSE;
2146   SensePtr    = SenseData;
2147
2148   for (Index = 0; Index < SenseCounts; Index++) {
2149
2150     switch (SensePtr->Sense_Key) {
2151
2152     case EFI_SCSI_SK_NOT_READY:
2153       //
2154       // Sense Key is EFI_SCSI_SK_NOT_READY (0x2)
2155       //
2156       switch (SensePtr->Addnl_Sense_Code) {
2157       case EFI_SCSI_ASC_NOT_READY:
2158         //
2159         // Additional Sense Code is EFI_SCSI_ASC_NOT_READY (0x4)
2160         //
2161         switch (SensePtr->Addnl_Sense_Code_Qualifier) {
2162         case EFI_SCSI_ASCQ_IN_PROGRESS:
2163           //
2164           // Additional Sense Code Qualifier is
2165           // EFI_SCSI_ASCQ_IN_PROGRESS (0x1)
2166           //
2167           IsReady     = FALSE;
2168           *RetryLater = TRUE;
2169           break;
2170
2171         default:
2172           IsReady     = FALSE;
2173           *RetryLater = FALSE;
2174           break;
2175         }
2176         break;
2177
2178       default:
2179         break;
2180       }
2181       break;
2182
2183     default:
2184       break;
2185     }
2186
2187     SensePtr++;
2188   }
2189
2190   return IsReady;
2191 }
2192
2193 /**
2194   Check sense key to find if it has sense key.
2195
2196   @param  SenseData   - The pointer of EFI_SCSI_SENSE_DATA
2197   @param  SenseCounts - The number of sense key
2198
2199   @retval TRUE  It has sense key.
2200   @retval FALSE It has NOT any sense key.
2201
2202 **/
2203 BOOLEAN
2204 ScsiDiskHaveSenseKey (
2205   IN  EFI_SCSI_SENSE_DATA   *SenseData,
2206   IN  UINTN                 SenseCounts
2207   )
2208 {
2209   EFI_SCSI_SENSE_DATA *SensePtr;
2210   UINTN               Index;
2211   BOOLEAN             HaveSenseKey;
2212
2213   if (SenseCounts == 0) {
2214     HaveSenseKey = FALSE;
2215   } else {
2216     HaveSenseKey = TRUE;
2217   }
2218
2219   SensePtr = SenseData;
2220
2221   for (Index = 0; Index < SenseCounts; Index++) {
2222
2223     //
2224     // Sense Key is SK_NO_SENSE (0x0)
2225     //
2226     if ((SensePtr->Sense_Key == EFI_SCSI_SK_NO_SENSE) &&
2227         (Index == 0)) {
2228       HaveSenseKey = FALSE;
2229     }
2230
2231     SensePtr++;
2232   }
2233
2234   return HaveSenseKey;
2235 }
2236
2237 /**
2238   Release resource about disk device.
2239
2240   @param  ScsiDiskDevice  The pointer of SCSI_DISK_DEV
2241
2242 **/
2243 VOID
2244 ReleaseScsiDiskDeviceResources (
2245   IN  SCSI_DISK_DEV   *ScsiDiskDevice
2246   )
2247 {
2248   if (ScsiDiskDevice == NULL) {
2249     return ;
2250   }
2251
2252   if (ScsiDiskDevice->SenseData != NULL) {
2253     FreePool (ScsiDiskDevice->SenseData);
2254     ScsiDiskDevice->SenseData = NULL;
2255   }
2256
2257   if (ScsiDiskDevice->ControllerNameTable != NULL) {
2258     FreeUnicodeStringTable (ScsiDiskDevice->ControllerNameTable);
2259     ScsiDiskDevice->ControllerNameTable = NULL;
2260   }
2261
2262   FreePool (ScsiDiskDevice);
2263
2264   ScsiDiskDevice = NULL;
2265 }
2266
2267 /**
2268   Determine if Block Io should be produced.
2269
2270
2271   @param  ChildHandle  Child Handle to retrieve Parent information.
2272
2273   @retval  TRUE    Should produce Block Io.
2274   @retval  FALSE   Should not produce Block Io.
2275
2276 **/
2277 BOOLEAN
2278 DetermineInstallBlockIo (
2279   IN  EFI_HANDLE      ChildHandle
2280   )
2281 {
2282   EFI_SCSI_PASS_THRU_PROTOCOL           *ScsiPassThru;
2283   EFI_EXT_SCSI_PASS_THRU_PROTOCOL       *ExtScsiPassThru;
2284
2285   //
2286   // Firstly, check if ExtScsiPassThru Protocol parent handle exists. If existence,
2287   // check its attribute, logic or physical.
2288   //
2289   ExtScsiPassThru = (EFI_EXT_SCSI_PASS_THRU_PROTOCOL *)GetParentProtocol (&gEfiExtScsiPassThruProtocolGuid, ChildHandle);
2290   if (ExtScsiPassThru != NULL) {
2291     if ((ExtScsiPassThru->Mode->Attributes & EFI_SCSI_PASS_THRU_ATTRIBUTES_LOGICAL) != 0) {
2292       return TRUE;
2293     }
2294   }
2295
2296   //
2297   // Secondly, check if ScsiPassThru Protocol parent handle exists. If existence,
2298   // check its attribute, logic or physical.
2299   //
2300   ScsiPassThru = (EFI_SCSI_PASS_THRU_PROTOCOL *)GetParentProtocol (&gEfiScsiPassThruProtocolGuid, ChildHandle);
2301   if (ScsiPassThru != NULL) {
2302     if ((ScsiPassThru->Mode->Attributes & EFI_SCSI_PASS_THRU_ATTRIBUTES_LOGICAL) != 0) {
2303       return TRUE;
2304     }
2305   }
2306
2307   return FALSE;
2308 }
2309
2310 /**
2311   Search protocol database and check to see if the protocol
2312   specified by ProtocolGuid is present on a ControllerHandle and opened by
2313   ChildHandle with an attribute of EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER.
2314   If the ControllerHandle is found, then the protocol specified by ProtocolGuid
2315   will be opened on it.
2316
2317
2318   @param  ProtocolGuid   ProtocolGuid pointer.
2319   @param  ChildHandle    Child Handle to retrieve Parent information.
2320
2321 **/
2322 VOID *
2323 EFIAPI
2324 GetParentProtocol (
2325   IN  EFI_GUID                          *ProtocolGuid,
2326   IN  EFI_HANDLE                        ChildHandle
2327   )
2328 {
2329   UINTN                                 Index;
2330   UINTN                                 HandleCount;
2331   VOID                                  *Interface;
2332   EFI_STATUS                            Status;
2333   EFI_HANDLE                            *HandleBuffer;
2334
2335   //
2336   // Retrieve the list of all handles from the handle database
2337   //
2338   Status = gBS->LocateHandleBuffer (
2339                   ByProtocol,
2340                   ProtocolGuid,
2341                   NULL,
2342                   &HandleCount,
2343                   &HandleBuffer
2344                   );
2345
2346   if (EFI_ERROR (Status)) {
2347     return NULL;
2348   }
2349
2350   //
2351   // Iterate to find who is parent handle that is opened with ProtocolGuid by ChildHandle
2352   //
2353   for (Index = 0; Index < HandleCount; Index++) {
2354     Status = EfiTestChildHandle (HandleBuffer[Index], ChildHandle, ProtocolGuid);
2355     if (!EFI_ERROR (Status)) {
2356       Status = gBS->HandleProtocol (HandleBuffer[Index], ProtocolGuid, (VOID **)&Interface);
2357       if (!EFI_ERROR (Status)) {
2358         gBS->FreePool (HandleBuffer);
2359         return Interface;
2360       }
2361     }
2362   }
2363
2364   gBS->FreePool (HandleBuffer);
2365   return NULL;
2366 }
2367
2368 /**
2369   Provides inquiry information for the controller type.
2370
2371   This function is used by the IDE bus driver to get inquiry data.  Data format
2372   of Identify data is defined by the Interface GUID.
2373
2374   @param[in]     This              Pointer to the EFI_DISK_INFO_PROTOCOL instance.
2375   @param[in,out] InquiryData       Pointer to a buffer for the inquiry data.
2376   @param[in,out] InquiryDataSize   Pointer to the value for the inquiry data size.
2377
2378   @retval EFI_SUCCESS            The command was accepted without any errors.
2379   @retval EFI_NOT_FOUND          Device does not support this data class
2380   @retval EFI_DEVICE_ERROR       Error reading InquiryData from device
2381   @retval EFI_BUFFER_TOO_SMALL   InquiryDataSize not big enough
2382
2383 **/
2384 EFI_STATUS
2385 EFIAPI
2386 ScsiDiskInfoInquiry (
2387   IN     EFI_DISK_INFO_PROTOCOL   *This,
2388   IN OUT VOID                     *InquiryData,
2389   IN OUT UINT32                   *InquiryDataSize
2390   )
2391 {
2392   EFI_STATUS      Status;
2393   SCSI_DISK_DEV   *ScsiDiskDevice;
2394
2395   ScsiDiskDevice  = SCSI_DISK_DEV_FROM_DISKINFO (This);
2396
2397   Status = EFI_BUFFER_TOO_SMALL;
2398   if (*InquiryDataSize >= sizeof (ScsiDiskDevice->InquiryData)) {
2399     Status = EFI_SUCCESS;
2400     CopyMem (InquiryData, &ScsiDiskDevice->InquiryData, sizeof (ScsiDiskDevice->InquiryData));
2401   }
2402   *InquiryDataSize = sizeof (ScsiDiskDevice->InquiryData);
2403   return Status;
2404 }
2405
2406
2407 /**
2408   Provides identify information for the controller type.
2409
2410   This function is used by the IDE bus driver to get identify data.  Data format
2411   of Identify data is defined by the Interface GUID.
2412
2413   @param[in]     This               Pointer to the EFI_DISK_INFO_PROTOCOL
2414                                     instance.
2415   @param[in,out] IdentifyData       Pointer to a buffer for the identify data.
2416   @param[in,out] IdentifyDataSize   Pointer to the value for the identify data
2417                                     size.
2418
2419   @retval EFI_SUCCESS            The command was accepted without any errors.
2420   @retval EFI_NOT_FOUND          Device does not support this data class
2421   @retval EFI_DEVICE_ERROR       Error reading IdentifyData from device
2422   @retval EFI_BUFFER_TOO_SMALL   IdentifyDataSize not big enough
2423
2424 **/
2425 EFI_STATUS
2426 EFIAPI
2427 ScsiDiskInfoIdentify (
2428   IN     EFI_DISK_INFO_PROTOCOL   *This,
2429   IN OUT VOID                     *IdentifyData,
2430   IN OUT UINT32                   *IdentifyDataSize
2431   )
2432 {
2433   EFI_STATUS      Status;
2434   SCSI_DISK_DEV   *ScsiDiskDevice;
2435
2436   if (CompareGuid (&This->Interface, &gEfiDiskInfoScsiInterfaceGuid)) {
2437     //
2438     // Physical SCSI bus does not support this data class.
2439     //
2440     return EFI_NOT_FOUND;
2441   }
2442
2443   ScsiDiskDevice  = SCSI_DISK_DEV_FROM_DISKINFO (This);
2444
2445   Status = EFI_BUFFER_TOO_SMALL;
2446   if (*IdentifyDataSize >= sizeof (ScsiDiskDevice->IdentifyData)) {
2447     Status = EFI_SUCCESS;
2448     CopyMem (IdentifyData, &ScsiDiskDevice->IdentifyData, sizeof (ScsiDiskDevice->IdentifyData));
2449   }
2450   *IdentifyDataSize = sizeof (ScsiDiskDevice->IdentifyData);
2451   return Status;
2452 }
2453
2454 /**
2455   Provides sense data information for the controller type.
2456
2457   This function is used by the IDE bus driver to get sense data.
2458   Data format of Sense data is defined by the Interface GUID.
2459
2460   @param[in]     This              Pointer to the EFI_DISK_INFO_PROTOCOL instance.
2461   @param[in,out] SenseData         Pointer to the SenseData.
2462   @param[in,out] SenseDataSize     Size of SenseData in bytes.
2463   @param[out]    SenseDataNumber   Pointer to the value for the sense data size.
2464
2465   @retval EFI_SUCCESS            The command was accepted without any errors.
2466   @retval EFI_NOT_FOUND          Device does not support this data class.
2467   @retval EFI_DEVICE_ERROR       Error reading SenseData from device.
2468   @retval EFI_BUFFER_TOO_SMALL   SenseDataSize not big enough.
2469
2470 **/
2471 EFI_STATUS
2472 EFIAPI
2473 ScsiDiskInfoSenseData (
2474   IN     EFI_DISK_INFO_PROTOCOL   *This,
2475   IN OUT VOID                     *SenseData,
2476   IN OUT UINT32                   *SenseDataSize,
2477   OUT    UINT8                    *SenseDataNumber
2478   )
2479 {
2480   return EFI_NOT_FOUND;
2481 }
2482
2483
2484 /**
2485   This function is used by the IDE bus driver to get controller information.
2486
2487   @param[in]  This         Pointer to the EFI_DISK_INFO_PROTOCOL instance.
2488   @param[out] IdeChannel   Pointer to the Ide Channel number.  Primary or secondary.
2489   @param[out] IdeDevice    Pointer to the Ide Device number.  Master or slave.
2490
2491   @retval EFI_SUCCESS       IdeChannel and IdeDevice are valid.
2492   @retval EFI_UNSUPPORTED   This is not an IDE device.
2493
2494 **/
2495 EFI_STATUS
2496 EFIAPI
2497 ScsiDiskInfoWhichIde (
2498   IN  EFI_DISK_INFO_PROTOCOL   *This,
2499   OUT UINT32                   *IdeChannel,
2500   OUT UINT32                   *IdeDevice
2501   )
2502 {
2503   SCSI_DISK_DEV   *ScsiDiskDevice;
2504
2505   if (CompareGuid (&This->Interface, &gEfiDiskInfoScsiInterfaceGuid)) {
2506     //
2507     // This is not an IDE physical device.
2508     //
2509     return EFI_UNSUPPORTED;
2510   }
2511
2512   ScsiDiskDevice  = SCSI_DISK_DEV_FROM_DISKINFO (This);
2513   *IdeChannel     = ScsiDiskDevice->Channel;
2514   *IdeDevice      = ScsiDiskDevice->Device;
2515
2516   return EFI_SUCCESS;
2517 }
2518
2519
2520 /**
2521   Issues ATA IDENTIFY DEVICE command to identify ATAPI device.
2522
2523   This function tries to fill 512-byte ATAPI_IDENTIFY_DATA for ATAPI device to
2524   implement Identify() interface for DiskInfo protocol. The ATA command is sent
2525   via SCSI Request Packet.
2526
2527   @param  ScsiDiskDevice  The pointer of SCSI_DISK_DEV
2528
2529   @retval EFI_SUCCESS     The ATAPI device identify data were retrieved successfully.
2530   @retval others          Some error occurred during the identification that ATAPI device.
2531
2532 **/
2533 EFI_STATUS
2534 AtapiIdentifyDevice (
2535   IN OUT SCSI_DISK_DEV   *ScsiDiskDevice
2536   )
2537 {
2538   EFI_SCSI_IO_SCSI_REQUEST_PACKET CommandPacket;
2539   UINT8                           Cdb[6];
2540
2541   //
2542   // Initialize SCSI REQUEST_PACKET and 6-byte Cdb
2543   //
2544   ZeroMem (&CommandPacket, sizeof (CommandPacket));
2545   ZeroMem (Cdb, sizeof (Cdb));
2546
2547   Cdb[0] = ATA_CMD_IDENTIFY_DEVICE;
2548   CommandPacket.Timeout = EFI_TIMER_PERIOD_SECONDS (1);
2549   CommandPacket.Cdb = Cdb;
2550   CommandPacket.CdbLength = sizeof (Cdb);
2551   CommandPacket.InDataBuffer = &ScsiDiskDevice->IdentifyData;
2552   CommandPacket.InTransferLength = sizeof (ScsiDiskDevice->IdentifyData);
2553
2554   return ScsiDiskDevice->ScsiIo->ExecuteScsiCommand (ScsiDiskDevice->ScsiIo, &CommandPacket, NULL);
2555 }
2556
2557
2558 /**
2559   Initialize the installation of DiskInfo protocol.
2560
2561   This function prepares for the installation of DiskInfo protocol on the child handle.
2562   By default, it installs DiskInfo protocol with SCSI interface GUID. If it further
2563   detects that the physical device is an ATAPI/AHCI device, it then updates interface GUID
2564   to be IDE/AHCI interface GUID.
2565
2566   @param  ScsiDiskDevice  The pointer of SCSI_DISK_DEV.
2567   @param  ChildHandle     Child handle to install DiskInfo protocol.
2568
2569 **/
2570 VOID
2571 InitializeInstallDiskInfo (
2572   IN  SCSI_DISK_DEV   *ScsiDiskDevice,
2573   IN  EFI_HANDLE      ChildHandle
2574   )
2575 {
2576   EFI_STATUS                Status;
2577   EFI_DEVICE_PATH_PROTOCOL  *DevicePathNode;
2578   EFI_DEVICE_PATH_PROTOCOL  *ChildDevicePathNode;
2579   ATAPI_DEVICE_PATH         *AtapiDevicePath;
2580   SATA_DEVICE_PATH          *SataDevicePath;
2581   UINTN                     IdentifyRetry;
2582
2583   Status = gBS->HandleProtocol (ChildHandle, &gEfiDevicePathProtocolGuid, (VOID **) &DevicePathNode);
2584   //
2585   // Device Path protocol must be installed on the device handle.
2586   //
2587   ASSERT_EFI_ERROR (Status);
2588   //
2589   // Copy the DiskInfo protocol template.
2590   //
2591   CopyMem (&ScsiDiskDevice->DiskInfo, &gScsiDiskInfoProtocolTemplate, sizeof (gScsiDiskInfoProtocolTemplate));
2592
2593   while (!IsDevicePathEnd (DevicePathNode)) {
2594     ChildDevicePathNode = NextDevicePathNode (DevicePathNode);
2595     if ((DevicePathType (DevicePathNode) == HARDWARE_DEVICE_PATH) &&
2596         (DevicePathSubType (DevicePathNode) == HW_PCI_DP) &&
2597         (DevicePathType (ChildDevicePathNode) == MESSAGING_DEVICE_PATH) &&
2598        ((DevicePathSubType (ChildDevicePathNode) == MSG_ATAPI_DP) ||
2599         (DevicePathSubType (ChildDevicePathNode) == MSG_SATA_DP))) {
2600
2601       IdentifyRetry = 3;
2602       do {
2603         //
2604         // Issue ATA Identify Device Command via SCSI command, which is required to publish DiskInfo protocol
2605         // with IDE/AHCI interface GUID.
2606         //
2607         Status = AtapiIdentifyDevice (ScsiDiskDevice);
2608         if (!EFI_ERROR (Status)) {
2609           if (DevicePathSubType(ChildDevicePathNode) == MSG_ATAPI_DP) {
2610             //
2611             // We find the valid ATAPI device path
2612             //
2613             AtapiDevicePath = (ATAPI_DEVICE_PATH *) ChildDevicePathNode;
2614             ScsiDiskDevice->Channel = AtapiDevicePath->PrimarySecondary;
2615             ScsiDiskDevice->Device = AtapiDevicePath->SlaveMaster;
2616             //
2617             // Update the DiskInfo.Interface to IDE interface GUID for the physical ATAPI device.
2618             //
2619             CopyGuid (&ScsiDiskDevice->DiskInfo.Interface, &gEfiDiskInfoIdeInterfaceGuid);
2620           } else {
2621             //
2622             // We find the valid SATA device path
2623             //
2624             SataDevicePath = (SATA_DEVICE_PATH *) ChildDevicePathNode;
2625             ScsiDiskDevice->Channel = SataDevicePath->HBAPortNumber;
2626             ScsiDiskDevice->Device = SataDevicePath->PortMultiplierPortNumber;
2627             //
2628             // Update the DiskInfo.Interface to AHCI interface GUID for the physical AHCI device.
2629             //
2630             CopyGuid (&ScsiDiskDevice->DiskInfo.Interface, &gEfiDiskInfoAhciInterfaceGuid);
2631           }
2632           return;
2633         }
2634       } while (--IdentifyRetry > 0);
2635     }
2636     DevicePathNode = ChildDevicePathNode;
2637   }
2638
2639   return;
2640 }