MdeModulePkg/Bus/Ata/AtaBusDxe/AtaPassThruExecute.c

   1 /** @file
   2   This file implements ATA pass through transaction for ATA bus driver.
   3
   4   This file implements the low level execution of ATA pass through transaction.
   5   It transforms the high level identity, read/write, reset command to ATA pass
   6   through command and protocol.
   7
   8   NOTE: This file also implements the StorageSecurityCommandProtocol(SSP). For input
   9   parameter SecurityProtocolSpecificData, ATA spec has no explicitly definition
  10   for Security Protocol Specific layout. This implementation uses big endian for
  11   Cylinder register.
  12
  13   Copyright (c) 2009 - 2013, Intel Corporation. All rights reserved.<BR>
  14   This program and the accompanying materials
  15   are licensed and made available under the terms and conditions of the BSD License
  16   which accompanies this distribution.  The full text of the license may be found at
  17   http://opensource.org/licenses/bsd-license.php
  18
  19   THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  20   WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  21
  22
  23 **/
  24
  25 #include "AtaBus.h"
  26
  27 #define ATA_CMD_TRUST_NON_DATA    0x5B
  28 #define ATA_CMD_TRUST_RECEIVE     0x5C
  29 #define ATA_CMD_TRUST_RECEIVE_DMA 0x5D
  30 #define ATA_CMD_TRUST_SEND        0x5E
  31 #define ATA_CMD_TRUST_SEND_DMA    0x5F
  32
  33 //
  34 // Look up table (UdmaValid, IsWrite) for EFI_ATA_PASS_THRU_CMD_PROTOCOL
  35 //
  36 EFI_ATA_PASS_THRU_CMD_PROTOCOL mAtaPassThruCmdProtocols[][2] = {
  37   {
  38     EFI_ATA_PASS_THRU_PROTOCOL_PIO_DATA_IN,
  39     EFI_ATA_PASS_THRU_PROTOCOL_PIO_DATA_OUT
  40   },
  41   {
  42     EFI_ATA_PASS_THRU_PROTOCOL_UDMA_DATA_IN,
  43     EFI_ATA_PASS_THRU_PROTOCOL_UDMA_DATA_OUT,
  44   }
  45 };
  46
  47 //
  48 // Look up table (UdmaValid, Lba48Bit, IsIsWrite) for ATA_CMD
  49 //
  50 UINT8 mAtaCommands[][2][2] = {
  51   {
  52     {
  53       ATA_CMD_READ_SECTORS,            // 28-bit LBA; PIO read
  54       ATA_CMD_WRITE_SECTORS            // 28-bit LBA; PIO write
  55     },
  56     {
  57       ATA_CMD_READ_SECTORS_EXT,        // 48-bit LBA; PIO read
  58       ATA_CMD_WRITE_SECTORS_EXT        // 48-bit LBA; PIO write
  59     }
  60   },
  61   {
  62     {
  63       ATA_CMD_READ_DMA,                // 28-bit LBA; DMA read
  64       ATA_CMD_WRITE_DMA                // 28-bit LBA; DMA write
  65     },
  66     {
  67       ATA_CMD_READ_DMA_EXT,            // 48-bit LBA; DMA read
  68       ATA_CMD_WRITE_DMA_EXT            // 48-bit LBA; DMA write
  69     }
  70   }
  71 };
  72
  73 //
  74 // Look up table (UdmaValid, IsTrustSend) for ATA_CMD
  75 //
  76 UINT8 mAtaTrustCommands[2][2] = {
  77   {
  78     ATA_CMD_TRUST_RECEIVE,            // PIO read
  79     ATA_CMD_TRUST_SEND                // PIO write
  80   },
  81   {
  82     ATA_CMD_TRUST_RECEIVE_DMA,        // DMA read
  83     ATA_CMD_TRUST_SEND_DMA            // DMA write
  84   }
  85 };
  86
  87
  88 //
  89 // Look up table (Lba48Bit) for maximum transfer block number
  90 //
  91 UINTN mMaxTransferBlockNumber[] = {
  92   MAX_28BIT_TRANSFER_BLOCK_NUM,
  93   MAX_48BIT_TRANSFER_BLOCK_NUM
  94 };
  95
  96
  97 /**
  98   Wrapper for EFI_ATA_PASS_THRU_PROTOCOL.PassThru().
  99
 100   This function wraps the PassThru() invocation for ATA pass through function
 101   for an ATA device. It assembles the ATA pass through command packet for ATA
 102   transaction.
 103
 104   @param[in, out]  AtaDevice   The ATA child device involved for the operation.
 105   @param[in, out]  TaskPacket  Pointer to a Pass Thru Command Packet. Optional,
 106                                if it is NULL, blocking mode, and use the packet
 107                                in AtaDevice. If it is not NULL, non blocking mode,
 108                                and pass down this Packet.
 109   @param[in, out]  Event       If Event is NULL, then blocking I/O is performed.
 110                                If Event is not NULL and non-blocking I/O is
 111                                supported,then non-blocking I/O is performed,
 112                                and Event will be signaled when the write
 113                                request is completed.
 114
 115   @return The return status from EFI_ATA_PASS_THRU_PROTOCOL.PassThru().
 116
 117 **/
 118 EFI_STATUS
 119 AtaDevicePassThru (
 120   IN OUT ATA_DEVICE                       *AtaDevice,
 121   IN OUT EFI_ATA_PASS_THRU_COMMAND_PACKET *TaskPacket, OPTIONAL
 122   IN OUT EFI_EVENT                        Event OPTIONAL
 123   )
 124 {
 125   EFI_STATUS                              Status;
 126   EFI_ATA_PASS_THRU_PROTOCOL              *AtaPassThru;
 127   EFI_ATA_PASS_THRU_COMMAND_PACKET        *Packet;
 128
 129   //
 130   // Assemble packet. If it is non blocking mode, the Ata driver should keep each
 131   // subtask and clean them when the event is signaled.
 132   //
 133   if (TaskPacket != NULL) {
 134     Packet = TaskPacket;
 135     Packet->Asb = AllocateAlignedBuffer (AtaDevice, sizeof (EFI_ATA_STATUS_BLOCK));
 136     if (Packet->Asb == NULL) {
 137       return EFI_OUT_OF_RESOURCES;
 138     }
 139
 140     CopyMem (Packet->Asb, AtaDevice->Asb, sizeof (EFI_ATA_STATUS_BLOCK));
 141     Packet->Acb = AllocateCopyPool (sizeof (EFI_ATA_COMMAND_BLOCK), &AtaDevice->Acb);
 142   } else {
 143     Packet = &AtaDevice->Packet;
 144     Packet->Asb = AtaDevice->Asb;
 145     Packet->Acb = &AtaDevice->Acb;
 146   }
 147
 148   AtaPassThru = AtaDevice->AtaBusDriverData->AtaPassThru;
 149
 150   Status = AtaPassThru->PassThru (
 151                           AtaPassThru,
 152                           AtaDevice->Port,
 153                           AtaDevice->PortMultiplierPort,
 154                           Packet,
 155                           Event
 156                           );
 157   //
 158   // Ensure ATA pass through caller and callee have the same
 159   // interpretation of ATA pass through protocol.
 160   //
 161   ASSERT (Status != EFI_INVALID_PARAMETER);
 162   ASSERT (Status != EFI_BAD_BUFFER_SIZE);
 163
 164   return Status;
 165 }
 166
 167
 168 /**
 169   Wrapper for EFI_ATA_PASS_THRU_PROTOCOL.ResetDevice().
 170
 171   This function wraps the ResetDevice() invocation for ATA pass through function
 172   for an ATA device.
 173
 174   @param  AtaDevice         The ATA child device involved for the operation.
 175
 176   @return The return status from EFI_ATA_PASS_THRU_PROTOCOL.PassThru().
 177
 178 **/
 179 EFI_STATUS
 180 ResetAtaDevice (
 181   IN ATA_DEVICE                           *AtaDevice
 182   )
 183 {
 184   EFI_ATA_PASS_THRU_PROTOCOL              *AtaPassThru;
 185
 186   AtaPassThru = AtaDevice->AtaBusDriverData->AtaPassThru;
 187
 188   //
 189   // Report Status Code to indicate reset happens
 190   //
 191   REPORT_STATUS_CODE_WITH_DEVICE_PATH (
 192     EFI_PROGRESS_CODE,
 193     (EFI_IO_BUS_ATA_ATAPI | EFI_IOB_PC_RESET),
 194     AtaDevice->AtaBusDriverData->ParentDevicePath
 195     );
 196
 197   return AtaPassThru->ResetDevice (
 198                         AtaPassThru,
 199                         AtaDevice->Port,
 200                         AtaDevice->PortMultiplierPort
 201                         );
 202 }
 203
 204
 205 /**
 206   Prints ATA model name to ATA device structure.
 207
 208   This function converts ATA device model name from ATA identify data
 209   to a string in ATA device structure. It needs to change the character
 210   order in the original model name string.
 211
 212   @param  AtaDevice         The ATA child device involved for the operation.
 213
 214 **/
 215 VOID
 216 PrintAtaModelName (
 217   IN OUT ATA_DEVICE  *AtaDevice
 218   )
 219 {
 220   UINTN   Index;
 221   CHAR8   *Source;
 222   CHAR16  *Destination;
 223
 224   Source = AtaDevice->IdentifyData->ModelName;
 225   Destination = AtaDevice->ModelName;
 226
 227   //
 228   // Swap the byte order in the original module name.
 229   //
 230   for (Index = 0; Index < MAX_MODEL_NAME_LEN; Index += 2) {
 231     Destination[Index]      = Source[Index + 1];
 232     Destination[Index + 1]  = Source[Index];
 233   }
 234   AtaDevice->ModelName[MAX_MODEL_NAME_LEN] = L'\0';
 235 }
 236
 237
 238 /**
 239   Gets ATA device Capacity according to ATA 6.
 240
 241   This function returns the capacity of the ATA device if it follows
 242   ATA 6 to support 48 bit addressing.
 243
 244   @param  AtaDevice         The ATA child device involved for the operation.
 245
 246   @return The capacity of the ATA device or 0 if the device does not support
 247           48-bit addressing defined in ATA 6.
 248
 249 **/
 250 EFI_LBA
 251 GetAtapi6Capacity (
 252   IN ATA_DEVICE                 *AtaDevice
 253   )
 254 {
 255   EFI_LBA                       Capacity;
 256   EFI_LBA                       TmpLba;
 257   UINTN                         Index;
 258   ATA_IDENTIFY_DATA             *IdentifyData;
 259
 260   IdentifyData = AtaDevice->IdentifyData;
 261   if ((IdentifyData->command_set_supported_83 & BIT10) == 0) {
 262     //
 263     // The device doesn't support 48 bit addressing
 264     //
 265     return 0;
 266   }
 267
 268   //
 269   // 48 bit address feature set is supported, get maximum capacity
 270   //
 271   Capacity = 0;
 272   for (Index = 0; Index < 4; Index++) {
 273     //
 274     // Lower byte goes first: word[100] is the lowest word, word[103] is highest
 275     //
 276     TmpLba = IdentifyData->maximum_lba_for_48bit_addressing[Index];
 277     Capacity |= LShiftU64 (TmpLba, 16 * Index);
 278   }
 279
 280   return Capacity;
 281 }
 282
 283
 284 /**
 285   Identifies ATA device via the Identify data.
 286
 287   This function identifies the ATA device and initializes the Media information in
 288   Block IO protocol interface.
 289
 290   @param  AtaDevice         The ATA child device involved for the operation.
 291
 292   @retval EFI_UNSUPPORTED   The device is not a valid ATA device (hard disk).
 293   @retval EFI_SUCCESS       The device is successfully identified and Media information
 294                             is correctly initialized.
 295
 296 **/
 297 EFI_STATUS
 298 IdentifyAtaDevice (
 299   IN OUT ATA_DEVICE                 *AtaDevice
 300   )
 301 {
 302   ATA_IDENTIFY_DATA                 *IdentifyData;
 303   EFI_BLOCK_IO_MEDIA                *BlockMedia;
 304   EFI_LBA                           Capacity;
 305   UINT16                            PhyLogicSectorSupport;
 306   UINT16                            UdmaMode;
 307
 308   IdentifyData = AtaDevice->IdentifyData;
 309
 310   if ((IdentifyData->config & BIT15) != 0) {
 311     //
 312     // This is not an hard disk
 313     //
 314     return EFI_UNSUPPORTED;
 315   }
 316
 317   DEBUG ((EFI_D_INFO, "AtaBus - Identify Device: Port %x PortMultiplierPort %x\n", AtaDevice->Port, AtaDevice->PortMultiplierPort));
 318
 319   //
 320   // Check whether the WORD 88 (supported UltraDMA by drive) is valid
 321   //
 322   if ((IdentifyData->field_validity & BIT2) != 0) {
 323     UdmaMode = IdentifyData->ultra_dma_mode;
 324     if ((UdmaMode & (BIT0 | BIT1 | BIT2 | BIT3 | BIT4 | BIT5 | BIT6)) != 0) {
 325       //
 326       // If BIT0~BIT6 is selected, then UDMA is supported
 327       //
 328       AtaDevice->UdmaValid = TRUE;
 329     }
 330   }
 331
 332   Capacity = GetAtapi6Capacity (AtaDevice);
 333   if (Capacity > MAX_28BIT_ADDRESSING_CAPACITY) {
 334     //
 335     // Capacity exceeds 120GB. 48-bit addressing is really needed
 336     //
 337     AtaDevice->Lba48Bit = TRUE;
 338   } else {
 339     //
 340     // This is a hard disk <= 120GB capacity, treat it as normal hard disk
 341     //
 342     Capacity = ((UINT32)IdentifyData->user_addressable_sectors_hi << 16) | IdentifyData->user_addressable_sectors_lo;
 343     AtaDevice->Lba48Bit = FALSE;
 344   }
 345
 346   //
 347   // Block Media Information:
 348   //
 349   BlockMedia = &AtaDevice->BlockMedia;
 350   BlockMedia->LastBlock = Capacity - 1;
 351   BlockMedia->IoAlign = AtaDevice->AtaBusDriverData->AtaPassThru->Mode->IoAlign;
 352   //
 353   // Check whether Long Physical Sector Feature is supported
 354   //
 355   PhyLogicSectorSupport = IdentifyData->phy_logic_sector_support;
 356   if ((PhyLogicSectorSupport & (BIT14 | BIT15)) == BIT14) {
 357     //
 358     // Check whether one physical block contains multiple physical blocks
 359     //
 360     if ((PhyLogicSectorSupport & BIT13) != 0) {
 361       BlockMedia->LogicalBlocksPerPhysicalBlock = (UINT32) (1 << (PhyLogicSectorSupport & 0x000f));
 362       //
 363       // Check lowest alignment of logical blocks within physical block
 364       //
 365       if ((IdentifyData->alignment_logic_in_phy_blocks & (BIT14 | BIT15)) == BIT14) {
 366         BlockMedia->LowestAlignedLba = (EFI_LBA) ((BlockMedia->LogicalBlocksPerPhysicalBlock - ((UINT32)IdentifyData->alignment_logic_in_phy_blocks & 0x3fff)) %
 367           BlockMedia->LogicalBlocksPerPhysicalBlock);
 368       }
 369     }
 370     //
 371     // Check logical block size
 372     //
 373     if ((PhyLogicSectorSupport & BIT12) != 0) {
 374       BlockMedia->BlockSize = (UINT32) (((IdentifyData->logic_sector_size_hi << 16) | IdentifyData->logic_sector_size_lo) * sizeof (UINT16));
 375     }
 376     AtaDevice->BlockIo.Revision = EFI_BLOCK_IO_PROTOCOL_REVISION2;
 377   }
 378   //
 379   // Get ATA model name from identify data structure.
 380   //
 381   PrintAtaModelName (AtaDevice);
 382
 383   return EFI_SUCCESS;
 384 }
 385
 386
 387 /**
 388   Discovers whether it is a valid ATA device.
 389
 390   This function issues ATA_CMD_IDENTIFY_DRIVE command to the ATA device to identify it.
 391   If the command is executed successfully, it then identifies it and initializes
 392   the Media information in Block IO protocol interface.
 393
 394   @param  AtaDevice         The ATA child device involved for the operation.
 395
 396   @retval EFI_SUCCESS       The device is successfully identified and Media information
 397                             is correctly initialized.
 398   @return others            Some error occurs when discovering the ATA device.
 399
 400 **/
 401 EFI_STATUS
 402 DiscoverAtaDevice (
 403   IN OUT ATA_DEVICE                 *AtaDevice
 404   )
 405 {
 406   EFI_STATUS                        Status;
 407   EFI_ATA_COMMAND_BLOCK             *Acb;
 408   EFI_ATA_PASS_THRU_COMMAND_PACKET  *Packet;
 409   UINTN                             Retry;
 410
 411   //
 412   // Prepare for ATA command block.
 413   //
 414   Acb = ZeroMem (&AtaDevice->Acb, sizeof (EFI_ATA_COMMAND_BLOCK));
 415   Acb->AtaCommand = ATA_CMD_IDENTIFY_DRIVE;
 416   Acb->AtaDeviceHead = (UINT8) (BIT7 | BIT6 | BIT5 | (AtaDevice->PortMultiplierPort << 4));
 417
 418   //
 419   // Prepare for ATA pass through packet.
 420   //
 421   Packet = ZeroMem (&AtaDevice->Packet, sizeof (EFI_ATA_PASS_THRU_COMMAND_PACKET));
 422   Packet->InDataBuffer = AtaDevice->IdentifyData;
 423   Packet->InTransferLength = sizeof (ATA_IDENTIFY_DATA);
 424   Packet->Protocol = EFI_ATA_PASS_THRU_PROTOCOL_PIO_DATA_IN;
 425   Packet->Length   = EFI_ATA_PASS_THRU_LENGTH_BYTES | EFI_ATA_PASS_THRU_LENGTH_SECTOR_COUNT;
 426   Packet->Timeout  = ATA_TIMEOUT;
 427
 428   Retry = MAX_RETRY_TIMES;
 429   do {
 430     Status = AtaDevicePassThru (AtaDevice, NULL, NULL);
 431     if (!EFI_ERROR (Status)) {
 432       //
 433       // The command is issued successfully
 434       //
 435       Status = IdentifyAtaDevice (AtaDevice);
 436       return Status;
 437     }
 438   } while (Retry-- > 0);
 439
 440   return Status;
 441 }
 442
 443 /**
 444   Transfer data from ATA device.
 445
 446   This function performs one ATA pass through transaction to transfer data from/to
 447   ATA device. It chooses the appropriate ATA command and protocol to invoke PassThru
 448   interface of ATA pass through.
 449
 450   @param[in, out]  AtaDevice       The ATA child device involved for the operation.
 451   @param[in, out]  TaskPacket      Pointer to a Pass Thru Command Packet. Optional,
 452                                    if it is NULL, blocking mode, and use the packet
 453                                    in AtaDevice. If it is not NULL, non blocking mode,
 454                                    and pass down this Packet.
 455   @param[in, out]  Buffer          The pointer to the current transaction buffer.
 456   @param[in]       StartLba        The starting logical block address to be accessed.
 457   @param[in]       TransferLength  The block number or sector count of the transfer.
 458   @param[in]       IsWrite         Indicates whether it is a write operation.
 459   @param[in]       Event           If Event is NULL, then blocking I/O is performed.
 460                                    If Event is not NULL and non-blocking I/O is
 461                                    supported,then non-blocking I/O is performed,
 462                                    and Event will be signaled when the write
 463                                    request is completed.
 464
 465   @retval EFI_SUCCESS       The data transfer is complete successfully.
 466   @return others            Some error occurs when transferring data.
 467
 468 **/
 469 EFI_STATUS
 470 TransferAtaDevice (
 471   IN OUT ATA_DEVICE                       *AtaDevice,
 472   IN OUT EFI_ATA_PASS_THRU_COMMAND_PACKET *TaskPacket, OPTIONAL
 473   IN OUT VOID                             *Buffer,
 474   IN EFI_LBA                              StartLba,
 475   IN UINT32                               TransferLength,
 476   IN BOOLEAN                              IsWrite,
 477   IN EFI_EVENT                            Event OPTIONAL
 478   )
 479 {
 480   EFI_ATA_COMMAND_BLOCK             *Acb;
 481   EFI_ATA_PASS_THRU_COMMAND_PACKET  *Packet;
 482
 483   //
 484   // Ensure AtaDevice->UdmaValid, AtaDevice->Lba48Bit and IsWrite are valid boolean values
 485   //
 486   ASSERT ((UINTN) AtaDevice->UdmaValid < 2);
 487   ASSERT ((UINTN) AtaDevice->Lba48Bit < 2);
 488   ASSERT ((UINTN) IsWrite < 2);
 489   //
 490   // Prepare for ATA command block.
 491   //
 492   Acb = ZeroMem (&AtaDevice->Acb, sizeof (EFI_ATA_COMMAND_BLOCK));
 493   Acb->AtaCommand = mAtaCommands[AtaDevice->UdmaValid][AtaDevice->Lba48Bit][IsWrite];
 494   Acb->AtaSectorNumber = (UINT8) StartLba;
 495   Acb->AtaCylinderLow = (UINT8) RShiftU64 (StartLba, 8);
 496   Acb->AtaCylinderHigh = (UINT8) RShiftU64 (StartLba, 16);
 497   Acb->AtaDeviceHead = (UINT8) (BIT7 | BIT6 | BIT5 | (AtaDevice->PortMultiplierPort << 4));
 498   Acb->AtaSectorCount = (UINT8) TransferLength;
 499   if (AtaDevice->Lba48Bit) {
 500     Acb->AtaSectorNumberExp = (UINT8) RShiftU64 (StartLba, 24);
 501     Acb->AtaCylinderLowExp = (UINT8) RShiftU64 (StartLba, 32);
 502     Acb->AtaCylinderHighExp = (UINT8) RShiftU64 (StartLba, 40);
 503     Acb->AtaSectorCountExp = (UINT8) (TransferLength >> 8);
 504   } else {
 505     Acb->AtaDeviceHead = (UINT8) (Acb->AtaDeviceHead | RShiftU64 (StartLba, 24));
 506   }
 507
 508   //
 509   // Prepare for ATA pass through packet.
 510   //
 511   if (TaskPacket != NULL) {
 512     Packet = ZeroMem (TaskPacket, sizeof (EFI_ATA_PASS_THRU_COMMAND_PACKET));
 513   } else {
 514     Packet = ZeroMem (&AtaDevice->Packet, sizeof (EFI_ATA_PASS_THRU_COMMAND_PACKET));
 515   }
 516
 517   if (IsWrite) {
 518     Packet->OutDataBuffer = Buffer;
 519     Packet->OutTransferLength = TransferLength;
 520   } else {
 521     Packet->InDataBuffer = Buffer;
 522     Packet->InTransferLength = TransferLength;
 523   }
 524
 525   Packet->Protocol = mAtaPassThruCmdProtocols[AtaDevice->UdmaValid][IsWrite];
 526   Packet->Length = EFI_ATA_PASS_THRU_LENGTH_SECTOR_COUNT;
 527   //
 528   // |------------------------|-----------------|------------------------|-----------------|
 529   // | ATA PIO Transfer Mode  |  Transfer Rate  | ATA DMA Transfer Mode  |  Transfer Rate  |
 530   // |------------------------|-----------------|------------------------|-----------------|
 531   // |       PIO Mode 0       |  3.3Mbytes/sec  | Single-word DMA Mode 0 |  2.1Mbytes/sec  |
 532   // |------------------------|-----------------|------------------------|-----------------|
 533   // |       PIO Mode 1       |  5.2Mbytes/sec  | Single-word DMA Mode 1 |  4.2Mbytes/sec  |
 534   // |------------------------|-----------------|------------------------|-----------------|
 535   // |       PIO Mode 2       |  8.3Mbytes/sec  | Single-word DMA Mode 2 |  8.4Mbytes/sec  |
 536   // |------------------------|-----------------|------------------------|-----------------|
 537   // |       PIO Mode 3       | 11.1Mbytes/sec  | Multi-word DMA Mode 0  |  4.2Mbytes/sec  |
 538   // |------------------------|-----------------|------------------------|-----------------|
 539   // |       PIO Mode 4       | 16.6Mbytes/sec  | Multi-word DMA Mode 1  | 13.3Mbytes/sec  |
 540   // |------------------------|-----------------|------------------------|-----------------|
 541   //
 542   // As AtaBus is used to manage ATA devices, we have to use the lowest transfer rate to
 543   // calculate the possible maximum timeout value for each read/write operation.
 544   // The timout value is rounded up to nearest integar and here an additional 30s is added
 545   // to follow ATA spec in which it mentioned that the device may take up to 30s to respond
 546   // commands in the Standby/Idle mode.
 547   //
 548   if (AtaDevice->UdmaValid) {
 549     //
 550     // Calculate the maximum timeout value for DMA read/write operation.
 551     //
 552     Packet->Timeout  = EFI_TIMER_PERIOD_SECONDS (DivU64x32 (MultU64x32 (TransferLength, AtaDevice->BlockMedia.BlockSize), 2100000) + 31);
 553   } else {
 554     //
 555     // Calculate the maximum timeout value for PIO read/write operation
 556     //
 557     Packet->Timeout  = EFI_TIMER_PERIOD_SECONDS (DivU64x32 (MultU64x32 (TransferLength, AtaDevice->BlockMedia.BlockSize), 3300000) + 31);
 558   }
 559
 560   return AtaDevicePassThru (AtaDevice, TaskPacket, Event);
 561 }
 562
 563 /**
 564   Free SubTask.
 565
 566   @param[in, out]  Task      Pointer to task to be freed.
 567
 568 **/
 569 VOID
 570 EFIAPI
 571 FreeAtaSubTask (
 572   IN OUT ATA_BUS_ASYN_SUB_TASK  *Task
 573   )
 574 {
 575   if (Task->Packet.Asb != NULL) {
 576     FreeAlignedBuffer (Task->Packet.Asb, sizeof (EFI_ATA_STATUS_BLOCK));
 577   }
 578   if (Task->Packet.Acb != NULL) {
 579     FreePool (Task->Packet.Acb);
 580   }
 581
 582   FreePool (Task);
 583 }
 584
 585 /**
 586   Call back funtion when the event is signaled.
 587
 588   @param[in]  Event     The Event this notify function registered to.
 589   @param[in]  Context   Pointer to the context data registered to the
 590                         Event.
 591
 592 **/
 593 VOID
 594 EFIAPI
 595 AtaNonBlockingCallBack (
 596   IN EFI_EVENT                Event,
 597   IN VOID                     *Context
 598   )
 599 {
 600   ATA_BUS_ASYN_SUB_TASK *Task;
 601   ATA_BUS_ASYN_TASK     *AtaTask;
 602   ATA_DEVICE            *AtaDevice;
 603   LIST_ENTRY            *Entry;
 604   EFI_STATUS            Status;
 605
 606   Task = (ATA_BUS_ASYN_SUB_TASK *) Context;
 607   gBS->CloseEvent (Event);
 608
 609   AtaDevice = Task->AtaDevice;
 610
 611   //
 612   // Check the command status.
 613   // If there is error during the sub task source allocation, the error status
 614   // should be returned to the caller directly, so here the Task->Token may already
 615   // be deleted by the caller and no need to update the status.
 616   //
 617   if ((!(*Task->IsError)) && ((Task->Packet.Asb->AtaStatus & 0x01) == 0x01)) {
 618     Task->Token->TransactionStatus = EFI_DEVICE_ERROR;
 619   }
 620   DEBUG ((
 621     EFI_D_BLKIO,
 622     "NON-BLOCKING EVENT FINISHED!- STATUS = %r\n",
 623     Task->Token->TransactionStatus
 624     ));
 625
 626   //
 627   // Reduce the SubEventCount, till it comes to zero.
 628   //
 629   (*Task->UnsignalledEventCount) --;
 630   DEBUG ((EFI_D_BLKIO, "UnsignalledEventCount = %d\n", *Task->UnsignalledEventCount));
 631
 632   //
 633   // Remove the SubTask from the Task list.
 634   //
 635   RemoveEntryList (&Task->TaskEntry);
 636   if ((*Task->UnsignalledEventCount) == 0) {
 637     //
 638     // All Sub tasks are done, then signal the upper layer event.
 639     // Except there is error during the sub task source allocation.
 640     //
 641     if (!(*Task->IsError)) {
 642       gBS->SignalEvent (Task->Token->Event);
 643       DEBUG ((EFI_D_BLKIO, "Signal the upper layer event!\n"));
 644     }
 645
 646     FreePool (Task->UnsignalledEventCount);
 647     FreePool (Task->IsError);
 648
 649
 650     //
 651     // Finish all subtasks and move to the next task in AtaTaskList.
 652     //
 653     if (!IsListEmpty (&AtaDevice->AtaTaskList)) {
 654       Entry   = GetFirstNode (&AtaDevice->AtaTaskList);
 655       AtaTask = ATA_AYNS_TASK_FROM_ENTRY (Entry);
 656       DEBUG ((EFI_D_BLKIO, "Start to embark a new Ata Task\n"));
 657       DEBUG ((EFI_D_BLKIO, "AtaTask->NumberOfBlocks = %x; AtaTask->Token=%x\n", AtaTask->NumberOfBlocks, AtaTask->Token));
 658       Status = AccessAtaDevice (
 659                  AtaTask->AtaDevice,
 660                  AtaTask->Buffer,
 661                  AtaTask->StartLba,
 662                  AtaTask->NumberOfBlocks,
 663                  AtaTask->IsWrite,
 664                  AtaTask->Token
 665                  );
 666       if (EFI_ERROR (Status)) {
 667         AtaTask->Token->TransactionStatus = Status;
 668         gBS->SignalEvent (AtaTask->Token->Event);
 669       }
 670       RemoveEntryList (Entry);
 671       FreePool (AtaTask);
 672     }
 673   }
 674
 675   DEBUG ((
 676     EFI_D_BLKIO,
 677     "PACKET INFO: Write=%s, Length=%x, LowCylinder=%x, HighCylinder=%x, SectionNumber=%x\n",
 678     Task->Packet.OutDataBuffer != NULL ? L"YES" : L"NO",
 679     Task->Packet.OutDataBuffer != NULL ? Task->Packet.OutTransferLength : Task->Packet.InTransferLength,
 680     Task->Packet.Acb->AtaCylinderLow,
 681     Task->Packet.Acb->AtaCylinderHigh,
 682     Task->Packet.Acb->AtaSectorCount
 683     ));
 684
 685   //
 686   // Free the buffer of SubTask.
 687   //
 688   FreeAtaSubTask (Task);
 689 }
 690
 691 /**
 692   Read or write a number of blocks from ATA device.
 693
 694   This function performs ATA pass through transactions to read/write data from/to
 695   ATA device. It may separate the read/write request into several ATA pass through
 696   transactions.
 697
 698   @param[in, out]  AtaDevice       The ATA child device involved for the operation.
 699   @param[in, out]  Buffer          The pointer to the current transaction buffer.
 700   @param[in]       StartLba        The starting logical block address to be accessed.
 701   @param[in]       NumberOfBlocks  The block number or sector count of the transfer.
 702   @param[in]       IsWrite         Indicates whether it is a write operation.
 703   @param[in, out]  Token           A pointer to the token associated with the transaction.
 704
 705   @retval EFI_SUCCESS       The data transfer is complete successfully.
 706   @return others            Some error occurs when transferring data.
 707
 708 **/
 709 EFI_STATUS
 710 AccessAtaDevice(
 711   IN OUT ATA_DEVICE                 *AtaDevice,
 712   IN OUT UINT8                      *Buffer,
 713   IN EFI_LBA                        StartLba,
 714   IN UINTN                          NumberOfBlocks,
 715   IN BOOLEAN                        IsWrite,
 716   IN OUT EFI_BLOCK_IO2_TOKEN        *Token
 717   )
 718 {
 719   EFI_STATUS                        Status;
 720   UINTN                             MaxTransferBlockNumber;
 721   UINTN                             TransferBlockNumber;
 722   UINTN                             BlockSize;
 723   ATA_BUS_ASYN_SUB_TASK             *SubTask;
 724   UINTN                             *EventCount;
 725   UINTN                             TempCount;
 726   ATA_BUS_ASYN_TASK                 *AtaTask;
 727   EFI_EVENT                         SubEvent;
 728   UINTN                             Index;
 729   BOOLEAN                           *IsError;
 730   EFI_TPL                           OldTpl;
 731
 732   TempCount  = 0;
 733   Status     = EFI_SUCCESS;
 734   EventCount = NULL;
 735   IsError    = NULL;
 736   Index      = 0;
 737   SubTask    = NULL;
 738   SubEvent   = NULL;
 739   AtaTask    = NULL;
 740
 741   //
 742   // Ensure AtaDevice->Lba48Bit is a valid boolean value
 743   //
 744   ASSERT ((UINTN) AtaDevice->Lba48Bit < 2);
 745   MaxTransferBlockNumber = mMaxTransferBlockNumber[AtaDevice->Lba48Bit];
 746   BlockSize              = AtaDevice->BlockMedia.BlockSize;
 747
 748   //
 749   // Initial the return status and shared account for Non Blocking.
 750   //
 751   if ((Token != NULL) && (Token->Event != NULL)) {
 752     OldTpl = gBS->RaiseTPL (TPL_NOTIFY);
 753     if (!IsListEmpty (&AtaDevice->AtaSubTaskList)) {
 754       AtaTask = AllocateZeroPool (sizeof (ATA_BUS_ASYN_TASK));
 755       if (AtaTask == NULL) {
 756         gBS->RestoreTPL (OldTpl);
 757         return EFI_OUT_OF_RESOURCES;
 758       }
 759       AtaTask->AtaDevice      = AtaDevice;
 760       AtaTask->Buffer         = Buffer;
 761       AtaTask->IsWrite        = IsWrite;
 762       AtaTask->NumberOfBlocks = NumberOfBlocks;
 763       AtaTask->Signature      = ATA_TASK_SIGNATURE;
 764       AtaTask->StartLba       = StartLba;
 765       AtaTask->Token          = Token;
 766
 767       InsertTailList (&AtaDevice->AtaTaskList, &AtaTask->TaskEntry);
 768       gBS->RestoreTPL (OldTpl);
 769       return EFI_SUCCESS;
 770     }
 771     gBS->RestoreTPL (OldTpl);
 772
 773     Token->TransactionStatus = EFI_SUCCESS;
 774     EventCount = AllocateZeroPool (sizeof (UINTN));
 775     if (EventCount == NULL) {
 776       return EFI_OUT_OF_RESOURCES;
 777     }
 778
 779     IsError = AllocateZeroPool (sizeof (BOOLEAN));
 780     if (IsError == NULL) {
 781       FreePool (EventCount);
 782       return EFI_OUT_OF_RESOURCES;
 783     }
 784     DEBUG ((EFI_D_BLKIO, "Allocation IsError Addr=%x\n", IsError));
 785     *IsError = FALSE;
 786     TempCount   = (NumberOfBlocks + MaxTransferBlockNumber - 1) / MaxTransferBlockNumber;
 787     *EventCount = TempCount;
 788     DEBUG ((EFI_D_BLKIO, "AccessAtaDevice, NumberOfBlocks=%x\n", NumberOfBlocks));
 789     DEBUG ((EFI_D_BLKIO, "AccessAtaDevice, MaxTransferBlockNumber=%x\n", MaxTransferBlockNumber));
 790     DEBUG ((EFI_D_BLKIO, "AccessAtaDevice, EventCount=%x\n", TempCount));
 791   }else {
 792     while (!IsListEmpty (&AtaDevice->AtaTaskList) || !IsListEmpty (&AtaDevice->AtaSubTaskList)) {
 793       //
 794       // Stall for 100us.
 795       //
 796       MicroSecondDelay (100);
 797     }
 798   }
 799
 800   do {
 801     if (NumberOfBlocks > MaxTransferBlockNumber) {
 802       TransferBlockNumber = MaxTransferBlockNumber;
 803       NumberOfBlocks     -= MaxTransferBlockNumber;
 804     } else  {
 805       TransferBlockNumber = NumberOfBlocks;
 806       NumberOfBlocks      = 0;
 807     }
 808
 809     //
 810     // Create sub event for the sub ata task. Non-blocking mode.
 811     //
 812     if ((Token != NULL) && (Token->Event != NULL)) {
 813       SubTask  = NULL;
 814       SubEvent = NULL;
 815
 816       SubTask = AllocateZeroPool (sizeof (ATA_BUS_ASYN_SUB_TASK));
 817       if (SubTask == NULL) {
 818         Status = EFI_OUT_OF_RESOURCES;
 819         goto EXIT;
 820       }
 821
 822       OldTpl = gBS->RaiseTPL (TPL_NOTIFY);
 823       SubTask->UnsignalledEventCount = EventCount;
 824       SubTask->Signature             = ATA_SUB_TASK_SIGNATURE;
 825       SubTask->AtaDevice             = AtaDevice;
 826       SubTask->Token                 = Token;
 827       SubTask->IsError               = IsError;
 828       InsertTailList (&AtaDevice->AtaSubTaskList, &SubTask->TaskEntry);
 829       gBS->RestoreTPL (OldTpl);
 830
 831       Status = gBS->CreateEvent (
 832                       EVT_NOTIFY_SIGNAL,
 833                       TPL_NOTIFY,
 834                       AtaNonBlockingCallBack,
 835                       SubTask,
 836                       &SubEvent
 837                       );
 838       //
 839       // If resource allocation fail, the un-signalled event count should equal to
 840       // the original one minus the unassigned subtasks number.
 841       //
 842       if (EFI_ERROR (Status)) {
 843         Status = EFI_OUT_OF_RESOURCES;
 844         goto EXIT;
 845       }
 846
 847       Status = TransferAtaDevice (AtaDevice, &SubTask->Packet, Buffer, StartLba, (UINT32) TransferBlockNumber, IsWrite, SubEvent);
 848     } else {
 849       //
 850       // Blocking Mode.
 851       //
 852       DEBUG ((EFI_D_BLKIO, "Blocking AccessAtaDevice, TransferBlockNumber=%x; StartLba = %x\n", TransferBlockNumber, StartLba));
 853       Status = TransferAtaDevice (AtaDevice, NULL, Buffer, StartLba, (UINT32) TransferBlockNumber, IsWrite, NULL);
 854     }
 855
 856     if (EFI_ERROR (Status)) {
 857       goto EXIT;
 858     }
 859
 860     Index++;
 861     StartLba += TransferBlockNumber;
 862     Buffer   += TransferBlockNumber * BlockSize;
 863   } while (NumberOfBlocks > 0);
 864
 865 EXIT:
 866   if ((Token != NULL) && (Token->Event != NULL)) {
 867     //
 868     // Release resource at non-blocking mode.
 869     //
 870     if (EFI_ERROR (Status)) {
 871       OldTpl = gBS->RaiseTPL (TPL_NOTIFY);
 872       Token->TransactionStatus = Status;
 873       *EventCount = (*EventCount) - (TempCount - Index);
 874       *IsError    = TRUE;
 875
 876       if (*EventCount == 0) {
 877         FreePool (EventCount);
 878         FreePool (IsError);
 879       }
 880
 881       if (SubTask != NULL) {
 882         RemoveEntryList (&SubTask->TaskEntry);
 883         FreeAtaSubTask (SubTask);
 884       }
 885
 886       if (SubEvent != NULL) {
 887         gBS->CloseEvent (SubEvent);
 888       }
 889       gBS->RestoreTPL (OldTpl);
 890     }
 891   }
 892
 893   return Status;
 894 }
 895
 896 /**
 897   Trust transfer data from/to ATA device.
 898
 899   This function performs one ATA pass through transaction to do a trust transfer from/to
 900   ATA device. It chooses the appropriate ATA command and protocol to invoke PassThru
 901   interface of ATA pass through.
 902
 903   @param  AtaDevice                    The ATA child device involved for the operation.
 904   @param  Buffer                       The pointer to the current transaction buffer.
 905   @param  SecurityProtocolId           The value of the "Security Protocol" parameter of
 906                                        the security protocol command to be sent.
 907   @param  SecurityProtocolSpecificData The value of the "Security Protocol Specific" parameter
 908                                        of the security protocol command to be sent.
 909   @param  TransferLength               The block number or sector count of the transfer.
 910   @param  IsTrustSend                  Indicates whether it is a trust send operation or not.
 911   @param  Timeout                      The timeout, in 100ns units, to use for the execution
 912                                        of the security protocol command. A Timeout value of 0
 913                                        means that this function will wait indefinitely for the
 914                                        security protocol command to execute. If Timeout is greater
 915                                        than zero, then this function will return EFI_TIMEOUT
 916                                        if the time required to execute the receive data command
 917                                        is greater than Timeout.
 918   @param  TransferLengthOut            A pointer to a buffer to store the size in bytes of the data
 919                                        written to the buffer. Ignore it when IsTrustSend is TRUE.
 920
 921   @retval EFI_SUCCESS       The data transfer is complete successfully.
 922   @return others            Some error occurs when transferring data.
 923
 924 **/
 925 EFI_STATUS
 926 EFIAPI
 927 TrustTransferAtaDevice (
 928   IN OUT ATA_DEVICE                 *AtaDevice,
 929   IN OUT VOID                       *Buffer,
 930   IN UINT8                          SecurityProtocolId,
 931   IN UINT16                         SecurityProtocolSpecificData,
 932   IN UINTN                          TransferLength,
 933   IN BOOLEAN                        IsTrustSend,
 934   IN UINT64                         Timeout,
 935   OUT UINTN                         *TransferLengthOut
 936   )
 937 {
 938   EFI_ATA_COMMAND_BLOCK             *Acb;
 939   EFI_ATA_PASS_THRU_COMMAND_PACKET  *Packet;
 940   EFI_STATUS                        Status;
 941   VOID                              *NewBuffer;
 942   EFI_ATA_PASS_THRU_PROTOCOL        *AtaPassThru;
 943
 944   //
 945   // Ensure AtaDevice->UdmaValid and IsTrustSend are valid boolean values
 946   //
 947   ASSERT ((UINTN) AtaDevice->UdmaValid < 2);
 948   ASSERT ((UINTN) IsTrustSend < 2);
 949   //
 950   // Prepare for ATA command block.
 951   //
 952   Acb = ZeroMem (&AtaDevice->Acb, sizeof (EFI_ATA_COMMAND_BLOCK));
 953   if (TransferLength == 0) {
 954     Acb->AtaCommand    = ATA_CMD_TRUST_NON_DATA;
 955   } else {
 956     Acb->AtaCommand    = mAtaTrustCommands[AtaDevice->UdmaValid][IsTrustSend];
 957   }
 958   Acb->AtaFeatures      = SecurityProtocolId;
 959   Acb->AtaSectorCount   = (UINT8) (TransferLength / 512);
 960   Acb->AtaSectorNumber  = (UINT8) ((TransferLength / 512) >> 8);
 961   //
 962   // NOTE: ATA Spec has no explicitly definition for Security Protocol Specific layout.
 963   // Here use big endian for Cylinder register.
 964   //
 965   Acb->AtaCylinderHigh  = (UINT8) SecurityProtocolSpecificData;
 966   Acb->AtaCylinderLow   = (UINT8) (SecurityProtocolSpecificData >> 8);
 967   Acb->AtaDeviceHead    = (UINT8) (BIT7 | BIT6 | BIT5 | (AtaDevice->PortMultiplierPort << 4));
 968
 969   //
 970   // Prepare for ATA pass through packet.
 971   //
 972   Packet = ZeroMem (&AtaDevice->Packet, sizeof (EFI_ATA_PASS_THRU_COMMAND_PACKET));
 973   if (TransferLength == 0) {
 974     Packet->InTransferLength  = 0;
 975     Packet->OutTransferLength = 0;
 976     Packet->Protocol = EFI_ATA_PASS_THRU_PROTOCOL_ATA_NON_DATA;
 977   } else if (IsTrustSend) {
 978     //
 979     // Check the alignment of the incoming buffer prior to invoking underlying ATA PassThru
 980     //
 981     AtaPassThru = AtaDevice->AtaBusDriverData->AtaPassThru;
 982     if ((AtaPassThru->Mode->IoAlign > 1) && !IS_ALIGNED (Buffer, AtaPassThru->Mode->IoAlign)) {
 983       NewBuffer = AllocateAlignedBuffer (AtaDevice, TransferLength);
 984       if (NewBuffer == NULL) {
 985         return EFI_OUT_OF_RESOURCES;
 986       }
 987
 988       CopyMem (NewBuffer, Buffer, TransferLength);
 989       FreePool (Buffer);
 990       Buffer = NewBuffer;
 991     }
 992     Packet->OutDataBuffer = Buffer;
 993     Packet->OutTransferLength = (UINT32) TransferLength;
 994     Packet->Protocol = mAtaPassThruCmdProtocols[AtaDevice->UdmaValid][IsTrustSend];
 995   } else {
 996     Packet->InDataBuffer = Buffer;
 997     Packet->InTransferLength = (UINT32) TransferLength;
 998     Packet->Protocol = mAtaPassThruCmdProtocols[AtaDevice->UdmaValid][IsTrustSend];
 999   }
1000   Packet->Length   = EFI_ATA_PASS_THRU_LENGTH_BYTES;
1001   Packet->Timeout  = Timeout;
1002
1003   Status = AtaDevicePassThru (AtaDevice, NULL, NULL);
1004   if (TransferLengthOut != NULL) {
1005     if (! IsTrustSend) {
1006       *TransferLengthOut = Packet->InTransferLength;
1007     }
1008   }
1009   return Status;
1010 }