]> git.proxmox.com Git - mirror_edk2.git/blob - MdeModulePkg/Bus/Ata/AtaBusDxe/AtaPassThruExecute.c
projects / mirror_edk2.git / blob
? search:


a3008f92d9e2972abc79618a367f4d66020897f7
[mirror_edk2.git] / 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 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 }
EFI Development Kit II mirror for PVE