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