VirtualBox

source: vbox/trunk/src/VBox/Devices/EFI/Firmware2/VBoxPkg/VBoxIdeBusDxe/Ata.c@ 33024

Last change on this file since 33024 was 33024, checked in by vboxsync, 14 years ago

EFI: Initial commit of VBoxIdeBusDxe, taken from IntelFrameworkModulePkg/Bus/Pci/IdeBusDxe.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 80.5 KB
Line 
1/** @file
2 This file contains all helper functions on the ATA command
3
4 Copyright (c) 2006 - 2008, Intel Corporation.<BR>
5 All rights reserved. This program and the accompanying materials
6 are licensed and made available under the terms and conditions of the BSD License
7 which accompanies this distribution. The full text of the license may be found at
8 http://opensource.org/licenses/bsd-license.php
9
10 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
11 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
12
13 @par Revision Reference:
14 2002-6: Add Atapi6 enhancement, support >120GB hard disk, including
15 update - ATAIdentity() func
16 update - AtaBlockIoReadBlocks() func
17 update - AtaBlockIoWriteBlocks() func
18 add - AtaAtapi6Identify() func
19 add - AtaReadSectorsExt() func
20 add - AtaWriteSectorsExt() func
21 add - AtaPioDataInExt() func
22 add - AtaPioDataOutExt() func
23
24**/
25
26#include "IdeBus.h"
27/**
28 This function is called by ATAIdentify() to identity whether this disk
29 supports ATA/ATAPI6 48bit addressing, ie support >120G capacity
30
31 @param IdeDev pointer pointing to IDE_BLK_IO_DEV data structure, used to record
32 all the information of the IDE device.
33
34 @retval EFI_SUCCESS The disk specified by IdeDev is a Atapi6 supported one and
35 48-bit addressing must be used
36 @retval EFI_UNSUPPORTED The disk dosn't not support Atapi6 or it supports but the
37 capacity is below 120G, 48bit addressing is not needed
38 @retval EFI_DEVICE_ERROR The identify data in IdeDev is incorrect
39 @retval EFI_INVALID_PARAMETER The identify data in IdeDev is NULL.
40
41 @note This function must be called after DEVICE_IDENTITY command has been
42 successfully returned
43
44**/
45EFI_STATUS
46AtaAtapi6Identify (
47 IN IDE_BLK_IO_DEV *IdeDev
48 )
49{
50 UINT8 Index;
51 EFI_LBA TmpLba;
52 EFI_LBA Capacity;
53 EFI_IDENTIFY_DATA *Atapi6IdentifyStruct;
54
55 if (IdeDev->IdData == NULL) {
56 return EFI_INVALID_PARAMETER;
57 }
58
59 Atapi6IdentifyStruct = IdeDev->IdData;
60
61 if ((Atapi6IdentifyStruct->AtapiData.cmd_set_support_83 & (BIT15 | BIT14)) != 0x4000) {
62 //
63 // Per ATA-6 spec, word83: bit15 is zero and bit14 is one
64 //
65 return EFI_DEVICE_ERROR;
66 }
67
68 if ((Atapi6IdentifyStruct->AtapiData.cmd_set_support_83 & BIT10) == 0) {
69 //
70 // The device dosn't support 48 bit addressing
71 //
72 return EFI_UNSUPPORTED;
73 }
74
75 //
76 // 48 bit address feature set is supported, get maximum capacity
77 //
78 Capacity = Atapi6IdentifyStruct->AtapiData.max_user_lba_for_48bit_addr[0];
79 for (Index = 1; Index < 4; Index++) {
80 //
81 // Lower byte goes first: word[100] is the lowest word, word[103] is highest
82 //
83 TmpLba = Atapi6IdentifyStruct->AtapiData.max_user_lba_for_48bit_addr[Index];
84 Capacity |= LShiftU64 (TmpLba, 16 * Index);
85 }
86
87 if (Capacity > MAX_28BIT_ADDRESSING_CAPACITY) {
88 //
89 // Capacity exceeds 120GB. 48-bit addressing is really needed
90 //
91 IdeDev->Type = Ide48bitAddressingHardDisk;
92
93 //
94 // Fill block media information:Media->LogicalPartition ,
95 // Media->WriteCaching will be filledin the DiscoverIdeDevcie() function.
96 //
97 IdeDev->BlkIo.Media->IoAlign = 4;
98 IdeDev->BlkIo.Media->MediaId = 1;
99 IdeDev->BlkIo.Media->RemovableMedia = FALSE;
100 IdeDev->BlkIo.Media->MediaPresent = TRUE;
101 IdeDev->BlkIo.Media->ReadOnly = FALSE;
102 IdeDev->BlkIo.Media->BlockSize = 0x200;
103 IdeDev->BlkIo.Media->LastBlock = Capacity - 1;
104
105 return EFI_SUCCESS;
106 }
107
108 return EFI_UNSUPPORTED;
109}
110/**
111 Enable SMART of the disk if supported
112
113 @param IdeDev pointer pointing to IDE_BLK_IO_DEV data structure,used to record
114 all the information of the IDE device.
115**/
116VOID
117AtaSMARTSupport (
118 IN IDE_BLK_IO_DEV *IdeDev
119 )
120{
121 EFI_STATUS Status;
122 BOOLEAN SMARTSupported;
123 UINT8 Device;
124 EFI_IDENTIFY_DATA *TmpAtaIdentifyPointer;
125 UINT8 DeviceSelect;
126 UINT8 LBAMid;
127 UINT8 LBAHigh;
128
129 //
130 // Detect if the device supports S.M.A.R.T.
131 //
132 if ((IdeDev->IdData->AtaData.command_set_supported_83 & 0xc000) != 0x4000) {
133 //
134 // Data in word 82 is not valid (bit15 shall be zero and bit14 shall be to one)
135 //
136 return ;
137 } else {
138 if ((IdeDev->IdData->AtaData.command_set_supported_82 & 0x0001) != 0x0001) {
139 //
140 // S.M.A.R.T is not supported by the device
141 //
142 SMARTSupported = FALSE;
143 } else {
144 SMARTSupported = TRUE;
145 }
146 }
147
148 if (!SMARTSupported) {
149 //
150 // Report nonsupport status code
151 //
152 REPORT_STATUS_CODE (
153 EFI_ERROR_CODE | EFI_ERROR_MINOR,
154 (EFI_IO_BUS_ATA_ATAPI | EFI_IOB_ATA_BUS_SMART_NOTSUPPORTED)
155 );
156 } else {
157 //
158 // Enable this feature
159 //
160 REPORT_STATUS_CODE (
161 EFI_PROGRESS_CODE,
162 (EFI_IO_BUS_ATA_ATAPI | EFI_IOB_ATA_BUS_SMART_ENABLE)
163 );
164
165 Device = (UINT8) ((IdeDev->Device << 4) | 0xe0);
166 Status = AtaNonDataCommandIn (
167 IdeDev,
168 ATA_CMD_SMART,
169 Device,
170 ATA_SMART_ENABLE_OPERATION,
171 0,
172 0,
173 ATA_CONSTANT_4F,
174 ATA_CONSTANT_C2
175 );
176 //
177 // Detect if this feature is enabled
178 //
179 TmpAtaIdentifyPointer = (EFI_IDENTIFY_DATA *) AllocateZeroPool (sizeof (EFI_IDENTIFY_DATA));
180 if (TmpAtaIdentifyPointer == NULL) {
181 return;
182 }
183
184 DeviceSelect = (UINT8) ((IdeDev->Device) << 4);
185 Status = AtaPioDataIn (
186 IdeDev,
187 (VOID *) TmpAtaIdentifyPointer,
188 sizeof (EFI_IDENTIFY_DATA),
189 ATA_CMD_IDENTIFY_DRIVE,
190 DeviceSelect,
191 0,
192 0,
193 0,
194 0
195 );
196 if (EFI_ERROR (Status)) {
197 gBS->FreePool (TmpAtaIdentifyPointer);
198 return ;
199 }
200
201 //
202 // Check if the feature is enabled
203 //
204 if ((TmpAtaIdentifyPointer->AtaData.command_set_feature_enb_85 & 0x0001) == 0x0001) {
205 //
206 // Read status data
207 //
208 AtaNonDataCommandIn (
209 IdeDev,
210 ATA_CMD_SMART,
211 Device,
212 ATA_SMART_RETURN_STATUS,
213 0,
214 0,
215 ATA_CONSTANT_4F,
216 ATA_CONSTANT_C2
217 );
218 LBAMid = IDEReadPortB (IdeDev->PciIo, IdeDev->IoPort->CylinderLsb);
219 LBAHigh = IDEReadPortB (IdeDev->PciIo, IdeDev->IoPort->CylinderMsb);
220
221 if ((LBAMid == 0x4f) && (LBAHigh == 0xc2)) {
222 //
223 // The threshold exceeded condition is not detected by the device
224 //
225 REPORT_STATUS_CODE (
226 EFI_PROGRESS_CODE,
227 (EFI_IO_BUS_ATA_ATAPI | EFI_IOB_ATA_BUS_SMART_UNDERTHRESHOLD)
228 );
229
230 } else if ((LBAMid == 0xf4) && (LBAHigh == 0x2c)) {
231 //
232 // The threshold exceeded condition is detected by the device
233 //
234 REPORT_STATUS_CODE (
235 EFI_PROGRESS_CODE,
236 (EFI_IO_BUS_ATA_ATAPI | EFI_IOB_ATA_BUS_SMART_OVERTHRESHOLD)
237 );
238 }
239
240 } else {
241 //
242 // Report disabled status code
243 //
244 REPORT_STATUS_CODE (
245 EFI_ERROR_CODE | EFI_ERROR_MINOR,
246 (EFI_IO_BUS_ATA_ATAPI | EFI_IOB_ATA_BUS_SMART_DISABLED)
247 );
248 }
249
250 gBS->FreePool (TmpAtaIdentifyPointer);
251 }
252
253 return ;
254}
255/**
256 Sends out an ATA Identify Command to the specified device.
257
258 This function is called by DiscoverIdeDevice() during its device
259 identification. It sends out the ATA Identify Command to the
260 specified device. Only ATA device responses to this command. If
261 the command succeeds, it returns the Identify data structure which
262 contains information about the device. This function extracts the
263 information it needs to fill the IDE_BLK_IO_DEV data structure,
264 including device type, media block size, media capacity, and etc.
265
266 @param IdeDev pointer pointing to IDE_BLK_IO_DEV data structure,used to record
267 all the information of the IDE device.
268
269 @retval EFI_SUCCESS Identify ATA device successfully.
270 @retval EFI_DEVICE_ERROR ATA Identify Device Command failed or device is not ATA device.
271 @note parameter IdeDev will be updated in this function.
272
273**/
274EFI_STATUS
275ATAIdentify (
276 IN IDE_BLK_IO_DEV *IdeDev
277 )
278{
279 EFI_STATUS Status;
280 EFI_IDENTIFY_DATA *AtaIdentifyPointer;
281 UINT32 Capacity;
282 UINT8 DeviceSelect;
283 UINTN Retry;
284
285 //
286 // AtaIdentifyPointer is used for accommodating returned IDENTIFY data of
287 // the ATA Identify command
288 //
289 AtaIdentifyPointer = (EFI_IDENTIFY_DATA *) AllocateZeroPool (sizeof (EFI_IDENTIFY_DATA));
290 if (AtaIdentifyPointer == NULL) {
291 return EFI_OUT_OF_RESOURCES;
292 }
293
294 //
295 // use ATA PIO Data In protocol to send ATA Identify command
296 // and receive data from device
297 //
298 DeviceSelect = (UINT8) ((IdeDev->Device) << 4);
299
300
301 Retry = 3;
302 while (Retry > 0) {
303 Status = AtaPioDataIn (
304 IdeDev,
305 (VOID *) AtaIdentifyPointer,
306 sizeof (EFI_IDENTIFY_DATA),
307 ATA_CMD_IDENTIFY_DRIVE,
308 DeviceSelect,
309 0,
310 0,
311 0,
312 0
313 );
314 //
315 // If ATA Identify command succeeds, then according to the received
316 // IDENTIFY data,
317 // identify the device type ( ATA or not ).
318 // If ATA device, fill the information in IdeDev.
319 // If not ATA device, return IDE_DEVICE_ERROR
320 //
321 if (!EFI_ERROR (Status)) {
322
323 IdeDev->IdData = AtaIdentifyPointer;
324
325 //
326 // Print ATA Module Name
327 //
328 PrintAtaModuleName (IdeDev);
329
330 //
331 // bit 15 of pAtaIdentify->config is used to identify whether device is
332 // ATA device or ATAPI device.
333 // if 0, means ATA device; if 1, means ATAPI device.
334 //
335 if ((AtaIdentifyPointer->AtaData.config & 0x8000) == 0x00) {
336 //
337 // Detect if support S.M.A.R.T. If yes, enable it as default
338 //
339 AtaSMARTSupport (IdeDev);
340
341 //
342 // Check whether this device needs 48-bit addressing (ATAPI-6 ata device)
343 //
344 Status = AtaAtapi6Identify (IdeDev);
345 if (!EFI_ERROR (Status)) {
346 //
347 // It's a disk with >120GB capacity, initialized in AtaAtapi6Identify()
348 //
349 return EFI_SUCCESS;
350 } else if (Status == EFI_DEVICE_ERROR) {
351 //
352 // Some disk with big capacity (>200GB) is slow when being identified
353 // and will return all zero for word83.
354 // We try twice at first. If it fails, we do a SoftRest and try again.
355 //
356 Retry--;
357 if (Retry == 1) {
358 //
359 // Do a SoftRest before the third attempt.
360 //
361 AtaSoftReset (IdeDev);
362 }
363 continue;
364 }
365 //
366 // This is a hard disk <= 120GB capacity, treat it as normal hard disk
367 //
368 IdeDev->Type = IdeHardDisk;
369
370 //
371 // Block Media Information:
372 // Media->LogicalPartition , Media->WriteCaching will be filled
373 // in the DiscoverIdeDevcie() function.
374 //
375 IdeDev->BlkIo.Media->IoAlign = 4;
376 IdeDev->BlkIo.Media->MediaId = 1;
377 IdeDev->BlkIo.Media->RemovableMedia = FALSE;
378 IdeDev->BlkIo.Media->MediaPresent = TRUE;
379 IdeDev->BlkIo.Media->ReadOnly = FALSE;
380 IdeDev->BlkIo.Media->BlockSize = 0x200;
381
382 //
383 // Calculate device capacity
384 //
385 Capacity = ((UINT32)AtaIdentifyPointer->AtaData.user_addressable_sectors_hi << 16) |
386 AtaIdentifyPointer->AtaData.user_addressable_sectors_lo ;
387 IdeDev->BlkIo.Media->LastBlock = Capacity - 1;
388
389 return EFI_SUCCESS;
390 }
391
392 }
393 break;
394 }
395
396 gBS->FreePool (AtaIdentifyPointer);
397 //
398 // Make sure the pIdData will not be freed again.
399 //
400 IdeDev->IdData = NULL;
401
402 return EFI_DEVICE_ERROR;
403}
404
405/**
406 This function is a helper function used to change the char order in a string. It
407 is designed specially for the PrintAtaModuleName() function. After the IDE device
408 is detected, the IDE driver gets the device module name by sending ATA command
409 called ATA Identify Command or ATAPI Identify Command to the specified IDE device.
410 The module name returned is a string of ASCII characters: the first character is bit8--bit15
411 of the first word, the second character is BIT0--bit7 of the first word and so on. Thus
412 the string can not be print directly before it is preprocessed by this func to change
413 the order of characters in each word in the string.
414
415 @param Destination Indicates the destination string.
416 @param Source Indicates the source string.
417 @param Size the length of the string
418**/
419VOID
420SwapStringChars (
421 IN CHAR8 *Destination,
422 IN CHAR8 *Source,
423 IN UINT32 Size
424 )
425{
426 UINT32 Index;
427 CHAR8 Temp;
428
429 for (Index = 0; Index < Size; Index += 2) {
430
431 Temp = Source[Index + 1];
432 Destination[Index + 1] = Source[Index];
433 Destination[Index] = Temp;
434 }
435}
436/**
437 This function is called by ATAIdentify() or ATAPIIdentify() to print device's module name.
438
439 @param IdeDev pointer pointing to IDE_BLK_IO_DEV data structure, used to record
440 all the information of the IDE device.
441**/
442VOID
443PrintAtaModuleName (
444 IN IDE_BLK_IO_DEV *IdeDev
445 )
446{
447 if (IdeDev->IdData == NULL) {
448 return ;
449 }
450
451 SwapStringChars (IdeDev->ModelName, IdeDev->IdData->AtaData.ModelName, 40);
452 IdeDev->ModelName[40] = 0x00;
453}
454
455/**
456 This function is used to send out ATA commands conforms to the PIO Data In Protocol.
457
458 @param IdeDev pointer pointing to IDE_BLK_IO_DEV data structure, used to record
459 all the information of the IDE device.
460 @param Buffer buffer contained data transferred from device to host.
461 @param ByteCount data size in byte unit of the buffer.
462 @param AtaCommand value of the Command Register
463 @param Head value of the Head/Device Register
464 @param SectorCount value of the Sector Count Register
465 @param SectorNumber value of the Sector Number Register
466 @param CylinderLsb value of the low byte of the Cylinder Register
467 @param CylinderMsb value of the high byte of the Cylinder Register
468
469 @retval EFI_SUCCESS send out the ATA command and device send required data successfully.
470 @retval EFI_DEVICE_ERROR command sent failed.
471
472**/
473EFI_STATUS
474AtaPioDataIn (
475 IN IDE_BLK_IO_DEV *IdeDev,
476 IN VOID *Buffer,
477 IN UINT32 ByteCount,
478 IN UINT8 AtaCommand,
479 IN UINT8 Head,
480 IN UINT8 SectorCount,
481 IN UINT8 SectorNumber,
482 IN UINT8 CylinderLsb,
483 IN UINT8 CylinderMsb
484 )
485{
486 UINTN WordCount;
487 UINTN Increment;
488 UINT16 *Buffer16;
489 EFI_STATUS Status;
490
491 Status = WaitForBSYClear (IdeDev, ATATIMEOUT);
492 if (EFI_ERROR (Status)) {
493 return EFI_DEVICE_ERROR;
494 }
495
496 //
497 // e0:1110,0000-- bit7 and bit5 are reserved bits.
498 // bit6 set means LBA mode
499 //
500 IDEWritePortB (
501 IdeDev->PciIo,
502 IdeDev->IoPort->Head,
503 (UINT8) ((IdeDev->Device << 4) | 0xe0 | Head)
504 );
505
506 //
507 // All ATAPI device's ATA commands can be issued regardless of the
508 // state of the DRDY
509 //
510 if (IdeDev->Type == IdeHardDisk) {
511
512 Status = DRDYReady (IdeDev, ATATIMEOUT);
513 if (EFI_ERROR (Status)) {
514 return EFI_DEVICE_ERROR;
515 }
516 }
517 //
518 // set all the command parameters
519 // Before write to all the following registers, BSY and DRQ must be 0.
520 //
521 Status = DRQClear2 (IdeDev, ATATIMEOUT);
522 if (EFI_ERROR (Status)) {
523 return EFI_DEVICE_ERROR;
524 }
525
526 if (AtaCommand == ATA_CMD_SET_FEATURES) {
527 IDEWritePortB (IdeDev->PciIo, IdeDev->IoPort->Reg1.Feature, 0x03);
528 }
529
530 IDEWritePortB (IdeDev->PciIo, IdeDev->IoPort->SectorCount, SectorCount);
531 IDEWritePortB (IdeDev->PciIo, IdeDev->IoPort->SectorNumber, SectorNumber);
532 IDEWritePortB (IdeDev->PciIo, IdeDev->IoPort->CylinderLsb, CylinderLsb);
533 IDEWritePortB (IdeDev->PciIo, IdeDev->IoPort->CylinderMsb, CylinderMsb);
534
535 //
536 // send command via Command Register
537 //
538 IDEWritePortB (IdeDev->PciIo, IdeDev->IoPort->Reg.Command, AtaCommand);
539
540 Buffer16 = (UINT16 *) Buffer;
541
542 //
543 // According to PIO data in protocol, host can perform a series of reads to
544 // the data register after each time device set DRQ ready;
545 // The data size of "a series of read" is command specific.
546 // For most ATA command, data size received from device will not exceed
547 // 1 sector, hence the data size for "a series of read" can be the whole data
548 // size of one command request.
549 // For ATA command such as Read Sector command, the data size of one ATA
550 // command request is often larger than 1 sector, according to the
551 // Read Sector command, the data size of "a series of read" is exactly 1
552 // sector.
553 // Here for simplification reason, we specify the data size for
554 // "a series of read" to 1 sector (256 words) if data size of one ATA command
555 // request is larger than 256 words.
556 //
557 Increment = 256;
558
559 //
560 // used to record bytes of currently transfered data
561 //
562 WordCount = 0;
563
564 while (WordCount < ByteCount / 2) {
565 //
566 // Poll DRQ bit set, data transfer can be performed only when DRQ is ready.
567 //
568 Status = DRQReady2 (IdeDev, ATATIMEOUT);
569 if (EFI_ERROR (Status)) {
570 return EFI_DEVICE_ERROR;
571 }
572
573 Status = CheckErrorStatus (IdeDev);
574 if (EFI_ERROR (Status)) {
575 return EFI_DEVICE_ERROR;
576 }
577
578 //
579 // Get the byte count for one series of read
580 //
581 if ((WordCount + Increment) > ByteCount / 2) {
582 Increment = ByteCount / 2 - WordCount;
583 }
584
585 IDEReadPortWMultiple (
586 IdeDev->PciIo,
587 IdeDev->IoPort->Data,
588 Increment,
589 Buffer16
590 );
591
592 WordCount += Increment;
593 Buffer16 += Increment;
594
595 }
596
597 DRQClear (IdeDev, ATATIMEOUT);
598
599 return CheckErrorStatus (IdeDev);
600}
601
602/**
603 This function is used to send out ATA commands conforms to the
604 PIO Data Out Protocol.
605
606 @param IdeDev pointer pointing to IDE_BLK_IO_DEV data structure, used
607 to record all the information of the IDE device.
608 @param *Buffer buffer contained data transferred from host to device.
609 @param ByteCount data size in byte unit of the buffer.
610 @param AtaCommand value of the Command Register
611 @param Head value of the Head/Device Register
612 @param SectorCount value of the Sector Count Register
613 @param SectorNumber value of the Sector Number Register
614 @param CylinderLsb value of the low byte of the Cylinder Register
615 @param CylinderMsb value of the high byte of the Cylinder Register
616
617 @retval EFI_SUCCESS send out the ATA command and device received required
618 data successfully.
619 @retval EFI_DEVICE_ERROR command sent failed.
620
621**/
622EFI_STATUS
623AtaPioDataOut (
624 IN IDE_BLK_IO_DEV *IdeDev,
625 IN VOID *Buffer,
626 IN UINT32 ByteCount,
627 IN UINT8 AtaCommand,
628 IN UINT8 Head,
629 IN UINT8 SectorCount,
630 IN UINT8 SectorNumber,
631 IN UINT8 CylinderLsb,
632 IN UINT8 CylinderMsb
633 )
634{
635 UINTN WordCount;
636 UINTN Increment;
637 UINT16 *Buffer16;
638 EFI_STATUS Status;
639
640 Status = WaitForBSYClear (IdeDev, ATATIMEOUT);
641 if (EFI_ERROR (Status)) {
642 return EFI_DEVICE_ERROR;
643 }
644
645 //
646 // select device via Head/Device register.
647 // Before write Head/Device register, BSY and DRQ must be 0.
648 //
649 Status = DRQClear2 (IdeDev, ATATIMEOUT);
650 if (EFI_ERROR (Status)) {
651 return EFI_DEVICE_ERROR;
652 }
653
654 //
655 // e0:1110,0000-- bit7 and bit5 are reserved bits.
656 // bit6 set means LBA mode
657 //
658 IDEWritePortB (
659 IdeDev->PciIo,
660 IdeDev->IoPort->Head,
661 (UINT8) ((IdeDev->Device << 4) | 0xe0 | Head)
662 );
663
664 Status = DRDYReady (IdeDev, ATATIMEOUT);
665 if (EFI_ERROR (Status)) {
666 return EFI_DEVICE_ERROR;
667 }
668
669 //
670 // set all the command parameters
671 // Before write to all the following registers, BSY and DRQ must be 0.
672 //
673 Status = DRQClear2 (IdeDev, ATATIMEOUT);
674 if (EFI_ERROR (Status)) {
675 return EFI_DEVICE_ERROR;
676 }
677
678 IDEWritePortB (IdeDev->PciIo, IdeDev->IoPort->SectorCount, SectorCount);
679 IDEWritePortB (IdeDev->PciIo, IdeDev->IoPort->SectorNumber, SectorNumber);
680 IDEWritePortB (IdeDev->PciIo, IdeDev->IoPort->CylinderLsb, CylinderLsb);
681 IDEWritePortB (IdeDev->PciIo, IdeDev->IoPort->CylinderMsb, CylinderMsb);
682
683 //
684 // send command via Command Register
685 //
686 IDEWritePortB (IdeDev->PciIo, IdeDev->IoPort->Reg.Command, AtaCommand);
687
688 Buffer16 = (UINT16 *) Buffer;
689
690 //
691 // According to PIO data out protocol, host can perform a series of
692 // writes to the data register after each time device set DRQ ready;
693 // The data size of "a series of read" is command specific.
694 // For most ATA command, data size written to device will not exceed 1 sector,
695 // hence the data size for "a series of write" can be the data size of one
696 // command request.
697 // For ATA command such as Write Sector command, the data size of one
698 // ATA command request is often larger than 1 sector, according to the
699 // Write Sector command, the data size of "a series of read" is exactly
700 // 1 sector.
701 // Here for simplification reason, we specify the data size for
702 // "a series of write" to 1 sector (256 words) if data size of one ATA command
703 // request is larger than 256 words.
704 //
705 Increment = 256;
706 WordCount = 0;
707
708 while (WordCount < ByteCount / 2) {
709
710 //
711 // DRQReady2-- read Alternate Status Register to determine the DRQ bit
712 // data transfer can be performed only when DRQ is ready.
713 //
714 Status = DRQReady2 (IdeDev, ATATIMEOUT);
715 if (EFI_ERROR (Status)) {
716 return EFI_DEVICE_ERROR;
717 }
718
719 Status = CheckErrorStatus (IdeDev);
720 if (EFI_ERROR (Status)) {
721 return EFI_DEVICE_ERROR;
722 }
723
724 //
725 // Check the remaining byte count is less than 512 bytes
726 //
727 if ((WordCount + Increment) > ByteCount / 2) {
728 Increment = ByteCount / 2 - WordCount;
729 }
730 //
731 // perform a series of write without check DRQ ready
732 //
733
734 IDEWritePortWMultiple (
735 IdeDev->PciIo,
736 IdeDev->IoPort->Data,
737 Increment,
738 Buffer16
739 );
740 WordCount += Increment;
741 Buffer16 += Increment;
742
743 }
744
745 DRQClear (IdeDev, ATATIMEOUT);
746
747 return CheckErrorStatus (IdeDev);
748}
749
750/**
751 This function is used to analyze the Status Register and print out
752 some debug information and if there is ERR bit set in the Status
753 Register, the Error Register's value is also be parsed and print out.
754
755 @param IdeDev pointer pointing to IDE_BLK_IO_DEV data structure, used to
756 record all the information of the IDE device.
757
758 @retval EFI_SUCCESS No err information in the Status Register.
759 @retval EFI_DEVICE_ERROR Any err information in the Status Register.
760
761**/
762EFI_STATUS
763CheckErrorStatus (
764 IN IDE_BLK_IO_DEV *IdeDev
765 )
766{
767 UINT8 StatusRegister;
768 UINT8 ErrorRegister;
769
770 StatusRegister = IDEReadPortB (IdeDev->PciIo, IdeDev->IoPort->Reg.Status);
771
772 DEBUG_CODE_BEGIN ();
773
774 if ((StatusRegister & ATA_STSREG_DWF) != 0) {
775 DEBUG (
776 (EFI_D_BLKIO,
777 "CheckErrorStatus()-- %02x : Error : Write Fault\n",
778 StatusRegister)
779 );
780 }
781
782 if ((StatusRegister & ATA_STSREG_CORR) != 0) {
783 DEBUG (
784 (EFI_D_BLKIO,
785 "CheckErrorStatus()-- %02x : Error : Corrected Data\n",
786 StatusRegister)
787 );
788 }
789
790 if ((StatusRegister & ATA_STSREG_ERR) != 0) {
791 ErrorRegister = IDEReadPortB (IdeDev->PciIo, IdeDev->IoPort->Reg1.Error);
792
793 if ((ErrorRegister & ATA_ERRREG_BBK) != 0) {
794 DEBUG (
795 (EFI_D_BLKIO,
796 "CheckErrorStatus()-- %02x : Error : Bad Block Detected\n",
797 ErrorRegister)
798 );
799 }
800
801 if ((ErrorRegister & ATA_ERRREG_UNC) != 0) {
802 DEBUG (
803 (EFI_D_BLKIO,
804 "CheckErrorStatus()-- %02x : Error : Uncorrectable Data\n",
805 ErrorRegister)
806 );
807 }
808
809 if ((ErrorRegister & ATA_ERRREG_MC) != 0) {
810 DEBUG (
811 (EFI_D_BLKIO,
812 "CheckErrorStatus()-- %02x : Error : Media Change\n",
813 ErrorRegister)
814 );
815 }
816
817 if ((ErrorRegister & ATA_ERRREG_ABRT) != 0) {
818 DEBUG (
819 (EFI_D_BLKIO,
820 "CheckErrorStatus()-- %02x : Error : Abort\n",
821 ErrorRegister)
822 );
823 }
824
825 if ((ErrorRegister & ATA_ERRREG_TK0NF) != 0) {
826 DEBUG (
827 (EFI_D_BLKIO,
828 "CheckErrorStatus()-- %02x : Error : Track 0 Not Found\n",
829 ErrorRegister)
830 );
831 }
832
833 if ((ErrorRegister & ATA_ERRREG_AMNF) != 0) {
834 DEBUG (
835 (EFI_D_BLKIO,
836 "CheckErrorStatus()-- %02x : Error : Address Mark Not Found\n",
837 ErrorRegister)
838 );
839 }
840 }
841
842 DEBUG_CODE_END ();
843
844 if ((StatusRegister & (ATA_STSREG_ERR | ATA_STSREG_DWF | ATA_STSREG_CORR)) == 0) {
845 return EFI_SUCCESS;
846 }
847
848 return EFI_DEVICE_ERROR;
849
850}
851
852/**
853 This function is called by the AtaBlkIoReadBlocks() to perform reading from
854 media in block unit.
855
856 @param IdeDev pointer pointing to IDE_BLK_IO_DEV data structure, used to record
857 all the information of the IDE device.
858 @param DataBuffer A pointer to the destination buffer for the data.
859 @param Lba The starting logical block address to read from on the device media.
860 @param NumberOfBlocks The number of transfer data blocks.
861
862 @return status is fully dependent on the return status of AtaPioDataIn() function.
863
864**/
865EFI_STATUS
866AtaReadSectors (
867 IN IDE_BLK_IO_DEV *IdeDev,
868 IN VOID *DataBuffer,
869 IN EFI_LBA Lba,
870 IN UINTN NumberOfBlocks
871 )
872{
873 EFI_STATUS Status;
874 UINTN BlocksRemaining;
875 UINT32 Lba32;
876 UINT8 Lba0;
877 UINT8 Lba1;
878 UINT8 Lba2;
879 UINT8 Lba3;
880 UINT8 AtaCommand;
881 UINT8 SectorCount8;
882 UINT16 SectorCount;
883 UINTN ByteCount;
884 VOID *Buffer;
885
886 Buffer = DataBuffer;
887
888 //
889 // Using ATA Read Sector(s) command (opcode=0x20) with PIO DATA IN protocol
890 //
891 AtaCommand = ATA_CMD_READ_SECTORS;
892
893
894 BlocksRemaining = NumberOfBlocks;
895
896 Lba32 = (UINT32) Lba;
897
898 Status = EFI_SUCCESS;
899
900 while (BlocksRemaining > 0) {
901
902 //
903 // in ATA-3 spec, LBA is in 28 bit width
904 //
905 Lba0 = (UINT8) Lba32;
906 Lba1 = (UINT8) (Lba32 >> 8);
907 Lba2 = (UINT8) (Lba32 >> 16);
908 //
909 // low 4 bit of Lba3 stands for LBA bit24~bit27.
910 //
911 Lba3 = (UINT8) ((Lba32 >> 24) & 0x0f);
912
913 if (BlocksRemaining >= 0x100) {
914
915 //
916 // SectorCount8 is sent to Sector Count register, 0x00 means 256
917 // sectors to be read
918 //
919 SectorCount8 = 0x00;
920 //
921 // SectorCount is used to record the number of sectors to be read
922 //
923 SectorCount = 256;
924 } else {
925
926 SectorCount8 = (UINT8) BlocksRemaining;
927 SectorCount = (UINT16) BlocksRemaining;
928 }
929
930 //
931 // ByteCount is the number of bytes that will be read
932 //
933 ByteCount = SectorCount * (IdeDev->BlkIo.Media->BlockSize);
934
935 //
936 // call AtaPioDataIn() to send Read Sector Command and receive data read
937 //
938 Status = AtaPioDataIn (
939 IdeDev,
940 Buffer,
941 (UINT32) ByteCount,
942 AtaCommand,
943 Lba3,
944 SectorCount8,
945 Lba0,
946 Lba1,
947 Lba2
948 );
949 if (EFI_ERROR (Status)) {
950 return Status;
951 }
952
953 Lba32 += SectorCount;
954 Buffer = ((UINT8 *) Buffer + ByteCount);
955 BlocksRemaining -= SectorCount;
956 }
957
958 return Status;
959}
960
961/**
962 This function is called by the AtaBlkIoWriteBlocks() to perform writing onto
963 media in block unit.
964
965 @param IdeDev pointer pointing to IDE_BLK_IO_DEV data structure,used to record
966 all the information of the IDE device.
967 @param BufferData A pointer to the source buffer for the data.
968 @param Lba The starting logical block address to write onto the device media.
969 @param NumberOfBlocks The number of transfer data blocks.
970
971 @return status is fully dependent on the return status of AtaPioDataIn() function.
972
973**/
974EFI_STATUS
975AtaWriteSectors (
976 IN IDE_BLK_IO_DEV *IdeDev,
977 IN VOID *BufferData,
978 IN EFI_LBA Lba,
979 IN UINTN NumberOfBlocks
980 )
981{
982 EFI_STATUS Status;
983 UINTN BlocksRemaining;
984 UINT32 Lba32;
985 UINT8 Lba0;
986 UINT8 Lba1;
987 UINT8 Lba2;
988 UINT8 Lba3;
989 UINT8 AtaCommand;
990 UINT8 SectorCount8;
991 UINT16 SectorCount;
992 UINTN ByteCount;
993 VOID *Buffer;
994
995 Buffer = BufferData;
996
997 //
998 // Using Write Sector(s) command (opcode=0x30) with PIO DATA OUT protocol
999 //
1000 AtaCommand = ATA_CMD_WRITE_SECTORS;
1001
1002 BlocksRemaining = NumberOfBlocks;
1003
1004 Lba32 = (UINT32) Lba;
1005
1006 Status = EFI_SUCCESS;
1007
1008 while (BlocksRemaining > 0) {
1009
1010 Lba0 = (UINT8) Lba32;
1011 Lba1 = (UINT8) (Lba32 >> 8);
1012 Lba2 = (UINT8) (Lba32 >> 16);
1013 Lba3 = (UINT8) ((Lba32 >> 24) & 0x0f);
1014
1015 if (BlocksRemaining >= 0x100) {
1016
1017 //
1018 // SectorCount8 is sent to Sector Count register, 0x00 means 256 sectors
1019 // to be written
1020 //
1021 SectorCount8 = 0x00;
1022 //
1023 // SectorCount is used to record the number of sectors to be written
1024 //
1025 SectorCount = 256;
1026 } else {
1027
1028 SectorCount8 = (UINT8) BlocksRemaining;
1029 SectorCount = (UINT16) BlocksRemaining;
1030 }
1031
1032 ByteCount = SectorCount * (IdeDev->BlkIo.Media->BlockSize);
1033
1034 Status = AtaPioDataOut (
1035 IdeDev,
1036 Buffer,
1037 (UINT32) ByteCount,
1038 AtaCommand,
1039 Lba3,
1040 SectorCount8,
1041 Lba0,
1042 Lba1,
1043 Lba2
1044 );
1045 if (EFI_ERROR (Status)) {
1046 return Status;
1047 }
1048
1049 Lba32 += SectorCount;
1050 Buffer = ((UINT8 *) Buffer + ByteCount);
1051 BlocksRemaining -= SectorCount;
1052 }
1053
1054 return Status;
1055}
1056/**
1057 This function is used to implement the Soft Reset on the specified device. But,
1058 the ATA Soft Reset mechanism is so strong a reset method that it will force
1059 resetting on both devices connected to the same cable.
1060
1061 It is called by IdeBlkIoReset(), a interface function of Block
1062 I/O protocol.
1063
1064 This function can also be used by the ATAPI device to perform reset when
1065 ATAPI Reset command is failed.
1066
1067 @param IdeDev pointer pointing to IDE_BLK_IO_DEV data structure, used to record
1068 all the information of the IDE device.
1069 @retval EFI_SUCCESS Soft reset completes successfully.
1070 @retval EFI_DEVICE_ERROR Any step during the reset process is failed.
1071
1072 @note The registers initial values after ATA soft reset are different
1073 to the ATA device and ATAPI device.
1074**/
1075EFI_STATUS
1076AtaSoftReset (
1077 IN IDE_BLK_IO_DEV *IdeDev
1078 )
1079{
1080
1081 UINT8 DeviceControl;
1082
1083 DeviceControl = 0;
1084 //
1085 // set SRST bit to initiate soft reset
1086 //
1087 DeviceControl |= ATA_CTLREG_SRST;
1088
1089 //
1090 // disable Interrupt
1091 //
1092 DeviceControl |= BIT1;
1093
1094 IDEWritePortB (IdeDev->PciIo, IdeDev->IoPort->Alt.DeviceControl, DeviceControl);
1095
1096 //
1097 // SRST should assert for at least 5 us, we use 10 us for
1098 // better compatibility
1099 //
1100 gBS->Stall (10);
1101
1102 //
1103 // Enable interrupt to support UDMA, and clear SRST bit
1104 //
1105 DeviceControl = 0;
1106 IDEWritePortB (IdeDev->PciIo, IdeDev->IoPort->Alt.DeviceControl, DeviceControl);
1107
1108 //
1109 // Wait for at least 2 ms to check BSY status, we use 10 ms
1110 // for better compatibility
1111 //
1112 gBS->Stall(10000);
1113 //
1114 // slave device needs at most 31s to clear BSY
1115 //
1116 if (WaitForBSYClear (IdeDev, 31000) == EFI_TIMEOUT) {
1117 return EFI_DEVICE_ERROR;
1118 }
1119
1120 return EFI_SUCCESS;
1121}
1122/**
1123 This function is used to send out ATA commands conforms to the PIO Data In
1124 Protocol, supporting ATA/ATAPI-6 standard
1125
1126 Comparing with ATA-3 data in protocol, we have two differents here:
1127 1. Do NOT wait for DRQ clear before sending command into IDE device.(the
1128 wait will frequently fail... cause writing function return error)
1129
1130 2. Do NOT wait for DRQ clear after all data readed.(the wait greatly
1131 slow down writing performance by 100 times!)
1132
1133 @param IdeDev pointer pointing to IDE_BLK_IO_DEV data structure, used
1134 to record all the information of the IDE device.
1135 @param Buffer buffer contained data transferred from device to host.
1136 @param ByteCount data size in byte unit of the buffer.
1137 @param AtaCommand value of the Command Register
1138 @param StartLba the start LBA of this transaction
1139 @param SectorCount the count of sectors to be transfered
1140
1141 @retval EFI_SUCCESS send out the ATA command and device send required data successfully.
1142 @retval EFI_DEVICE_ERROR command sent failed.
1143
1144**/
1145EFI_STATUS
1146AtaPioDataInExt (
1147 IN IDE_BLK_IO_DEV *IdeDev,
1148 IN OUT VOID *Buffer,
1149 IN UINT32 ByteCount,
1150 IN UINT8 AtaCommand,
1151 IN EFI_LBA StartLba,
1152 IN UINT16 SectorCount
1153 )
1154{
1155 UINT8 DevSel;
1156 UINT8 SectorCount8;
1157 UINT8 LbaLow;
1158 UINT8 LbaMid;
1159 UINT8 LbaHigh;
1160 UINTN WordCount;
1161 UINTN Increment;
1162 UINT16 *Buffer16;
1163 EFI_STATUS Status;
1164
1165 Status = WaitForBSYClear (IdeDev, ATATIMEOUT);
1166 if (EFI_ERROR (Status)) {
1167 return EFI_DEVICE_ERROR;
1168 }
1169
1170 //
1171 // Select device, set bit6 as 1 to indicate LBA mode is used
1172 //
1173 DevSel = (UINT8) (IdeDev->Device << 4);
1174 DevSel |= 0x40;
1175 IDEWritePortB (
1176 IdeDev->PciIo,
1177 IdeDev->IoPort->Head,
1178 DevSel
1179 );
1180
1181 //
1182 // Wait for DRDY singnal asserting. ATAPI device needn't wait
1183 //
1184 if ( (IdeDev->Type == IdeHardDisk) ||
1185 (IdeDev->Type == Ide48bitAddressingHardDisk)) {
1186
1187 Status = DRDYReady (IdeDev, ATATIMEOUT);
1188 if (EFI_ERROR (Status)) {
1189 return EFI_DEVICE_ERROR;
1190 }
1191 }
1192
1193 //
1194 // Fill feature register if needed
1195 //
1196 if (AtaCommand == ATA_CMD_SET_FEATURES) {
1197 IDEWritePortB (IdeDev->PciIo, IdeDev->IoPort->Reg1.Feature, 0x03);
1198 }
1199
1200 //
1201 // Fill the sector count register, which is a two-byte FIFO. Need write twice.
1202 //
1203 SectorCount8 = (UINT8) (SectorCount >> 8);
1204 IDEWritePortB (IdeDev->PciIo, IdeDev->IoPort->SectorCount, SectorCount8);
1205
1206 SectorCount8 = (UINT8) SectorCount;
1207 IDEWritePortB (IdeDev->PciIo, IdeDev->IoPort->SectorCount, SectorCount8);
1208
1209 //
1210 // Fill the start LBA registers, which are also two-byte FIFO
1211 //
1212 LbaLow = (UINT8) RShiftU64 (StartLba, 24);
1213 LbaMid = (UINT8) RShiftU64 (StartLba, 32);
1214 LbaHigh = (UINT8) RShiftU64 (StartLba, 40);
1215 IDEWritePortB (IdeDev->PciIo, IdeDev->IoPort->SectorNumber, LbaLow);
1216 IDEWritePortB (IdeDev->PciIo, IdeDev->IoPort->CylinderLsb, LbaMid);
1217 IDEWritePortB (IdeDev->PciIo, IdeDev->IoPort->CylinderMsb, LbaHigh);
1218
1219 LbaLow = (UINT8) StartLba;
1220 LbaMid = (UINT8) RShiftU64 (StartLba, 8);
1221 LbaHigh = (UINT8) RShiftU64 (StartLba, 16);
1222 IDEWritePortB (IdeDev->PciIo, IdeDev->IoPort->SectorNumber, LbaLow);
1223 IDEWritePortB (IdeDev->PciIo, IdeDev->IoPort->CylinderLsb, LbaMid);
1224 IDEWritePortB (IdeDev->PciIo, IdeDev->IoPort->CylinderMsb, LbaHigh);
1225
1226 //
1227 // Send command via Command Register, invoking the processing of this command
1228 //
1229 IDEWritePortB (IdeDev->PciIo, IdeDev->IoPort->Reg.Command, AtaCommand);
1230
1231 Buffer16 = (UINT16 *) Buffer;
1232
1233 //
1234 // According to PIO data in protocol, host can perform a series of reads to
1235 // the data register after each time device set DRQ ready;
1236 //
1237
1238 //
1239 // 256 words
1240 //
1241 Increment = 256;
1242
1243 //
1244 // used to record bytes of currently transfered data
1245 //
1246 WordCount = 0;
1247
1248 while (WordCount < ByteCount / 2) {
1249 //
1250 // Poll DRQ bit set, data transfer can be performed only when DRQ is ready.
1251 //
1252 Status = DRQReady2 (IdeDev, ATATIMEOUT);
1253 if (EFI_ERROR (Status)) {
1254 return EFI_DEVICE_ERROR;
1255 }
1256
1257 Status = CheckErrorStatus (IdeDev);
1258 if (EFI_ERROR (Status)) {
1259 return EFI_DEVICE_ERROR;
1260 }
1261
1262 //
1263 // Get the byte count for one series of read
1264 //
1265 if ((WordCount + Increment) > ByteCount / 2) {
1266 Increment = ByteCount / 2 - WordCount;
1267 }
1268
1269 IDEReadPortWMultiple (
1270 IdeDev->PciIo,
1271 IdeDev->IoPort->Data,
1272 Increment,
1273 Buffer16
1274 );
1275
1276 WordCount += Increment;
1277 Buffer16 += Increment;
1278
1279 }
1280
1281 return CheckErrorStatus (IdeDev);
1282}
1283/**
1284 Send ATA Ext command into device with NON_DATA protocol.
1285
1286 @param IdeDev Standard IDE device private data structure
1287 @param AtaCommand The ATA command to be sent
1288 @param Device The value in Device register
1289 @param Feature The value in Feature register
1290 @param SectorCount The value in SectorCount register
1291 @param LbaAddress The LBA address in 48-bit mode
1292
1293 @retval EFI_SUCCESS Reading succeed
1294 @retval EFI_DEVICE_ERROR Error executing commands on this device.
1295
1296**/
1297EFI_STATUS
1298AtaCommandIssueExt (
1299 IN IDE_BLK_IO_DEV *IdeDev,
1300 IN UINT8 AtaCommand,
1301 IN UINT8 Device,
1302 IN UINT16 Feature,
1303 IN UINT16 SectorCount,
1304 IN EFI_LBA LbaAddress
1305 )
1306{
1307 EFI_STATUS Status;
1308 UINT8 SectorCount8;
1309 UINT8 Feature8;
1310 UINT8 LbaLow;
1311 UINT8 LbaMid;
1312 UINT8 LbaHigh;
1313
1314 Status = WaitForBSYClear (IdeDev, ATATIMEOUT);
1315 if (EFI_ERROR (Status)) {
1316 return EFI_DEVICE_ERROR;
1317 }
1318
1319 //
1320 // Select device (bit4), set LBA mode(bit6) (use 0xe0 for compatibility)
1321 //
1322 IDEWritePortB (
1323 IdeDev->PciIo,
1324 IdeDev->IoPort->Head,
1325 (UINT8) ((IdeDev->Device << 4) | 0xe0)
1326 );
1327
1328 //
1329 // ATA commands for ATA device must be issued when DRDY is set
1330 //
1331 Status = DRDYReady (IdeDev, ATATIMEOUT);
1332 if (EFI_ERROR (Status)) {
1333 return EFI_DEVICE_ERROR;
1334 }
1335
1336 //
1337 // Pass parameter into device register block
1338 //
1339 IDEWritePortB (IdeDev->PciIo, IdeDev->IoPort->Head, Device);
1340
1341 //
1342 // Fill the feature register, which is a two-byte FIFO. Need write twice.
1343 //
1344 Feature8 = (UINT8) (Feature >> 8);
1345 IDEWritePortB (IdeDev->PciIo, IdeDev->IoPort->Reg1.Feature, Feature8);
1346
1347 Feature8 = (UINT8) Feature;
1348 IDEWritePortB (IdeDev->PciIo, IdeDev->IoPort->Reg1.Feature, Feature8);
1349
1350 //
1351 // Fill the sector count register, which is a two-byte FIFO. Need write twice.
1352 //
1353 SectorCount8 = (UINT8) (SectorCount >> 8);
1354 IDEWritePortB (IdeDev->PciIo, IdeDev->IoPort->SectorCount, SectorCount8);
1355
1356 SectorCount8 = (UINT8) SectorCount;
1357 IDEWritePortB (IdeDev->PciIo, IdeDev->IoPort->SectorCount, SectorCount8);
1358
1359 //
1360 // Fill the start LBA registers, which are also two-byte FIFO
1361 //
1362 LbaLow = (UINT8) RShiftU64 (LbaAddress, 24);
1363 IDEWritePortB (IdeDev->PciIo, IdeDev->IoPort->SectorNumber, LbaLow);
1364 LbaLow = (UINT8) LbaAddress;
1365 IDEWritePortB (IdeDev->PciIo, IdeDev->IoPort->SectorNumber, LbaLow);
1366
1367 LbaMid = (UINT8) RShiftU64 (LbaAddress, 32);
1368 IDEWritePortB (IdeDev->PciIo, IdeDev->IoPort->CylinderLsb, LbaMid);
1369 LbaMid = (UINT8) RShiftU64 (LbaAddress, 8);
1370 IDEWritePortB (IdeDev->PciIo, IdeDev->IoPort->CylinderLsb, LbaMid);
1371
1372 LbaHigh = (UINT8) RShiftU64 (LbaAddress, 40);
1373 IDEWritePortB (IdeDev->PciIo, IdeDev->IoPort->CylinderMsb, LbaHigh);
1374 LbaHigh = (UINT8) RShiftU64 (LbaAddress, 16);
1375 IDEWritePortB (IdeDev->PciIo, IdeDev->IoPort->CylinderMsb, LbaHigh);
1376
1377 //
1378 // Work around for Segate 160G disk writing
1379 //
1380 gBS->Stall (1800);
1381
1382 //
1383 // Send command via Command Register
1384 //
1385 IDEWritePortB (IdeDev->PciIo, IdeDev->IoPort->Reg.Command, AtaCommand);
1386
1387 //
1388 // Stall at least 400ns
1389 //
1390 gBS->Stall (100);
1391
1392 return EFI_SUCCESS;
1393}
1394/**
1395 Send ATA Ext command into device with NON_DATA protocol
1396
1397 @param IdeDev Standard IDE device private data structure
1398 @param AtaCommand The ATA command to be sent
1399 @param Device The value in Device register
1400 @param Feature The value in Feature register
1401 @param SectorCount The value in SectorCount register
1402 @param LbaAddress The LBA address in 48-bit mode
1403
1404 @retval EFI_SUCCESS Reading succeed
1405 @retval EFI_DEVICE_ERROR Error executing commands on this device.
1406
1407**/
1408EFI_STATUS
1409AtaCommandIssue (
1410 IN IDE_BLK_IO_DEV *IdeDev,
1411 IN UINT8 AtaCommand,
1412 IN UINT8 Device,
1413 IN UINT16 Feature,
1414 IN UINT16 SectorCount,
1415 IN EFI_LBA LbaAddress
1416 )
1417{
1418 EFI_STATUS Status;
1419 UINT8 SectorCount8;
1420 UINT8 Feature8;
1421 UINT8 Lba0;
1422 UINT8 Lba1;
1423 UINT8 Lba2;
1424 UINT8 Lba3;
1425
1426 Status = WaitForBSYClear (IdeDev, ATATIMEOUT);
1427 if (EFI_ERROR (Status)) {
1428 return EFI_DEVICE_ERROR;
1429 }
1430
1431 //
1432 // Select device (bit4), set LBA mode(bit6) (use 0xe0 for compatibility)
1433 //
1434 IDEWritePortB (
1435 IdeDev->PciIo,
1436 IdeDev->IoPort->Head,
1437 (UINT8) ((IdeDev->Device << 4) | 0xe0)
1438 );
1439
1440 //
1441 // ATA commands for ATA device must be issued when DRDY is set
1442 //
1443 Status = DRDYReady (IdeDev, ATATIMEOUT);
1444 if (EFI_ERROR (Status)) {
1445 return EFI_DEVICE_ERROR;
1446 }
1447
1448 Lba0 = (UINT8) LbaAddress;
1449 Lba1 = (UINT8) RShiftU64 (LbaAddress, 8);
1450 Lba2 = (UINT8) RShiftU64 (LbaAddress, 16);
1451 Lba3 = (UINT8) RShiftU64 (LbaAddress, 24);
1452 Device = (UINT8) (Device | Lba3);
1453
1454 //
1455 // Pass parameter into device register block
1456 //
1457 IDEWritePortB (IdeDev->PciIo, IdeDev->IoPort->Head, Device);
1458
1459 //
1460 // Fill the feature register, which is a two-byte FIFO. Need write twice.
1461 //
1462 Feature8 = (UINT8) Feature;
1463 IDEWritePortB (IdeDev->PciIo, IdeDev->IoPort->Reg1.Feature, Feature8);
1464
1465 //
1466 // Fill the sector count register, which is a two-byte FIFO. Need write twice.
1467 //
1468 SectorCount8 = (UINT8) SectorCount;
1469 IDEWritePortB (IdeDev->PciIo, IdeDev->IoPort->SectorCount, SectorCount8);
1470
1471 //
1472 // Fill the start LBA registers, which are also two-byte FIFO
1473 //
1474
1475 IDEWritePortB (IdeDev->PciIo, IdeDev->IoPort->SectorNumber, Lba0);
1476 IDEWritePortB (IdeDev->PciIo, IdeDev->IoPort->CylinderLsb, Lba1);
1477 IDEWritePortB (IdeDev->PciIo, IdeDev->IoPort->CylinderMsb, Lba2);
1478
1479 //
1480 // Send command via Command Register
1481 //
1482 IDEWritePortB (IdeDev->PciIo, IdeDev->IoPort->Reg.Command, AtaCommand);
1483
1484 //
1485 // Stall at least 400ns
1486 //
1487 gBS->Stall (100);
1488
1489 return EFI_SUCCESS;
1490}
1491/**
1492 Perform an ATA Udma operation (Read, ReadExt, Write, WriteExt).
1493
1494 @param IdeDev pointer pointing to IDE_BLK_IO_DEV data structure, used
1495 to record all the information of the IDE device.
1496 @param DataBuffer A pointer to the source buffer for the data.
1497 @param StartLba The starting logical block address to write to
1498 on the device media.
1499 @param NumberOfBlocks The number of transfer data blocks.
1500 @param UdmaOp The perform operations could be AtaUdmaReadOp, AtaUdmaReadExOp,
1501 AtaUdmaWriteOp, AtaUdmaWriteExOp
1502
1503 @retval EFI_SUCCESS the operation is successful.
1504 @retval EFI_OUT_OF_RESOURCES Build PRD table failed
1505 @retval EFI_UNSUPPORTED Unknown channel or operations command
1506 @retval EFI_DEVICE_ERROR Ata command execute failed
1507
1508**/
1509EFI_STATUS
1510DoAtaUdma (
1511 IN IDE_BLK_IO_DEV *IdeDev,
1512 IN VOID *DataBuffer,
1513 IN EFI_LBA StartLba,
1514 IN UINTN NumberOfBlocks,
1515 IN ATA_UDMA_OPERATION UdmaOp
1516 )
1517{
1518 IDE_DMA_PRD *PrdAddr;
1519 IDE_DMA_PRD *UsedPrdAddr;
1520 IDE_DMA_PRD *TempPrdAddr;
1521 UINT8 RegisterValue;
1522 UINT8 Device;
1523 UINT64 IoPortForBmic;
1524 UINT64 IoPortForBmis;
1525 UINT64 IoPortForBmid;
1526 EFI_STATUS Status;
1527 UINTN PrdTableNum;
1528 UINTN ByteCount;
1529 UINTN ByteAvailable;
1530 UINT8 *PrdBuffer;
1531 UINTN RemainBlockNum;
1532 UINT8 DeviceControl;
1533 UINT32 Count;
1534 UINTN PageCount;
1535 VOID *Map;
1536 VOID *MemPage;
1537 EFI_PHYSICAL_ADDRESS DeviceAddress;
1538 UINTN MaxDmaCommandSectors;
1539 EFI_PCI_IO_PROTOCOL_OPERATION PciIoProtocolOp;
1540 UINT8 AtaCommand;
1541
1542 switch (UdmaOp) {
1543 case AtaUdmaReadOp:
1544 MaxDmaCommandSectors = ATAPI_MAX_DMA_CMD_SECTORS;
1545 PciIoProtocolOp = EfiPciIoOperationBusMasterWrite;
1546 AtaCommand = ATA_CMD_READ_DMA;
1547 break;
1548 case AtaUdmaReadExtOp:
1549 MaxDmaCommandSectors = ATAPI_MAX_DMA_EXT_CMD_SECTORS;
1550 PciIoProtocolOp = EfiPciIoOperationBusMasterWrite;
1551 AtaCommand = ATA_CMD_READ_DMA_EXT;
1552 break;
1553 case AtaUdmaWriteOp:
1554 MaxDmaCommandSectors = ATAPI_MAX_DMA_CMD_SECTORS;
1555 PciIoProtocolOp = EfiPciIoOperationBusMasterRead;
1556 AtaCommand = ATA_CMD_WRITE_DMA;
1557 break;
1558 case AtaUdmaWriteExtOp:
1559 MaxDmaCommandSectors = ATAPI_MAX_DMA_EXT_CMD_SECTORS;
1560 PciIoProtocolOp = EfiPciIoOperationBusMasterRead;
1561 AtaCommand = ATA_CMD_WRITE_DMA_EXT;
1562 break;
1563 default:
1564 return EFI_UNSUPPORTED;
1565 break;
1566 }
1567
1568 //
1569 // Select device
1570 //
1571 Device = (UINT8) ((IdeDev->Device << 4) | 0xe0);
1572 IDEWritePortB (IdeDev->PciIo, IdeDev->IoPort->Head, Device);
1573
1574 //
1575 // Enable interrupt to support UDMA
1576 //
1577 DeviceControl = 0;
1578 IDEWritePortB (IdeDev->PciIo, IdeDev->IoPort->Alt.DeviceControl, DeviceControl);
1579
1580 if (IdePrimary == IdeDev->Channel) {
1581 IoPortForBmic = IdeDev->IoPort->BusMasterBaseAddr + BMICP_OFFSET;
1582 IoPortForBmis = IdeDev->IoPort->BusMasterBaseAddr + BMISP_OFFSET;
1583 IoPortForBmid = IdeDev->IoPort->BusMasterBaseAddr + BMIDP_OFFSET;
1584 } else {
1585 if (IdeSecondary == IdeDev->Channel) {
1586 IoPortForBmic = IdeDev->IoPort->BusMasterBaseAddr + BMICS_OFFSET;
1587 IoPortForBmis = IdeDev->IoPort->BusMasterBaseAddr + BMISS_OFFSET;
1588 IoPortForBmid = IdeDev->IoPort->BusMasterBaseAddr + BMIDS_OFFSET;
1589 } else {
1590 return EFI_UNSUPPORTED;
1591 }
1592 }
1593
1594 //
1595 // Read BMIS register and clear ERROR and INTR bit
1596 //
1597 IdeDev->PciIo->Io.Read (
1598 IdeDev->PciIo,
1599 EfiPciIoWidthUint8,
1600 EFI_PCI_IO_PASS_THROUGH_BAR,
1601 IoPortForBmis,
1602 1,
1603 &RegisterValue
1604 );
1605
1606 RegisterValue |= (BMIS_INTERRUPT | BMIS_ERROR);
1607
1608 IdeDev->PciIo->Io.Write (
1609 IdeDev->PciIo,
1610 EfiPciIoWidthUint8,
1611 EFI_PCI_IO_PASS_THROUGH_BAR,
1612 IoPortForBmis,
1613 1,
1614 &RegisterValue
1615 );
1616
1617 Status = EFI_SUCCESS;
1618
1619 RemainBlockNum = NumberOfBlocks;
1620 while (RemainBlockNum > 0) {
1621
1622 if (RemainBlockNum >= MaxDmaCommandSectors) {
1623 //
1624 // SectorCount is used to record the number of sectors to be read
1625 // Max 65536 sectors can be transfered at a time.
1626 //
1627 NumberOfBlocks = MaxDmaCommandSectors;
1628 RemainBlockNum -= MaxDmaCommandSectors;
1629 } else {
1630 NumberOfBlocks = (UINT16) RemainBlockNum;
1631 RemainBlockNum = 0;
1632 }
1633
1634 //
1635 // Calculate the number of PRD table to make sure the memory region
1636 // not cross 64K boundary
1637 //
1638 ByteCount = NumberOfBlocks * IdeDev->BlkIo.Media->BlockSize;
1639 PrdTableNum = ((ByteCount >> 16) + 1) + 1;
1640
1641 //
1642 // Build PRD table
1643 //
1644 PageCount = EFI_SIZE_TO_PAGES (2 * PrdTableNum * sizeof (IDE_DMA_PRD));
1645 Status = IdeDev->PciIo->AllocateBuffer (
1646 IdeDev->PciIo,
1647 AllocateAnyPages,
1648 EfiBootServicesData,
1649 PageCount,
1650 &MemPage,
1651 0
1652 );
1653 if (EFI_ERROR (Status)) {
1654 return EFI_OUT_OF_RESOURCES;
1655 }
1656 ZeroMem ((VOID *) ((UINTN) MemPage), EFI_PAGES_TO_SIZE (PageCount));
1657
1658 PrdAddr = (IDE_DMA_PRD *) ((UINTN) MemPage);
1659 //
1660 // To make sure PRD is allocated in one 64K page
1661 //
1662 if (((UINTN) PrdAddr & 0x0FFFF) > (((UINTN) PrdAddr + PrdTableNum * sizeof (IDE_DMA_PRD) - 1) & 0x0FFFF)) {
1663 UsedPrdAddr = (IDE_DMA_PRD *) ((UINTN) ((UINT8 *) PrdAddr + 0x10000) & 0xFFFF0000);
1664 } else {
1665 if ((UINTN) PrdAddr & 0x03) {
1666 UsedPrdAddr = (IDE_DMA_PRD *) ((UINTN) ((UINT8 *) PrdAddr + 0x04) & 0xFFFFFFFC);
1667 } else {
1668 UsedPrdAddr = PrdAddr;
1669 }
1670 }
1671
1672 //
1673 // Build the PRD table
1674 //
1675 Status = IdeDev->PciIo->Map (
1676 IdeDev->PciIo,
1677 PciIoProtocolOp,
1678 DataBuffer,
1679 &ByteCount,
1680 &DeviceAddress,
1681 &Map
1682 );
1683 if (EFI_ERROR (Status)) {
1684 IdeDev->PciIo->FreeBuffer (IdeDev->PciIo, PageCount, MemPage);
1685 return EFI_OUT_OF_RESOURCES;
1686 }
1687 PrdBuffer = (VOID *) ((UINTN) DeviceAddress);
1688 TempPrdAddr = UsedPrdAddr;
1689 while (TRUE) {
1690
1691 ByteAvailable = 0x10000 - ((UINTN) PrdBuffer & 0xFFFF);
1692
1693 if (ByteCount <= ByteAvailable) {
1694 TempPrdAddr->RegionBaseAddr = (UINT32) ((UINTN) PrdBuffer);
1695 TempPrdAddr->ByteCount = (UINT16) ByteCount;
1696 TempPrdAddr->EndOfTable = 0x8000;
1697 break;
1698 }
1699
1700 TempPrdAddr->RegionBaseAddr = (UINT32) ((UINTN) PrdBuffer);
1701 TempPrdAddr->ByteCount = (UINT16) ByteAvailable;
1702
1703 ByteCount -= ByteAvailable;
1704 PrdBuffer += ByteAvailable;
1705 TempPrdAddr++;
1706 }
1707
1708 //
1709 // Set the base address to BMID register
1710 //
1711 IdeDev->PciIo->Io.Write (
1712 IdeDev->PciIo,
1713 EfiPciIoWidthUint32,
1714 EFI_PCI_IO_PASS_THROUGH_BAR,
1715 IoPortForBmid,
1716 1,
1717 &UsedPrdAddr
1718 );
1719
1720 //
1721 // Set BMIC register to identify the operation direction
1722 //
1723 IdeDev->PciIo->Io.Read (
1724 IdeDev->PciIo,
1725 EfiPciIoWidthUint8,
1726 EFI_PCI_IO_PASS_THROUGH_BAR,
1727 IoPortForBmic,
1728 1,
1729 &RegisterValue
1730 );
1731
1732 if (UdmaOp == AtaUdmaReadExtOp || UdmaOp == AtaUdmaReadOp) {
1733 RegisterValue |= BMIC_NREAD;
1734 } else {
1735 RegisterValue &= ~((UINT8) BMIC_NREAD);
1736 }
1737
1738 IdeDev->PciIo->Io.Write (
1739 IdeDev->PciIo,
1740 EfiPciIoWidthUint8,
1741 EFI_PCI_IO_PASS_THROUGH_BAR,
1742 IoPortForBmic,
1743 1,
1744 &RegisterValue
1745 );
1746
1747 if (UdmaOp == AtaUdmaWriteExtOp || UdmaOp == AtaUdmaReadExtOp) {
1748 Status = AtaCommandIssueExt (
1749 IdeDev,
1750 AtaCommand,
1751 Device,
1752 0,
1753 (UINT16) NumberOfBlocks,
1754 StartLba
1755 );
1756 } else {
1757 Status = AtaCommandIssue (
1758 IdeDev,
1759 AtaCommand,
1760 Device,
1761 0,
1762 (UINT16) NumberOfBlocks,
1763 StartLba
1764 );
1765 }
1766
1767 if (EFI_ERROR (Status)) {
1768 IdeDev->PciIo->FreeBuffer (IdeDev->PciIo, PageCount, MemPage);
1769 IdeDev->PciIo->Unmap (IdeDev->PciIo, Map);
1770 return EFI_DEVICE_ERROR;
1771 }
1772
1773 //
1774 // Set START bit of BMIC register
1775 //
1776 IdeDev->PciIo->Io.Read (
1777 IdeDev->PciIo,
1778 EfiPciIoWidthUint8,
1779 EFI_PCI_IO_PASS_THROUGH_BAR,
1780 IoPortForBmic,
1781 1,
1782 &RegisterValue
1783 );
1784
1785 RegisterValue |= BMIC_START;
1786
1787 IdeDev->PciIo->Io.Write (
1788 IdeDev->PciIo,
1789 EfiPciIoWidthUint8,
1790 EFI_PCI_IO_PASS_THROUGH_BAR,
1791 IoPortForBmic,
1792 1,
1793 &RegisterValue
1794 );
1795
1796 //
1797 // Check the INTERRUPT and ERROR bit of BMIS
1798 // Max transfer number of sectors for one command is 65536(32Mbyte),
1799 // it will cost 1 second to transfer these data in UDMA mode 2(33.3MBps).
1800 // So set the variable Count to 2000, for about 2 second timeout time.
1801 //
1802 Status = EFI_SUCCESS;
1803 Count = 2000;
1804 while (TRUE) {
1805
1806 IdeDev->PciIo->Io.Read (
1807 IdeDev->PciIo,
1808 EfiPciIoWidthUint8,
1809 EFI_PCI_IO_PASS_THROUGH_BAR,
1810 IoPortForBmis,
1811 1,
1812 &RegisterValue
1813 );
1814 if (((RegisterValue & (BMIS_INTERRUPT | BMIS_ERROR)) != 0) || (Count == 0)) {
1815 if (((RegisterValue & BMIS_ERROR) != 0) || (Count == 0)) {
1816 Status = EFI_DEVICE_ERROR;
1817 break;
1818 }
1819 break;
1820 }
1821
1822 gBS->Stall (1000);
1823 Count --;
1824 }
1825
1826 IdeDev->PciIo->FreeBuffer (IdeDev->PciIo, PageCount, MemPage);
1827 IdeDev->PciIo->Unmap (IdeDev->PciIo, Map);
1828 //
1829 // Read BMIS register and clear ERROR and INTR bit
1830 //
1831 IdeDev->PciIo->Io.Read (
1832 IdeDev->PciIo,
1833 EfiPciIoWidthUint8,
1834 EFI_PCI_IO_PASS_THROUGH_BAR,
1835 IoPortForBmis,
1836 1,
1837 &RegisterValue
1838 );
1839
1840 RegisterValue |= (BMIS_INTERRUPT | BMIS_ERROR);
1841
1842 IdeDev->PciIo->Io.Write (
1843 IdeDev->PciIo,
1844 EfiPciIoWidthUint8,
1845 EFI_PCI_IO_PASS_THROUGH_BAR,
1846 IoPortForBmis,
1847 1,
1848 &RegisterValue
1849 );
1850 //
1851 // Read Status Register of IDE device to clear interrupt
1852 //
1853 RegisterValue = IDEReadPortB(IdeDev->PciIo,IdeDev->IoPort->Reg.Status);
1854 //
1855 // Clear START bit of BMIC register
1856 //
1857 IdeDev->PciIo->Io.Read (
1858 IdeDev->PciIo,
1859 EfiPciIoWidthUint8,
1860 EFI_PCI_IO_PASS_THROUGH_BAR,
1861 IoPortForBmic,
1862 1,
1863 &RegisterValue
1864 );
1865
1866 RegisterValue &= ~((UINT8) BMIC_START);
1867
1868 IdeDev->PciIo->Io.Write (
1869 IdeDev->PciIo,
1870 EfiPciIoWidthUint8,
1871 EFI_PCI_IO_PASS_THROUGH_BAR,
1872 IoPortForBmic,
1873 1,
1874 &RegisterValue
1875 );
1876
1877 if ((RegisterValue & BMIS_ERROR) != 0) {
1878 return EFI_DEVICE_ERROR;
1879 }
1880
1881 if (EFI_ERROR (Status)) {
1882 break;
1883 }
1884 DataBuffer = (UINT8 *) DataBuffer + NumberOfBlocks * IdeDev->BlkIo.Media->BlockSize;
1885 StartLba += NumberOfBlocks;
1886 }
1887
1888 //
1889 // Disable interrupt of Select device
1890 //
1891 IDEReadPortB (IdeDev->PciIo, IdeDev->IoPort->Alt.DeviceControl);
1892 DeviceControl |= ATA_CTLREG_IEN_L;
1893 IDEWritePortB (IdeDev->PciIo, IdeDev->IoPort->Alt.DeviceControl, DeviceControl);
1894
1895 return Status;
1896}
1897
1898
1899/**
1900 This function is called by the AtaBlkIoReadBlocks() to perform reading from
1901 media in block unit. The function has been enhanced to support >120GB access
1902 and transfer at most 65536 blocks per command
1903
1904 @param IdeDev pointer pointing to IDE_BLK_IO_DEV data structure, used to record
1905 all the information of the IDE device.
1906 @param DataBuffer A pointer to the destination buffer for the data.
1907 @param StartLba The starting logical block address to read from on the device media.
1908 @param NumberOfBlocks The number of transfer data blocks.
1909
1910 @return status depends on the function DoAtaUdma() returns.
1911**/
1912EFI_STATUS
1913AtaUdmaReadExt (
1914 IN IDE_BLK_IO_DEV *IdeDev,
1915 IN VOID *DataBuffer,
1916 IN EFI_LBA StartLba,
1917 IN UINTN NumberOfBlocks
1918 )
1919{
1920 return DoAtaUdma (IdeDev, DataBuffer, StartLba, NumberOfBlocks, AtaUdmaReadExtOp);
1921}
1922/**
1923 This function is called by the AtaBlkIoReadBlocks() to perform
1924 reading from media in block unit. The function has been enhanced to
1925 support >120GB access and transfer at most 65536 blocks per command
1926
1927 @param IdeDev pointer pointing to IDE_BLK_IO_DEV data structure, used to record
1928 all the information of the IDE device.
1929 @param DataBuffer A pointer to the destination buffer for the data.
1930 @param StartLba The starting logical block address to read from
1931 on the device media.
1932 @param NumberOfBlocks The number of transfer data blocks.
1933
1934 @return status depends on the function DoAtaUdma() returns.
1935**/
1936EFI_STATUS
1937AtaUdmaRead (
1938 IN IDE_BLK_IO_DEV *IdeDev,
1939 IN VOID *DataBuffer,
1940 IN EFI_LBA StartLba,
1941 IN UINTN NumberOfBlocks
1942 )
1943{
1944 return DoAtaUdma (IdeDev, DataBuffer, StartLba, NumberOfBlocks, AtaUdmaReadOp);
1945}
1946
1947/**
1948 This function is called by the AtaBlkIoReadBlocks() to perform
1949 reading from media in block unit. The function has been enhanced to
1950 support >120GB access and transfer at most 65536 blocks per command
1951
1952 @param IdeDev pointer pointing to IDE_BLK_IO_DEV data structure, used to record
1953 all the information of the IDE device.
1954 @param DataBuffer A pointer to the destination buffer for the data.
1955 @param StartLba The starting logical block address to read from on the device media.
1956 @param NumberOfBlocks The number of transfer data blocks.
1957
1958 @return status is fully dependent on the return status of AtaPioDataInExt() function.
1959**/
1960EFI_STATUS
1961AtaReadSectorsExt (
1962 IN IDE_BLK_IO_DEV *IdeDev,
1963 IN VOID *DataBuffer,
1964 IN EFI_LBA StartLba,
1965 IN UINTN NumberOfBlocks
1966 )
1967{
1968 EFI_STATUS Status;
1969 UINTN BlocksRemaining;
1970 EFI_LBA Lba64;
1971 UINT8 AtaCommand;
1972 UINT16 SectorCount;
1973 UINT32 ByteCount;
1974 VOID *Buffer;
1975
1976 //
1977 // Using ATA "Read Sectors Ext" command(opcode=0x24) with PIO DATA IN protocol
1978 //
1979 AtaCommand = ATA_CMD_READ_SECTORS_EXT;
1980 Buffer = DataBuffer;
1981 BlocksRemaining = NumberOfBlocks;
1982 Lba64 = StartLba;
1983 Status = EFI_SUCCESS;
1984
1985 while (BlocksRemaining > 0) {
1986
1987 if (BlocksRemaining >= 0x10000) {
1988 //
1989 // SectorCount is used to record the number of sectors to be read
1990 // Max 65536 sectors can be transfered at a time.
1991 //
1992 SectorCount = 0xffff;
1993 } else {
1994 SectorCount = (UINT16) BlocksRemaining;
1995 }
1996
1997 //
1998 // ByteCount is the number of bytes that will be read
1999 //
2000 ByteCount = SectorCount * (IdeDev->BlkIo.Media->BlockSize);
2001
2002 //
2003 // call AtaPioDataInExt() to send Read Sector Command and receive data read
2004 //
2005 Status = AtaPioDataInExt (
2006 IdeDev,
2007 Buffer,
2008 ByteCount,
2009 AtaCommand,
2010 Lba64,
2011 SectorCount
2012 );
2013 if (EFI_ERROR (Status)) {
2014 return Status;
2015 }
2016
2017 Lba64 += SectorCount;
2018 Buffer = ((UINT8 *) Buffer + ByteCount);
2019 BlocksRemaining -= SectorCount;
2020 }
2021
2022 return Status;
2023}
2024/**
2025 This function is the ATA implementation for ReadBlocks in the
2026 Block I/O Protocol interface.
2027
2028 @param IdeBlkIoDevice Indicates the calling context.
2029 @param MediaId The media id that the read request is for.
2030 @param Lba The starting logical block address to read from on the device.
2031 @param BufferSize The size of the Buffer in bytes. This must be a multiple
2032 of the intrinsic block size of the device.
2033
2034 @param Buffer A pointer to the destination buffer for the data. The caller
2035 is responsible for either having implicit or explicit ownership
2036 of the memory that data is read into.
2037
2038 @retval EFI_SUCCESS Read Blocks successfully.
2039 @retval EFI_DEVICE_ERROR Read Blocks failed.
2040 @retval EFI_NO_MEDIA There is no media in the device.
2041 @retval EFI_MEDIA_CHANGE The MediaId is not for the current media.
2042 @retval EFI_BAD_BUFFER_SIZE The BufferSize parameter is not a multiple of the
2043 intrinsic block size of the device.
2044 @retval EFI_INVALID_PARAMETER The read request contains LBAs that are not valid,
2045 or the data buffer is not valid.
2046
2047 @note If Read Block error because of device error, this function will call
2048 AtaSoftReset() function to reset device.
2049
2050**/
2051EFI_STATUS
2052AtaBlkIoReadBlocks (
2053 IN IDE_BLK_IO_DEV *IdeBlkIoDevice,
2054 IN UINT32 MediaId,
2055 IN EFI_LBA Lba,
2056 IN UINTN BufferSize,
2057 OUT VOID *Buffer
2058 )
2059{
2060 EFI_BLOCK_IO_MEDIA *Media;
2061 UINTN BlockSize;
2062 UINTN NumberOfBlocks;
2063 EFI_STATUS Status;
2064
2065 if (Buffer == NULL) {
2066 return EFI_INVALID_PARAMETER;
2067 }
2068
2069 if (BufferSize == 0) {
2070 return EFI_SUCCESS;
2071 }
2072
2073 Status = EFI_SUCCESS;
2074
2075 //
2076 // Get the intrinsic block size
2077 //
2078 Media = IdeBlkIoDevice->BlkIo.Media;
2079 BlockSize = Media->BlockSize;
2080
2081 NumberOfBlocks = BufferSize / BlockSize;
2082
2083 if (MediaId != Media->MediaId) {
2084 return EFI_MEDIA_CHANGED;
2085 }
2086
2087 if (BufferSize % BlockSize != 0) {
2088 return EFI_BAD_BUFFER_SIZE;
2089 }
2090
2091 if (!(Media->MediaPresent)) {
2092 return EFI_NO_MEDIA;
2093 }
2094
2095 if (Lba > Media->LastBlock) {
2096 return EFI_INVALID_PARAMETER;
2097 }
2098
2099 if ((Lba + NumberOfBlocks - 1) > Media->LastBlock) {
2100 return EFI_INVALID_PARAMETER;
2101 }
2102
2103 if ((Media->IoAlign > 1) && (((UINTN) Buffer & (Media->IoAlign - 1)) != 0)) {
2104 return EFI_INVALID_PARAMETER;
2105 }
2106
2107 Status = EFI_SUCCESS;
2108 if (IdeBlkIoDevice->Type == Ide48bitAddressingHardDisk) {
2109 //
2110 // For ATA/ATAPI-6 device(capcity > 120GB), use ATA-6 read block mechanism
2111 //
2112 if (IdeBlkIoDevice->UdmaMode.Valid) {
2113 Status = AtaUdmaReadExt (IdeBlkIoDevice, Buffer, Lba, NumberOfBlocks);
2114 } else {
2115 Status = AtaReadSectorsExt (IdeBlkIoDevice, Buffer, Lba, NumberOfBlocks);
2116 }
2117 } else {
2118 //
2119 // For ATA-3 compatible device, use ATA-3 read block mechanism
2120 //
2121 if (IdeBlkIoDevice->UdmaMode.Valid) {
2122 Status = AtaUdmaRead (IdeBlkIoDevice, Buffer, Lba, NumberOfBlocks);
2123 } else {
2124 Status = AtaReadSectors (IdeBlkIoDevice, Buffer, Lba, NumberOfBlocks);
2125 }
2126 }
2127
2128 if (EFI_ERROR (Status)) {
2129 AtaSoftReset (IdeBlkIoDevice);
2130 return EFI_DEVICE_ERROR;
2131 }
2132
2133 return EFI_SUCCESS;
2134
2135}
2136/**
2137 This function is used to send out ATA commands conforms to the
2138 PIO Data Out Protocol, supporting ATA/ATAPI-6 standard
2139
2140 Comparing with ATA-3 data out protocol, we have two differents here:<BR>
2141 1. Do NOT wait for DRQ clear before sending command into IDE device.(the
2142 wait will frequently fail... cause writing function return error)
2143
2144 2. Do NOT wait for DRQ clear after all data readed.(the wait greatly
2145 slow down writing performance by 100 times!)
2146
2147 @param IdeDev pointer pointing to IDE_BLK_IO_DEV data structure, used
2148 to record all the information of the IDE device.
2149 @param Buffer buffer contained data transferred from host to device.
2150 @param ByteCount data size in byte unit of the buffer.
2151 @param AtaCommand value of the Command Register
2152 @param StartLba the start LBA of this transaction
2153 @param SectorCount the count of sectors to be transfered
2154
2155 @retval EFI_SUCCESS send out the ATA command and device receive required
2156 data successfully.
2157 @retval EFI_DEVICE_ERROR command sent failed.
2158
2159**/
2160EFI_STATUS
2161AtaPioDataOutExt (
2162 IN IDE_BLK_IO_DEV *IdeDev,
2163 IN VOID *Buffer,
2164 IN UINT32 ByteCount,
2165 IN UINT8 AtaCommand,
2166 IN EFI_LBA StartLba,
2167 IN UINT16 SectorCount
2168 )
2169{
2170 UINT8 DevSel;
2171 UINT8 SectorCount8;
2172 UINT8 LbaLow;
2173 UINT8 LbaMid;
2174 UINT8 LbaHigh;
2175 UINTN WordCount;
2176 UINTN Increment;
2177 UINT16 *Buffer16;
2178 EFI_STATUS Status;
2179
2180 Status = WaitForBSYClear (IdeDev, ATATIMEOUT);
2181 if (EFI_ERROR (Status)) {
2182 return EFI_DEVICE_ERROR;
2183 }
2184
2185 //
2186 // Select device. Set bit6 as 1 to indicate LBA mode is used
2187 //
2188 DevSel = (UINT8) (IdeDev->Device << 4);
2189 DevSel |= 0x40;
2190 IDEWritePortB (
2191 IdeDev->PciIo,
2192 IdeDev->IoPort->Head,
2193 DevSel
2194 );
2195
2196 //
2197 // Wait for DRDY singnal asserting.
2198 //
2199 Status = DRDYReady (IdeDev, ATATIMEOUT);
2200 if (EFI_ERROR (Status)) {
2201 return EFI_DEVICE_ERROR;
2202 }
2203
2204 //
2205 // Fill feature register if needed
2206 //
2207 if (AtaCommand == ATA_CMD_SET_FEATURES) {
2208 IDEWritePortB (IdeDev->PciIo, IdeDev->IoPort->Reg1.Feature, 0x03);
2209 }
2210
2211 //
2212 // Fill the sector count register, which is a two-byte FIFO. Need write twice.
2213 //
2214 SectorCount8 = (UINT8) (SectorCount >> 8);
2215 IDEWritePortB (IdeDev->PciIo, IdeDev->IoPort->SectorCount, SectorCount8);
2216
2217 SectorCount8 = (UINT8) SectorCount;
2218 IDEWritePortB (IdeDev->PciIo, IdeDev->IoPort->SectorCount, SectorCount8);
2219
2220 //
2221 // Fill the start LBA registers, which are also two-byte FIFO
2222 //
2223 LbaLow = (UINT8) RShiftU64 (StartLba, 24);
2224 LbaMid = (UINT8) RShiftU64 (StartLba, 32);
2225 LbaHigh = (UINT8) RShiftU64 (StartLba, 40);
2226 IDEWritePortB (IdeDev->PciIo, IdeDev->IoPort->SectorNumber, LbaLow);
2227 IDEWritePortB (IdeDev->PciIo, IdeDev->IoPort->CylinderLsb, LbaMid);
2228 IDEWritePortB (IdeDev->PciIo, IdeDev->IoPort->CylinderMsb, LbaHigh);
2229
2230 LbaLow = (UINT8) StartLba;
2231 LbaMid = (UINT8) RShiftU64 (StartLba, 8);
2232 LbaHigh = (UINT8) RShiftU64 (StartLba, 16);
2233 IDEWritePortB (IdeDev->PciIo, IdeDev->IoPort->SectorNumber, LbaLow);
2234 IDEWritePortB (IdeDev->PciIo, IdeDev->IoPort->CylinderLsb, LbaMid);
2235 IDEWritePortB (IdeDev->PciIo, IdeDev->IoPort->CylinderMsb, LbaHigh);
2236
2237 //
2238 // Send command via Command Register, invoking the processing of this command
2239 //
2240 IDEWritePortB (IdeDev->PciIo, IdeDev->IoPort->Reg.Command, AtaCommand);
2241
2242 Buffer16 = (UINT16 *) Buffer;
2243
2244 //
2245 // According to PIO Data Out protocol, host can perform a series of writes to
2246 // the data register after each time device set DRQ ready;
2247 //
2248 Increment = 256;
2249
2250 //
2251 // used to record bytes of currently transfered data
2252 //
2253 WordCount = 0;
2254
2255 while (WordCount < ByteCount / 2) {
2256 //
2257 // Poll DRQ bit set, data transfer can be performed only when DRQ is ready.
2258 //
2259 Status = DRQReady2 (IdeDev, ATATIMEOUT);
2260 if (EFI_ERROR (Status)) {
2261 return EFI_DEVICE_ERROR;
2262 }
2263
2264 Status = CheckErrorStatus (IdeDev);
2265 if (EFI_ERROR (Status)) {
2266 return EFI_DEVICE_ERROR;
2267 }
2268
2269 //
2270 // Write data into device by one series of writing to data register
2271 //
2272 if ((WordCount + Increment) > ByteCount / 2) {
2273 Increment = ByteCount / 2 - WordCount;
2274 }
2275
2276 IDEWritePortWMultiple (
2277 IdeDev->PciIo,
2278 IdeDev->IoPort->Data,
2279 Increment,
2280 Buffer16
2281 );
2282
2283 WordCount += Increment;
2284 Buffer16 += Increment;
2285
2286 }
2287 return CheckErrorStatus (IdeDev);
2288}
2289/**
2290 This function is called by the AtaBlkIoWriteBlocks() to perform
2291 writing to media in block unit. The function has been enhanced to
2292 support >120GB access and transfer at most 65536 blocks per command
2293
2294 @param IdeDev pointer pointing to IDE_BLK_IO_DEV data structure, used
2295 to record all the information of the IDE device.
2296 @param DataBuffer A pointer to the source buffer for the data.
2297 @param StartLba The starting logical block address to write to
2298 on the device media.
2299 @param NumberOfBlocks The number of transfer data blocks.
2300
2301 @return status depends on the function DoAtaUdma() returns.
2302**/
2303EFI_STATUS
2304AtaUdmaWriteExt (
2305 IN IDE_BLK_IO_DEV *IdeDev,
2306 IN VOID *DataBuffer,
2307 IN EFI_LBA StartLba,
2308 IN UINTN NumberOfBlocks
2309 )
2310{
2311 return DoAtaUdma (IdeDev, DataBuffer, StartLba, NumberOfBlocks, AtaUdmaWriteExtOp);
2312}
2313
2314/**
2315 This function is called by the AtaBlkIoWriteBlocks() to perform
2316 writing to media in block unit.
2317
2318 @param IdeDev pointer pointing to IDE_BLK_IO_DEV data structure, used
2319 to record all the information of the IDE device.
2320 @param DataBuffer A pointer to the source buffer for the data.
2321 @param StartLba The starting logical block address to write to
2322 on the device media.
2323 @param NumberOfBlocks The number of transfer data blocks.
2324
2325 @return status depends on the function DoAtaUdma() returns.
2326**/
2327EFI_STATUS
2328AtaUdmaWrite (
2329 IN IDE_BLK_IO_DEV *IdeDev,
2330 IN VOID *DataBuffer,
2331 IN EFI_LBA StartLba,
2332 IN UINTN NumberOfBlocks
2333 )
2334{
2335 return DoAtaUdma (IdeDev, DataBuffer, StartLba, NumberOfBlocks, AtaUdmaWriteOp);
2336}
2337/**
2338 This function is called by the AtaBlkIoWriteBlocks() to perform
2339 writing onto media in block unit. The function has been enhanced to
2340 support >120GB access and transfer at most 65536 blocks per command
2341
2342 @param IdeDev pointer pointing to IDE_BLK_IO_DEV data structure,used
2343 to record all the information of the IDE device.
2344 @param DataBuffer A pointer to the source buffer for the data.
2345 @param StartLba The starting logical block address to write onto the device
2346 media.
2347 @param NumberOfBlocks The number of transfer data blocks.
2348
2349 @return status is fully dependent on the return status of AtaPioDataOutExt() function.
2350**/
2351EFI_STATUS
2352AtaWriteSectorsExt (
2353 IN IDE_BLK_IO_DEV *IdeDev,
2354 IN VOID *DataBuffer,
2355 IN EFI_LBA StartLba,
2356 IN UINTN NumberOfBlocks
2357 )
2358{
2359 EFI_STATUS Status;
2360 EFI_LBA Lba64;
2361 UINTN BlocksRemaining;
2362 UINT8 AtaCommand;
2363 UINT16 SectorCount;
2364 UINT32 ByteCount;
2365 VOID *Buffer;
2366
2367 //
2368 // Using ATA "Write Sectors Ext" cmd(opcode=0x24) with PIO DATA OUT protocol
2369 //
2370 AtaCommand = ATA_CMD_WRITE_SECTORS_EXT;
2371 Lba64 = StartLba;
2372 Buffer = DataBuffer;
2373 BlocksRemaining = NumberOfBlocks;
2374
2375 Status = EFI_SUCCESS;
2376
2377 while (BlocksRemaining > 0) {
2378
2379 if (BlocksRemaining >= 0x10000) {
2380 //
2381 // SectorCount is used to record the number of sectors to be written.
2382 // Max 65536 sectors can be transfered at a time.
2383 //
2384 SectorCount = 0xffff;
2385 } else {
2386 SectorCount = (UINT16) BlocksRemaining;
2387 }
2388
2389 //
2390 // ByteCount is the number of bytes that will be written
2391 //
2392 ByteCount = SectorCount * (IdeDev->BlkIo.Media->BlockSize);
2393
2394 //
2395 // Call AtaPioDataOutExt() to send "Write Sectors Ext" Command
2396 //
2397 Status = AtaPioDataOutExt (
2398 IdeDev,
2399 Buffer,
2400 ByteCount,
2401 AtaCommand,
2402 Lba64,
2403 SectorCount
2404 );
2405 if (EFI_ERROR (Status)) {
2406 return Status;
2407 }
2408
2409 Lba64 += SectorCount;
2410 Buffer = ((UINT8 *) Buffer + ByteCount);
2411 BlocksRemaining -= SectorCount;
2412 }
2413
2414 return Status;
2415}
2416/**
2417 This function is the ATA implementation for WriteBlocks in the
2418 Block I/O Protocol interface.
2419
2420 @param IdeBlkIoDevice Indicates the calling context.
2421 @param MediaId The media id that the write request is for.
2422 @param Lba The starting logical block address to write onto the device.
2423 @param BufferSize The size of the Buffer in bytes. This must be a multiple
2424 of the intrinsic block size of the device.
2425 @param Buffer A pointer to the source buffer for the data.The caller
2426 is responsible for either having implicit or explicit
2427 ownership of the memory that data is written from.
2428
2429 @retval EFI_SUCCESS Write Blocks successfully.
2430 @retval EFI_DEVICE_ERROR Write Blocks failed.
2431 @retval EFI_NO_MEDIA There is no media in the device.
2432 @retval EFI_MEDIA_CHANGE The MediaId is not for the current media.
2433
2434 @retval EFI_BAD_BUFFER_SIZE The BufferSize parameter is not a multiple of the
2435 intrinsic block size of the device.
2436 @retval EFI_INVALID_PARAMETER The write request contains LBAs that are not valid,
2437 or the data buffer is not valid.
2438
2439 @note If Write Block error because of device error, this function will call
2440 AtaSoftReset() function to reset device.
2441**/
2442EFI_STATUS
2443AtaBlkIoWriteBlocks (
2444 IN IDE_BLK_IO_DEV *IdeBlkIoDevice,
2445 IN UINT32 MediaId,
2446 IN EFI_LBA Lba,
2447 IN UINTN BufferSize,
2448 OUT VOID *Buffer
2449 )
2450{
2451
2452 EFI_BLOCK_IO_MEDIA *Media;
2453 UINTN BlockSize;
2454 UINTN NumberOfBlocks;
2455 EFI_STATUS Status;
2456
2457 if (Buffer == NULL) {
2458 return EFI_INVALID_PARAMETER;
2459 }
2460
2461 if (BufferSize == 0) {
2462 return EFI_SUCCESS;
2463 }
2464
2465 Status = EFI_SUCCESS;
2466
2467 //
2468 // Get the intrinsic block size
2469 //
2470 Media = IdeBlkIoDevice->BlkIo.Media;
2471 BlockSize = Media->BlockSize;
2472 NumberOfBlocks = BufferSize / BlockSize;
2473
2474 if (MediaId != Media->MediaId) {
2475 return EFI_MEDIA_CHANGED;
2476 }
2477
2478 if (BufferSize % BlockSize != 0) {
2479 return EFI_BAD_BUFFER_SIZE;
2480 }
2481
2482 if (Lba > Media->LastBlock) {
2483 return EFI_INVALID_PARAMETER;
2484 }
2485
2486 if ((Lba + NumberOfBlocks - 1) > Media->LastBlock) {
2487 return EFI_INVALID_PARAMETER;
2488 }
2489
2490 if ((Media->IoAlign > 1) && (((UINTN) Buffer & (Media->IoAlign - 1)) != 0)) {
2491 return EFI_INVALID_PARAMETER;
2492 }
2493
2494 Status = EFI_SUCCESS;
2495 if (IdeBlkIoDevice->Type == Ide48bitAddressingHardDisk) {
2496 //
2497 // For ATA/ATAPI-6 device(capcity > 120GB), use ATA-6 write block mechanism
2498 //
2499 if (IdeBlkIoDevice->UdmaMode.Valid) {
2500 Status = AtaUdmaWriteExt (IdeBlkIoDevice, Buffer, Lba, NumberOfBlocks);
2501 } else {
2502 Status = AtaWriteSectorsExt (IdeBlkIoDevice, Buffer, Lba, NumberOfBlocks);
2503 }
2504 } else {
2505 //
2506 // For ATA-3 compatible device, use ATA-3 write block mechanism
2507 //
2508 if (IdeBlkIoDevice->UdmaMode.Valid) {
2509 Status = AtaUdmaWrite (IdeBlkIoDevice, Buffer, Lba, NumberOfBlocks);
2510 } else {
2511 Status = AtaWriteSectors (IdeBlkIoDevice, Buffer, Lba, NumberOfBlocks);
2512 }
2513 }
2514
2515 if (EFI_ERROR (Status)) {
2516 AtaSoftReset (IdeBlkIoDevice);
2517 return EFI_DEVICE_ERROR;
2518 }
2519
2520 return EFI_SUCCESS;
2521}
2522/**
2523 Enable Long Physical Sector Feature for ATA device.
2524
2525 @param IdeDev The IDE device data
2526
2527 @retval EFI_SUCCESS The ATA device supports Long Physical Sector feature
2528 and corresponding fields in BlockIo structure is updated.
2529 @retval EFI_UNSUPPORTED The device is not ATA device or Long Physical Sector
2530 feature is not supported.
2531**/
2532EFI_STATUS
2533AtaEnableLongPhysicalSector (
2534 IN IDE_BLK_IO_DEV *IdeDev
2535 )
2536{
2537 EFI_ATA_IDENTIFY_DATA *AtaIdentifyData;
2538 UINT16 PhyLogicSectorSupport;
2539
2540 ASSERT (IdeDev->IdData != NULL);
2541 //
2542 // Only valid for ATA device
2543 //
2544 AtaIdentifyData = (EFI_ATA_IDENTIFY_DATA *) &IdeDev->IdData->AtaData;
2545 if ((AtaIdentifyData->config & 0x8000) != 0) {
2546 return EFI_UNSUPPORTED;
2547 }
2548 PhyLogicSectorSupport = AtaIdentifyData->phy_logic_sector_support;
2549 //
2550 // Check whether Long Physical Sector Feature is supported
2551 //
2552 if ((PhyLogicSectorSupport & 0xc000) == 0x4000) {
2553 IdeDev->BlkIo.Media->LogicalBlocksPerPhysicalBlock = 1;
2554 IdeDev->BlkIo.Media->LowestAlignedLba = 0;
2555 //
2556 // Check whether one physical block contains multiple physical blocks
2557 //
2558 if ((PhyLogicSectorSupport & 0x2000) != 0) {
2559 IdeDev->BlkIo.Media->LogicalBlocksPerPhysicalBlock =
2560 (UINT32) (1 << (PhyLogicSectorSupport & 0x000f));
2561 //
2562 // Check lowest alignment of logical blocks within physical block
2563 //
2564 if ((AtaIdentifyData->alignment_logic_in_phy_blocks & 0xc000) == 0x4000) {
2565 IdeDev->BlkIo.Media->LowestAlignedLba =
2566 (EFI_LBA) (AtaIdentifyData->alignment_logic_in_phy_blocks & 0x3fff);
2567 }
2568 }
2569 //
2570 // Check logical block size
2571 //
2572 IdeDev->BlkIo.Media->BlockSize = 0x200;
2573 if ((PhyLogicSectorSupport & 0x1000) != 0) {
2574 IdeDev->BlkIo.Media->BlockSize = (UINT32) (
2575 ((AtaIdentifyData->logic_sector_size_hi << 16) |
2576 AtaIdentifyData->logic_sector_size_lo) * sizeof (UINT16)
2577 );
2578 }
2579 return EFI_SUCCESS;
2580 } else {
2581 return EFI_UNSUPPORTED;
2582 }
2583}
2584/**
2585 Send ATA command into device with NON_DATA protocol
2586
2587 @param IdeDev Standard IDE device private data structure
2588 @param AtaCommand The ATA command to be sent
2589 @param Device The value in Device register
2590 @param Feature The value in Feature register
2591 @param SectorCount The value in SectorCount register
2592 @param LbaLow The value in LBA_LOW register
2593 @param LbaMiddle The value in LBA_MIDDLE register
2594 @param LbaHigh The value in LBA_HIGH register
2595
2596 @retval EFI_SUCCESS Reading succeed
2597 @retval EFI_ABORTED Command failed
2598 @retval EFI_DEVICE_ERROR Device status error.
2599
2600**/
2601EFI_STATUS
2602AtaNonDataCommandIn (
2603 IN IDE_BLK_IO_DEV *IdeDev,
2604 IN UINT8 AtaCommand,
2605 IN UINT8 Device,
2606 IN UINT8 Feature,
2607 IN UINT8 SectorCount,
2608 IN UINT8 LbaLow,
2609 IN UINT8 LbaMiddle,
2610 IN UINT8 LbaHigh
2611 )
2612{
2613 EFI_STATUS Status;
2614 UINT8 StatusRegister;
2615
2616 Status = WaitForBSYClear (IdeDev, ATATIMEOUT);
2617 if (EFI_ERROR (Status)) {
2618 return EFI_DEVICE_ERROR;
2619 }
2620
2621 //
2622 // Select device (bit4), set Lba mode(bit6) (use 0xe0 for compatibility)
2623 //
2624 IDEWritePortB (
2625 IdeDev->PciIo,
2626 IdeDev->IoPort->Head,
2627 (UINT8) ((IdeDev->Device << 4) | 0xe0)
2628 );
2629
2630 //
2631 // ATA commands for ATA device must be issued when DRDY is set
2632 //
2633 Status = DRDYReady (IdeDev, ATATIMEOUT);
2634 if (EFI_ERROR (Status)) {
2635 return EFI_DEVICE_ERROR;
2636 }
2637
2638 //
2639 // Pass parameter into device register block
2640 //
2641 IDEWritePortB (IdeDev->PciIo, IdeDev->IoPort->Head, Device);
2642 IDEWritePortB (IdeDev->PciIo, IdeDev->IoPort->Reg1.Feature, Feature);
2643 IDEWritePortB (IdeDev->PciIo, IdeDev->IoPort->SectorCount, SectorCount);
2644 IDEWritePortB (IdeDev->PciIo, IdeDev->IoPort->SectorNumber, LbaLow);
2645 IDEWritePortB (IdeDev->PciIo, IdeDev->IoPort->CylinderLsb, LbaMiddle);
2646 IDEWritePortB (IdeDev->PciIo, IdeDev->IoPort->CylinderMsb, LbaHigh);
2647
2648 //
2649 // Send command via Command Register
2650 //
2651 IDEWritePortB (IdeDev->PciIo, IdeDev->IoPort->Reg.Command, AtaCommand);
2652
2653 //
2654 // Wait for command completion
2655 // For ATAPI_SMART_CMD, we may need more timeout to let device
2656 // adjust internal states.
2657 //
2658 if (AtaCommand == ATA_CMD_SMART) {
2659 Status = WaitForBSYClear (IdeDev, ATASMARTTIMEOUT);
2660 } else {
2661 Status = WaitForBSYClear (IdeDev, ATATIMEOUT);
2662 }
2663 if (EFI_ERROR (Status)) {
2664 return EFI_DEVICE_ERROR;
2665 }
2666
2667 StatusRegister = IDEReadPortB (IdeDev->PciIo, IdeDev->IoPort->Reg.Status);
2668 if ((StatusRegister & ATA_STSREG_ERR) == ATA_STSREG_ERR) {
2669 //
2670 // Failed to execute command, abort operation
2671 //
2672 return EFI_ABORTED;
2673 }
2674
2675 return EFI_SUCCESS;
2676}
2677
2678/**
2679 Send ATA Ext command into device with NON_DATA protocol
2680
2681 @param IdeDev Standard IDE device private data structure
2682 @param AtaCommand The ATA command to be sent
2683 @param Device The value in Device register
2684 @param Feature The value in Feature register
2685 @param SectorCount The value in SectorCount register
2686 @param LbaAddress The LBA address in 48-bit mode
2687
2688 @retval EFI_SUCCESS Reading succeed
2689 @retval EFI_ABORTED Command failed
2690 @retval EFI_DEVICE_ERROR Device status error.
2691
2692**/
2693EFI_STATUS
2694AtaNonDataCommandInExt (
2695 IN IDE_BLK_IO_DEV *IdeDev,
2696 IN UINT8 AtaCommand,
2697 IN UINT8 Device,
2698 IN UINT16 Feature,
2699 IN UINT16 SectorCount,
2700 IN EFI_LBA LbaAddress
2701 )
2702{
2703 EFI_STATUS Status;
2704 UINT8 StatusRegister;
2705 UINT8 SectorCount8;
2706 UINT8 Feature8;
2707 UINT8 LbaLow;
2708 UINT8 LbaMid;
2709 UINT8 LbaHigh;
2710
2711 Status = WaitForBSYClear (IdeDev, ATATIMEOUT);
2712 if (EFI_ERROR (Status)) {
2713 return EFI_DEVICE_ERROR;
2714 }
2715
2716 //
2717 // Select device (bit4), set LBA mode(bit6) (use 0xe0 for compatibility)
2718 //
2719 IDEWritePortB (
2720 IdeDev->PciIo,
2721 IdeDev->IoPort->Head,
2722 (UINT8) ((IdeDev->Device << 4) | 0xe0)
2723 );
2724
2725 //
2726 // ATA commands for ATA device must be issued when DRDY is set
2727 //
2728 Status = DRDYReady (IdeDev, ATATIMEOUT);
2729 if (EFI_ERROR (Status)) {
2730 return EFI_DEVICE_ERROR;
2731 }
2732
2733 //
2734 // Pass parameter into device register block
2735 //
2736 IDEWritePortB (IdeDev->PciIo, IdeDev->IoPort->Head, Device);
2737
2738 //
2739 // Fill the feature register, which is a two-byte FIFO. Need write twice.
2740 //
2741 Feature8 = (UINT8) (Feature >> 8);
2742 IDEWritePortB (IdeDev->PciIo, IdeDev->IoPort->Reg1.Feature, Feature8);
2743
2744 Feature8 = (UINT8) Feature;
2745 IDEWritePortB (IdeDev->PciIo, IdeDev->IoPort->Reg1.Feature, Feature8);
2746
2747 //
2748 // Fill the sector count register, which is a two-byte FIFO. Need write twice.
2749 //
2750 SectorCount8 = (UINT8) (SectorCount >> 8);
2751 IDEWritePortB (IdeDev->PciIo, IdeDev->IoPort->SectorCount, SectorCount8);
2752
2753 SectorCount8 = (UINT8) SectorCount;
2754 IDEWritePortB (IdeDev->PciIo, IdeDev->IoPort->SectorCount, SectorCount8);
2755
2756 //
2757 // Fill the start LBA registers, which are also two-byte FIFO
2758 //
2759 LbaLow = (UINT8) RShiftU64 (LbaAddress, 24);
2760 LbaMid = (UINT8) RShiftU64 (LbaAddress, 32);
2761 LbaHigh = (UINT8) RShiftU64 (LbaAddress, 40);
2762 IDEWritePortB (IdeDev->PciIo, IdeDev->IoPort->SectorNumber, LbaLow);
2763 IDEWritePortB (IdeDev->PciIo, IdeDev->IoPort->CylinderLsb, LbaMid);
2764 IDEWritePortB (IdeDev->PciIo, IdeDev->IoPort->CylinderMsb, LbaHigh);
2765
2766 LbaLow = (UINT8) LbaAddress;
2767 LbaMid = (UINT8) RShiftU64 (LbaAddress, 8);
2768 LbaHigh = (UINT8) RShiftU64 (LbaAddress, 16);
2769 IDEWritePortB (IdeDev->PciIo, IdeDev->IoPort->SectorNumber, LbaLow);
2770 IDEWritePortB (IdeDev->PciIo, IdeDev->IoPort->CylinderLsb, LbaMid);
2771 IDEWritePortB (IdeDev->PciIo, IdeDev->IoPort->CylinderMsb, LbaHigh);
2772
2773 //
2774 // Send command via Command Register
2775 //
2776 IDEWritePortB (IdeDev->PciIo, IdeDev->IoPort->Reg.Command, AtaCommand);
2777
2778 //
2779 // Wait for command completion
2780 //
2781 Status = WaitForBSYClear (IdeDev, ATATIMEOUT);
2782 if (EFI_ERROR (Status)) {
2783 return EFI_DEVICE_ERROR;
2784 }
2785
2786 StatusRegister = IDEReadPortB (IdeDev->PciIo, IdeDev->IoPort->Reg.Status);
2787 if ((StatusRegister & ATA_STSREG_ERR) == ATA_STSREG_ERR) {
2788 //
2789 // Failed to execute command, abort operation
2790 //
2791 return EFI_ABORTED;
2792 }
2793
2794 return EFI_SUCCESS;
2795}
2796
2797
2798
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette