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


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