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   Copyright (c) 2009 Intel Corporation. <BR>
   9   All rights reserved. This program and the accompanying materials
  10   are licensed and made available under the terms and conditions of the BSD License
  11   which accompanies this distribution.  The full text of the license may be found at
  12   http://opensource.org/licenses/bsd-license.php
  13
  14   THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  15   WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  16
  17
  18 **/
  19
  20 #include "AtaBus.h"
  21
  22 //
  23 // Look up table (UdmaValid, IsWrite) for EFI_ATA_PASS_THRU_CMD_PROTOCOL
  24 //
  25 EFI_ATA_PASS_THRU_CMD_PROTOCOL mAtaPassThruCmdProtocols[][2] = {
  26   {
  27     EFI_ATA_PASS_THRU_PROTOCOL_PIO_DATA_IN,
  28     EFI_ATA_PASS_THRU_PROTOCOL_PIO_DATA_OUT
  29   },
  30   {
  31     EFI_ATA_PASS_THRU_PROTOCOL_UDMA_DATA_IN,
  32     EFI_ATA_PASS_THRU_PROTOCOL_UDMA_DATA_OUT,
  33   }
  34 };
  35
  36 //
  37 // Look up table (UdmaValid, Lba48Bit, IsIsWrite) for ATA_CMD
  38 //
  39 UINT8 mAtaCommands[][2][2] = {
  40   {
  41     {
  42       ATA_CMD_READ_SECTORS,            // 28-bit LBA; PIO read
  43       ATA_CMD_WRITE_SECTORS            // 28-bit LBA; PIO write
  44     },
  45     {
  46       ATA_CMD_READ_SECTORS_EXT,        // 48-bit LBA; PIO read
  47       ATA_CMD_WRITE_SECTORS_EXT        // 48-bit LBA; PIO write
  48     }
  49   },
  50   {
  51     {
  52       ATA_CMD_READ_DMA,                // 28-bit LBA; DMA read
  53       ATA_CMD_WRITE_DMA                // 28-bit LBA; DMA write
  54     },
  55     {
  56       ATA_CMD_READ_DMA_EXT,            // 48-bit LBA; DMA read
  57       ATA_CMD_WRITE_DMA_EXT            // 48-bit LBA; DMA write
  58     }
  59   }
  60 };
  61
  62 //
  63 // Look up table (Lba48Bit) for maximum transfer block number
  64 //
  65 UINTN mMaxTransferBlockNumber[] = {
  66   MAX_28BIT_TRANSFER_BLOCK_NUM,
  67   MAX_48BIT_TRANSFER_BLOCK_NUM
  68 };
  69
  70
  71 /**
  72   Wrapper for EFI_ATA_PASS_THRU_PROTOCOL.PassThru().
  73
  74   This function wraps the PassThru() invocation for ATA pass through function
  75   for an ATA device. It assembles the ATA pass through command packet for ATA
  76   transaction.
  77
  78   @param  AtaDevice         The ATA child device involved for the operation.
  79
  80   @return The return status from EFI_ATA_PASS_THRU_PROTOCOL.PassThru().
  81
  82 **/
  83 EFI_STATUS
  84 AtaDevicePassThru (
  85   IN OUT ATA_DEVICE                       *AtaDevice
  86   )
  87 {
  88   EFI_STATUS                              Status;
  89   EFI_ATA_PASS_THRU_PROTOCOL              *AtaPassThru;
  90   EFI_ATA_PASS_THRU_COMMAND_PACKET        *Packet;
  91
  92   //
  93   // Assemble packet
  94   //
  95   Packet = &AtaDevice->Packet;
  96   Packet->Asb = AtaDevice->Asb;
  97   Packet->Acb = &AtaDevice->Acb;
  98   Packet->Timeout = ATA_TIMEOUT;
  99
 100   AtaPassThru = AtaDevice->AtaBusDriverData->AtaPassThru;
 101
 102   Status = AtaPassThru->PassThru (
 103                           AtaPassThru,
 104                           AtaDevice->Port,
 105                           AtaDevice->PortMultiplierPort,
 106                           Packet,
 107                           NULL
 108                           );
 109   //
 110   // Ensure ATA pass through caller and callee have the same
 111   // interpretation of ATA pass through protocol.
 112   //
 113   ASSERT (Status != EFI_INVALID_PARAMETER);
 114   ASSERT (Status != EFI_BAD_BUFFER_SIZE);
 115
 116   return Status;
 117 }
 118
 119
 120 /**
 121   Wrapper for EFI_ATA_PASS_THRU_PROTOCOL.ResetDevice().
 122
 123   This function wraps the ResetDevice() invocation for ATA pass through function
 124   for an ATA device.
 125
 126   @param  AtaDevice         The ATA child device involved for the operation.
 127
 128   @return The return status from EFI_ATA_PASS_THRU_PROTOCOL.PassThru().
 129
 130 **/
 131 EFI_STATUS
 132 ResetAtaDevice (
 133   IN ATA_DEVICE                           *AtaDevice
 134   )
 135 {
 136   EFI_ATA_PASS_THRU_PROTOCOL              *AtaPassThru;
 137
 138   AtaPassThru = AtaDevice->AtaBusDriverData->AtaPassThru;
 139
 140   return AtaPassThru->ResetDevice (
 141                         AtaPassThru,
 142                         AtaDevice->Port,
 143                         AtaDevice->PortMultiplierPort
 144                         );
 145 }
 146
 147
 148 /**
 149   Prints ATA model name to ATA device structure.
 150
 151   This function converts ATA device model name from ATA identify data
 152   to a string in ATA device structure. It needs to change the character
 153   order in the original model name string.
 154
 155   @param  AtaDevice         The ATA child device involved for the operation.
 156
 157 **/
 158 VOID
 159 PrintAtaModelName (
 160   IN OUT ATA_DEVICE  *AtaDevice
 161   )
 162 {
 163   UINTN   Index;
 164   CHAR8   *Source;
 165   CHAR16  *Destination;
 166
 167   Source = AtaDevice->IdentifyData->AtaData.ModelName;
 168   Destination = AtaDevice->ModelName;
 169
 170   //
 171   // Swap the byte order in the original module name.
 172   //
 173   for (Index = 0; Index < MAX_MODEL_NAME_LEN; Index += 2) {
 174     Destination[Index]      = Source[Index + 1];
 175     Destination[Index + 1]  = Source[Index];
 176   }
 177   AtaDevice->ModelName[MAX_MODEL_NAME_LEN] = L'\0';
 178 }
 179
 180
 181 /**
 182   Gets ATA device Capacity according to ATA 6.
 183
 184   This function returns the capacity of the ATA device if it follows
 185   ATA 6 to support 48 bit addressing.
 186
 187   @param  AtaDevice         The ATA child device involved for the operation.
 188
 189   @return The capacity of the ATA device or 0 if the device does not support
 190           48-bit addressing defined in ATA 6.
 191
 192 **/
 193 EFI_LBA
 194 GetAtapi6Capacity (
 195   IN ATA_DEVICE                 *AtaDevice
 196   )
 197 {
 198   EFI_LBA                       Capacity;
 199   EFI_LBA                       TmpLba;
 200   UINTN                         Index;
 201   ATAPI_IDENTIFY_DATA           *IdentifyData;
 202
 203   IdentifyData = (ATAPI_IDENTIFY_DATA *) AtaDevice->IdentifyData;
 204   if ((IdentifyData->cmd_set_support_83 & BIT10) == 0) {
 205     //
 206     // The device doesn't support 48 bit addressing
 207     //
 208     return 0;
 209   }
 210
 211   //
 212   // 48 bit address feature set is supported, get maximum capacity
 213   //
 214   Capacity = 0;
 215   for (Index = 0; Index < 4; Index++) {
 216     //
 217     // Lower byte goes first: word[100] is the lowest word, word[103] is highest
 218     //
 219     TmpLba = IdentifyData->max_user_lba_for_48bit_addr[Index];
 220     Capacity |= LShiftU64 (TmpLba, 16 * Index);
 221   }
 222
 223   return Capacity;
 224 }
 225
 226
 227 /**
 228   Identifies ATA device via the Identify data.
 229
 230   This function identifies the ATA device and initializes the Media information in
 231   Block IO protocol interface.
 232
 233   @param  AtaDevice         The ATA child device involved for the operation.
 234
 235   @retval EFI_UNSUPPORTED   The device is not a valid ATA device (hard disk).
 236   @retval EFI_SUCCESS       The device is successfully identified and Media information
 237                             is correctly initialized.
 238
 239 **/
 240 EFI_STATUS
 241 IdentifyAtaDevice (
 242   IN OUT ATA_DEVICE                 *AtaDevice
 243   )
 244 {
 245   EFI_ATA_IDENTIFY_DATA             *IdentifyData;
 246   EFI_BLOCK_IO_MEDIA                *BlockMedia;
 247   EFI_LBA                           Capacity;
 248   UINT16                            PhyLogicSectorSupport;
 249   UINT16                            UdmaMode;
 250
 251   IdentifyData = &AtaDevice->IdentifyData->AtaData;
 252
 253   if ((IdentifyData->config & BIT15) != 0) {
 254     //
 255     // This is not an hard disk
 256     //
 257     return EFI_UNSUPPORTED;
 258   }
 259
 260   //
 261   // Check whether the WORD 88 (supported UltraDMA by drive) is valid
 262   //
 263   if ((IdentifyData->field_validity & BIT2) != 0) {
 264     UdmaMode = IdentifyData->ultra_dma_mode;
 265     if ((UdmaMode & (BIT0 | BIT1 | BIT2 | BIT3 | BIT4 | BIT5 | BIT6)) != 0) {
 266       //
 267       // If BIT0~BIT6 is selected, then UDMA is supported
 268       //
 269       AtaDevice->UdmaValid = TRUE;
 270     }
 271   }
 272
 273   Capacity = GetAtapi6Capacity (AtaDevice);
 274   if (Capacity > MAX_28BIT_ADDRESSING_CAPACITY) {
 275     //
 276     // Capacity exceeds 120GB. 48-bit addressing is really needed
 277     //
 278     AtaDevice->Lba48Bit = TRUE;
 279   } else {
 280     //
 281     // This is a hard disk <= 120GB capacity, treat it as normal hard disk
 282     //
 283     Capacity = ((UINT32)IdentifyData->user_addressable_sectors_hi << 16) | IdentifyData->user_addressable_sectors_lo;
 284     AtaDevice->Lba48Bit = FALSE;
 285   }
 286
 287   //
 288   // Block Media Information:
 289   //
 290   BlockMedia = &AtaDevice->BlockMedia;
 291   BlockMedia->LastBlock = Capacity - 1;
 292   //
 293   // Check whether Long Physical Sector Feature is supported
 294   //
 295   PhyLogicSectorSupport = IdentifyData->phy_logic_sector_support;
 296   if ((PhyLogicSectorSupport & (BIT14 | BIT15)) == BIT14) {
 297     //
 298     // Check whether one physical block contains multiple physical blocks
 299     //
 300     if ((PhyLogicSectorSupport & BIT13) != 0) {
 301       BlockMedia->LogicalBlocksPerPhysicalBlock = (UINT32) (1 << (PhyLogicSectorSupport & 0x000f));
 302       //
 303       // Check lowest alignment of logical blocks within physical block
 304       //
 305       if ((IdentifyData->alignment_logic_in_phy_blocks & (BIT14 | BIT15)) == BIT14) {
 306         BlockMedia->LowestAlignedLba = (EFI_LBA) (IdentifyData->alignment_logic_in_phy_blocks & 0x3fff);
 307       }
 308     }
 309     //
 310     // Check logical block size
 311     //
 312     if ((PhyLogicSectorSupport & BIT12) != 0) {
 313       BlockMedia->BlockSize = (UINT32) (((IdentifyData->logic_sector_size_hi << 16) | IdentifyData->logic_sector_size_lo) * sizeof (UINT16));
 314     }
 315     AtaDevice->BlockIo.Revision = EFI_BLOCK_IO_PROTOCOL_REVISION2;
 316   }
 317   //
 318   // Get ATA model name from identify data structure.
 319   //
 320   PrintAtaModelName (AtaDevice);
 321
 322   return EFI_SUCCESS;
 323 }
 324
 325
 326 /**
 327   Discovers whether it is a valid ATA device.
 328
 329   This function issues ATA_CMD_IDENTIFY_DRIVE command to the ATA device to identify it.
 330   If the command is executed successfully, it then identifies it and initializes
 331   the Media information in Block IO protocol interface.
 332
 333   @param  AtaDevice         The ATA child device involved for the operation.
 334
 335   @retval EFI_SUCCESS       The device is successfully identified and Media information
 336                             is correctly initialized.
 337   @return others            Some error occurs when discovering the ATA device.
 338
 339 **/
 340 EFI_STATUS
 341 DiscoverAtaDevice (
 342   IN OUT ATA_DEVICE                 *AtaDevice
 343   )
 344 {
 345   EFI_STATUS                        Status;
 346   EFI_ATA_COMMAND_BLOCK             *Acb;
 347   EFI_ATA_PASS_THRU_COMMAND_PACKET  *Packet;
 348   UINTN                             Retry;
 349
 350   //
 351   // Prepare for ATA command block.
 352   //
 353   Acb = ZeroMem (&AtaDevice->Acb, sizeof (*Acb));
 354   Acb->AtaCommand = ATA_CMD_IDENTIFY_DRIVE;
 355
 356   //
 357   // Prepare for ATA pass through packet.
 358   //
 359   Packet = ZeroMem (&AtaDevice->Packet, sizeof (*Packet));
 360   Packet->InDataBuffer = AtaDevice->IdentifyData;
 361   Packet->InTransferLength = sizeof (*AtaDevice->IdentifyData);
 362   Packet->Protocol = EFI_ATA_PASS_THRU_PROTOCOL_PIO_DATA_IN;
 363   Packet->Length = EFI_ATA_PASS_THRU_LENGTH_BYTES | EFI_ATA_PASS_THRU_LENGTH_SECTOR_COUNT;
 364
 365   Retry = MAX_RETRY_TIMES;
 366   do {
 367     Status = AtaDevicePassThru (AtaDevice);
 368     if (!EFI_ERROR (Status)) {
 369       //
 370       // The command is issued successfully
 371       //
 372       Status = IdentifyAtaDevice (AtaDevice);
 373       if (!EFI_ERROR (Status)) {
 374         return Status;
 375       }
 376     }
 377   } while (Retry-- > 0);
 378
 379   return Status;
 380 }
 381
 382 /**
 383   Transfer data from ATA device.
 384
 385   This function performs one ATA pass through transaction to transfer data from/to
 386   ATA device. It chooses the appropriate ATA command and protocol to invoke PassThru
 387   interface of ATA pass through.
 388
 389   @param  AtaDevice         The ATA child device involved for the operation.
 390   @param  Buffer            The pointer to the current transaction buffer.
 391   @param  StartLba          The starting logical block address to be accessed.
 392   @param  TransferLength    The block number or sector count of the transfer.
 393   @param  IsWrite           Indicates whether it is a write operation.
 394
 395   @retval EFI_SUCCESS       The data transfer is complete successfully.
 396   @return others            Some error occurs when transferring data.
 397
 398 **/
 399 EFI_STATUS
 400 TransferAtaDevice (
 401   IN OUT ATA_DEVICE                 *AtaDevice,
 402   IN OUT VOID                       *Buffer,
 403   IN EFI_LBA                        StartLba,
 404   IN UINT32                         TransferLength,
 405   IN BOOLEAN                        IsWrite
 406   )
 407 {
 408   EFI_ATA_COMMAND_BLOCK             *Acb;
 409   EFI_ATA_PASS_THRU_COMMAND_PACKET  *Packet;
 410
 411   //
 412   // Ensure AtaDevice->UdmaValid, AtaDevice->Lba48Bit and IsWrite are valid boolean values
 413   //
 414   ASSERT ((UINTN) AtaDevice->UdmaValid < 2);
 415   ASSERT ((UINTN) AtaDevice->Lba48Bit < 2);
 416   ASSERT ((UINTN) IsWrite < 2);
 417   //
 418   // Prepare for ATA command block.
 419   //
 420   Acb = ZeroMem (&AtaDevice->Acb, sizeof (*Acb));
 421   Acb->AtaCommand = mAtaCommands[AtaDevice->UdmaValid][AtaDevice->Lba48Bit][IsWrite];
 422   Acb->AtaSectorNumber = (UINT8) StartLba;
 423   Acb->AtaCylinderLow = (UINT8) RShiftU64 (StartLba, 8);
 424   Acb->AtaCylinderHigh = (UINT8) RShiftU64 (StartLba, 16);
 425   Acb->AtaDeviceHead = (UINT8) (BIT7 | BIT6 | BIT5 | (AtaDevice->PortMultiplierPort << 4));
 426   Acb->AtaSectorCount = (UINT8) TransferLength;
 427   if (AtaDevice->Lba48Bit) {
 428     Acb->AtaSectorNumberExp = (UINT8) RShiftU64 (StartLba, 24);
 429     Acb->AtaCylinderLowExp = (UINT8) RShiftU64 (StartLba, 32);
 430     Acb->AtaCylinderHighExp = (UINT8) RShiftU64 (StartLba, 40);
 431     Acb->AtaSectorCountExp = (UINT8) (TransferLength >> 8);
 432   } else {
 433     Acb->AtaDeviceHead = (UINT8) (Acb->AtaDeviceHead | RShiftU64 (StartLba, 24));
 434   }
 435
 436   //
 437   // Prepare for ATA pass through packet.
 438   //
 439   Packet = ZeroMem (&AtaDevice->Packet, sizeof (*Packet));
 440   if (IsWrite) {
 441     Packet->OutDataBuffer = Buffer;
 442     Packet->OutTransferLength = TransferLength;
 443   } else {
 444     Packet->InDataBuffer = Buffer;
 445     Packet->InTransferLength = TransferLength;
 446   }
 447   Packet->Protocol = mAtaPassThruCmdProtocols[AtaDevice->UdmaValid][IsWrite];
 448   Packet->Length = EFI_ATA_PASS_THRU_LENGTH_SECTOR_COUNT;
 449
 450   return AtaDevicePassThru (AtaDevice);
 451 }
 452
 453 /**
 454   Read or write a number of blocks from ATA device.
 455
 456   This function performs ATA pass through transactions to read/write data from/to
 457   ATA device. It may separate the read/write request into several ATA pass through
 458   transactions.
 459
 460   @param  AtaDevice         The ATA child device involved for the operation.
 461   @param  Buffer            The pointer to the current transaction buffer.
 462   @param  StartLba          The starting logical block address to be accessed.
 463   @param  NumberOfBlocks    The block number or sector count of the transfer.
 464   @param  IsWrite           Indicates whether it is a write operation.
 465
 466   @retval EFI_SUCCESS       The data transfer is complete successfully.
 467   @return others            Some error occurs when transferring data.
 468
 469 **/
 470 EFI_STATUS
 471 AccessAtaDevice(
 472   IN OUT ATA_DEVICE                 *AtaDevice,
 473   IN OUT UINT8                      *Buffer,
 474   IN EFI_LBA                        StartLba,
 475   IN UINTN                          NumberOfBlocks,
 476   IN BOOLEAN                        IsWrite
 477   )
 478 {
 479   EFI_STATUS                        Status;
 480   UINTN                             MaxTransferBlockNumber;
 481   UINTN                             TransferBlockNumber;
 482   UINTN                             BlockSize;
 483
 484   //
 485   // Ensure AtaDevice->Lba48Bit is a valid boolean value
 486   //
 487   ASSERT ((UINTN) AtaDevice->Lba48Bit < 2);
 488   MaxTransferBlockNumber = mMaxTransferBlockNumber[AtaDevice->Lba48Bit];
 489   BlockSize = AtaDevice->BlockMedia.BlockSize;
 490   do {
 491     if (NumberOfBlocks > MaxTransferBlockNumber) {
 492       TransferBlockNumber = MaxTransferBlockNumber;
 493       NumberOfBlocks -= MaxTransferBlockNumber;
 494     } else  {
 495       TransferBlockNumber = NumberOfBlocks;
 496       NumberOfBlocks  = 0;
 497     }
 498
 499     Status = TransferAtaDevice (AtaDevice, Buffer, StartLba, (UINT32) TransferBlockNumber, IsWrite);
 500     if (EFI_ERROR (Status)) {
 501       return Status;
 502     }
 503     StartLba += TransferBlockNumber;
 504     Buffer   += TransferBlockNumber * BlockSize;
 505   } while (NumberOfBlocks > 0);
 506
 507   return Status;
 508 }