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 - 2010 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->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   ATA_IDENTIFY_DATA             *IdentifyData;
 202
 203   IdentifyData = AtaDevice->IdentifyData;
 204   if ((IdentifyData->command_set_supported_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->maximum_lba_for_48bit_addressing[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   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;
 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   BlockMedia->IoAlign = AtaDevice->AtaBusDriverData->AtaPassThru->Mode->IoAlign;
 293   //
 294   // Check whether Long Physical Sector Feature is supported
 295   //
 296   PhyLogicSectorSupport = IdentifyData->phy_logic_sector_support;
 297   if ((PhyLogicSectorSupport & (BIT14 | BIT15)) == BIT14) {
 298     //
 299     // Check whether one physical block contains multiple physical blocks
 300     //
 301     if ((PhyLogicSectorSupport & BIT13) != 0) {
 302       BlockMedia->LogicalBlocksPerPhysicalBlock = (UINT32) (1 << (PhyLogicSectorSupport & 0x000f));
 303       //
 304       // Check lowest alignment of logical blocks within physical block
 305       //
 306       if ((IdentifyData->alignment_logic_in_phy_blocks & (BIT14 | BIT15)) == BIT14) {
 307         BlockMedia->LowestAlignedLba = (EFI_LBA) (IdentifyData->alignment_logic_in_phy_blocks & 0x3fff);
 308       }
 309     }
 310     //
 311     // Check logical block size
 312     //
 313     if ((PhyLogicSectorSupport & BIT12) != 0) {
 314       BlockMedia->BlockSize = (UINT32) (((IdentifyData->logic_sector_size_hi << 16) | IdentifyData->logic_sector_size_lo) * sizeof (UINT16));
 315     }
 316     AtaDevice->BlockIo.Revision = EFI_BLOCK_IO_PROTOCOL_REVISION2;
 317   }
 318   //
 319   // Get ATA model name from identify data structure.
 320   //
 321   PrintAtaModelName (AtaDevice);
 322
 323   return EFI_SUCCESS;
 324 }
 325
 326
 327 /**
 328   Discovers whether it is a valid ATA device.
 329
 330   This function issues ATA_CMD_IDENTIFY_DRIVE command to the ATA device to identify it.
 331   If the command is executed successfully, it then identifies it and initializes
 332   the Media information in Block IO protocol interface.
 333
 334   @param  AtaDevice         The ATA child device involved for the operation.
 335
 336   @retval EFI_SUCCESS       The device is successfully identified and Media information
 337                             is correctly initialized.
 338   @return others            Some error occurs when discovering the ATA device.
 339
 340 **/
 341 EFI_STATUS
 342 DiscoverAtaDevice (
 343   IN OUT ATA_DEVICE                 *AtaDevice
 344   )
 345 {
 346   EFI_STATUS                        Status;
 347   EFI_ATA_COMMAND_BLOCK             *Acb;
 348   EFI_ATA_PASS_THRU_COMMAND_PACKET  *Packet;
 349   UINTN                             Retry;
 350
 351   //
 352   // Prepare for ATA command block.
 353   //
 354   Acb = ZeroMem (&AtaDevice->Acb, sizeof (*Acb));
 355   Acb->AtaCommand = ATA_CMD_IDENTIFY_DRIVE;
 356
 357   //
 358   // Prepare for ATA pass through packet.
 359   //
 360   Packet = ZeroMem (&AtaDevice->Packet, sizeof (*Packet));
 361   Packet->InDataBuffer = AtaDevice->IdentifyData;
 362   Packet->InTransferLength = sizeof (*AtaDevice->IdentifyData);
 363   Packet->Protocol = EFI_ATA_PASS_THRU_PROTOCOL_PIO_DATA_IN;
 364   Packet->Length = EFI_ATA_PASS_THRU_LENGTH_BYTES | EFI_ATA_PASS_THRU_LENGTH_SECTOR_COUNT;
 365
 366   Retry = MAX_RETRY_TIMES;
 367   do {
 368     Status = AtaDevicePassThru (AtaDevice);
 369     if (!EFI_ERROR (Status)) {
 370       //
 371       // The command is issued successfully
 372       //
 373       Status = IdentifyAtaDevice (AtaDevice);
 374       if (!EFI_ERROR (Status)) {
 375         return Status;
 376       }
 377     }
 378   } while (Retry-- > 0);
 379
 380   return Status;
 381 }
 382
 383 /**
 384   Transfer data from ATA device.
 385
 386   This function performs one ATA pass through transaction to transfer data from/to
 387   ATA device. It chooses the appropriate ATA command and protocol to invoke PassThru
 388   interface of ATA pass through.
 389
 390   @param  AtaDevice         The ATA child device involved for the operation.
 391   @param  Buffer            The pointer to the current transaction buffer.
 392   @param  StartLba          The starting logical block address to be accessed.
 393   @param  TransferLength    The block number or sector count of the transfer.
 394   @param  IsWrite           Indicates whether it is a write operation.
 395
 396   @retval EFI_SUCCESS       The data transfer is complete successfully.
 397   @return others            Some error occurs when transferring data.
 398
 399 **/
 400 EFI_STATUS
 401 TransferAtaDevice (
 402   IN OUT ATA_DEVICE                 *AtaDevice,
 403   IN OUT VOID                       *Buffer,
 404   IN EFI_LBA                        StartLba,
 405   IN UINT32                         TransferLength,
 406   IN BOOLEAN                        IsWrite
 407   )
 408 {
 409   EFI_ATA_COMMAND_BLOCK             *Acb;
 410   EFI_ATA_PASS_THRU_COMMAND_PACKET  *Packet;
 411
 412   //
 413   // Ensure AtaDevice->UdmaValid, AtaDevice->Lba48Bit and IsWrite are valid boolean values
 414   //
 415   ASSERT ((UINTN) AtaDevice->UdmaValid < 2);
 416   ASSERT ((UINTN) AtaDevice->Lba48Bit < 2);
 417   ASSERT ((UINTN) IsWrite < 2);
 418   //
 419   // Prepare for ATA command block.
 420   //
 421   Acb = ZeroMem (&AtaDevice->Acb, sizeof (*Acb));
 422   Acb->AtaCommand = mAtaCommands[AtaDevice->UdmaValid][AtaDevice->Lba48Bit][IsWrite];
 423   Acb->AtaSectorNumber = (UINT8) StartLba;
 424   Acb->AtaCylinderLow = (UINT8) RShiftU64 (StartLba, 8);
 425   Acb->AtaCylinderHigh = (UINT8) RShiftU64 (StartLba, 16);
 426   Acb->AtaDeviceHead = (UINT8) (BIT7 | BIT6 | BIT5 | (AtaDevice->PortMultiplierPort << 4));
 427   Acb->AtaSectorCount = (UINT8) TransferLength;
 428   if (AtaDevice->Lba48Bit) {
 429     Acb->AtaSectorNumberExp = (UINT8) RShiftU64 (StartLba, 24);
 430     Acb->AtaCylinderLowExp = (UINT8) RShiftU64 (StartLba, 32);
 431     Acb->AtaCylinderHighExp = (UINT8) RShiftU64 (StartLba, 40);
 432     Acb->AtaSectorCountExp = (UINT8) (TransferLength >> 8);
 433   } else {
 434     Acb->AtaDeviceHead = (UINT8) (Acb->AtaDeviceHead | RShiftU64 (StartLba, 24));
 435   }
 436
 437   //
 438   // Prepare for ATA pass through packet.
 439   //
 440   Packet = ZeroMem (&AtaDevice->Packet, sizeof (*Packet));
 441   if (IsWrite) {
 442     Packet->OutDataBuffer = Buffer;
 443     Packet->OutTransferLength = TransferLength;
 444   } else {
 445     Packet->InDataBuffer = Buffer;
 446     Packet->InTransferLength = TransferLength;
 447   }
 448   Packet->Protocol = mAtaPassThruCmdProtocols[AtaDevice->UdmaValid][IsWrite];
 449   Packet->Length = EFI_ATA_PASS_THRU_LENGTH_SECTOR_COUNT;
 450
 451   return AtaDevicePassThru (AtaDevice);
 452 }
 453
 454 /**
 455   Read or write a number of blocks from ATA device.
 456
 457   This function performs ATA pass through transactions to read/write data from/to
 458   ATA device. It may separate the read/write request into several ATA pass through
 459   transactions.
 460
 461   @param  AtaDevice         The ATA child device involved for the operation.
 462   @param  Buffer            The pointer to the current transaction buffer.
 463   @param  StartLba          The starting logical block address to be accessed.
 464   @param  NumberOfBlocks    The block number or sector count of the transfer.
 465   @param  IsWrite           Indicates whether it is a write operation.
 466
 467   @retval EFI_SUCCESS       The data transfer is complete successfully.
 468   @return others            Some error occurs when transferring data.
 469
 470 **/
 471 EFI_STATUS
 472 AccessAtaDevice(
 473   IN OUT ATA_DEVICE                 *AtaDevice,
 474   IN OUT UINT8                      *Buffer,
 475   IN EFI_LBA                        StartLba,
 476   IN UINTN                          NumberOfBlocks,
 477   IN BOOLEAN                        IsWrite
 478   )
 479 {
 480   EFI_STATUS                        Status;
 481   UINTN                             MaxTransferBlockNumber;
 482   UINTN                             TransferBlockNumber;
 483   UINTN                             BlockSize;
 484
 485   //
 486   // Ensure AtaDevice->Lba48Bit is a valid boolean value
 487   //
 488   ASSERT ((UINTN) AtaDevice->Lba48Bit < 2);
 489   MaxTransferBlockNumber = mMaxTransferBlockNumber[AtaDevice->Lba48Bit];
 490   BlockSize = AtaDevice->BlockMedia.BlockSize;
 491   do {
 492     if (NumberOfBlocks > MaxTransferBlockNumber) {
 493       TransferBlockNumber = MaxTransferBlockNumber;
 494       NumberOfBlocks -= MaxTransferBlockNumber;
 495     } else  {
 496       TransferBlockNumber = NumberOfBlocks;
 497       NumberOfBlocks  = 0;
 498     }
 499
 500     Status = TransferAtaDevice (AtaDevice, Buffer, StartLba, (UINT32) TransferBlockNumber, IsWrite);
 501     if (EFI_ERROR (Status)) {
 502       return Status;
 503     }
 504     StartLba += TransferBlockNumber;
 505     Buffer   += TransferBlockNumber * BlockSize;
 506   } while (NumberOfBlocks > 0);
 507
 508   return Status;
 509 }