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 Terminate any in-flight non-blocking I/O requests by signaling an EFI_ABORTED 587 in the TransactionStatus member of the EFI_BLOCK_IO2_TOKEN for the non-blocking 588 I/O. After that it is safe to free any Token or Buffer data structures that 589 were allocated to initiate the non-blockingI/O requests that were in-flight for 590 this device. 591 592 @param[in] AtaDevice The ATA child device involved for the operation. 593 594 **/ 595 VOID 596 EFIAPI 597 AtaTerminateNonBlockingTask ( 598 IN ATA_DEVICE *AtaDevice 599 ) 600 { 601 BOOLEAN SubTaskEmpty; 602 EFI_TPL OldTpl; 603 ATA_BUS_ASYN_TASK *AtaTask; 604 LIST_ENTRY *Entry; 605 LIST_ENTRY *List; 606 607 OldTpl = gBS->RaiseTPL (TPL_NOTIFY); 608 // 609 // Abort all executing tasks from now. 610 // 611 AtaDevice->Abort = TRUE; 612 613 List = &AtaDevice->AtaTaskList; 614 for (Entry = GetFirstNode (List); !IsNull (List, Entry);) { 615 AtaTask = ATA_ASYN_TASK_FROM_ENTRY (Entry); 616 AtaTask->Token->TransactionStatus = EFI_ABORTED; 617 gBS->SignalEvent (AtaTask->Token->Event); 618 619 Entry = RemoveEntryList (Entry); 620 FreePool (AtaTask); 621 } 622 gBS->RestoreTPL (OldTpl); 623 624 do { 625 OldTpl = gBS->RaiseTPL (TPL_NOTIFY); 626 // 627 // Wait for executing subtasks done. 628 // 629 SubTaskEmpty = IsListEmpty (&AtaDevice->AtaSubTaskList); 630 gBS->RestoreTPL (OldTpl); 631 } while (!SubTaskEmpty); 632 633 // 634 // Aborting operation has been done. From now on, don't need to abort normal operation. 635 // 636 OldTpl = gBS->RaiseTPL (TPL_NOTIFY); 637 AtaDevice->Abort = FALSE; 638 gBS->RestoreTPL (OldTpl); 639 } 640 641 /** 642 Call back funtion when the event is signaled. 643 644 @param[in] Event The Event this notify function registered to. 645 @param[in] Context Pointer to the context data registered to the 646 Event. 647 648 **/ 649 VOID 650 EFIAPI 651 AtaNonBlockingCallBack ( 652 IN EFI_EVENT Event, 653 IN VOID *Context 654 ) 655 { 656 ATA_BUS_ASYN_SUB_TASK *Task; 657 ATA_BUS_ASYN_TASK *AtaTask; 658 ATA_DEVICE *AtaDevice; 659 LIST_ENTRY *Entry; 660 EFI_STATUS Status; 661 662 Task = (ATA_BUS_ASYN_SUB_TASK *) Context; 663 gBS->CloseEvent (Event); 664 665 AtaDevice = Task->AtaDevice; 666 667 // 668 // Check the command status. 669 // If there is error during the sub task source allocation, the error status 670 // should be returned to the caller directly, so here the Task->Token may already 671 // be deleted by the caller and no need to update the status. 672 // 673 if ((!(*Task->IsError)) && ((Task->Packet.Asb->AtaStatus & 0x01) == 0x01)) { 674 Task->Token->TransactionStatus = EFI_DEVICE_ERROR; 675 } 676 677 if (AtaDevice->Abort) { 678 Task->Token->TransactionStatus = EFI_ABORTED; 679 } 680 681 DEBUG (( 682 EFI_D_BLKIO, 683 "NON-BLOCKING EVENT FINISHED!- STATUS = %r\n", 684 Task->Token->TransactionStatus 685 )); 686 687 // 688 // Reduce the SubEventCount, till it comes to zero. 689 // 690 (*Task->UnsignalledEventCount) --; 691 DEBUG ((EFI_D_BLKIO, "UnsignalledEventCount = %d\n", *Task->UnsignalledEventCount)); 692 693 // 694 // Remove the SubTask from the Task list. 695 // 696 RemoveEntryList (&Task->TaskEntry); 697 if ((*Task->UnsignalledEventCount) == 0) { 698 // 699 // All Sub tasks are done, then signal the upper layer event. 700 // Except there is error during the sub task source allocation. 701 // 702 if (!(*Task->IsError)) { 703 gBS->SignalEvent (Task->Token->Event); 704 DEBUG ((EFI_D_BLKIO, "Signal the upper layer event!\n")); 705 } 706 707 FreePool (Task->UnsignalledEventCount); 708 FreePool (Task->IsError); 709 710 711 // 712 // Finish all subtasks and move to the next task in AtaTaskList. 713 // 714 if (!IsListEmpty (&AtaDevice->AtaTaskList)) { 715 Entry = GetFirstNode (&AtaDevice->AtaTaskList); 716 AtaTask = ATA_ASYN_TASK_FROM_ENTRY (Entry); 717 DEBUG ((EFI_D_BLKIO, "Start to embark a new Ata Task\n")); 718 DEBUG ((EFI_D_BLKIO, "AtaTask->NumberOfBlocks = %x; AtaTask->Token=%x\n", AtaTask->NumberOfBlocks, AtaTask->Token)); 719 Status = AccessAtaDevice ( 720 AtaTask->AtaDevice, 721 AtaTask->Buffer, 722 AtaTask->StartLba, 723 AtaTask->NumberOfBlocks, 724 AtaTask->IsWrite, 725 AtaTask->Token 726 ); 727 if (EFI_ERROR (Status)) { 728 AtaTask->Token->TransactionStatus = Status; 729 gBS->SignalEvent (AtaTask->Token->Event); 730 } 731 RemoveEntryList (Entry); 732 FreePool (AtaTask); 733 } 734 } 735 736 DEBUG (( 737 EFI_D_BLKIO, 738 "PACKET INFO: Write=%s, Length=%x, LowCylinder=%x, HighCylinder=%x, SectionNumber=%x\n", 739 Task->Packet.OutDataBuffer != NULL ? L"YES" : L"NO", 740 Task->Packet.OutDataBuffer != NULL ? Task->Packet.OutTransferLength : Task->Packet.InTransferLength, 741 Task->Packet.Acb->AtaCylinderLow, 742 Task->Packet.Acb->AtaCylinderHigh, 743 Task->Packet.Acb->AtaSectorCount 744 )); 745 746 // 747 // Free the buffer of SubTask. 748 // 749 FreeAtaSubTask (Task); 750 } 751 752 /** 753 Read or write a number of blocks from ATA device. 754 755 This function performs ATA pass through transactions to read/write data from/to 756 ATA device. It may separate the read/write request into several ATA pass through 757 transactions. 758 759 @param[in, out] AtaDevice The ATA child device involved for the operation. 760 @param[in, out] Buffer The pointer to the current transaction buffer. 761 @param[in] StartLba The starting logical block address to be accessed. 762 @param[in] NumberOfBlocks The block number or sector count of the transfer. 763 @param[in] IsWrite Indicates whether it is a write operation. 764 @param[in, out] Token A pointer to the token associated with the transaction. 765 766 @retval EFI_SUCCESS The data transfer is complete successfully. 767 @return others Some error occurs when transferring data. 768 769 **/ 770 EFI_STATUS 771 AccessAtaDevice( 772 IN OUT ATA_DEVICE *AtaDevice, 773 IN OUT UINT8 *Buffer, 774 IN EFI_LBA StartLba, 775 IN UINTN NumberOfBlocks, 776 IN BOOLEAN IsWrite, 777 IN OUT EFI_BLOCK_IO2_TOKEN *Token 778 ) 779 { 780 EFI_STATUS Status; 781 UINTN MaxTransferBlockNumber; 782 UINTN TransferBlockNumber; 783 UINTN BlockSize; 784 ATA_BUS_ASYN_SUB_TASK *SubTask; 785 UINTN *EventCount; 786 UINTN TempCount; 787 ATA_BUS_ASYN_TASK *AtaTask; 788 EFI_EVENT SubEvent; 789 UINTN Index; 790 BOOLEAN *IsError; 791 EFI_TPL OldTpl; 792 793 TempCount = 0; 794 Status = EFI_SUCCESS; 795 EventCount = NULL; 796 IsError = NULL; 797 Index = 0; 798 SubTask = NULL; 799 SubEvent = NULL; 800 AtaTask = NULL; 801 802 // 803 // Ensure AtaDevice->Lba48Bit is a valid boolean value 804 // 805 ASSERT ((UINTN) AtaDevice->Lba48Bit < 2); 806 MaxTransferBlockNumber = mMaxTransferBlockNumber[AtaDevice->Lba48Bit]; 807 BlockSize = AtaDevice->BlockMedia.BlockSize; 808 809 // 810 // Initial the return status and shared account for Non Blocking. 811 // 812 if ((Token != NULL) && (Token->Event != NULL)) { 813 OldTpl = gBS->RaiseTPL (TPL_NOTIFY); 814 815 if (!IsListEmpty (&AtaDevice->AtaSubTaskList)) { 816 AtaTask = AllocateZeroPool (sizeof (ATA_BUS_ASYN_TASK)); 817 if (AtaTask == NULL) { 818 gBS->RestoreTPL (OldTpl); 819 return EFI_OUT_OF_RESOURCES; 820 } 821 AtaTask->AtaDevice = AtaDevice; 822 AtaTask->Buffer = Buffer; 823 AtaTask->IsWrite = IsWrite; 824 AtaTask->NumberOfBlocks = NumberOfBlocks; 825 AtaTask->Signature = ATA_TASK_SIGNATURE; 826 AtaTask->StartLba = StartLba; 827 AtaTask->Token = Token; 828 829 InsertTailList (&AtaDevice->AtaTaskList, &AtaTask->TaskEntry); 830 gBS->RestoreTPL (OldTpl); 831 return EFI_SUCCESS; 832 } 833 gBS->RestoreTPL (OldTpl); 834 835 Token->TransactionStatus = EFI_SUCCESS; 836 EventCount = AllocateZeroPool (sizeof (UINTN)); 837 if (EventCount == NULL) { 838 return EFI_OUT_OF_RESOURCES; 839 } 840 841 IsError = AllocateZeroPool (sizeof (BOOLEAN)); 842 if (IsError == NULL) { 843 FreePool (EventCount); 844 return EFI_OUT_OF_RESOURCES; 845 } 846 DEBUG ((EFI_D_BLKIO, "Allocation IsError Addr=%x\n", IsError)); 847 *IsError = FALSE; 848 TempCount = (NumberOfBlocks + MaxTransferBlockNumber - 1) / MaxTransferBlockNumber; 849 *EventCount = TempCount; 850 DEBUG ((EFI_D_BLKIO, "AccessAtaDevice, NumberOfBlocks=%x\n", NumberOfBlocks)); 851 DEBUG ((EFI_D_BLKIO, "AccessAtaDevice, MaxTransferBlockNumber=%x\n", MaxTransferBlockNumber)); 852 DEBUG ((EFI_D_BLKIO, "AccessAtaDevice, EventCount=%x\n", TempCount)); 853 } else { 854 while (!IsListEmpty (&AtaDevice->AtaTaskList) || !IsListEmpty (&AtaDevice->AtaSubTaskList)) { 855 // 856 // Stall for 100us. 857 // 858 MicroSecondDelay (100); 859 } 860 } 861 862 do { 863 if (NumberOfBlocks > MaxTransferBlockNumber) { 864 TransferBlockNumber = MaxTransferBlockNumber; 865 NumberOfBlocks -= MaxTransferBlockNumber; 866 } else { 867 TransferBlockNumber = NumberOfBlocks; 868 NumberOfBlocks = 0; 869 } 870 871 // 872 // Create sub event for the sub ata task. Non-blocking mode. 873 // 874 if ((Token != NULL) && (Token->Event != NULL)) { 875 SubTask = NULL; 876 SubEvent = NULL; 877 878 SubTask = AllocateZeroPool (sizeof (ATA_BUS_ASYN_SUB_TASK)); 879 if (SubTask == NULL) { 880 Status = EFI_OUT_OF_RESOURCES; 881 goto EXIT; 882 } 883 884 OldTpl = gBS->RaiseTPL (TPL_NOTIFY); 885 SubTask->UnsignalledEventCount = EventCount; 886 SubTask->Signature = ATA_SUB_TASK_SIGNATURE; 887 SubTask->AtaDevice = AtaDevice; 888 SubTask->Token = Token; 889 SubTask->IsError = IsError; 890 InsertTailList (&AtaDevice->AtaSubTaskList, &SubTask->TaskEntry); 891 gBS->RestoreTPL (OldTpl); 892 893 Status = gBS->CreateEvent ( 894 EVT_NOTIFY_SIGNAL, 895 TPL_NOTIFY, 896 AtaNonBlockingCallBack, 897 SubTask, 898 &SubEvent 899 ); 900 // 901 // If resource allocation fail, the un-signalled event count should equal to 902 // the original one minus the unassigned subtasks number. 903 // 904 if (EFI_ERROR (Status)) { 905 Status = EFI_OUT_OF_RESOURCES; 906 goto EXIT; 907 } 908 909 Status = TransferAtaDevice (AtaDevice, &SubTask->Packet, Buffer, StartLba, (UINT32) TransferBlockNumber, IsWrite, SubEvent); 910 } else { 911 // 912 // Blocking Mode. 913 // 914 DEBUG ((EFI_D_BLKIO, "Blocking AccessAtaDevice, TransferBlockNumber=%x; StartLba = %x\n", TransferBlockNumber, StartLba)); 915 Status = TransferAtaDevice (AtaDevice, NULL, Buffer, StartLba, (UINT32) TransferBlockNumber, IsWrite, NULL); 916 } 917 918 if (EFI_ERROR (Status)) { 919 goto EXIT; 920 } 921 922 Index++; 923 StartLba += TransferBlockNumber; 924 Buffer += TransferBlockNumber * BlockSize; 925 } while (NumberOfBlocks > 0); 926 927 EXIT: 928 if ((Token != NULL) && (Token->Event != NULL)) { 929 // 930 // Release resource at non-blocking mode. 931 // 932 if (EFI_ERROR (Status)) { 933 OldTpl = gBS->RaiseTPL (TPL_NOTIFY); 934 Token->TransactionStatus = Status; 935 *EventCount = (*EventCount) - (TempCount - Index); 936 *IsError = TRUE; 937 938 if (*EventCount == 0) { 939 FreePool (EventCount); 940 FreePool (IsError); 941 } 942 943 if (SubTask != NULL) { 944 RemoveEntryList (&SubTask->TaskEntry); 945 FreeAtaSubTask (SubTask); 946 } 947 948 if (SubEvent != NULL) { 949 gBS->CloseEvent (SubEvent); 950 } 951 gBS->RestoreTPL (OldTpl); 952 } 953 } 954 955 return Status; 956 } 957 958 /** 959 Trust transfer data from/to ATA device. 960 961 This function performs one ATA pass through transaction to do a trust transfer from/to 962 ATA device. It chooses the appropriate ATA command and protocol to invoke PassThru 963 interface of ATA pass through. 964 965 @param AtaDevice The ATA child device involved for the operation. 966 @param Buffer The pointer to the current transaction buffer. 967 @param SecurityProtocolId The value of the "Security Protocol" parameter of 968 the security protocol command to be sent. 969 @param SecurityProtocolSpecificData The value of the "Security Protocol Specific" parameter 970 of the security protocol command to be sent. 971 @param TransferLength The block number or sector count of the transfer. 972 @param IsTrustSend Indicates whether it is a trust send operation or not. 973 @param Timeout The timeout, in 100ns units, to use for the execution 974 of the security protocol command. A Timeout value of 0 975 means that this function will wait indefinitely for the 976 security protocol command to execute. If Timeout is greater 977 than zero, then this function will return EFI_TIMEOUT 978 if the time required to execute the receive data command 979 is greater than Timeout. 980 @param TransferLengthOut A pointer to a buffer to store the size in bytes of the data 981 written to the buffer. Ignore it when IsTrustSend is TRUE. 982 983 @retval EFI_SUCCESS The data transfer is complete successfully. 984 @return others Some error occurs when transferring data. 985 986 **/ 987 EFI_STATUS 988 EFIAPI 989 TrustTransferAtaDevice ( 990 IN OUT ATA_DEVICE *AtaDevice, 991 IN OUT VOID *Buffer, 992 IN UINT8 SecurityProtocolId, 993 IN UINT16 SecurityProtocolSpecificData, 994 IN UINTN TransferLength, 995 IN BOOLEAN IsTrustSend, 996 IN UINT64 Timeout, 997 OUT UINTN *TransferLengthOut 998 ) 999 { 1000 EFI_ATA_COMMAND_BLOCK *Acb; 1001 EFI_ATA_PASS_THRU_COMMAND_PACKET *Packet; 1002 EFI_STATUS Status; 1003 VOID *NewBuffer; 1004 EFI_ATA_PASS_THRU_PROTOCOL *AtaPassThru; 1005 1006 // 1007 // Ensure AtaDevice->UdmaValid and IsTrustSend are valid boolean values 1008 // 1009 ASSERT ((UINTN) AtaDevice->UdmaValid < 2); 1010 ASSERT ((UINTN) IsTrustSend < 2); 1011 // 1012 // Prepare for ATA command block. 1013 // 1014 Acb = ZeroMem (&AtaDevice->Acb, sizeof (EFI_ATA_COMMAND_BLOCK)); 1015 if (TransferLength == 0) { 1016 Acb->AtaCommand = ATA_CMD_TRUST_NON_DATA; 1017 } else { 1018 Acb->AtaCommand = mAtaTrustCommands[AtaDevice->UdmaValid][IsTrustSend]; 1019 } 1020 Acb->AtaFeatures = SecurityProtocolId; 1021 Acb->AtaSectorCount = (UINT8) (TransferLength / 512); 1022 Acb->AtaSectorNumber = (UINT8) ((TransferLength / 512) >> 8); 1023 // 1024 // NOTE: ATA Spec has no explicitly definition for Security Protocol Specific layout. 1025 // Here use big endian for Cylinder register. 1026 // 1027 Acb->AtaCylinderHigh = (UINT8) SecurityProtocolSpecificData; 1028 Acb->AtaCylinderLow = (UINT8) (SecurityProtocolSpecificData >> 8); 1029 Acb->AtaDeviceHead = (UINT8) (BIT7 | BIT6 | BIT5 | (AtaDevice->PortMultiplierPort << 4)); 1030 1031 // 1032 // Prepare for ATA pass through packet. 1033 // 1034 Packet = ZeroMem (&AtaDevice->Packet, sizeof (EFI_ATA_PASS_THRU_COMMAND_PACKET)); 1035 if (TransferLength == 0) { 1036 Packet->InTransferLength = 0; 1037 Packet->OutTransferLength = 0; 1038 Packet->Protocol = EFI_ATA_PASS_THRU_PROTOCOL_ATA_NON_DATA; 1039 } else if (IsTrustSend) { 1040 // 1041 // Check the alignment of the incoming buffer prior to invoking underlying ATA PassThru 1042 // 1043 AtaPassThru = AtaDevice->AtaBusDriverData->AtaPassThru; 1044 if ((AtaPassThru->Mode->IoAlign > 1) && !IS_ALIGNED (Buffer, AtaPassThru->Mode->IoAlign)) { 1045 NewBuffer = AllocateAlignedBuffer (AtaDevice, TransferLength); 1046 if (NewBuffer == NULL) { 1047 return EFI_OUT_OF_RESOURCES; 1048 } 1049 1050 CopyMem (NewBuffer, Buffer, TransferLength); 1051 FreePool (Buffer); 1052 Buffer = NewBuffer; 1053 } 1054 Packet->OutDataBuffer = Buffer; 1055 Packet->OutTransferLength = (UINT32) TransferLength; 1056 Packet->Protocol = mAtaPassThruCmdProtocols[AtaDevice->UdmaValid][IsTrustSend]; 1057 } else { 1058 Packet->InDataBuffer = Buffer; 1059 Packet->InTransferLength = (UINT32) TransferLength; 1060 Packet->Protocol = mAtaPassThruCmdProtocols[AtaDevice->UdmaValid][IsTrustSend]; 1061 } 1062 Packet->Length = EFI_ATA_PASS_THRU_LENGTH_BYTES; 1063 Packet->Timeout = Timeout; 1064 1065 Status = AtaDevicePassThru (AtaDevice, NULL, NULL); 1066 if (TransferLengthOut != NULL) { 1067 if (! IsTrustSend) { 1068 *TransferLengthOut = Packet->InTransferLength; 1069 } 1070 } 1071 return Status; 1072 } 1073
