/** @file\r
SCSI disk driver that layers on every SCSI IO protocol in the system.\r
\r
-Copyright (c) 2006 - 2011, Intel Corporation. All rights reserved.<BR>\r
+Copyright (c) 2006 - 2014, Intel Corporation. All rights reserved.<BR>\r
This program and the accompanying materials\r
are licensed and made available under the terms and conditions of the BSD License\r
which accompanies this distribution. The full text of the license may be found at\r
ScsiDiskInfoWhichIde\r
};\r
\r
+/**\r
+ Allocates an aligned buffer for SCSI disk.\r
+\r
+ This function allocates an aligned buffer for the SCSI disk to perform\r
+ SCSI IO operations. The alignment requirement is from SCSI IO interface.\r
+\r
+ @param ScsiDiskDevice The SCSI disk involved for the operation.\r
+ @param BufferSize The request buffer size.\r
+\r
+ @return A pointer to the aligned buffer or NULL if the allocation fails.\r
+\r
+**/\r
+VOID *\r
+AllocateAlignedBuffer (\r
+ IN SCSI_DISK_DEV *ScsiDiskDevice,\r
+ IN UINTN BufferSize\r
+ )\r
+{\r
+ return AllocateAlignedPages (EFI_SIZE_TO_PAGES (BufferSize), ScsiDiskDevice->ScsiIo->IoAlign);\r
+}\r
+\r
+/**\r
+ Frees an aligned buffer for SCSI disk.\r
+\r
+ This function frees an aligned buffer for the SCSI disk to perform\r
+ SCSI IO operations.\r
+\r
+ @param Buffer The aligned buffer to be freed.\r
+ @param BufferSize The request buffer size.\r
+\r
+**/\r
+VOID\r
+FreeAlignedBuffer (\r
+ IN VOID *Buffer,\r
+ IN UINTN BufferSize\r
+ )\r
+{\r
+ if (Buffer != NULL) {\r
+ FreeAlignedPages (Buffer, EFI_SIZE_TO_PAGES (BufferSize));\r
+ }\r
+}\r
+\r
/**\r
The user Entry Point for module ScsiDisk.\r
\r
UINT8 Index;\r
UINT8 MaxRetry;\r
BOOLEAN NeedRetry;\r
+ BOOLEAN MustReadCapacity;\r
+\r
+ MustReadCapacity = TRUE;\r
\r
ScsiDiskDevice = (SCSI_DISK_DEV *) AllocateZeroPool (sizeof (SCSI_DISK_DEV));\r
if (ScsiDiskDevice == NULL) {\r
\r
ScsiDiskDevice->Signature = SCSI_DISK_DEV_SIGNATURE;\r
ScsiDiskDevice->ScsiIo = ScsiIo;\r
+ ScsiDiskDevice->BlkIo.Revision = EFI_BLOCK_IO_PROTOCOL_REVISION3;\r
ScsiDiskDevice->BlkIo.Media = &ScsiDiskDevice->BlkIoMedia;\r
ScsiDiskDevice->BlkIo.Reset = ScsiDiskReset;\r
ScsiDiskDevice->BlkIo.ReadBlocks = ScsiDiskReadBlocks;\r
switch (ScsiDiskDevice->DeviceType) {\r
case EFI_SCSI_TYPE_DISK:\r
ScsiDiskDevice->BlkIo.Media->BlockSize = 0x200;\r
+ MustReadCapacity = TRUE;\r
break;\r
\r
case EFI_SCSI_TYPE_CDROM:\r
ScsiDiskDevice->BlkIo.Media->BlockSize = 0x800;\r
+ MustReadCapacity = FALSE;\r
break;\r
}\r
//\r
// The second parameter "TRUE" means must\r
// retrieve media capacity\r
//\r
- Status = ScsiDiskDetectMedia (ScsiDiskDevice, TRUE, &Temp);\r
+ Status = ScsiDiskDetectMedia (ScsiDiskDevice, MustReadCapacity, &Temp);\r
if (!EFI_ERROR (Status)) {\r
//\r
// Determine if Block IO should be produced on this controller handle\r
&ScsiDiskDevice->BlkIo,\r
&ScsiDiskDevice->BlkIo\r
);\r
+ Status = EFI_MEDIA_CHANGED;\r
+ goto Done;\r
}\r
}\r
//\r
&ScsiDiskDevice->BlkIo,\r
&ScsiDiskDevice->BlkIo\r
);\r
+ Status = EFI_MEDIA_CHANGED;\r
+ goto Done;\r
}\r
}\r
//\r
)\r
{\r
EFI_STATUS Status;\r
- EFI_STATUS ReadCapacityStatus;\r
EFI_SCSI_SENSE_DATA *SenseData;\r
UINTN NumberOfSenseKeys;\r
BOOLEAN NeedRetry;\r
BOOLEAN NeedReadCapacity;\r
- UINT8 Index;\r
+ UINT8 Retry;\r
UINT8 MaxRetry;\r
EFI_BLOCK_IO_MEDIA OldMedia;\r
UINTN Action;\r
+ EFI_EVENT TimeoutEvt;\r
\r
Status = EFI_SUCCESS;\r
- ReadCapacityStatus = EFI_SUCCESS;\r
SenseData = NULL;\r
NumberOfSenseKeys = 0;\r
+ Retry = 0;\r
+ MaxRetry = 3;\r
+ Action = ACTION_NO_ACTION;\r
NeedReadCapacity = FALSE;\r
- CopyMem (&OldMedia, ScsiDiskDevice->BlkIo.Media, sizeof (OldMedia));\r
*MediaChange = FALSE;\r
- MaxRetry = 3;\r
+ TimeoutEvt = NULL;\r
\r
- for (Index = 0; Index < MaxRetry; Index++) {\r
+ CopyMem (&OldMedia, ScsiDiskDevice->BlkIo.Media, sizeof (OldMedia));\r
+\r
+ Status = gBS->CreateEvent (\r
+ EVT_TIMER,\r
+ TPL_CALLBACK,\r
+ NULL,\r
+ NULL,\r
+ &TimeoutEvt\r
+ );\r
+ if (EFI_ERROR (Status)) {\r
+ return Status;\r
+ }\r
+\r
+ Status = gBS->SetTimer (TimeoutEvt, TimerRelative, EFI_TIMER_PERIOD_SECONDS(120));\r
+ if (EFI_ERROR (Status)) {\r
+ goto EXIT;\r
+ }\r
+\r
+ //\r
+ // Sending Test_Unit cmd to poll device status.\r
+ // If the sense data shows the drive is not ready or reset before, we need poll the device status again.\r
+ // We limit the upper boundary to 120 seconds.\r
+ //\r
+ while (EFI_ERROR (gBS->CheckEvent (TimeoutEvt))) {\r
Status = ScsiDiskTestUnitReady (\r
ScsiDiskDevice,\r
&NeedRetry,\r
&NumberOfSenseKeys\r
);\r
if (!EFI_ERROR (Status)) {\r
- break;\r
- }\r
-\r
- if (!NeedRetry) {\r
- return Status;\r
+ Status = DetectMediaParsingSenseKeys (\r
+ ScsiDiskDevice,\r
+ SenseData,\r
+ NumberOfSenseKeys,\r
+ &Action\r
+ );\r
+ if (EFI_ERROR (Status)) {\r
+ goto EXIT;\r
+ } else if (Action == ACTION_RETRY_COMMAND_LATER) {\r
+ continue;\r
+ } else {\r
+ break;\r
+ }\r
+ } else {\r
+ Retry++;\r
+ if (!NeedRetry || (Retry >= MaxRetry)) {\r
+ goto EXIT;\r
+ }\r
}\r
}\r
\r
- if ((Index == MaxRetry) && EFI_ERROR (Status)) {\r
- return EFI_DEVICE_ERROR;\r
- }\r
-\r
- Status = DetectMediaParsingSenseKeys (\r
- ScsiDiskDevice,\r
- SenseData,\r
- NumberOfSenseKeys,\r
- &Action\r
- );\r
if (EFI_ERROR (Status)) {\r
- return Status;\r
+ goto EXIT;\r
}\r
+\r
//\r
// ACTION_NO_ACTION: need not read capacity\r
// other action code: need read capacity\r
//\r
- if (Action == ACTION_NO_ACTION) {\r
- NeedReadCapacity = FALSE;\r
- } else {\r
+ if (Action == ACTION_READ_CAPACITY) {\r
NeedReadCapacity = TRUE;\r
}\r
\r
//\r
// retrieve media information\r
//\r
- MaxRetry = 3;\r
- for (Index = 0; Index < MaxRetry; Index++) {\r
-\r
- ReadCapacityStatus = ScsiDiskReadCapacity (\r
- ScsiDiskDevice,\r
- &NeedRetry,\r
- &SenseData,\r
- &NumberOfSenseKeys\r
- );\r
- if (EFI_ERROR (ReadCapacityStatus) && !NeedRetry) {\r
- return EFI_DEVICE_ERROR;\r
- }\r
- //\r
- // analyze sense key to action\r
- //\r
- Status = DetectMediaParsingSenseKeys (\r
- ScsiDiskDevice,\r
- SenseData,\r
- NumberOfSenseKeys,\r
- &Action\r
- );\r
- //\r
- // if Status is error, it may indicate crisis error,\r
- // so return without retry.\r
- //\r
- if (EFI_ERROR (Status)) {\r
- return Status;\r
- }\r
-\r
- switch (Action) {\r
- case ACTION_NO_ACTION:\r
- //\r
- // no retry\r
- //\r
- Index = MaxRetry;\r
- break;\r
-\r
- case ACTION_RETRY_COMMAND_LATER:\r
- //\r
- // retry the ReadCapacity later and continuously, until the condition\r
- // no longer emerges.\r
- // stall time is 100000us, or say 0.1 second.\r
- //\r
- gBS->Stall (100000);\r
- Index = 0;\r
- break;\r
-\r
- default:\r
+ for (Retry = 0; Retry < MaxRetry; Retry++) {\r
+ Status = ScsiDiskReadCapacity (\r
+ ScsiDiskDevice,\r
+ &NeedRetry,\r
+ &SenseData,\r
+ &NumberOfSenseKeys\r
+ );\r
+ if (!EFI_ERROR (Status)) {\r
//\r
- // other cases, just retry the command\r
+ // analyze sense key to action\r
//\r
- break;\r
+ Status = DetectMediaParsingSenseKeys (\r
+ ScsiDiskDevice,\r
+ SenseData,\r
+ NumberOfSenseKeys,\r
+ &Action\r
+ );\r
+ if (EFI_ERROR (Status)) {\r
+ //\r
+ // if Status is error, it may indicate crisis error,\r
+ // so return without retry.\r
+ //\r
+ goto EXIT;\r
+ } else if (Action == ACTION_RETRY_COMMAND_LATER) {\r
+ Retry = 0;\r
+ continue;\r
+ } else {\r
+ break;\r
+ }\r
+ } else { \r
+ Retry++;\r
+ if (!NeedRetry || (Retry >= MaxRetry)) {\r
+ goto EXIT;\r
+ }\r
}\r
}\r
\r
- if ((Index == MaxRetry) && EFI_ERROR (ReadCapacityStatus)) {\r
- return EFI_DEVICE_ERROR;\r
+ if (EFI_ERROR (Status)) {\r
+ goto EXIT;\r
}\r
}\r
\r
*MediaChange = TRUE;\r
}\r
\r
- return EFI_SUCCESS;\r
+EXIT:\r
+ if (TimeoutEvt != NULL) {\r
+ gBS->CloseEvent (TimeoutEvt);\r
+ }\r
+ return Status;\r
}\r
\r
\r
OUT BOOLEAN *NeedRetry\r
)\r
{\r
- UINT32 InquiryDataLength;\r
- UINT8 SenseDataLength;\r
- UINT8 HostAdapterStatus;\r
- UINT8 TargetStatus;\r
- EFI_SCSI_SENSE_DATA *SenseDataArray;\r
- UINTN NumberOfSenseKeys;\r
- EFI_STATUS Status;\r
- UINT8 MaxRetry;\r
- UINT8 Index;\r
+ UINT32 InquiryDataLength;\r
+ UINT8 SenseDataLength;\r
+ UINT8 HostAdapterStatus;\r
+ UINT8 TargetStatus;\r
+ EFI_SCSI_SENSE_DATA *SenseDataArray;\r
+ UINTN NumberOfSenseKeys;\r
+ EFI_STATUS Status;\r
+ UINT8 MaxRetry;\r
+ UINT8 Index;\r
+ EFI_SCSI_SUPPORTED_VPD_PAGES_VPD_PAGE *SupportedVpdPages;\r
+ EFI_SCSI_BLOCK_LIMITS_VPD_PAGE *BlockLimits;\r
+ UINTN PageLength;\r
\r
InquiryDataLength = sizeof (EFI_SCSI_INQUIRY_DATA);\r
SenseDataLength = 0;\r
\r
Status = ScsiInquiryCommand (\r
ScsiDiskDevice->ScsiIo,\r
- EFI_TIMER_PERIOD_SECONDS (1),\r
+ SCSI_DISK_TIMEOUT,\r
NULL,\r
&SenseDataLength,\r
&HostAdapterStatus,\r
// no need to check HostAdapterStatus and TargetStatus\r
//\r
if ((Status == EFI_SUCCESS) || (Status == EFI_WARN_BUFFER_TOO_SMALL)) {\r
- ParseInquiryData (ScsiDiskDevice);\r
- return EFI_SUCCESS;\r
- \r
- } else if (Status == EFI_NOT_READY) {\r
- *NeedRetry = TRUE;\r
- return EFI_DEVICE_ERROR;\r
- \r
- } else if ((Status == EFI_INVALID_PARAMETER) || (Status == EFI_UNSUPPORTED)) {\r
- *NeedRetry = FALSE;\r
- return EFI_DEVICE_ERROR;\r
- }\r
- //\r
- // go ahead to check HostAdapterStatus and TargetStatus\r
- // (EFI_TIMEOUT, EFI_DEVICE_ERROR)\r
- //\r
+ ParseInquiryData (ScsiDiskDevice);\r
+\r
+ if (ScsiDiskDevice->DeviceType == EFI_SCSI_TYPE_DISK) {\r
+ //\r
+ // Check whether the device supports Block Limits VPD page (0xB0)\r
+ //\r
+ SupportedVpdPages = AllocateAlignedBuffer (ScsiDiskDevice, sizeof (EFI_SCSI_SUPPORTED_VPD_PAGES_VPD_PAGE));\r
+ if (SupportedVpdPages == NULL) {\r
+ *NeedRetry = FALSE;\r
+ return EFI_DEVICE_ERROR;\r
+ }\r
+ ZeroMem (SupportedVpdPages, sizeof (EFI_SCSI_SUPPORTED_VPD_PAGES_VPD_PAGE));\r
+ InquiryDataLength = sizeof (EFI_SCSI_SUPPORTED_VPD_PAGES_VPD_PAGE);\r
+ SenseDataLength = 0;\r
+ Status = ScsiInquiryCommandEx (\r
+ ScsiDiskDevice->ScsiIo,\r
+ SCSI_DISK_TIMEOUT,\r
+ NULL,\r
+ &SenseDataLength,\r
+ &HostAdapterStatus,\r
+ &TargetStatus,\r
+ (VOID *) SupportedVpdPages,\r
+ &InquiryDataLength,\r
+ TRUE,\r
+ EFI_SCSI_PAGE_CODE_SUPPORTED_VPD\r
+ );\r
+ if (!EFI_ERROR (Status)) {\r
+ PageLength = (SupportedVpdPages->PageLength2 << 8)\r
+ | SupportedVpdPages->PageLength1;\r
+ for (Index = 0; Index < PageLength; Index++) {\r
+ if (SupportedVpdPages->SupportedVpdPageList[Index] == EFI_SCSI_PAGE_CODE_BLOCK_LIMITS_VPD) {\r
+ break;\r
+ }\r
+ }\r
+\r
+ //\r
+ // Query the Block Limits VPD page\r
+ //\r
+ if (Index < PageLength) {\r
+ BlockLimits = AllocateAlignedBuffer (ScsiDiskDevice, sizeof (EFI_SCSI_BLOCK_LIMITS_VPD_PAGE));\r
+ if (BlockLimits == NULL) {\r
+ FreeAlignedBuffer (SupportedVpdPages, sizeof (EFI_SCSI_SUPPORTED_VPD_PAGES_VPD_PAGE));\r
+ *NeedRetry = FALSE;\r
+ return EFI_DEVICE_ERROR;\r
+ }\r
+ ZeroMem (BlockLimits, sizeof (EFI_SCSI_BLOCK_LIMITS_VPD_PAGE));\r
+ InquiryDataLength = sizeof (EFI_SCSI_BLOCK_LIMITS_VPD_PAGE);\r
+ SenseDataLength = 0;\r
+ Status = ScsiInquiryCommandEx (\r
+ ScsiDiskDevice->ScsiIo,\r
+ SCSI_DISK_TIMEOUT,\r
+ NULL,\r
+ &SenseDataLength,\r
+ &HostAdapterStatus,\r
+ &TargetStatus,\r
+ (VOID *) BlockLimits,\r
+ &InquiryDataLength,\r
+ TRUE,\r
+ EFI_SCSI_PAGE_CODE_BLOCK_LIMITS_VPD\r
+ );\r
+ if (!EFI_ERROR (Status)) {\r
+ ScsiDiskDevice->BlkIo.Media->OptimalTransferLengthGranularity = \r
+ (BlockLimits->OptimalTransferLengthGranularity2 << 8) |\r
+ BlockLimits->OptimalTransferLengthGranularity1;\r
+ }\r
+\r
+ FreeAlignedBuffer (BlockLimits, sizeof (EFI_SCSI_BLOCK_LIMITS_VPD_PAGE));\r
+ }\r
+ }\r
+\r
+ FreeAlignedBuffer (SupportedVpdPages, sizeof (EFI_SCSI_SUPPORTED_VPD_PAGES_VPD_PAGE));\r
+ }\r
+ }\r
+\r
+ if (!EFI_ERROR (Status)) {\r
+ return EFI_SUCCESS;\r
+\r
+ } else if (Status == EFI_NOT_READY) {\r
+ *NeedRetry = TRUE;\r
+ return EFI_DEVICE_ERROR;\r
\r
- Status = CheckHostAdapterStatus (HostAdapterStatus);\r
- if ((Status == EFI_TIMEOUT) || (Status == EFI_NOT_READY)) {\r
- *NeedRetry = TRUE;\r
- return EFI_DEVICE_ERROR;\r
- } else if (Status == EFI_DEVICE_ERROR) {\r
+ } else if ((Status == EFI_INVALID_PARAMETER) || (Status == EFI_UNSUPPORTED)) {\r
+ *NeedRetry = FALSE;\r
+ return EFI_DEVICE_ERROR;\r
+ }\r
+ //\r
+ // go ahead to check HostAdapterStatus and TargetStatus\r
+ // (EFI_TIMEOUT, EFI_DEVICE_ERROR)\r
+ //\r
+\r
+ Status = CheckHostAdapterStatus (HostAdapterStatus);\r
+ if ((Status == EFI_TIMEOUT) || (Status == EFI_NOT_READY)) {\r
+ *NeedRetry = TRUE;\r
+ return EFI_DEVICE_ERROR;\r
+ } else if (Status == EFI_DEVICE_ERROR) {\r
//\r
// reset the scsi channel\r
//\r
//\r
Status = ScsiTestUnitReadyCommand (\r
ScsiDiskDevice->ScsiIo,\r
- EFI_TIMER_PERIOD_SECONDS (1),\r
+ SCSI_DISK_TIMEOUT,\r
NULL,\r
&SenseDataLength,\r
&HostAdapterStatus,\r
*Action = ACTION_READ_CAPACITY;\r
\r
if (NumberOfSenseKeys == 0) {\r
- *Action = ACTION_NO_ACTION;\r
+ if (ScsiDiskDevice->BlkIo.Media->MediaPresent == TRUE) {\r
+ *Action = ACTION_NO_ACTION;\r
+ }\r
return EFI_SUCCESS;\r
}\r
\r
//\r
// No Sense Key returned from last submitted command\r
//\r
- *Action = ACTION_NO_ACTION;\r
+ if (ScsiDiskDevice->BlkIo.Media->MediaPresent == TRUE) {\r
+ *Action = ACTION_NO_ACTION;\r
+ }\r
return EFI_SUCCESS;\r
}\r
\r
ScsiDiskDevice->BlkIo.Media->MediaPresent = FALSE;\r
ScsiDiskDevice->BlkIo.Media->LastBlock = 0;\r
*Action = ACTION_NO_ACTION;\r
+ DEBUG ((EFI_D_VERBOSE, "ScsiDisk: ScsiDiskIsNoMedia\n"));\r
return EFI_SUCCESS;\r
}\r
\r
if (ScsiDiskIsMediaChange (SenseData, NumberOfSenseKeys)) {\r
ScsiDiskDevice->BlkIo.Media->MediaId++;\r
+ DEBUG ((EFI_D_VERBOSE, "ScsiDisk: ScsiDiskIsMediaChange!\n"));\r
+ return EFI_SUCCESS;\r
+ }\r
+\r
+ if (ScsiDiskIsResetBefore (SenseData, NumberOfSenseKeys)) {\r
+ *Action = ACTION_RETRY_COMMAND_LATER;\r
+ DEBUG ((EFI_D_VERBOSE, "ScsiDisk: ScsiDiskIsResetBefore!\n"));\r
return EFI_SUCCESS;\r
}\r
\r
if (ScsiDiskIsMediaError (SenseData, NumberOfSenseKeys)) {\r
- ScsiDiskDevice->BlkIo.Media->MediaPresent = FALSE;\r
- ScsiDiskDevice->BlkIo.Media->LastBlock = 0;\r
+ DEBUG ((EFI_D_VERBOSE, "ScsiDisk: ScsiDiskIsMediaError\n"));\r
+ *Action = ACTION_RETRY_WITH_BACKOFF_ALGO;\r
return EFI_DEVICE_ERROR;\r
}\r
\r
if (ScsiDiskIsHardwareError (SenseData, NumberOfSenseKeys)) {\r
+ DEBUG ((EFI_D_VERBOSE, "ScsiDisk: ScsiDiskIsHardwareError\n"));\r
+ *Action = ACTION_RETRY_WITH_BACKOFF_ALGO;\r
return EFI_DEVICE_ERROR;\r
}\r
\r
if (!ScsiDiskIsDriveReady (SenseData, NumberOfSenseKeys, &RetryLater)) {\r
if (RetryLater) {\r
*Action = ACTION_RETRY_COMMAND_LATER;\r
+ DEBUG ((EFI_D_VERBOSE, "ScsiDisk: ScsiDiskDriveNotReady!\n"));\r
return EFI_SUCCESS;\r
}\r
-\r
+ *Action = ACTION_NO_ACTION;\r
return EFI_DEVICE_ERROR;\r
}\r
\r
+ *Action = ACTION_RETRY_WITH_BACKOFF_ALGO;\r
+ DEBUG ((EFI_D_VERBOSE, "ScsiDisk: Sense Key = 0x%x ASC = 0x%x!\n", SenseData->Sense_Key, SenseData->Addnl_Sense_Code));\r
return EFI_SUCCESS;\r
}\r
\r
@param NumberOfSenseKeys The number of sense key\r
\r
@retval EFI_DEVICE_ERROR Indicates that error occurs\r
- @retval EFI_SUCCESS Successfully to read capacity\r
+ @retval EFI_SUCCESS Successfully to read capacity or sense data is received.\r
\r
**/\r
EFI_STATUS\r
UINT8 SenseDataLength;\r
UINT32 DataLength10;\r
UINT32 DataLength16;\r
- EFI_SCSI_DISK_CAPACITY_DATA CapacityData10;\r
- EFI_SCSI_DISK_CAPACITY_DATA16 CapacityData16;\r
+ EFI_SCSI_DISK_CAPACITY_DATA *CapacityData10;\r
+ EFI_SCSI_DISK_CAPACITY_DATA16 *CapacityData16;\r
\r
+ CapacityData10 = AllocateAlignedBuffer (ScsiDiskDevice, sizeof (EFI_SCSI_DISK_CAPACITY_DATA));\r
+ if (CapacityData10 == NULL) {\r
+ *NeedRetry = FALSE;\r
+ return EFI_DEVICE_ERROR;\r
+ }\r
+ CapacityData16 = AllocateAlignedBuffer (ScsiDiskDevice, sizeof (EFI_SCSI_DISK_CAPACITY_DATA16));\r
+ if (CapacityData16 == NULL) {\r
+ FreeAlignedBuffer (CapacityData10, sizeof (EFI_SCSI_DISK_CAPACITY_DATA));\r
+ *NeedRetry = FALSE;\r
+ return EFI_DEVICE_ERROR;\r
+ }\r
\r
SenseDataLength = 0;\r
DataLength10 = sizeof (EFI_SCSI_DISK_CAPACITY_DATA);\r
DataLength16 = sizeof (EFI_SCSI_DISK_CAPACITY_DATA16);\r
- ZeroMem (&CapacityData10, sizeof (EFI_SCSI_DISK_CAPACITY_DATA));\r
- ZeroMem (&CapacityData16, sizeof (EFI_SCSI_DISK_CAPACITY_DATA16));\r
+ ZeroMem (CapacityData10, sizeof (EFI_SCSI_DISK_CAPACITY_DATA));\r
+ ZeroMem (CapacityData16, sizeof (EFI_SCSI_DISK_CAPACITY_DATA16));\r
\r
*NumberOfSenseKeys = 0;\r
*NeedRetry = FALSE;\r
//\r
CommandStatus = ScsiReadCapacityCommand (\r
ScsiDiskDevice->ScsiIo,\r
- EFI_TIMER_PERIOD_SECONDS(1),\r
+ SCSI_DISK_TIMEOUT,\r
NULL,\r
&SenseDataLength,\r
&HostAdapterStatus,\r
&TargetStatus,\r
- (VOID *) &CapacityData10,\r
+ (VOID *) CapacityData10,\r
&DataLength10,\r
FALSE\r
);\r
\r
ScsiDiskDevice->Cdb16Byte = FALSE;\r
- if ((!EFI_ERROR (CommandStatus)) && (CapacityData10.LastLba3 == 0xff) && (CapacityData10.LastLba2 == 0xff) &&\r
- (CapacityData10.LastLba1 == 0xff) && (CapacityData10.LastLba0 == 0xff)) {\r
+ if ((!EFI_ERROR (CommandStatus)) && (CapacityData10->LastLba3 == 0xff) && (CapacityData10->LastLba2 == 0xff) &&\r
+ (CapacityData10->LastLba1 == 0xff) && (CapacityData10->LastLba0 == 0xff)) {\r
//\r
// use Read Capacity (16), Read (16) and Write (16) next when hard disk size > 2TB\r
//\r
//\r
CommandStatus = ScsiReadCapacity16Command (\r
ScsiDiskDevice->ScsiIo,\r
- EFI_TIMER_PERIOD_SECONDS (1),\r
+ SCSI_DISK_TIMEOUT,\r
NULL,\r
&SenseDataLength,\r
&HostAdapterStatus,\r
&TargetStatus,\r
- (VOID *) &CapacityData16,\r
+ (VOID *) CapacityData16,\r
&DataLength16,\r
FALSE\r
);\r
// no need to check HostAdapterStatus and TargetStatus\r
//\r
if (CommandStatus == EFI_SUCCESS) {\r
- GetMediaInfo (ScsiDiskDevice, &CapacityData10,&CapacityData16);\r
+ GetMediaInfo (ScsiDiskDevice, CapacityData10, CapacityData16);\r
+ FreeAlignedBuffer (CapacityData10, sizeof (EFI_SCSI_DISK_CAPACITY_DATA));\r
+ FreeAlignedBuffer (CapacityData16, sizeof (EFI_SCSI_DISK_CAPACITY_DATA16));\r
return EFI_SUCCESS;\r
- \r
- } else if (CommandStatus == EFI_NOT_READY) {\r
+ }\r
+\r
+ FreeAlignedBuffer (CapacityData10, sizeof (EFI_SCSI_DISK_CAPACITY_DATA));\r
+ FreeAlignedBuffer (CapacityData16, sizeof (EFI_SCSI_DISK_CAPACITY_DATA16));\r
+\r
+ if (CommandStatus == EFI_NOT_READY) {\r
*NeedRetry = TRUE;\r
return EFI_DEVICE_ERROR;\r
- \r
} else if ((CommandStatus == EFI_INVALID_PARAMETER) || (CommandStatus == EFI_UNSUPPORTED)) {\r
*NeedRetry = FALSE;\r
return EFI_DEVICE_ERROR;\r
}\r
+\r
//\r
// go ahead to check HostAdapterStatus and TargetStatus\r
// (EFI_TIMEOUT, EFI_DEVICE_ERROR, EFI_WARN_BUFFER_TOO_SMALL)\r
TRUE\r
);\r
if (!EFI_ERROR (Status)) {\r
- *NeedRetry = TRUE;\r
- return EFI_DEVICE_ERROR;\r
+ return EFI_SUCCESS;\r
}\r
\r
if (!*NeedRetry) {\r
\r
*NumberOfSenseKeys = 0;\r
*SenseDataArray = ScsiDiskDevice->SenseData;\r
- PtrSenseData = ScsiDiskDevice->SenseData;\r
+ Status = EFI_SUCCESS;\r
+ PtrSenseData = AllocateAlignedBuffer (ScsiDiskDevice, sizeof (EFI_SCSI_SENSE_DATA));\r
+ if (PtrSenseData == NULL) {\r
+ return EFI_DEVICE_ERROR;\r
+ }\r
\r
for (SenseReq = TRUE; SenseReq;) {\r
+ ZeroMem (PtrSenseData, sizeof (EFI_SCSI_SENSE_DATA));\r
Status = ScsiRequestSenseCommand (\r
ScsiDiskDevice->ScsiIo,\r
- EFI_TIMER_PERIOD_SECONDS (2),\r
+ SCSI_DISK_TIMEOUT,\r
PtrSenseData,\r
&SenseDataLength,\r
&HostAdapterStatus,\r
if (EFI_ERROR (FallStatus)) {\r
if (*NumberOfSenseKeys != 0) {\r
*NeedRetry = FALSE;\r
- return EFI_SUCCESS;\r
+ Status = EFI_SUCCESS;\r
+ goto EXIT;\r
} else {\r
- return EFI_DEVICE_ERROR;\r
+ Status = EFI_DEVICE_ERROR;\r
+ goto EXIT;\r
}\r
}\r
\r
+ CopyMem (ScsiDiskDevice->SenseData + *NumberOfSenseKeys, PtrSenseData, SenseDataLength);\r
(*NumberOfSenseKeys) += 1;\r
\r
//\r
(*NumberOfSenseKeys == ScsiDiskDevice->SenseDataNumber)) {\r
SenseReq = FALSE;\r
}\r
- PtrSenseData += 1;\r
}\r
- return EFI_SUCCESS;\r
+\r
+EXIT:\r
+ FreeAlignedBuffer (PtrSenseData, sizeof (EFI_SCSI_SENSE_DATA));\r
+ return Status;\r
}\r
\r
\r
{\r
UINT8 *Ptr;\r
\r
- ScsiDiskDevice->BlkIo.Media->LowestAlignedLba = 0;\r
- ScsiDiskDevice->BlkIo.Media->LogicalBlocksPerPhysicalBlock = 1;\r
- \r
-\r
if (!ScsiDiskDevice->Cdb16Byte) {\r
ScsiDiskDevice->BlkIo.Media->LastBlock = (Capacity10->LastLba3 << 24) |\r
(Capacity10->LastLba2 << 16) |\r
(Capacity10->BlockSize2 << 16) | \r
(Capacity10->BlockSize1 << 8) |\r
Capacity10->BlockSize0;\r
- ScsiDiskDevice->BlkIo.Revision = EFI_BLOCK_IO_PROTOCOL_REVISION; \r
+ ScsiDiskDevice->BlkIo.Media->LowestAlignedLba = 0;\r
+ ScsiDiskDevice->BlkIo.Media->LogicalBlocksPerPhysicalBlock = 0;\r
} else {\r
-\r
Ptr = (UINT8*)&ScsiDiskDevice->BlkIo.Media->LastBlock;\r
*Ptr++ = Capacity16->LastLba0;\r
*Ptr++ = Capacity16->LastLba1;\r
*Ptr++ = Capacity16->LastLba5;\r
*Ptr++ = Capacity16->LastLba6;\r
*Ptr = Capacity16->LastLba7;\r
- \r
+\r
ScsiDiskDevice->BlkIo.Media->BlockSize = (Capacity16->BlockSize3 << 24) |\r
(Capacity16->BlockSize2 << 16) | \r
(Capacity16->BlockSize1 << 8) |\r
Capacity16->BlockSize0;\r
\r
- ScsiDiskDevice->BlkIo.Media->LowestAlignedLba = (Capacity16->LowestAlignLogic2 << 8)|(Capacity16->LowestAlignLogic1);\r
- ScsiDiskDevice->BlkIo.Media->LogicalBlocksPerPhysicalBlock = Capacity16->LogicPerPhysical;\r
- ScsiDiskDevice->BlkIo.Revision = EFI_BLOCK_IO_PROTOCOL_REVISION2; \r
+ ScsiDiskDevice->BlkIo.Media->LowestAlignedLba = (Capacity16->LowestAlignLogic2 << 8) |\r
+ Capacity16->LowestAlignLogic1;\r
+ ScsiDiskDevice->BlkIo.Media->LogicalBlocksPerPhysicalBlock = (1 << Capacity16->LogicPerPhysical);\r
}\r
\r
-\r
ScsiDiskDevice->BlkIo.Media->MediaPresent = TRUE;\r
\r
if (ScsiDiskDevice->DeviceType == EFI_SCSI_TYPE_DISK) {\r
UINT8 Index;\r
UINT8 MaxRetry;\r
BOOLEAN NeedRetry;\r
- EFI_SCSI_SENSE_DATA *SenseData;\r
- UINTN NumberOfSenseKeys;\r
-\r
- SenseData = NULL;\r
- NumberOfSenseKeys = 0;\r
\r
Status = EFI_SUCCESS;\r
\r
}\r
\r
ByteCount = SectorCount * BlockSize;\r
- Timeout = EFI_TIMER_PERIOD_SECONDS (2);\r
+ //\r
+ // |------------------------|-----------------|------------------|-----------------|\r
+ // | ATA Transfer Mode | Transfer Rate | SCSI Interface | Transfer Rate |\r
+ // |------------------------|-----------------|------------------|-----------------|\r
+ // | PIO Mode 0 | 3.3Mbytes/sec | SCSI-1 | 5Mbytes/sec |\r
+ // |------------------------|-----------------|------------------|-----------------|\r
+ // | PIO Mode 1 | 5.2Mbytes/sec | Fast SCSI | 10Mbytes/sec |\r
+ // |------------------------|-----------------|------------------|-----------------|\r
+ // | PIO Mode 2 | 8.3Mbytes/sec | Fast-Wide SCSI | 20Mbytes/sec |\r
+ // |------------------------|-----------------|------------------|-----------------|\r
+ // | PIO Mode 3 | 11.1Mbytes/sec | Ultra SCSI | 20Mbytes/sec |\r
+ // |------------------------|-----------------|------------------|-----------------|\r
+ // | PIO Mode 4 | 16.6Mbytes/sec | Ultra Wide SCSI | 40Mbytes/sec |\r
+ // |------------------------|-----------------|------------------|-----------------|\r
+ // | Single-word DMA Mode 0 | 2.1Mbytes/sec | Ultra2 SCSI | 40Mbytes/sec |\r
+ // |------------------------|-----------------|------------------|-----------------|\r
+ // | Single-word DMA Mode 1 | 4.2Mbytes/sec | Ultra2 Wide SCSI | 80Mbytes/sec |\r
+ // |------------------------|-----------------|------------------|-----------------|\r
+ // | Single-word DMA Mode 2 | 8.4Mbytes/sec | Ultra3 SCSI | 160Mbytes/sec |\r
+ // |------------------------|-----------------|------------------|-----------------|\r
+ // | Multi-word DMA Mode 0 | 4.2Mbytes/sec | Ultra-320 SCSI | 320Mbytes/sec |\r
+ // |------------------------|-----------------|------------------|-----------------|\r
+ // | Multi-word DMA Mode 1 | 13.3Mbytes/sec | Ultra-640 SCSI | 640Mbytes/sec |\r
+ // |------------------------|-----------------|------------------|-----------------|\r
+ //\r
+ // As ScsiDisk and ScsiBus driver are used to manage SCSI or ATAPI devices, we have to use\r
+ // the lowest transfer rate to calculate the possible maximum timeout value for each operation.\r
+ // From the above table, we could know 2.1Mbytes per second is lowest one.\r
+ // The timout value is rounded up to nearest integar and here an additional 30s is added\r
+ // to follow ATA spec in which it mentioned that the device may take up to 30s to respond\r
+ // commands in the Standby/Idle mode.\r
+ //\r
+ Timeout = EFI_TIMER_PERIOD_SECONDS (ByteCount / 2100000 + 31);\r
\r
MaxRetry = 2;\r
for (Index = 0; Index < MaxRetry; Index++) {\r
Status = ScsiDiskRead10 (\r
ScsiDiskDevice,\r
&NeedRetry,\r
- &SenseData,\r
- &NumberOfSenseKeys,\r
Timeout,\r
PtrBuffer,\r
&ByteCount,\r
Status = ScsiDiskRead16 (\r
ScsiDiskDevice,\r
&NeedRetry,\r
- &SenseData,\r
- &NumberOfSenseKeys,\r
Timeout,\r
PtrBuffer,\r
&ByteCount,\r
UINT8 Index;\r
UINT8 MaxRetry;\r
BOOLEAN NeedRetry;\r
- EFI_SCSI_SENSE_DATA *SenseData;\r
- UINTN NumberOfSenseKeys;\r
-\r
- SenseData = NULL;\r
- NumberOfSenseKeys = 0;\r
\r
Status = EFI_SUCCESS;\r
\r
}\r
\r
ByteCount = SectorCount * BlockSize;\r
- Timeout = EFI_TIMER_PERIOD_SECONDS (2);\r
+ //\r
+ // |------------------------|-----------------|------------------|-----------------|\r
+ // | ATA Transfer Mode | Transfer Rate | SCSI Interface | Transfer Rate |\r
+ // |------------------------|-----------------|------------------|-----------------|\r
+ // | PIO Mode 0 | 3.3Mbytes/sec | SCSI-1 | 5Mbytes/sec |\r
+ // |------------------------|-----------------|------------------|-----------------|\r
+ // | PIO Mode 1 | 5.2Mbytes/sec | Fast SCSI | 10Mbytes/sec |\r
+ // |------------------------|-----------------|------------------|-----------------|\r
+ // | PIO Mode 2 | 8.3Mbytes/sec | Fast-Wide SCSI | 20Mbytes/sec |\r
+ // |------------------------|-----------------|------------------|-----------------|\r
+ // | PIO Mode 3 | 11.1Mbytes/sec | Ultra SCSI | 20Mbytes/sec |\r
+ // |------------------------|-----------------|------------------|-----------------|\r
+ // | PIO Mode 4 | 16.6Mbytes/sec | Ultra Wide SCSI | 40Mbytes/sec |\r
+ // |------------------------|-----------------|------------------|-----------------|\r
+ // | Single-word DMA Mode 0 | 2.1Mbytes/sec | Ultra2 SCSI | 40Mbytes/sec |\r
+ // |------------------------|-----------------|------------------|-----------------|\r
+ // | Single-word DMA Mode 1 | 4.2Mbytes/sec | Ultra2 Wide SCSI | 80Mbytes/sec |\r
+ // |------------------------|-----------------|------------------|-----------------|\r
+ // | Single-word DMA Mode 2 | 8.4Mbytes/sec | Ultra3 SCSI | 160Mbytes/sec |\r
+ // |------------------------|-----------------|------------------|-----------------|\r
+ // | Multi-word DMA Mode 0 | 4.2Mbytes/sec | Ultra-320 SCSI | 320Mbytes/sec |\r
+ // |------------------------|-----------------|------------------|-----------------|\r
+ // | Multi-word DMA Mode 1 | 13.3Mbytes/sec | Ultra-640 SCSI | 640Mbytes/sec |\r
+ // |------------------------|-----------------|------------------|-----------------|\r
+ //\r
+ // As ScsiDisk and ScsiBus driver are used to manage SCSI or ATAPI devices, we have to use\r
+ // the lowest transfer rate to calculate the possible maximum timeout value for each operation.\r
+ // From the above table, we could know 2.1Mbytes per second is lowest one.\r
+ // The timout value is rounded up to nearest integar and here an additional 30s is added\r
+ // to follow ATA spec in which it mentioned that the device may take up to 30s to respond\r
+ // commands in the Standby/Idle mode.\r
+ //\r
+ Timeout = EFI_TIMER_PERIOD_SECONDS (ByteCount / 2100000 + 31);\r
MaxRetry = 2;\r
for (Index = 0; Index < MaxRetry; Index++) {\r
if (!ScsiDiskDevice->Cdb16Byte) {\r
Status = ScsiDiskWrite10 (\r
ScsiDiskDevice,\r
&NeedRetry,\r
- &SenseData,\r
- &NumberOfSenseKeys,\r
Timeout,\r
PtrBuffer,\r
&ByteCount,\r
Status = ScsiDiskWrite16 (\r
ScsiDiskDevice,\r
&NeedRetry,\r
- &SenseData,\r
- &NumberOfSenseKeys,\r
Timeout,\r
PtrBuffer,\r
&ByteCount,\r
\r
@param ScsiDiskDevice The pointer of ScsiDiskDevice\r
@param NeedRetry The pointer of flag indicates if needs retry if error happens\r
- @param SenseDataArray NOT used yet in this function\r
- @param NumberOfSenseKeys The number of sense key\r
@param Timeout The time to complete the command\r
@param DataBuffer The buffer to fill with the read out data\r
@param DataLength The length of buffer\r
@param StartLba The start logic block address\r
- @param SectorSize The size of sector\r
+ @param SectorCount The number of blocks to read\r
\r
@return EFI_STATUS is returned by calling ScsiRead10Command().\r
**/\r
ScsiDiskRead10 (\r
IN SCSI_DISK_DEV *ScsiDiskDevice,\r
OUT BOOLEAN *NeedRetry,\r
- OUT EFI_SCSI_SENSE_DATA **SenseDataArray, OPTIONAL\r
- OUT UINTN *NumberOfSenseKeys,\r
IN UINT64 Timeout,\r
OUT UINT8 *DataBuffer,\r
IN OUT UINT32 *DataLength,\r
IN UINT32 StartLba,\r
- IN UINT32 SectorSize\r
+ IN UINT32 SectorCount\r
)\r
{\r
UINT8 SenseDataLength;\r
EFI_STATUS Status;\r
+ EFI_STATUS ReturnStatus;\r
UINT8 HostAdapterStatus;\r
UINT8 TargetStatus;\r
+ UINTN Action;\r
\r
+ //\r
+ // Implement a backoff algorithem to resolve some compatibility issues that\r
+ // some SCSI targets or ATAPI devices couldn't correctly response reading/writing\r
+ // big data in a single operation.\r
+ // This algorithem will at first try to execute original request. If the request fails\r
+ // with media error sense data or else, it will reduce the transfer length to half and\r
+ // try again till the operation succeeds or fails with one sector transfer length.\r
+ //\r
+BackOff:\r
*NeedRetry = FALSE;\r
- *NumberOfSenseKeys = 0;\r
- SenseDataLength = 0;\r
- Status = ScsiRead10Command (\r
- ScsiDiskDevice->ScsiIo,\r
- Timeout,\r
- NULL,\r
- &SenseDataLength,\r
- &HostAdapterStatus,\r
- &TargetStatus,\r
- DataBuffer,\r
- DataLength,\r
- StartLba,\r
- SectorSize\r
- );\r
- return Status;\r
+ Action = ACTION_NO_ACTION;\r
+ SenseDataLength = (UINT8) (ScsiDiskDevice->SenseDataNumber * sizeof (EFI_SCSI_SENSE_DATA));\r
+ ReturnStatus = ScsiRead10Command (\r
+ ScsiDiskDevice->ScsiIo,\r
+ Timeout,\r
+ ScsiDiskDevice->SenseData,\r
+ &SenseDataLength,\r
+ &HostAdapterStatus,\r
+ &TargetStatus,\r
+ DataBuffer,\r
+ DataLength,\r
+ StartLba,\r
+ SectorCount\r
+ );\r
+\r
+ if (ReturnStatus == EFI_NOT_READY) {\r
+ *NeedRetry = TRUE;\r
+ return EFI_DEVICE_ERROR;\r
+ } else if ((ReturnStatus == EFI_INVALID_PARAMETER) || (ReturnStatus == EFI_UNSUPPORTED)) {\r
+ *NeedRetry = FALSE;\r
+ return ReturnStatus;\r
+ }\r
+\r
+ //\r
+ // go ahead to check HostAdapterStatus and TargetStatus\r
+ // (EFI_TIMEOUT, EFI_DEVICE_ERROR, EFI_WARN_BUFFER_TOO_SMALL)\r
+ //\r
+ Status = CheckHostAdapterStatus (HostAdapterStatus);\r
+ if ((Status == EFI_TIMEOUT) || (Status == EFI_NOT_READY)) {\r
+ *NeedRetry = TRUE;\r
+ return EFI_DEVICE_ERROR;\r
+ } else if (Status == EFI_DEVICE_ERROR) {\r
+ //\r
+ // reset the scsi channel\r
+ //\r
+ ScsiDiskDevice->ScsiIo->ResetBus (ScsiDiskDevice->ScsiIo);\r
+ *NeedRetry = FALSE;\r
+ return EFI_DEVICE_ERROR;\r
+ }\r
+\r
+ Status = CheckTargetStatus (TargetStatus);\r
+ if (Status == EFI_NOT_READY) {\r
+ //\r
+ // reset the scsi device\r
+ //\r
+ ScsiDiskDevice->ScsiIo->ResetDevice (ScsiDiskDevice->ScsiIo);\r
+ *NeedRetry = TRUE;\r
+ return EFI_DEVICE_ERROR;\r
+ } else if (Status == EFI_DEVICE_ERROR) {\r
+ *NeedRetry = FALSE;\r
+ return EFI_DEVICE_ERROR;\r
+ }\r
+\r
+ if ((TargetStatus == EFI_EXT_SCSI_STATUS_TARGET_CHECK_CONDITION) || (EFI_ERROR (ReturnStatus))) {\r
+ DEBUG ((EFI_D_ERROR, "ScsiDiskRead10: Check Condition happened!\n"));\r
+ Status = DetectMediaParsingSenseKeys (ScsiDiskDevice, ScsiDiskDevice->SenseData, SenseDataLength / sizeof (EFI_SCSI_SENSE_DATA), &Action);\r
+ if (Action == ACTION_RETRY_COMMAND_LATER) {\r
+ *NeedRetry = TRUE;\r
+ return EFI_DEVICE_ERROR;\r
+ } else if (Action == ACTION_RETRY_WITH_BACKOFF_ALGO) {\r
+ if (SectorCount <= 1) {\r
+ //\r
+ // Jump out if the operation still fails with one sector transfer length.\r
+ //\r
+ *NeedRetry = FALSE;\r
+ return EFI_DEVICE_ERROR;\r
+ }\r
+ //\r
+ // Try again with half length if the sense data shows we need to retry.\r
+ //\r
+ SectorCount >>= 1;\r
+ *DataLength = SectorCount * ScsiDiskDevice->BlkIo.Media->BlockSize;\r
+ goto BackOff;\r
+ } else {\r
+ *NeedRetry = FALSE;\r
+ return EFI_DEVICE_ERROR;\r
+ }\r
+ }\r
+\r
+ return ReturnStatus;\r
}\r
\r
\r
\r
@param ScsiDiskDevice The pointer of ScsiDiskDevice\r
@param NeedRetry The pointer of flag indicates if needs retry if error happens\r
- @param SenseDataArray NOT used yet in this function\r
- @param NumberOfSenseKeys The number of sense key\r
@param Timeout The time to complete the command\r
@param DataBuffer The buffer to fill with the read out data\r
@param DataLength The length of buffer\r
@param StartLba The start logic block address\r
- @param SectorSize The size of sector\r
+ @param SectorCount The number of blocks to write\r
\r
@return EFI_STATUS is returned by calling ScsiWrite10Command().\r
\r
ScsiDiskWrite10 (\r
IN SCSI_DISK_DEV *ScsiDiskDevice,\r
OUT BOOLEAN *NeedRetry,\r
- OUT EFI_SCSI_SENSE_DATA **SenseDataArray, OPTIONAL\r
- OUT UINTN *NumberOfSenseKeys,\r
IN UINT64 Timeout,\r
IN UINT8 *DataBuffer,\r
IN OUT UINT32 *DataLength,\r
IN UINT32 StartLba,\r
- IN UINT32 SectorSize\r
+ IN UINT32 SectorCount\r
)\r
{\r
EFI_STATUS Status;\r
+ EFI_STATUS ReturnStatus;\r
UINT8 SenseDataLength;\r
UINT8 HostAdapterStatus;\r
UINT8 TargetStatus;\r
+ UINTN Action;\r
\r
+ //\r
+ // Implement a backoff algorithem to resolve some compatibility issues that\r
+ // some SCSI targets or ATAPI devices couldn't correctly response reading/writing\r
+ // big data in a single operation.\r
+ // This algorithem will at first try to execute original request. If the request fails\r
+ // with media error sense data or else, it will reduce the transfer length to half and\r
+ // try again till the operation succeeds or fails with one sector transfer length.\r
+ //\r
+BackOff:\r
*NeedRetry = FALSE;\r
- *NumberOfSenseKeys = 0;\r
- SenseDataLength = 0;\r
- Status = ScsiWrite10Command (\r
- ScsiDiskDevice->ScsiIo,\r
- Timeout,\r
- NULL,\r
- &SenseDataLength,\r
- &HostAdapterStatus,\r
- &TargetStatus,\r
- DataBuffer,\r
- DataLength,\r
- StartLba,\r
- SectorSize\r
- );\r
- return Status;\r
+ Action = ACTION_NO_ACTION;\r
+ SenseDataLength = (UINT8) (ScsiDiskDevice->SenseDataNumber * sizeof (EFI_SCSI_SENSE_DATA));\r
+ ReturnStatus = ScsiWrite10Command (\r
+ ScsiDiskDevice->ScsiIo,\r
+ Timeout,\r
+ ScsiDiskDevice->SenseData,\r
+ &SenseDataLength,\r
+ &HostAdapterStatus,\r
+ &TargetStatus,\r
+ DataBuffer,\r
+ DataLength,\r
+ StartLba,\r
+ SectorCount\r
+ );\r
+ if (ReturnStatus == EFI_NOT_READY) {\r
+ *NeedRetry = TRUE;\r
+ return EFI_DEVICE_ERROR;\r
+ } else if ((ReturnStatus == EFI_INVALID_PARAMETER) || (ReturnStatus == EFI_UNSUPPORTED)) {\r
+ *NeedRetry = FALSE;\r
+ return ReturnStatus;\r
+ }\r
+\r
+ //\r
+ // go ahead to check HostAdapterStatus and TargetStatus\r
+ // (EFI_TIMEOUT, EFI_DEVICE_ERROR, EFI_WARN_BUFFER_TOO_SMALL)\r
+ //\r
+ Status = CheckHostAdapterStatus (HostAdapterStatus);\r
+ if ((Status == EFI_TIMEOUT) || (Status == EFI_NOT_READY)) {\r
+ *NeedRetry = TRUE;\r
+ return EFI_DEVICE_ERROR;\r
+ } else if (Status == EFI_DEVICE_ERROR) {\r
+ //\r
+ // reset the scsi channel\r
+ //\r
+ ScsiDiskDevice->ScsiIo->ResetBus (ScsiDiskDevice->ScsiIo);\r
+ *NeedRetry = FALSE;\r
+ return EFI_DEVICE_ERROR;\r
+ }\r
+\r
+ Status = CheckTargetStatus (TargetStatus);\r
+ if (Status == EFI_NOT_READY) {\r
+ //\r
+ // reset the scsi device\r
+ //\r
+ ScsiDiskDevice->ScsiIo->ResetDevice (ScsiDiskDevice->ScsiIo);\r
+ *NeedRetry = TRUE;\r
+ return EFI_DEVICE_ERROR;\r
+ } else if (Status == EFI_DEVICE_ERROR) {\r
+ *NeedRetry = FALSE;\r
+ return EFI_DEVICE_ERROR;\r
+ }\r
+\r
+ if ((TargetStatus == EFI_EXT_SCSI_STATUS_TARGET_CHECK_CONDITION) || (EFI_ERROR (ReturnStatus))) {\r
+ DEBUG ((EFI_D_ERROR, "ScsiDiskWrite10: Check Condition happened!\n"));\r
+ Status = DetectMediaParsingSenseKeys (ScsiDiskDevice, ScsiDiskDevice->SenseData, SenseDataLength / sizeof (EFI_SCSI_SENSE_DATA), &Action);\r
+ if (Action == ACTION_RETRY_COMMAND_LATER) {\r
+ *NeedRetry = TRUE;\r
+ return EFI_DEVICE_ERROR;\r
+ } else if (Action == ACTION_RETRY_WITH_BACKOFF_ALGO) {\r
+ if (SectorCount <= 1) {\r
+ //\r
+ // Jump out if the operation still fails with one sector transfer length.\r
+ //\r
+ *NeedRetry = FALSE;\r
+ return EFI_DEVICE_ERROR;\r
+ }\r
+ //\r
+ // Try again with half length if the sense data shows we need to retry.\r
+ //\r
+ SectorCount >>= 1;\r
+ *DataLength = SectorCount * ScsiDiskDevice->BlkIo.Media->BlockSize;\r
+ goto BackOff;\r
+ } else {\r
+ *NeedRetry = FALSE;\r
+ return EFI_DEVICE_ERROR;\r
+ }\r
+ }\r
+\r
+ return ReturnStatus;\r
}\r
\r
\r
\r
@param ScsiDiskDevice The pointer of ScsiDiskDevice\r
@param NeedRetry The pointer of flag indicates if needs retry if error happens\r
- @param SenseDataArray NOT used yet in this function\r
- @param NumberOfSenseKeys The number of sense key\r
@param Timeout The time to complete the command\r
@param DataBuffer The buffer to fill with the read out data\r
@param DataLength The length of buffer\r
@param StartLba The start logic block address\r
- @param SectorSize The size of sector\r
+ @param SectorCount The number of blocks to read\r
\r
- @return EFI_STATUS is returned by calling ScsiRead10Command().\r
+ @return EFI_STATUS is returned by calling ScsiRead16Command().\r
**/\r
EFI_STATUS\r
ScsiDiskRead16 (\r
IN SCSI_DISK_DEV *ScsiDiskDevice,\r
OUT BOOLEAN *NeedRetry,\r
- OUT EFI_SCSI_SENSE_DATA **SenseDataArray, OPTIONAL\r
- OUT UINTN *NumberOfSenseKeys,\r
IN UINT64 Timeout,\r
OUT UINT8 *DataBuffer,\r
IN OUT UINT32 *DataLength,\r
IN UINT64 StartLba,\r
- IN UINT32 SectorSize\r
+ IN UINT32 SectorCount\r
)\r
{\r
UINT8 SenseDataLength;\r
EFI_STATUS Status;\r
+ EFI_STATUS ReturnStatus;\r
UINT8 HostAdapterStatus;\r
UINT8 TargetStatus;\r
+ UINTN Action;\r
\r
+ //\r
+ // Implement a backoff algorithem to resolve some compatibility issues that\r
+ // some SCSI targets or ATAPI devices couldn't correctly response reading/writing\r
+ // big data in a single operation.\r
+ // This algorithem will at first try to execute original request. If the request fails\r
+ // with media error sense data or else, it will reduce the transfer length to half and\r
+ // try again till the operation succeeds or fails with one sector transfer length.\r
+ //\r
+BackOff:\r
*NeedRetry = FALSE;\r
- *NumberOfSenseKeys = 0;\r
- SenseDataLength = 0;\r
- Status = ScsiRead16Command (\r
- ScsiDiskDevice->ScsiIo,\r
- Timeout,\r
- NULL,\r
- &SenseDataLength,\r
- &HostAdapterStatus,\r
- &TargetStatus,\r
- DataBuffer,\r
- DataLength,\r
- StartLba,\r
- SectorSize\r
- );\r
- return Status;\r
+ Action = ACTION_NO_ACTION;\r
+ SenseDataLength = (UINT8) (ScsiDiskDevice->SenseDataNumber * sizeof (EFI_SCSI_SENSE_DATA));\r
+ ReturnStatus = ScsiRead16Command (\r
+ ScsiDiskDevice->ScsiIo,\r
+ Timeout,\r
+ ScsiDiskDevice->SenseData,\r
+ &SenseDataLength,\r
+ &HostAdapterStatus,\r
+ &TargetStatus,\r
+ DataBuffer,\r
+ DataLength,\r
+ StartLba,\r
+ SectorCount\r
+ );\r
+ if (ReturnStatus == EFI_NOT_READY) {\r
+ *NeedRetry = TRUE;\r
+ return EFI_DEVICE_ERROR;\r
+ } else if ((ReturnStatus == EFI_INVALID_PARAMETER) || (ReturnStatus == EFI_UNSUPPORTED)) {\r
+ *NeedRetry = FALSE;\r
+ return ReturnStatus;\r
+ }\r
+\r
+ //\r
+ // go ahead to check HostAdapterStatus and TargetStatus\r
+ // (EFI_TIMEOUT, EFI_DEVICE_ERROR, EFI_WARN_BUFFER_TOO_SMALL)\r
+ //\r
+ Status = CheckHostAdapterStatus (HostAdapterStatus);\r
+ if ((Status == EFI_TIMEOUT) || (Status == EFI_NOT_READY)) {\r
+ *NeedRetry = TRUE;\r
+ return EFI_DEVICE_ERROR;\r
+ } else if (Status == EFI_DEVICE_ERROR) {\r
+ //\r
+ // reset the scsi channel\r
+ //\r
+ ScsiDiskDevice->ScsiIo->ResetBus (ScsiDiskDevice->ScsiIo);\r
+ *NeedRetry = FALSE;\r
+ return EFI_DEVICE_ERROR;\r
+ }\r
+\r
+ Status = CheckTargetStatus (TargetStatus);\r
+ if (Status == EFI_NOT_READY) {\r
+ //\r
+ // reset the scsi device\r
+ //\r
+ ScsiDiskDevice->ScsiIo->ResetDevice (ScsiDiskDevice->ScsiIo);\r
+ *NeedRetry = TRUE;\r
+ return EFI_DEVICE_ERROR;\r
+ } else if (Status == EFI_DEVICE_ERROR) {\r
+ *NeedRetry = FALSE;\r
+ return EFI_DEVICE_ERROR;\r
+ }\r
+\r
+ if ((TargetStatus == EFI_EXT_SCSI_STATUS_TARGET_CHECK_CONDITION) || (EFI_ERROR (ReturnStatus))) {\r
+ DEBUG ((EFI_D_ERROR, "ScsiDiskRead16: Check Condition happened!\n"));\r
+ Status = DetectMediaParsingSenseKeys (ScsiDiskDevice, ScsiDiskDevice->SenseData, SenseDataLength / sizeof (EFI_SCSI_SENSE_DATA), &Action);\r
+ if (Action == ACTION_RETRY_COMMAND_LATER) {\r
+ *NeedRetry = TRUE;\r
+ return EFI_DEVICE_ERROR;\r
+ } else if (Action == ACTION_RETRY_WITH_BACKOFF_ALGO) {\r
+ if (SectorCount <= 1) {\r
+ //\r
+ // Jump out if the operation still fails with one sector transfer length.\r
+ //\r
+ *NeedRetry = FALSE;\r
+ return EFI_DEVICE_ERROR;\r
+ }\r
+ //\r
+ // Try again with half length if the sense data shows we need to retry.\r
+ //\r
+ SectorCount >>= 1;\r
+ *DataLength = SectorCount * ScsiDiskDevice->BlkIo.Media->BlockSize;\r
+ goto BackOff;\r
+ } else {\r
+ *NeedRetry = FALSE;\r
+ return EFI_DEVICE_ERROR;\r
+ }\r
+ }\r
+\r
+ return ReturnStatus;\r
}\r
\r
\r
\r
@param ScsiDiskDevice The pointer of ScsiDiskDevice\r
@param NeedRetry The pointer of flag indicates if needs retry if error happens\r
- @param SenseDataArray NOT used yet in this function\r
- @param NumberOfSenseKeys The number of sense key\r
@param Timeout The time to complete the command\r
@param DataBuffer The buffer to fill with the read out data\r
@param DataLength The length of buffer\r
@param StartLba The start logic block address\r
- @param SectorSize The size of sector\r
+ @param SectorCount The number of blocks to write\r
\r
- @return EFI_STATUS is returned by calling ScsiWrite10Command().\r
+ @return EFI_STATUS is returned by calling ScsiWrite16Command().\r
\r
**/\r
EFI_STATUS\r
ScsiDiskWrite16 (\r
IN SCSI_DISK_DEV *ScsiDiskDevice,\r
OUT BOOLEAN *NeedRetry,\r
- OUT EFI_SCSI_SENSE_DATA **SenseDataArray, OPTIONAL\r
- OUT UINTN *NumberOfSenseKeys,\r
IN UINT64 Timeout,\r
IN UINT8 *DataBuffer,\r
IN OUT UINT32 *DataLength,\r
IN UINT64 StartLba,\r
- IN UINT32 SectorSize\r
+ IN UINT32 SectorCount\r
)\r
{\r
EFI_STATUS Status;\r
+ EFI_STATUS ReturnStatus;\r
UINT8 SenseDataLength;\r
UINT8 HostAdapterStatus;\r
UINT8 TargetStatus;\r
+ UINTN Action;\r
\r
+ //\r
+ // Implement a backoff algorithem to resolve some compatibility issues that\r
+ // some SCSI targets or ATAPI devices couldn't correctly response reading/writing\r
+ // big data in a single operation.\r
+ // This algorithem will at first try to execute original request. If the request fails\r
+ // with media error sense data or else, it will reduce the transfer length to half and\r
+ // try again till the operation succeeds or fails with one sector transfer length.\r
+ //\r
+BackOff:\r
*NeedRetry = FALSE;\r
- *NumberOfSenseKeys = 0;\r
- SenseDataLength = 0;\r
- Status = ScsiWrite16Command (\r
- ScsiDiskDevice->ScsiIo,\r
- Timeout,\r
- NULL,\r
- &SenseDataLength,\r
- &HostAdapterStatus,\r
- &TargetStatus,\r
- DataBuffer,\r
- DataLength,\r
- StartLba,\r
- SectorSize\r
- );\r
- return Status;\r
+ Action = ACTION_NO_ACTION;\r
+ SenseDataLength = (UINT8) (ScsiDiskDevice->SenseDataNumber * sizeof (EFI_SCSI_SENSE_DATA));\r
+ ReturnStatus = ScsiWrite16Command (\r
+ ScsiDiskDevice->ScsiIo,\r
+ Timeout,\r
+ ScsiDiskDevice->SenseData,\r
+ &SenseDataLength,\r
+ &HostAdapterStatus,\r
+ &TargetStatus,\r
+ DataBuffer,\r
+ DataLength,\r
+ StartLba,\r
+ SectorCount\r
+ );\r
+ if (ReturnStatus == EFI_NOT_READY) {\r
+ *NeedRetry = TRUE;\r
+ return EFI_DEVICE_ERROR;\r
+ } else if ((ReturnStatus == EFI_INVALID_PARAMETER) || (ReturnStatus == EFI_UNSUPPORTED)) {\r
+ *NeedRetry = FALSE;\r
+ return ReturnStatus;\r
+ }\r
+\r
+ //\r
+ // go ahead to check HostAdapterStatus and TargetStatus\r
+ // (EFI_TIMEOUT, EFI_DEVICE_ERROR, EFI_WARN_BUFFER_TOO_SMALL)\r
+ //\r
+ Status = CheckHostAdapterStatus (HostAdapterStatus);\r
+ if ((Status == EFI_TIMEOUT) || (Status == EFI_NOT_READY)) {\r
+ *NeedRetry = TRUE;\r
+ return EFI_DEVICE_ERROR;\r
+ } else if (Status == EFI_DEVICE_ERROR) {\r
+ //\r
+ // reset the scsi channel\r
+ //\r
+ ScsiDiskDevice->ScsiIo->ResetBus (ScsiDiskDevice->ScsiIo);\r
+ *NeedRetry = FALSE;\r
+ return EFI_DEVICE_ERROR;\r
+ }\r
+\r
+ Status = CheckTargetStatus (TargetStatus);\r
+ if (Status == EFI_NOT_READY) {\r
+ //\r
+ // reset the scsi device\r
+ //\r
+ ScsiDiskDevice->ScsiIo->ResetDevice (ScsiDiskDevice->ScsiIo);\r
+ *NeedRetry = TRUE;\r
+ return EFI_DEVICE_ERROR;\r
+ } else if (Status == EFI_DEVICE_ERROR) {\r
+ *NeedRetry = FALSE;\r
+ return EFI_DEVICE_ERROR;\r
+ }\r
+\r
+ if ((TargetStatus == EFI_EXT_SCSI_STATUS_TARGET_CHECK_CONDITION) || (EFI_ERROR (ReturnStatus))) {\r
+ DEBUG ((EFI_D_ERROR, "ScsiDiskWrite16: Check Condition happened!\n"));\r
+ Status = DetectMediaParsingSenseKeys (ScsiDiskDevice, ScsiDiskDevice->SenseData, SenseDataLength / sizeof (EFI_SCSI_SENSE_DATA), &Action);\r
+ if (Action == ACTION_RETRY_COMMAND_LATER) {\r
+ *NeedRetry = TRUE;\r
+ return EFI_DEVICE_ERROR;\r
+ } else if (Action == ACTION_RETRY_WITH_BACKOFF_ALGO) {\r
+ if (SectorCount <= 1) {\r
+ //\r
+ // Jump out if the operation still fails with one sector transfer length.\r
+ //\r
+ *NeedRetry = FALSE;\r
+ return EFI_DEVICE_ERROR;\r
+ }\r
+ //\r
+ // Try again with half length if the sense data shows we need to retry.\r
+ //\r
+ SectorCount >>= 1;\r
+ *DataLength = SectorCount * ScsiDiskDevice->BlkIo.Media->BlockSize;\r
+ goto BackOff;\r
+ } else {\r
+ *NeedRetry = FALSE;\r
+ return EFI_DEVICE_ERROR;\r
+ }\r
+ }\r
+\r
+ return ReturnStatus;\r
}\r
\r
\r
ZeroMem (Cdb, sizeof (Cdb));\r
\r
Cdb[0] = ATA_CMD_IDENTIFY_DEVICE;\r
- CommandPacket.Timeout = EFI_TIMER_PERIOD_SECONDS (1);\r
+ CommandPacket.Timeout = SCSI_DISK_TIMEOUT;\r
CommandPacket.Cdb = Cdb;\r
CommandPacket.CdbLength = (UINT8) sizeof (Cdb);\r
CommandPacket.InDataBuffer = &ScsiDiskDevice->IdentifyData;\r