EmbeddedPkg: Apply uncrustify changes
REF: https://bugzilla.tianocore.org/show_bug.cgi?id=3737 Apply uncrustify changes to .c/.h files in the EmbeddedPkg package Cc: Andrew Fish <afish@apple.com> Cc: Leif Lindholm <leif@nuviainc.com> Cc: Michael D Kinney <michael.d.kinney@intel.com> Signed-off-by: Michael Kubacki <michael.kubacki@microsoft.com> Reviewed-by: Andrew Fish <afish@apple.com>
This commit is contained in:
committed by
mergify[bot]
parent
731c67e1d7
commit
e7108d0e96
@@ -21,16 +21,16 @@ GLOBAL_REMOVE_IF_UNREFERENCED EFI_COMPONENT_NAME_PROTOCOL gMmcComponentName = {
|
||||
//
|
||||
// EFI Component Name 2 Protocol
|
||||
//
|
||||
GLOBAL_REMOVE_IF_UNREFERENCED EFI_COMPONENT_NAME2_PROTOCOL gMmcComponentName2 = {
|
||||
(EFI_COMPONENT_NAME2_GET_DRIVER_NAME) MmcGetDriverName,
|
||||
(EFI_COMPONENT_NAME2_GET_CONTROLLER_NAME) MmcGetControllerName,
|
||||
GLOBAL_REMOVE_IF_UNREFERENCED EFI_COMPONENT_NAME2_PROTOCOL gMmcComponentName2 = {
|
||||
(EFI_COMPONENT_NAME2_GET_DRIVER_NAME)MmcGetDriverName,
|
||||
(EFI_COMPONENT_NAME2_GET_CONTROLLER_NAME)MmcGetControllerName,
|
||||
"en"
|
||||
};
|
||||
|
||||
GLOBAL_REMOVE_IF_UNREFERENCED EFI_UNICODE_STRING_TABLE
|
||||
mMmcDriverNameTable[] = {
|
||||
{"eng;en", L"MMC/SD Card Interface Driver"},
|
||||
{NULL, NULL}
|
||||
mMmcDriverNameTable[] = {
|
||||
{ "eng;en", L"MMC/SD Card Interface Driver" },
|
||||
{ NULL, NULL }
|
||||
};
|
||||
|
||||
/**
|
||||
@@ -145,11 +145,11 @@ MmcGetDriverName (
|
||||
EFI_STATUS
|
||||
EFIAPI
|
||||
MmcGetControllerName (
|
||||
IN EFI_COMPONENT_NAME_PROTOCOL *This,
|
||||
IN EFI_HANDLE ControllerHandle,
|
||||
IN EFI_HANDLE ChildHandle OPTIONAL,
|
||||
IN CHAR8 *Language,
|
||||
OUT CHAR16 **ControllerName
|
||||
IN EFI_COMPONENT_NAME_PROTOCOL *This,
|
||||
IN EFI_HANDLE ControllerHandle,
|
||||
IN EFI_HANDLE ChildHandle OPTIONAL,
|
||||
IN CHAR8 *Language,
|
||||
OUT CHAR16 **ControllerName
|
||||
)
|
||||
{
|
||||
return EFI_UNSUPPORTED;
|
||||
|
@@ -17,29 +17,30 @@
|
||||
|
||||
#define DIAGNOSTIC_LOGBUFFER_MAXCHAR 1024
|
||||
|
||||
CHAR16* mLogBuffer = NULL;
|
||||
CHAR16 *mLogBuffer = NULL;
|
||||
UINTN mLogRemainChar = 0;
|
||||
|
||||
CHAR16*
|
||||
CHAR16 *
|
||||
DiagnosticInitLog (
|
||||
UINTN MaxBufferChar
|
||||
UINTN MaxBufferChar
|
||||
)
|
||||
{
|
||||
mLogRemainChar = MaxBufferChar;
|
||||
mLogBuffer = AllocatePool ((UINTN)MaxBufferChar * sizeof (CHAR16));
|
||||
mLogBuffer = AllocatePool ((UINTN)MaxBufferChar * sizeof (CHAR16));
|
||||
return mLogBuffer;
|
||||
}
|
||||
|
||||
UINTN
|
||||
DiagnosticLog (
|
||||
CONST CHAR16* Str
|
||||
CONST CHAR16 *Str
|
||||
)
|
||||
{
|
||||
UINTN len = StrLen (Str);
|
||||
UINTN len = StrLen (Str);
|
||||
|
||||
if (len < mLogRemainChar) {
|
||||
StrCpyS (mLogBuffer, mLogRemainChar, Str);
|
||||
mLogRemainChar -= len;
|
||||
mLogBuffer += len;
|
||||
mLogBuffer += len;
|
||||
return len;
|
||||
} else {
|
||||
return 0;
|
||||
@@ -48,12 +49,12 @@ DiagnosticLog (
|
||||
|
||||
VOID
|
||||
GenerateRandomBuffer (
|
||||
VOID* Buffer,
|
||||
UINTN BufferSize
|
||||
VOID *Buffer,
|
||||
UINTN BufferSize
|
||||
)
|
||||
{
|
||||
UINT64 i;
|
||||
UINT64* Buffer64 = (UINT64*)Buffer;
|
||||
UINT64 *Buffer64 = (UINT64 *)Buffer;
|
||||
|
||||
for (i = 0; i < (BufferSize >> 3); i++) {
|
||||
*Buffer64 = i | LShiftU64 (~i, 32);
|
||||
@@ -63,14 +64,14 @@ GenerateRandomBuffer (
|
||||
|
||||
BOOLEAN
|
||||
CompareBuffer (
|
||||
VOID *BufferA,
|
||||
VOID *BufferB,
|
||||
UINTN BufferSize
|
||||
VOID *BufferA,
|
||||
VOID *BufferB,
|
||||
UINTN BufferSize
|
||||
)
|
||||
{
|
||||
UINTN i;
|
||||
UINT64* BufferA64 = (UINT64*)BufferA;
|
||||
UINT64* BufferB64 = (UINT64*)BufferB;
|
||||
UINTN i;
|
||||
UINT64 *BufferA64 = (UINT64 *)BufferA;
|
||||
UINT64 *BufferB64 = (UINT64 *)BufferB;
|
||||
|
||||
for (i = 0; i < (BufferSize >> 3); i++) {
|
||||
if (*BufferA64 != *BufferB64) {
|
||||
@@ -78,23 +79,25 @@ CompareBuffer (
|
||||
DEBUG ((DEBUG_ERROR, "(0x%lX) != (0x%lX)\n", *BufferA64, *BufferB64));
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
BufferA64++;
|
||||
BufferB64++;
|
||||
}
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
EFI_STATUS
|
||||
MmcReadWriteDataTest (
|
||||
MMC_HOST_INSTANCE *MmcHostInstance,
|
||||
EFI_LBA Lba,
|
||||
UINTN BufferSize
|
||||
MMC_HOST_INSTANCE *MmcHostInstance,
|
||||
EFI_LBA Lba,
|
||||
UINTN BufferSize
|
||||
)
|
||||
{
|
||||
VOID *BackBuffer;
|
||||
VOID *WriteBuffer;
|
||||
VOID *ReadBuffer;
|
||||
EFI_STATUS Status;
|
||||
VOID *BackBuffer;
|
||||
VOID *WriteBuffer;
|
||||
VOID *ReadBuffer;
|
||||
EFI_STATUS Status;
|
||||
|
||||
// Check if a Media is Present
|
||||
if (!MmcHostInstance->BlockIo.Media->MediaPresent) {
|
||||
@@ -107,54 +110,54 @@ MmcReadWriteDataTest (
|
||||
return EFI_NOT_READY;
|
||||
}
|
||||
|
||||
BackBuffer = AllocatePool (BufferSize);
|
||||
BackBuffer = AllocatePool (BufferSize);
|
||||
WriteBuffer = AllocatePool (BufferSize);
|
||||
ReadBuffer = AllocatePool (BufferSize);
|
||||
ReadBuffer = AllocatePool (BufferSize);
|
||||
|
||||
// Read (and save) buffer at a specific location
|
||||
Status = MmcReadBlocks (&(MmcHostInstance->BlockIo), MmcHostInstance->BlockIo.Media->MediaId,Lba,BufferSize,BackBuffer);
|
||||
Status = MmcReadBlocks (&(MmcHostInstance->BlockIo), MmcHostInstance->BlockIo.Media->MediaId, Lba, BufferSize, BackBuffer);
|
||||
if (Status != EFI_SUCCESS) {
|
||||
DiagnosticLog (L"ERROR: Fail to Read Block (1)\n");
|
||||
return Status;
|
||||
}
|
||||
|
||||
// Write buffer at the same location
|
||||
GenerateRandomBuffer (WriteBuffer,BufferSize);
|
||||
Status = MmcWriteBlocks (&(MmcHostInstance->BlockIo), MmcHostInstance->BlockIo.Media->MediaId,Lba,BufferSize,WriteBuffer);
|
||||
GenerateRandomBuffer (WriteBuffer, BufferSize);
|
||||
Status = MmcWriteBlocks (&(MmcHostInstance->BlockIo), MmcHostInstance->BlockIo.Media->MediaId, Lba, BufferSize, WriteBuffer);
|
||||
if (Status != EFI_SUCCESS) {
|
||||
DiagnosticLog (L"ERROR: Fail to Write Block (1)\n");
|
||||
return Status;
|
||||
}
|
||||
|
||||
// Read the buffer at the same location
|
||||
Status = MmcReadBlocks (&(MmcHostInstance->BlockIo), MmcHostInstance->BlockIo.Media->MediaId,Lba,BufferSize,ReadBuffer);
|
||||
Status = MmcReadBlocks (&(MmcHostInstance->BlockIo), MmcHostInstance->BlockIo.Media->MediaId, Lba, BufferSize, ReadBuffer);
|
||||
if (Status != EFI_SUCCESS) {
|
||||
DiagnosticLog (L"ERROR: Fail to Read Block (2)\n");
|
||||
return Status;
|
||||
}
|
||||
|
||||
// Check that is conform
|
||||
if (!CompareBuffer (ReadBuffer,WriteBuffer,BufferSize)) {
|
||||
if (!CompareBuffer (ReadBuffer, WriteBuffer, BufferSize)) {
|
||||
DiagnosticLog (L"ERROR: Fail to Read/Write Block (1)\n");
|
||||
return EFI_INVALID_PARAMETER;
|
||||
}
|
||||
|
||||
// Restore content at the original location
|
||||
Status = MmcWriteBlocks (&(MmcHostInstance->BlockIo), MmcHostInstance->BlockIo.Media->MediaId,Lba,BufferSize,BackBuffer);
|
||||
Status = MmcWriteBlocks (&(MmcHostInstance->BlockIo), MmcHostInstance->BlockIo.Media->MediaId, Lba, BufferSize, BackBuffer);
|
||||
if (Status != EFI_SUCCESS) {
|
||||
DiagnosticLog (L"ERROR: Fail to Write Block (2)\n");
|
||||
return Status;
|
||||
}
|
||||
|
||||
// Read the restored content
|
||||
Status = MmcReadBlocks (&(MmcHostInstance->BlockIo), MmcHostInstance->BlockIo.Media->MediaId,Lba,BufferSize,ReadBuffer);
|
||||
Status = MmcReadBlocks (&(MmcHostInstance->BlockIo), MmcHostInstance->BlockIo.Media->MediaId, Lba, BufferSize, ReadBuffer);
|
||||
if (Status != EFI_SUCCESS) {
|
||||
DiagnosticLog (L"ERROR: Fail to Read Block (3)\n");
|
||||
return Status;
|
||||
}
|
||||
|
||||
// Check the content is correct
|
||||
if (!CompareBuffer (ReadBuffer,BackBuffer,BufferSize)) {
|
||||
if (!CompareBuffer (ReadBuffer, BackBuffer, BufferSize)) {
|
||||
DiagnosticLog (L"ERROR: Fail to Read/Write Block (2)\n");
|
||||
return EFI_INVALID_PARAMETER;
|
||||
}
|
||||
@@ -165,25 +168,26 @@ MmcReadWriteDataTest (
|
||||
EFI_STATUS
|
||||
EFIAPI
|
||||
MmcDriverDiagnosticsRunDiagnostics (
|
||||
IN EFI_DRIVER_DIAGNOSTICS_PROTOCOL *This,
|
||||
IN EFI_HANDLE ControllerHandle,
|
||||
IN EFI_HANDLE ChildHandle OPTIONAL,
|
||||
IN EFI_DRIVER_DIAGNOSTIC_TYPE DiagnosticType,
|
||||
IN CHAR8 *Language,
|
||||
OUT EFI_GUID **ErrorType,
|
||||
OUT UINTN *BufferSize,
|
||||
OUT CHAR16 **Buffer
|
||||
IN EFI_DRIVER_DIAGNOSTICS_PROTOCOL *This,
|
||||
IN EFI_HANDLE ControllerHandle,
|
||||
IN EFI_HANDLE ChildHandle OPTIONAL,
|
||||
IN EFI_DRIVER_DIAGNOSTIC_TYPE DiagnosticType,
|
||||
IN CHAR8 *Language,
|
||||
OUT EFI_GUID **ErrorType,
|
||||
OUT UINTN *BufferSize,
|
||||
OUT CHAR16 **Buffer
|
||||
)
|
||||
{
|
||||
LIST_ENTRY *CurrentLink;
|
||||
MMC_HOST_INSTANCE *MmcHostInstance;
|
||||
EFI_STATUS Status;
|
||||
LIST_ENTRY *CurrentLink;
|
||||
MMC_HOST_INSTANCE *MmcHostInstance;
|
||||
EFI_STATUS Status;
|
||||
|
||||
if ((Language == NULL) ||
|
||||
(ErrorType == NULL) ||
|
||||
(Buffer == NULL) ||
|
||||
(ControllerHandle == NULL) ||
|
||||
(BufferSize == NULL)) {
|
||||
(BufferSize == NULL))
|
||||
{
|
||||
return EFI_INVALID_PARAMETER;
|
||||
}
|
||||
|
||||
@@ -192,28 +196,30 @@ MmcDriverDiagnosticsRunDiagnostics (
|
||||
return EFI_UNSUPPORTED;
|
||||
}
|
||||
|
||||
Status = EFI_SUCCESS;
|
||||
Status = EFI_SUCCESS;
|
||||
*ErrorType = NULL;
|
||||
*BufferSize = DIAGNOSTIC_LOGBUFFER_MAXCHAR;
|
||||
*Buffer = DiagnosticInitLog (DIAGNOSTIC_LOGBUFFER_MAXCHAR);
|
||||
*Buffer = DiagnosticInitLog (DIAGNOSTIC_LOGBUFFER_MAXCHAR);
|
||||
|
||||
DiagnosticLog (L"MMC Driver Diagnostics\n");
|
||||
|
||||
// Find the MMC Host instance on which we have been asked to run diagnostics
|
||||
MmcHostInstance = NULL;
|
||||
CurrentLink = mMmcHostPool.ForwardLink;
|
||||
CurrentLink = mMmcHostPool.ForwardLink;
|
||||
while (CurrentLink != NULL && CurrentLink != &mMmcHostPool && (Status == EFI_SUCCESS)) {
|
||||
MmcHostInstance = MMC_HOST_INSTANCE_FROM_LINK(CurrentLink);
|
||||
ASSERT(MmcHostInstance != NULL);
|
||||
MmcHostInstance = MMC_HOST_INSTANCE_FROM_LINK (CurrentLink);
|
||||
ASSERT (MmcHostInstance != NULL);
|
||||
if (MmcHostInstance->MmcHandle == ControllerHandle) {
|
||||
break;
|
||||
}
|
||||
|
||||
CurrentLink = CurrentLink->ForwardLink;
|
||||
}
|
||||
|
||||
// If we didn't find the controller, return EFI_UNSUPPORTED
|
||||
if ((MmcHostInstance == NULL)
|
||||
|| (MmcHostInstance->MmcHandle != ControllerHandle)) {
|
||||
if ( (MmcHostInstance == NULL)
|
||||
|| (MmcHostInstance->MmcHandle != ControllerHandle))
|
||||
{
|
||||
return EFI_UNSUPPORTED;
|
||||
}
|
||||
|
||||
@@ -247,7 +253,7 @@ MmcDriverDiagnosticsRunDiagnostics (
|
||||
//
|
||||
// EFI Driver Diagnostics 2 Protocol
|
||||
//
|
||||
GLOBAL_REMOVE_IF_UNREFERENCED EFI_DRIVER_DIAGNOSTICS2_PROTOCOL gMmcDriverDiagnostics2 = {
|
||||
(EFI_DRIVER_DIAGNOSTICS2_RUN_DIAGNOSTICS) MmcDriverDiagnosticsRunDiagnostics,
|
||||
GLOBAL_REMOVE_IF_UNREFERENCED EFI_DRIVER_DIAGNOSTICS2_PROTOCOL gMmcDriverDiagnostics2 = {
|
||||
(EFI_DRIVER_DIAGNOSTICS2_RUN_DIAGNOSTICS)MmcDriverDiagnosticsRunDiagnostics,
|
||||
"en"
|
||||
};
|
||||
|
@@ -17,17 +17,17 @@
|
||||
|
||||
#include "Mmc.h"
|
||||
|
||||
EFI_BLOCK_IO_MEDIA mMmcMediaTemplate = {
|
||||
SIGNATURE_32('m','m','c','o'), // MediaId
|
||||
TRUE, // RemovableMedia
|
||||
FALSE, // MediaPresent
|
||||
FALSE, // LogicalPartition
|
||||
FALSE, // ReadOnly
|
||||
FALSE, // WriteCaching
|
||||
512, // BlockSize
|
||||
4, // IoAlign
|
||||
0, // Pad
|
||||
0 // LastBlock
|
||||
EFI_BLOCK_IO_MEDIA mMmcMediaTemplate = {
|
||||
SIGNATURE_32 ('m', 'm', 'c', 'o'), // MediaId
|
||||
TRUE, // RemovableMedia
|
||||
FALSE, // MediaPresent
|
||||
FALSE, // LogicalPartition
|
||||
FALSE, // ReadOnly
|
||||
FALSE, // WriteCaching
|
||||
512, // BlockSize
|
||||
4, // IoAlign
|
||||
0, // Pad
|
||||
0 // LastBlock
|
||||
};
|
||||
|
||||
//
|
||||
@@ -41,7 +41,7 @@ LIST_ENTRY mMmcHostPool;
|
||||
or if new ones have been plugged in
|
||||
**/
|
||||
|
||||
EFI_EVENT gCheckCardsEvent;
|
||||
EFI_EVENT gCheckCardsEvent;
|
||||
|
||||
/**
|
||||
Initialize the MMC Host Pool to support multiple MMC devices
|
||||
@@ -59,7 +59,7 @@ InitializeMmcHostPool (
|
||||
**/
|
||||
VOID
|
||||
InsertMmcHost (
|
||||
IN MMC_HOST_INSTANCE *MmcHostInstance
|
||||
IN MMC_HOST_INSTANCE *MmcHostInstance
|
||||
)
|
||||
{
|
||||
InsertTailList (&mMmcHostPool, &(MmcHostInstance->Link));
|
||||
@@ -70,20 +70,21 @@ InsertMmcHost (
|
||||
*/
|
||||
VOID
|
||||
RemoveMmcHost (
|
||||
IN MMC_HOST_INSTANCE *MmcHostInstance
|
||||
IN MMC_HOST_INSTANCE *MmcHostInstance
|
||||
)
|
||||
{
|
||||
RemoveEntryList (&(MmcHostInstance->Link));
|
||||
}
|
||||
|
||||
MMC_HOST_INSTANCE* CreateMmcHostInstance (
|
||||
IN EFI_MMC_HOST_PROTOCOL* MmcHost
|
||||
MMC_HOST_INSTANCE *
|
||||
CreateMmcHostInstance (
|
||||
IN EFI_MMC_HOST_PROTOCOL *MmcHost
|
||||
)
|
||||
{
|
||||
EFI_STATUS Status;
|
||||
MMC_HOST_INSTANCE* MmcHostInstance;
|
||||
EFI_DEVICE_PATH_PROTOCOL *NewDevicePathNode;
|
||||
EFI_DEVICE_PATH_PROTOCOL *DevicePath;
|
||||
EFI_STATUS Status;
|
||||
MMC_HOST_INSTANCE *MmcHostInstance;
|
||||
EFI_DEVICE_PATH_PROTOCOL *NewDevicePathNode;
|
||||
EFI_DEVICE_PATH_PROTOCOL *DevicePath;
|
||||
|
||||
MmcHostInstance = AllocateZeroPool (sizeof (MMC_HOST_INSTANCE));
|
||||
if (MmcHostInstance == NULL) {
|
||||
@@ -94,14 +95,14 @@ MMC_HOST_INSTANCE* CreateMmcHostInstance (
|
||||
|
||||
MmcHostInstance->State = MmcHwInitializationState;
|
||||
|
||||
MmcHostInstance->BlockIo.Media = AllocateCopyPool (sizeof(EFI_BLOCK_IO_MEDIA), &mMmcMediaTemplate);
|
||||
MmcHostInstance->BlockIo.Media = AllocateCopyPool (sizeof (EFI_BLOCK_IO_MEDIA), &mMmcMediaTemplate);
|
||||
if (MmcHostInstance->BlockIo.Media == NULL) {
|
||||
goto FREE_INSTANCE;
|
||||
}
|
||||
|
||||
MmcHostInstance->BlockIo.Revision = EFI_BLOCK_IO_INTERFACE_REVISION;
|
||||
MmcHostInstance->BlockIo.Reset = MmcReset;
|
||||
MmcHostInstance->BlockIo.ReadBlocks = MmcReadBlocks;
|
||||
MmcHostInstance->BlockIo.Revision = EFI_BLOCK_IO_INTERFACE_REVISION;
|
||||
MmcHostInstance->BlockIo.Reset = MmcReset;
|
||||
MmcHostInstance->BlockIo.ReadBlocks = MmcReadBlocks;
|
||||
MmcHostInstance->BlockIo.WriteBlocks = MmcWriteBlocks;
|
||||
MmcHostInstance->BlockIo.FlushBlocks = MmcFlushBlocks;
|
||||
|
||||
@@ -113,7 +114,7 @@ MMC_HOST_INSTANCE* CreateMmcHostInstance (
|
||||
goto FREE_MEDIA;
|
||||
}
|
||||
|
||||
DevicePath = (EFI_DEVICE_PATH_PROTOCOL *) AllocatePool (END_DEVICE_PATH_LENGTH);
|
||||
DevicePath = (EFI_DEVICE_PATH_PROTOCOL *)AllocatePool (END_DEVICE_PATH_LENGTH);
|
||||
if (DevicePath == NULL) {
|
||||
goto FREE_MEDIA;
|
||||
}
|
||||
@@ -123,51 +124,58 @@ MMC_HOST_INSTANCE* CreateMmcHostInstance (
|
||||
|
||||
// Publish BlockIO protocol interface
|
||||
Status = gBS->InstallMultipleProtocolInterfaces (
|
||||
&MmcHostInstance->MmcHandle,
|
||||
&gEfiBlockIoProtocolGuid,&MmcHostInstance->BlockIo,
|
||||
&gEfiDevicePathProtocolGuid,MmcHostInstance->DevicePath,
|
||||
NULL
|
||||
);
|
||||
if (EFI_ERROR(Status)) {
|
||||
&MmcHostInstance->MmcHandle,
|
||||
&gEfiBlockIoProtocolGuid,
|
||||
&MmcHostInstance->BlockIo,
|
||||
&gEfiDevicePathProtocolGuid,
|
||||
MmcHostInstance->DevicePath,
|
||||
NULL
|
||||
);
|
||||
if (EFI_ERROR (Status)) {
|
||||
goto FREE_DEVICE_PATH;
|
||||
}
|
||||
|
||||
return MmcHostInstance;
|
||||
|
||||
FREE_DEVICE_PATH:
|
||||
FreePool(DevicePath);
|
||||
FreePool (DevicePath);
|
||||
|
||||
FREE_MEDIA:
|
||||
FreePool(MmcHostInstance->BlockIo.Media);
|
||||
FreePool (MmcHostInstance->BlockIo.Media);
|
||||
|
||||
FREE_INSTANCE:
|
||||
FreePool(MmcHostInstance);
|
||||
FreePool (MmcHostInstance);
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
EFI_STATUS DestroyMmcHostInstance (
|
||||
IN MMC_HOST_INSTANCE* MmcHostInstance
|
||||
EFI_STATUS
|
||||
DestroyMmcHostInstance (
|
||||
IN MMC_HOST_INSTANCE *MmcHostInstance
|
||||
)
|
||||
{
|
||||
EFI_STATUS Status;
|
||||
EFI_STATUS Status;
|
||||
|
||||
// Uninstall Protocol Interfaces
|
||||
Status = gBS->UninstallMultipleProtocolInterfaces (
|
||||
MmcHostInstance->MmcHandle,
|
||||
&gEfiBlockIoProtocolGuid,&(MmcHostInstance->BlockIo),
|
||||
&gEfiDevicePathProtocolGuid,MmcHostInstance->DevicePath,
|
||||
NULL
|
||||
);
|
||||
MmcHostInstance->MmcHandle,
|
||||
&gEfiBlockIoProtocolGuid,
|
||||
&(MmcHostInstance->BlockIo),
|
||||
&gEfiDevicePathProtocolGuid,
|
||||
MmcHostInstance->DevicePath,
|
||||
NULL
|
||||
);
|
||||
ASSERT_EFI_ERROR (Status);
|
||||
|
||||
// Free Memory allocated for the instance
|
||||
if (MmcHostInstance->BlockIo.Media) {
|
||||
FreePool(MmcHostInstance->BlockIo.Media);
|
||||
FreePool (MmcHostInstance->BlockIo.Media);
|
||||
}
|
||||
|
||||
if (MmcHostInstance->CardInfo.ECSDData) {
|
||||
FreePages (MmcHostInstance->CardInfo.ECSDData, EFI_SIZE_TO_PAGES (sizeof (ECSD)));
|
||||
}
|
||||
|
||||
FreePool (MmcHostInstance);
|
||||
|
||||
return Status;
|
||||
@@ -179,15 +187,15 @@ EFI_STATUS DestroyMmcHostInstance (
|
||||
EFI_STATUS
|
||||
EFIAPI
|
||||
MmcDriverBindingSupported (
|
||||
IN EFI_DRIVER_BINDING_PROTOCOL *This,
|
||||
IN EFI_HANDLE Controller,
|
||||
IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath
|
||||
IN EFI_DRIVER_BINDING_PROTOCOL *This,
|
||||
IN EFI_HANDLE Controller,
|
||||
IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath
|
||||
)
|
||||
{
|
||||
EFI_STATUS Status;
|
||||
//EFI_DEVICE_PATH_PROTOCOL *ParentDevicePath;
|
||||
EFI_MMC_HOST_PROTOCOL *MmcHost;
|
||||
EFI_DEV_PATH_PTR Node;
|
||||
EFI_STATUS Status;
|
||||
// EFI_DEVICE_PATH_PROTOCOL *ParentDevicePath;
|
||||
EFI_MMC_HOST_PROTOCOL *MmcHost;
|
||||
EFI_DEV_PATH_PTR Node;
|
||||
|
||||
//
|
||||
// Check RemainingDevicePath validation
|
||||
@@ -203,10 +211,11 @@ MmcDriverBindingSupported (
|
||||
// check its validation
|
||||
//
|
||||
Node.DevPath = RemainingDevicePath;
|
||||
if (Node.DevPath->Type != HARDWARE_DEVICE_PATH ||
|
||||
Node.DevPath->SubType != HW_VENDOR_DP ||
|
||||
DevicePathNodeLength(Node.DevPath) != sizeof(VENDOR_DEVICE_PATH)) {
|
||||
return EFI_UNSUPPORTED;
|
||||
if ((Node.DevPath->Type != HARDWARE_DEVICE_PATH) ||
|
||||
(Node.DevPath->SubType != HW_VENDOR_DP) ||
|
||||
(DevicePathNodeLength (Node.DevPath) != sizeof (VENDOR_DEVICE_PATH)))
|
||||
{
|
||||
return EFI_UNSUPPORTED;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -215,16 +224,17 @@ MmcDriverBindingSupported (
|
||||
// Check if Mmc Host protocol is installed by platform
|
||||
//
|
||||
Status = gBS->OpenProtocol (
|
||||
Controller,
|
||||
&gEmbeddedMmcHostProtocolGuid,
|
||||
(VOID **) &MmcHost,
|
||||
This->DriverBindingHandle,
|
||||
Controller,
|
||||
EFI_OPEN_PROTOCOL_BY_DRIVER
|
||||
);
|
||||
Controller,
|
||||
&gEmbeddedMmcHostProtocolGuid,
|
||||
(VOID **)&MmcHost,
|
||||
This->DriverBindingHandle,
|
||||
Controller,
|
||||
EFI_OPEN_PROTOCOL_BY_DRIVER
|
||||
);
|
||||
if (Status == EFI_ALREADY_STARTED) {
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
|
||||
if (EFI_ERROR (Status)) {
|
||||
return Status;
|
||||
}
|
||||
@@ -233,11 +243,11 @@ MmcDriverBindingSupported (
|
||||
// Close the Mmc Host used to perform the supported test
|
||||
//
|
||||
gBS->CloseProtocol (
|
||||
Controller,
|
||||
&gEmbeddedMmcHostProtocolGuid,
|
||||
This->DriverBindingHandle,
|
||||
Controller
|
||||
);
|
||||
Controller,
|
||||
&gEmbeddedMmcHostProtocolGuid,
|
||||
This->DriverBindingHandle,
|
||||
Controller
|
||||
);
|
||||
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
@@ -253,9 +263,9 @@ MmcDriverBindingStart (
|
||||
IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath
|
||||
)
|
||||
{
|
||||
EFI_STATUS Status;
|
||||
MMC_HOST_INSTANCE *MmcHostInstance;
|
||||
EFI_MMC_HOST_PROTOCOL *MmcHost;
|
||||
EFI_STATUS Status;
|
||||
MMC_HOST_INSTANCE *MmcHostInstance;
|
||||
EFI_MMC_HOST_PROTOCOL *MmcHost;
|
||||
|
||||
//
|
||||
// Check RemainingDevicePath validation
|
||||
@@ -274,21 +284,22 @@ MmcDriverBindingStart (
|
||||
// Get the Mmc Host protocol
|
||||
//
|
||||
Status = gBS->OpenProtocol (
|
||||
Controller,
|
||||
&gEmbeddedMmcHostProtocolGuid,
|
||||
(VOID **) &MmcHost,
|
||||
This->DriverBindingHandle,
|
||||
Controller,
|
||||
EFI_OPEN_PROTOCOL_BY_DRIVER
|
||||
);
|
||||
Controller,
|
||||
&gEmbeddedMmcHostProtocolGuid,
|
||||
(VOID **)&MmcHost,
|
||||
This->DriverBindingHandle,
|
||||
Controller,
|
||||
EFI_OPEN_PROTOCOL_BY_DRIVER
|
||||
);
|
||||
if (EFI_ERROR (Status)) {
|
||||
if (Status == EFI_ALREADY_STARTED) {
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
|
||||
return Status;
|
||||
}
|
||||
|
||||
MmcHostInstance = CreateMmcHostInstance(MmcHost);
|
||||
MmcHostInstance = CreateMmcHostInstance (MmcHost);
|
||||
if (MmcHostInstance != NULL) {
|
||||
// Add the handle to the pool
|
||||
InsertMmcHost (MmcHostInstance);
|
||||
@@ -308,31 +319,31 @@ MmcDriverBindingStart (
|
||||
EFI_STATUS
|
||||
EFIAPI
|
||||
MmcDriverBindingStop (
|
||||
IN EFI_DRIVER_BINDING_PROTOCOL *This,
|
||||
IN EFI_HANDLE Controller,
|
||||
IN UINTN NumberOfChildren,
|
||||
IN EFI_HANDLE *ChildHandleBuffer
|
||||
IN EFI_DRIVER_BINDING_PROTOCOL *This,
|
||||
IN EFI_HANDLE Controller,
|
||||
IN UINTN NumberOfChildren,
|
||||
IN EFI_HANDLE *ChildHandleBuffer
|
||||
)
|
||||
{
|
||||
EFI_STATUS Status = EFI_SUCCESS;
|
||||
LIST_ENTRY *CurrentLink;
|
||||
MMC_HOST_INSTANCE *MmcHostInstance;
|
||||
EFI_STATUS Status = EFI_SUCCESS;
|
||||
LIST_ENTRY *CurrentLink;
|
||||
MMC_HOST_INSTANCE *MmcHostInstance;
|
||||
|
||||
MMC_TRACE("MmcDriverBindingStop()");
|
||||
MMC_TRACE ("MmcDriverBindingStop()");
|
||||
|
||||
// For each MMC instance
|
||||
CurrentLink = mMmcHostPool.ForwardLink;
|
||||
while (CurrentLink != NULL && CurrentLink != &mMmcHostPool && (Status == EFI_SUCCESS)) {
|
||||
MmcHostInstance = MMC_HOST_INSTANCE_FROM_LINK(CurrentLink);
|
||||
ASSERT(MmcHostInstance != NULL);
|
||||
MmcHostInstance = MMC_HOST_INSTANCE_FROM_LINK (CurrentLink);
|
||||
ASSERT (MmcHostInstance != NULL);
|
||||
|
||||
// Close gEmbeddedMmcHostProtocolGuid
|
||||
Status = gBS->CloseProtocol (
|
||||
Controller,
|
||||
&gEmbeddedMmcHostProtocolGuid,
|
||||
This->DriverBindingHandle,
|
||||
Controller
|
||||
);
|
||||
Controller,
|
||||
&gEmbeddedMmcHostProtocolGuid,
|
||||
This->DriverBindingHandle,
|
||||
Controller
|
||||
);
|
||||
|
||||
// Remove MMC Host Instance from the pool
|
||||
RemoveMmcHost (MmcHostInstance);
|
||||
@@ -347,37 +358,37 @@ MmcDriverBindingStop (
|
||||
VOID
|
||||
EFIAPI
|
||||
CheckCardsCallback (
|
||||
IN EFI_EVENT Event,
|
||||
IN VOID *Context
|
||||
IN EFI_EVENT Event,
|
||||
IN VOID *Context
|
||||
)
|
||||
{
|
||||
LIST_ENTRY *CurrentLink;
|
||||
MMC_HOST_INSTANCE *MmcHostInstance;
|
||||
EFI_STATUS Status;
|
||||
LIST_ENTRY *CurrentLink;
|
||||
MMC_HOST_INSTANCE *MmcHostInstance;
|
||||
EFI_STATUS Status;
|
||||
|
||||
CurrentLink = mMmcHostPool.ForwardLink;
|
||||
while (CurrentLink != NULL && CurrentLink != &mMmcHostPool) {
|
||||
MmcHostInstance = MMC_HOST_INSTANCE_FROM_LINK(CurrentLink);
|
||||
ASSERT(MmcHostInstance != NULL);
|
||||
MmcHostInstance = MMC_HOST_INSTANCE_FROM_LINK (CurrentLink);
|
||||
ASSERT (MmcHostInstance != NULL);
|
||||
|
||||
if (MmcHostInstance->MmcHost->IsCardPresent (MmcHostInstance->MmcHost) == !MmcHostInstance->Initialized) {
|
||||
MmcHostInstance->State = MmcHwInitializationState;
|
||||
MmcHostInstance->State = MmcHwInitializationState;
|
||||
MmcHostInstance->BlockIo.Media->MediaPresent = !MmcHostInstance->Initialized;
|
||||
MmcHostInstance->Initialized = !MmcHostInstance->Initialized;
|
||||
MmcHostInstance->Initialized = !MmcHostInstance->Initialized;
|
||||
|
||||
if (MmcHostInstance->BlockIo.Media->MediaPresent) {
|
||||
InitializeMmcDevice (MmcHostInstance);
|
||||
}
|
||||
|
||||
Status = gBS->ReinstallProtocolInterface (
|
||||
(MmcHostInstance->MmcHandle),
|
||||
&gEfiBlockIoProtocolGuid,
|
||||
&(MmcHostInstance->BlockIo),
|
||||
&(MmcHostInstance->BlockIo)
|
||||
);
|
||||
(MmcHostInstance->MmcHandle),
|
||||
&gEfiBlockIoProtocolGuid,
|
||||
&(MmcHostInstance->BlockIo),
|
||||
&(MmcHostInstance->BlockIo)
|
||||
);
|
||||
|
||||
if (EFI_ERROR(Status)) {
|
||||
Print(L"MMC Card: Error reinstalling BlockIo interface\n");
|
||||
if (EFI_ERROR (Status)) {
|
||||
Print (L"MMC Card: Error reinstalling BlockIo interface\n");
|
||||
}
|
||||
}
|
||||
|
||||
@@ -385,8 +396,7 @@ CheckCardsCallback (
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
EFI_DRIVER_BINDING_PROTOCOL gMmcDriverBinding = {
|
||||
EFI_DRIVER_BINDING_PROTOCOL gMmcDriverBinding = {
|
||||
MmcDriverBindingSupported,
|
||||
MmcDriverBindingStart,
|
||||
MmcDriverBindingStop,
|
||||
@@ -401,8 +411,8 @@ EFI_DRIVER_BINDING_PROTOCOL gMmcDriverBinding = {
|
||||
EFI_STATUS
|
||||
EFIAPI
|
||||
MmcDxeInitialize (
|
||||
IN EFI_HANDLE ImageHandle,
|
||||
IN EFI_SYSTEM_TABLE *SystemTable
|
||||
IN EFI_HANDLE ImageHandle,
|
||||
IN EFI_SYSTEM_TABLE *SystemTable
|
||||
)
|
||||
{
|
||||
EFI_STATUS Status;
|
||||
@@ -416,36 +426,39 @@ MmcDxeInitialize (
|
||||
// Install driver model protocol(s).
|
||||
//
|
||||
Status = EfiLibInstallDriverBindingComponentName2 (
|
||||
ImageHandle,
|
||||
SystemTable,
|
||||
&gMmcDriverBinding,
|
||||
ImageHandle,
|
||||
&gMmcComponentName,
|
||||
&gMmcComponentName2
|
||||
);
|
||||
ImageHandle,
|
||||
SystemTable,
|
||||
&gMmcDriverBinding,
|
||||
ImageHandle,
|
||||
&gMmcComponentName,
|
||||
&gMmcComponentName2
|
||||
);
|
||||
ASSERT_EFI_ERROR (Status);
|
||||
|
||||
// Install driver diagnostics
|
||||
Status = gBS->InstallMultipleProtocolInterfaces (
|
||||
&ImageHandle,
|
||||
&gEfiDriverDiagnostics2ProtocolGuid,&gMmcDriverDiagnostics2,
|
||||
NULL
|
||||
);
|
||||
&ImageHandle,
|
||||
&gEfiDriverDiagnostics2ProtocolGuid,
|
||||
&gMmcDriverDiagnostics2,
|
||||
NULL
|
||||
);
|
||||
ASSERT_EFI_ERROR (Status);
|
||||
|
||||
// Use a timer to detect if a card has been plugged in or removed
|
||||
Status = gBS->CreateEvent (
|
||||
EVT_NOTIFY_SIGNAL | EVT_TIMER,
|
||||
TPL_CALLBACK,
|
||||
CheckCardsCallback,
|
||||
NULL,
|
||||
&gCheckCardsEvent);
|
||||
EVT_NOTIFY_SIGNAL | EVT_TIMER,
|
||||
TPL_CALLBACK,
|
||||
CheckCardsCallback,
|
||||
NULL,
|
||||
&gCheckCardsEvent
|
||||
);
|
||||
ASSERT_EFI_ERROR (Status);
|
||||
|
||||
Status = gBS->SetTimer(
|
||||
gCheckCardsEvent,
|
||||
TimerPeriodic,
|
||||
(UINT64)(10*1000*200)); // 200 ms
|
||||
Status = gBS->SetTimer (
|
||||
gCheckCardsEvent,
|
||||
TimerPeriodic,
|
||||
(UINT64)(10*1000*200)
|
||||
); // 200 ms
|
||||
ASSERT_EFI_ERROR (Status);
|
||||
|
||||
return Status;
|
||||
|
@@ -23,327 +23,326 @@
|
||||
|
||||
#define MMC_TRACE(txt) DEBUG((DEBUG_BLKIO, "MMC: " txt "\n"))
|
||||
|
||||
#define MMC_IOBLOCKS_READ 0
|
||||
#define MMC_IOBLOCKS_WRITE 1
|
||||
#define MMC_IOBLOCKS_READ 0
|
||||
#define MMC_IOBLOCKS_WRITE 1
|
||||
|
||||
#define MMC_OCR_POWERUP 0x80000000
|
||||
#define MMC_OCR_POWERUP 0x80000000
|
||||
|
||||
#define MMC_OCR_ACCESS_MASK 0x3 /* bit[30-29] */
|
||||
#define MMC_OCR_ACCESS_BYTE 0x1 /* bit[29] */
|
||||
#define MMC_OCR_ACCESS_SECTOR 0x2 /* bit[30] */
|
||||
#define MMC_OCR_ACCESS_MASK 0x3 /* bit[30-29] */
|
||||
#define MMC_OCR_ACCESS_BYTE 0x1 /* bit[29] */
|
||||
#define MMC_OCR_ACCESS_SECTOR 0x2 /* bit[30] */
|
||||
|
||||
#define MMC_CSD_GET_CCC(Response) (Response[2] >> 20)
|
||||
#define MMC_CSD_GET_TRANSPEED(Response) (Response[3] & 0xFF)
|
||||
#define MMC_CSD_GET_READBLLEN(Response) ((Response[2] >> 16) & 0xF)
|
||||
#define MMC_CSD_GET_WRITEBLLEN(Response) ((Response[0] >> 22) & 0xF)
|
||||
#define MMC_CSD_GET_FILEFORMAT(Response) ((Response[0] >> 10) & 0x3)
|
||||
#define MMC_CSD_GET_CCC(Response) (Response[2] >> 20)
|
||||
#define MMC_CSD_GET_TRANSPEED(Response) (Response[3] & 0xFF)
|
||||
#define MMC_CSD_GET_READBLLEN(Response) ((Response[2] >> 16) & 0xF)
|
||||
#define MMC_CSD_GET_WRITEBLLEN(Response) ((Response[0] >> 22) & 0xF)
|
||||
#define MMC_CSD_GET_FILEFORMAT(Response) ((Response[0] >> 10) & 0x3)
|
||||
#define MMC_CSD_GET_FILEFORMATGRP(Response) ((Response[0] >> 15) & 0x1)
|
||||
#define MMC_CSD_GET_DEVICESIZE(csd) (((Response[1] >> 30) & 0x3) | ((Response[2] & 0x3FF) << 2))
|
||||
#define HC_MMC_CSD_GET_DEVICESIZE(Response) ((Response[1] >> 16) | ((Response[2] & 0x40) << 16));
|
||||
#define MMC_CSD_GET_DEVICESIZEMULT(csd) ((Response[1] >> 15) & 0x7)
|
||||
#define MMC_CSD_GET_DEVICESIZE(csd) (((Response[1] >> 30) & 0x3) | ((Response[2] & 0x3FF) << 2))
|
||||
#define HC_MMC_CSD_GET_DEVICESIZE(Response) ((Response[1] >> 16) | ((Response[2] & 0x40) << 16));
|
||||
#define MMC_CSD_GET_DEVICESIZEMULT(csd) ((Response[1] >> 15) & 0x7)
|
||||
|
||||
#define MMC_R0_READY_FOR_DATA (1 << 8)
|
||||
#define MMC_R0_READY_FOR_DATA (1 << 8)
|
||||
|
||||
#define MMC_R0_CURRENTSTATE(Response) ((Response[0] >> 9) & 0xF)
|
||||
#define MMC_R0_CURRENTSTATE(Response) ((Response[0] >> 9) & 0xF)
|
||||
|
||||
#define MMC_R0_STATE_IDLE 0
|
||||
#define MMC_R0_STATE_READY 1
|
||||
#define MMC_R0_STATE_IDENT 2
|
||||
#define MMC_R0_STATE_STDBY 3
|
||||
#define MMC_R0_STATE_TRAN 4
|
||||
#define MMC_R0_STATE_DATA 5
|
||||
#define MMC_R0_STATE_IDLE 0
|
||||
#define MMC_R0_STATE_READY 1
|
||||
#define MMC_R0_STATE_IDENT 2
|
||||
#define MMC_R0_STATE_STDBY 3
|
||||
#define MMC_R0_STATE_TRAN 4
|
||||
#define MMC_R0_STATE_DATA 5
|
||||
|
||||
#define EMMC_CMD6_ARG_ACCESS(x) (((x) & 0x3) << 24)
|
||||
#define EMMC_CMD6_ARG_INDEX(x) (((x) & 0xFF) << 16)
|
||||
#define EMMC_CMD6_ARG_VALUE(x) (((x) & 0xFF) << 8)
|
||||
#define EMMC_CMD6_ARG_CMD_SET(x) (((x) & 0x7) << 0)
|
||||
#define EMMC_CMD6_ARG_ACCESS(x) (((x) & 0x3) << 24)
|
||||
#define EMMC_CMD6_ARG_INDEX(x) (((x) & 0xFF) << 16)
|
||||
#define EMMC_CMD6_ARG_VALUE(x) (((x) & 0xFF) << 8)
|
||||
#define EMMC_CMD6_ARG_CMD_SET(x) (((x) & 0x7) << 0)
|
||||
|
||||
#define SWITCH_CMD_DATA_LENGTH 64
|
||||
#define SD_HIGH_SPEED_SUPPORTED 0x20000
|
||||
#define SD_DEFAULT_SPEED 25000000
|
||||
#define SD_HIGH_SPEED 50000000
|
||||
#define SWITCH_CMD_SUCCESS_MASK 0x0f000000
|
||||
#define SWITCH_CMD_DATA_LENGTH 64
|
||||
#define SD_HIGH_SPEED_SUPPORTED 0x20000
|
||||
#define SD_DEFAULT_SPEED 25000000
|
||||
#define SD_HIGH_SPEED 50000000
|
||||
#define SWITCH_CMD_SUCCESS_MASK 0x0f000000
|
||||
|
||||
#define SD_CARD_CAPACITY 0x00000002
|
||||
#define SD_CARD_CAPACITY 0x00000002
|
||||
|
||||
#define BUSWIDTH_4 4
|
||||
#define BUSWIDTH_4 4
|
||||
|
||||
typedef enum {
|
||||
UNKNOWN_CARD,
|
||||
MMC_CARD, //MMC card
|
||||
MMC_CARD_HIGH, //MMC Card with High capacity
|
||||
EMMC_CARD, //eMMC 4.41 card
|
||||
SD_CARD, //SD 1.1 card
|
||||
SD_CARD_2, //SD 2.0 or above standard card
|
||||
SD_CARD_2_HIGH //SD 2.0 or above high capacity card
|
||||
MMC_CARD, // MMC card
|
||||
MMC_CARD_HIGH, // MMC Card with High capacity
|
||||
EMMC_CARD, // eMMC 4.41 card
|
||||
SD_CARD, // SD 1.1 card
|
||||
SD_CARD_2, // SD 2.0 or above standard card
|
||||
SD_CARD_2_HIGH // SD 2.0 or above high capacity card
|
||||
} CARD_TYPE;
|
||||
|
||||
typedef struct {
|
||||
UINT32 Reserved0: 7; // 0
|
||||
UINT32 V170_V195: 1; // 1.70V - 1.95V
|
||||
UINT32 V200_V260: 7; // 2.00V - 2.60V
|
||||
UINT32 V270_V360: 9; // 2.70V - 3.60V
|
||||
UINT32 RESERVED_1: 5; // Reserved
|
||||
UINT32 AccessMode: 2; // 00b (byte mode), 10b (sector mode)
|
||||
UINT32 PowerUp: 1; // This bit is set to LOW if the card has not finished the power up routine
|
||||
UINT32 Reserved0 : 7; // 0
|
||||
UINT32 V170_V195 : 1; // 1.70V - 1.95V
|
||||
UINT32 V200_V260 : 7; // 2.00V - 2.60V
|
||||
UINT32 V270_V360 : 9; // 2.70V - 3.60V
|
||||
UINT32 RESERVED_1 : 5; // Reserved
|
||||
UINT32 AccessMode : 2; // 00b (byte mode), 10b (sector mode)
|
||||
UINT32 PowerUp : 1; // This bit is set to LOW if the card has not finished the power up routine
|
||||
} OCR;
|
||||
|
||||
typedef struct {
|
||||
UINT8 SD_SPEC: 4; // SD Memory Card - Spec. Version [59:56]
|
||||
UINT8 SCR_STRUCTURE: 4; // SCR Structure [63:60]
|
||||
UINT8 SD_BUS_WIDTHS: 4; // DAT Bus widths supported [51:48]
|
||||
UINT8 DATA_STAT_AFTER_ERASE: 1; // Data Status after erases [55]
|
||||
UINT8 SD_SECURITY: 3; // CPRM Security Support [54:52]
|
||||
UINT8 EX_SECURITY_1: 1; // Extended Security Support [43]
|
||||
UINT8 SD_SPEC4: 1; // Spec. Version 4.00 or higher [42]
|
||||
UINT8 RESERVED_1: 2; // Reserved [41:40]
|
||||
UINT8 SD_SPEC3: 1; // Spec. Version 3.00 or higher [47]
|
||||
UINT8 EX_SECURITY_2: 3; // Extended Security Support [46:44]
|
||||
UINT8 CMD_SUPPORT: 4; // Command Support bits [35:32]
|
||||
UINT8 RESERVED_2: 4; // Reserved [39:36]
|
||||
UINT32 RESERVED_3; // Manufacturer Usage [31:0]
|
||||
UINT8 SD_SPEC : 4; // SD Memory Card - Spec. Version [59:56]
|
||||
UINT8 SCR_STRUCTURE : 4; // SCR Structure [63:60]
|
||||
UINT8 SD_BUS_WIDTHS : 4; // DAT Bus widths supported [51:48]
|
||||
UINT8 DATA_STAT_AFTER_ERASE : 1; // Data Status after erases [55]
|
||||
UINT8 SD_SECURITY : 3; // CPRM Security Support [54:52]
|
||||
UINT8 EX_SECURITY_1 : 1; // Extended Security Support [43]
|
||||
UINT8 SD_SPEC4 : 1; // Spec. Version 4.00 or higher [42]
|
||||
UINT8 RESERVED_1 : 2; // Reserved [41:40]
|
||||
UINT8 SD_SPEC3 : 1; // Spec. Version 3.00 or higher [47]
|
||||
UINT8 EX_SECURITY_2 : 3; // Extended Security Support [46:44]
|
||||
UINT8 CMD_SUPPORT : 4; // Command Support bits [35:32]
|
||||
UINT8 RESERVED_2 : 4; // Reserved [39:36]
|
||||
UINT32 RESERVED_3; // Manufacturer Usage [31:0]
|
||||
} SCR;
|
||||
|
||||
typedef struct {
|
||||
UINT32 NOT_USED; // 1 [0:0]
|
||||
UINT32 CRC; // CRC7 checksum [7:1]
|
||||
UINT32 MDT; // Manufacturing date [19:8]
|
||||
UINT32 RESERVED_1; // Reserved [23:20]
|
||||
UINT32 PSN; // Product serial number [55:24]
|
||||
UINT8 PRV; // Product revision [63:56]
|
||||
UINT8 PNM[5]; // Product name [64:103]
|
||||
UINT16 OID; // OEM/Application ID [119:104]
|
||||
UINT8 MID; // Manufacturer ID [127:120]
|
||||
UINT32 NOT_USED; // 1 [0:0]
|
||||
UINT32 CRC; // CRC7 checksum [7:1]
|
||||
UINT32 MDT; // Manufacturing date [19:8]
|
||||
UINT32 RESERVED_1; // Reserved [23:20]
|
||||
UINT32 PSN; // Product serial number [55:24]
|
||||
UINT8 PRV; // Product revision [63:56]
|
||||
UINT8 PNM[5]; // Product name [64:103]
|
||||
UINT16 OID; // OEM/Application ID [119:104]
|
||||
UINT8 MID; // Manufacturer ID [127:120]
|
||||
} CID;
|
||||
|
||||
typedef struct {
|
||||
UINT8 NOT_USED: 1; // Not used, always 1 [0:0]
|
||||
UINT8 CRC: 7; // CRC [7:1]
|
||||
UINT8 NOT_USED : 1; // Not used, always 1 [0:0]
|
||||
UINT8 CRC : 7; // CRC [7:1]
|
||||
|
||||
UINT8 RESERVED_1: 2; // Reserved [9:8]
|
||||
UINT8 FILE_FORMAT: 2; // File format [11:10]
|
||||
UINT8 TMP_WRITE_PROTECT: 1; // Temporary write protection [12:12]
|
||||
UINT8 PERM_WRITE_PROTECT: 1; // Permanent write protection [13:13]
|
||||
UINT8 COPY: 1; // Copy flag (OTP) [14:14]
|
||||
UINT8 FILE_FORMAT_GRP: 1; // File format group [15:15]
|
||||
UINT8 RESERVED_1 : 2; // Reserved [9:8]
|
||||
UINT8 FILE_FORMAT : 2; // File format [11:10]
|
||||
UINT8 TMP_WRITE_PROTECT : 1; // Temporary write protection [12:12]
|
||||
UINT8 PERM_WRITE_PROTECT : 1; // Permanent write protection [13:13]
|
||||
UINT8 COPY : 1; // Copy flag (OTP) [14:14]
|
||||
UINT8 FILE_FORMAT_GRP : 1; // File format group [15:15]
|
||||
|
||||
UINT16 RESERVED_2: 5; // Reserved [20:16]
|
||||
UINT16 WRITE_BL_PARTIAL: 1; // Partial blocks for write allowed [21:21]
|
||||
UINT16 WRITE_BL_LEN: 4; // Max. write data block length [25:22]
|
||||
UINT16 R2W_FACTOR: 3; // Write speed factor [28:26]
|
||||
UINT16 RESERVED_3: 2; // Reserved [30:29]
|
||||
UINT16 WP_GRP_ENABLE: 1; // Write protect group enable [31:31]
|
||||
UINT16 RESERVED_2 : 5; // Reserved [20:16]
|
||||
UINT16 WRITE_BL_PARTIAL : 1; // Partial blocks for write allowed [21:21]
|
||||
UINT16 WRITE_BL_LEN : 4; // Max. write data block length [25:22]
|
||||
UINT16 R2W_FACTOR : 3; // Write speed factor [28:26]
|
||||
UINT16 RESERVED_3 : 2; // Reserved [30:29]
|
||||
UINT16 WP_GRP_ENABLE : 1; // Write protect group enable [31:31]
|
||||
|
||||
UINT32 WP_GRP_SIZE: 7; // Write protect group size [38:32]
|
||||
UINT32 SECTOR_SIZE: 7; // Erase sector size [45:39]
|
||||
UINT32 ERASE_BLK_EN: 1; // Erase single block enable [46:46]
|
||||
UINT32 C_SIZE_MULT: 3; // Device size multiplier [49:47]
|
||||
UINT32 VDD_W_CURR_MAX: 3; // Max. write current @ VDD max [52:50]
|
||||
UINT32 VDD_W_CURR_MIN: 3; // Max. write current @ VDD min [55:53]
|
||||
UINT32 VDD_R_CURR_MAX: 3; // Max. read current @ VDD max [58:56]
|
||||
UINT32 VDD_R_CURR_MIN: 3; // Max. read current @ VDD min [61:59]
|
||||
UINT32 C_SIZELow2: 2; // Device size [63:62]
|
||||
UINT32 WP_GRP_SIZE : 7; // Write protect group size [38:32]
|
||||
UINT32 SECTOR_SIZE : 7; // Erase sector size [45:39]
|
||||
UINT32 ERASE_BLK_EN : 1; // Erase single block enable [46:46]
|
||||
UINT32 C_SIZE_MULT : 3; // Device size multiplier [49:47]
|
||||
UINT32 VDD_W_CURR_MAX : 3; // Max. write current @ VDD max [52:50]
|
||||
UINT32 VDD_W_CURR_MIN : 3; // Max. write current @ VDD min [55:53]
|
||||
UINT32 VDD_R_CURR_MAX : 3; // Max. read current @ VDD max [58:56]
|
||||
UINT32 VDD_R_CURR_MIN : 3; // Max. read current @ VDD min [61:59]
|
||||
UINT32 C_SIZELow2 : 2; // Device size [63:62]
|
||||
|
||||
UINT32 C_SIZEHigh10: 10;// Device size [73:64]
|
||||
UINT32 RESERVED_4: 2; // Reserved [75:74]
|
||||
UINT32 DSR_IMP: 1; // DSR implemented [76:76]
|
||||
UINT32 READ_BLK_MISALIGN: 1; // Read block misalignment [77:77]
|
||||
UINT32 WRITE_BLK_MISALIGN: 1; // Write block misalignment [78:78]
|
||||
UINT32 READ_BL_PARTIAL: 1; // Partial blocks for read allowed [79:79]
|
||||
UINT32 READ_BL_LEN: 4; // Max. read data block length [83:80]
|
||||
UINT32 CCC: 12;// Card command classes [95:84]
|
||||
UINT32 C_SIZEHigh10 : 10; // Device size [73:64]
|
||||
UINT32 RESERVED_4 : 2; // Reserved [75:74]
|
||||
UINT32 DSR_IMP : 1; // DSR implemented [76:76]
|
||||
UINT32 READ_BLK_MISALIGN : 1; // Read block misalignment [77:77]
|
||||
UINT32 WRITE_BLK_MISALIGN : 1; // Write block misalignment [78:78]
|
||||
UINT32 READ_BL_PARTIAL : 1; // Partial blocks for read allowed [79:79]
|
||||
UINT32 READ_BL_LEN : 4; // Max. read data block length [83:80]
|
||||
UINT32 CCC : 12; // Card command classes [95:84]
|
||||
|
||||
UINT8 TRAN_SPEED ; // Max. bus clock frequency [103:96]
|
||||
UINT8 NSAC ; // Data read access-time 2 in CLK cycles (NSAC*100) [111:104]
|
||||
UINT8 TAAC ; // Data read access-time 1 [119:112]
|
||||
UINT8 TRAN_SPEED; // Max. bus clock frequency [103:96]
|
||||
UINT8 NSAC; // Data read access-time 2 in CLK cycles (NSAC*100) [111:104]
|
||||
UINT8 TAAC; // Data read access-time 1 [119:112]
|
||||
|
||||
UINT8 RESERVED_5: 2; // Reserved [121:120]
|
||||
UINT8 SPEC_VERS: 4; // System specification version [125:122]
|
||||
UINT8 CSD_STRUCTURE: 2; // CSD structure [127:126]
|
||||
UINT8 RESERVED_5 : 2; // Reserved [121:120]
|
||||
UINT8 SPEC_VERS : 4; // System specification version [125:122]
|
||||
UINT8 CSD_STRUCTURE : 2; // CSD structure [127:126]
|
||||
} CSD;
|
||||
|
||||
typedef struct {
|
||||
UINT8 RESERVED_1[16]; // Reserved [15:0]
|
||||
UINT8 SECURE_REMOVAL_TYPE; // Secure Removal Type [16:16]
|
||||
UINT8 PRODUCT_STATE_AWARENESS_ENABLEMENT; // Product state awareness enablement [17:17]
|
||||
UINT8 MAX_PRE_LOADING_DATA_SIZE[4]; // MAX pre loading data size [21:18]
|
||||
UINT8 PRE_LOADING_DATA_SIZE[4]; // Pre loading data size [25:22]
|
||||
UINT8 FFU_STATUS; // FFU Status [26:26]
|
||||
UINT8 RESERVED_2[2]; // Reserved [28:27]
|
||||
UINT8 MODE_OPERATION_CODES; // Mode operation codes [29:29]
|
||||
UINT8 MODE_CONFIG; // Mode config [30:30]
|
||||
UINT8 RESERVED_3; // Reserved [31:31]
|
||||
UINT8 FLUSH_CACHE; // Flushing of the cache [32:32]
|
||||
UINT8 CACHE_CTRL; // Control to turn the cache ON/OFF [33:33]
|
||||
UINT8 POWER_OFF_NOTIFICATION; // Power Off Notification [34:34]
|
||||
UINT8 PACKED_FAILURE_INDEX; // Packed command failure index [35:35]
|
||||
UINT8 PACKED_COMMAND_STATUS; // Packed command status [36:36]
|
||||
UINT8 CONTEXT_CONF[15]; // Context configuration [51:37]
|
||||
UINT8 EXT_PARTITIONS_ATTRIBUTE[2]; // Extended partitions attribute [53:52]
|
||||
UINT8 EXCEPTION_EVENTS_STATUS[2]; // Exception events status [55:54]
|
||||
UINT8 EXCEPTION_EVENTS_CTRL[2]; // Exception events control [57:56]
|
||||
UINT8 DYNCAP_NEEDED; // Number of addressed group to be released [58:58]
|
||||
UINT8 CLASS_6_CTRL; // Class 6 commands control [59:59]
|
||||
UINT8 INI_TIMEOUT_EMU; // 1st initialization after disabling sector size emulation [60:60]
|
||||
UINT8 DATA_SECTOR_SIZE; // Sector size [61:61]
|
||||
UINT8 USE_NATIVE_SECTOR; // Sector size emulation [62:62]
|
||||
UINT8 NATIVE_SECTOR_SIZE; // Native sector size [63:63]
|
||||
UINT8 VENDOR_SPECIFIC_FIELD[64]; // Vendor specific fields [127:64]
|
||||
UINT8 RESERVED_4[2]; // Reserved [129:128]
|
||||
UINT8 PROGRAM_CID_CSD_DDR_SUPPORT; // Program CID/CSD in DDR mode support [130:130]
|
||||
UINT8 PERIODIC_WAKEUP; // Periodic wake-up [131:131]
|
||||
UINT8 TCASE_SUPPORT; // Package case temperature is controlled [132:132]
|
||||
UINT8 PRODUCTION_STATE_AWARENESS; // Production state awareness [133:133]
|
||||
UINT8 SECTOR_BAD_BLK_MGMNT; // Bad block management mode [134:134]
|
||||
UINT8 RESERVED_5; // Reserved [135:135]
|
||||
UINT8 ENH_START_ADDR[4]; // Enhanced user data start address [139:136]
|
||||
UINT8 ENH_SIZE_MULT[3]; // Enhanced user data area size [142:140]
|
||||
UINT8 GP_SIZE_MULT[12]; // General purpose partition size [154:143]
|
||||
UINT8 PARTITION_SETTING_COMPLETED; // Partitioning setting [155:155]
|
||||
UINT8 PARTITIONS_ATTRIBUTE; // Partitions attribute [156:156]
|
||||
UINT8 MAX_ENH_SIZE_MULT[3]; // Max enhanced area size [159:157]
|
||||
UINT8 PARTITIONING_SUPPORT; // Partitioning [160:160]
|
||||
UINT8 HPI_MGMT; // HPI management [161:161]
|
||||
UINT8 RST_N_FUNCTION; // H/W reset function [162:162]
|
||||
UINT8 BKOPS_EN; // Enable background operations handshake [163:163]
|
||||
UINT8 BKOPS_START; // Manually start background operations [164:164]
|
||||
UINT8 SANITIZE_START; // Start sanitize operation [165:165]
|
||||
UINT8 WR_REL_PARAM; // Write reliability parameter register [166:166]
|
||||
UINT8 WR_REL_SET; // Write reliability setting register [167:167]
|
||||
UINT8 RPMB_SIZE_MULT; // RPMB size [168:168]
|
||||
UINT8 FW_CONFIG; // FW configuration [169:169]
|
||||
UINT8 RESERVED_6; // Reserved [170:170]
|
||||
UINT8 USER_WP; // User area write protection register [171:171]
|
||||
UINT8 RESERVED_7; // Reserved [172:172]
|
||||
UINT8 BOOT_WP; // Boot area write protection register [173:173]
|
||||
UINT8 BOOT_WP_STATUS; // Boot write protection register [174:174]
|
||||
UINT8 ERASE_GROUP_DEF; // High-density erase group definition [175:175]
|
||||
UINT8 RESERVED_8; // Reserved [176:176]
|
||||
UINT8 BOOT_BUS_CONDITIONS; // Boot bus conditions [177:177]
|
||||
UINT8 BOOT_CONFIG_PROT; // Boot config protection [178:178]
|
||||
UINT8 PARTITION_CONFIG; // Partition config [179:179]
|
||||
UINT8 RESERVED_9; // Reserved [180:180]
|
||||
UINT8 ERASED_MEM_CONT; // Erased memory content [181:181]
|
||||
UINT8 RESERVED_10; // Reserved [182:182]
|
||||
UINT8 BUS_WIDTH; // Bus width mode [183:183]
|
||||
UINT8 RESERVED_11; // Reserved [184:184]
|
||||
UINT8 HS_TIMING; // High-speed interface timing [185:185]
|
||||
UINT8 RESERVED_12; // Reserved [186:186]
|
||||
UINT8 POWER_CLASS; // Power class [187:187]
|
||||
UINT8 RESERVED_13; // Reserved [188:188]
|
||||
UINT8 CMD_SET_REV; // Command set revision [189:189]
|
||||
UINT8 RESERVED_14; // Reserved [190:190]
|
||||
UINT8 CMD_SET; // Command set [191:191]
|
||||
UINT8 EXT_CSD_REV; // Extended CSD revision [192:192]
|
||||
UINT8 RESERVED_15; // Reserved [193:193]
|
||||
UINT8 CSD_STRUCTURE; // CSD Structure [194:194]
|
||||
UINT8 RESERVED_16; // Reserved [195:195]
|
||||
UINT8 DEVICE_TYPE; // Device type [196:196]
|
||||
UINT8 DRIVER_STRENGTH; // I/O Driver strength [197:197]
|
||||
UINT8 OUT_OF_INTERRUPT_TIME; // Out-of-interrupt busy timing [198:198]
|
||||
UINT8 PARTITION_SWITCH_TIME; // Partition switching timing [199:199]
|
||||
UINT8 PWR_CL_52_195; // Power class for 52MHz at 1.95V 1 R [200:200]
|
||||
UINT8 PWR_CL_26_195; // Power class for 26MHz at 1.95V 1 R [201:201]
|
||||
UINT8 PWR_CL_52_360; // Power class for 52MHz at 3.6V 1 R [202:202]
|
||||
UINT8 PWR_CL_26_360; // Power class for 26MHz at 3.6V 1 R [203:203]
|
||||
UINT8 RESERVED_17; // Reserved [204:204]
|
||||
UINT8 MIN_PERF_R_4_26; // Minimum read performance for 4bit at 26MHz [205:205]
|
||||
UINT8 MIN_PERF_W_4_26; // Minimum write performance for 4bit at 26MHz [206:206]
|
||||
UINT8 MIN_PERF_R_8_26_4_52; // Minimum read performance for 8bit at 26MHz, for 4bit at 52MHz [207:207]
|
||||
UINT8 MIN_PERF_W_8_26_4_52; // Minimum write performance for 8bit at 26MHz, for 4bit at 52MHz [208:208]
|
||||
UINT8 MIN_PERF_R_8_52; // Minimum read performance for 8bit at 52MHz [209:209]
|
||||
UINT8 MIN_PERF_W_8_52; // Minimum write performance for 8bit at 52MHz [210:210]
|
||||
UINT8 RESERVED_18; // Reserved [211:211]
|
||||
UINT32 SECTOR_COUNT; // Sector count [215:212]
|
||||
UINT8 SLEEP_NOTIFICATION_TIME; // Sleep notification timeout [216:216]
|
||||
UINT8 S_A_TIMEOUT; // Sleep/awake timeout [217:217]
|
||||
UINT8 PRODUCTION_STATE_AWARENESS_TIMEOUT; // Production state awareness timeout [218:218]
|
||||
UINT8 S_C_VCCQ; // Sleep current (VCCQ) [219:219]
|
||||
UINT8 S_C_VCC; // Sleep current (VCC) [220:220]
|
||||
UINT8 HC_WP_GRP_SIZE; // High-capacity write protect group size [221:221]
|
||||
UINT8 REL_WR_SECTOR_C; // Reliable write sector count [222:222]
|
||||
UINT8 ERASE_TIMEOUT_MULT; // High-capacity erase timeout [223:223]
|
||||
UINT8 HC_ERASE_GRP_SIZE; // High-capacity erase unit size [224:224]
|
||||
UINT8 ACC_SIZE; // Access size [225:225]
|
||||
UINT8 BOOT_SIZE_MULTI; // Boot partition size [226:226]
|
||||
UINT8 RESERVED_19; // Reserved [227:227]
|
||||
UINT8 BOOT_INFO; // Boot information [228:228]
|
||||
UINT8 SECURE_TRIM_MULT; // Secure TRIM Multiplier [229:229]
|
||||
UINT8 SECURE_ERASE_MULT; // Secure Erase Multiplier [230:230]
|
||||
UINT8 SECURE_FEATURE_SUPPORT; // Secure Feature Support [231:231]
|
||||
UINT8 TRIM_MULT; // TRIM Multiplier [232:232]
|
||||
UINT8 RESERVED_20; // Reserved [233:233]
|
||||
UINT8 MIN_PREF_DDR_R_8_52; // Minimum read performance for 8bit at 52MHz in DDR mode [234:234]
|
||||
UINT8 MIN_PREF_DDR_W_8_52; // Minimum write performance for 8bit at 52MHz in DDR mode [235:235]
|
||||
UINT8 PWR_CL_200_130; // Power class for 200MHz at VCCQ=1.3V, VCC=3.6V [236:236]
|
||||
UINT8 PWR_CL_200_195; // Power class for 200MHz at VCCQ=1.95V, VCC=3.6V [237:237]
|
||||
UINT8 PWR_CL_DDR_52_195; // Power class for 52MHz, DDR at 1.95V [238:238]
|
||||
UINT8 PWR_CL_DDR_52_360; // Power class for 52Mhz, DDR at 3.6V [239:239]
|
||||
UINT8 RESERVED_21; // Reserved [240:240]
|
||||
UINT8 INI_TIMEOUT_AP; // 1st initialization time after partitioning [241:241]
|
||||
UINT8 CORRECTLY_PRG_SECTORS_NUM[4]; // Number of correctly programmed sectors [245:242]
|
||||
UINT8 BKOPS_STATUS; // Background operations status [246:246]
|
||||
UINT8 POWER_OFF_LONG_TIME; // Power off notification (long) timeout [247:247]
|
||||
UINT8 GENERIC_CMD6_TIME; // Generic CMD6 timeout [248:248]
|
||||
UINT8 CACHE_SIZE[4]; // Cache size [252:249]
|
||||
UINT8 PWR_CL_DDR_200_360; // Power class for 200MHz, DDR at VCC=3.6V [253:253]
|
||||
UINT8 FIRMWARE_VERSION[8]; // Firmware version [261:254]
|
||||
UINT8 DEVICE_VERSION[2]; // Device version [263:262]
|
||||
UINT8 OPTIMAL_TRIM_UNIT_SIZE; // Optimal trim unit size [264:264]
|
||||
UINT8 OPTIMAL_WRITE_SIZE; // Optimal write size [265:265]
|
||||
UINT8 OPTIMAL_READ_SIZE; // Optimal read size [266:266]
|
||||
UINT8 PRE_EOL_INFO; // Pre EOL information [267:267]
|
||||
UINT8 DEVICE_LIFE_TIME_EST_TYP_A; // Device life time estimation type A [268:268]
|
||||
UINT8 DEVICE_LIFE_TIME_EST_TYP_B; // Device life time estimation type B [269:269]
|
||||
UINT8 VENDOR_PROPRIETARY_HEALTH_REPORT[32]; // Vendor proprietary health report [301:270]
|
||||
UINT8 NUMBER_OF_FW_SECTORS_CORRECTLY_PROGRAMMED[4]; // Number of FW sectors correctly programmed [305:302]
|
||||
UINT8 RESERVED_22[181]; // Reserved [486:306]
|
||||
UINT8 FFU_ARG[4]; // FFU argument [490:487]
|
||||
UINT8 OPERATION_CODE_TIMEOUT; // Operation codes timeout [491:491]
|
||||
UINT8 FFU_FEATURES; // FFU features [492:492]
|
||||
UINT8 SUPPORTED_MODES; // Supported modes [493:493]
|
||||
UINT8 EXT_SUPPORT; // Extended partitions attribute support [494:494]
|
||||
UINT8 LARGE_UNIT_SIZE_M1; // Large unit size [495:495]
|
||||
UINT8 CONTEXT_CAPABILITIES; // Context management capabilities [496:496]
|
||||
UINT8 TAG_RES_SIZE; // Tag resource size [497:497]
|
||||
UINT8 TAG_UNIT_SIZE; // Tag unit size [498:498]
|
||||
UINT8 DATA_TAG_SUPPORT; // Data tag support [499:499]
|
||||
UINT8 MAX_PACKED_WRITES; // Max packed write commands [500:500]
|
||||
UINT8 MAX_PACKED_READS; // Max packed read commands [501:501]
|
||||
UINT8 BKOPS_SUPPORT; // Background operations support [502:502]
|
||||
UINT8 HPI_FEATURES; // HPI features [503:503]
|
||||
UINT8 S_CMD_SET; // Supported command sets [504:504]
|
||||
UINT8 EXT_SECURITY_ERR; // Extended security commands error [505:505]
|
||||
UINT8 RESERVED_23[6]; // Reserved [511:506]
|
||||
UINT8 RESERVED_1[16]; // Reserved [15:0]
|
||||
UINT8 SECURE_REMOVAL_TYPE; // Secure Removal Type [16:16]
|
||||
UINT8 PRODUCT_STATE_AWARENESS_ENABLEMENT; // Product state awareness enablement [17:17]
|
||||
UINT8 MAX_PRE_LOADING_DATA_SIZE[4]; // MAX pre loading data size [21:18]
|
||||
UINT8 PRE_LOADING_DATA_SIZE[4]; // Pre loading data size [25:22]
|
||||
UINT8 FFU_STATUS; // FFU Status [26:26]
|
||||
UINT8 RESERVED_2[2]; // Reserved [28:27]
|
||||
UINT8 MODE_OPERATION_CODES; // Mode operation codes [29:29]
|
||||
UINT8 MODE_CONFIG; // Mode config [30:30]
|
||||
UINT8 RESERVED_3; // Reserved [31:31]
|
||||
UINT8 FLUSH_CACHE; // Flushing of the cache [32:32]
|
||||
UINT8 CACHE_CTRL; // Control to turn the cache ON/OFF [33:33]
|
||||
UINT8 POWER_OFF_NOTIFICATION; // Power Off Notification [34:34]
|
||||
UINT8 PACKED_FAILURE_INDEX; // Packed command failure index [35:35]
|
||||
UINT8 PACKED_COMMAND_STATUS; // Packed command status [36:36]
|
||||
UINT8 CONTEXT_CONF[15]; // Context configuration [51:37]
|
||||
UINT8 EXT_PARTITIONS_ATTRIBUTE[2]; // Extended partitions attribute [53:52]
|
||||
UINT8 EXCEPTION_EVENTS_STATUS[2]; // Exception events status [55:54]
|
||||
UINT8 EXCEPTION_EVENTS_CTRL[2]; // Exception events control [57:56]
|
||||
UINT8 DYNCAP_NEEDED; // Number of addressed group to be released [58:58]
|
||||
UINT8 CLASS_6_CTRL; // Class 6 commands control [59:59]
|
||||
UINT8 INI_TIMEOUT_EMU; // 1st initialization after disabling sector size emulation [60:60]
|
||||
UINT8 DATA_SECTOR_SIZE; // Sector size [61:61]
|
||||
UINT8 USE_NATIVE_SECTOR; // Sector size emulation [62:62]
|
||||
UINT8 NATIVE_SECTOR_SIZE; // Native sector size [63:63]
|
||||
UINT8 VENDOR_SPECIFIC_FIELD[64]; // Vendor specific fields [127:64]
|
||||
UINT8 RESERVED_4[2]; // Reserved [129:128]
|
||||
UINT8 PROGRAM_CID_CSD_DDR_SUPPORT; // Program CID/CSD in DDR mode support [130:130]
|
||||
UINT8 PERIODIC_WAKEUP; // Periodic wake-up [131:131]
|
||||
UINT8 TCASE_SUPPORT; // Package case temperature is controlled [132:132]
|
||||
UINT8 PRODUCTION_STATE_AWARENESS; // Production state awareness [133:133]
|
||||
UINT8 SECTOR_BAD_BLK_MGMNT; // Bad block management mode [134:134]
|
||||
UINT8 RESERVED_5; // Reserved [135:135]
|
||||
UINT8 ENH_START_ADDR[4]; // Enhanced user data start address [139:136]
|
||||
UINT8 ENH_SIZE_MULT[3]; // Enhanced user data area size [142:140]
|
||||
UINT8 GP_SIZE_MULT[12]; // General purpose partition size [154:143]
|
||||
UINT8 PARTITION_SETTING_COMPLETED; // Partitioning setting [155:155]
|
||||
UINT8 PARTITIONS_ATTRIBUTE; // Partitions attribute [156:156]
|
||||
UINT8 MAX_ENH_SIZE_MULT[3]; // Max enhanced area size [159:157]
|
||||
UINT8 PARTITIONING_SUPPORT; // Partitioning [160:160]
|
||||
UINT8 HPI_MGMT; // HPI management [161:161]
|
||||
UINT8 RST_N_FUNCTION; // H/W reset function [162:162]
|
||||
UINT8 BKOPS_EN; // Enable background operations handshake [163:163]
|
||||
UINT8 BKOPS_START; // Manually start background operations [164:164]
|
||||
UINT8 SANITIZE_START; // Start sanitize operation [165:165]
|
||||
UINT8 WR_REL_PARAM; // Write reliability parameter register [166:166]
|
||||
UINT8 WR_REL_SET; // Write reliability setting register [167:167]
|
||||
UINT8 RPMB_SIZE_MULT; // RPMB size [168:168]
|
||||
UINT8 FW_CONFIG; // FW configuration [169:169]
|
||||
UINT8 RESERVED_6; // Reserved [170:170]
|
||||
UINT8 USER_WP; // User area write protection register [171:171]
|
||||
UINT8 RESERVED_7; // Reserved [172:172]
|
||||
UINT8 BOOT_WP; // Boot area write protection register [173:173]
|
||||
UINT8 BOOT_WP_STATUS; // Boot write protection register [174:174]
|
||||
UINT8 ERASE_GROUP_DEF; // High-density erase group definition [175:175]
|
||||
UINT8 RESERVED_8; // Reserved [176:176]
|
||||
UINT8 BOOT_BUS_CONDITIONS; // Boot bus conditions [177:177]
|
||||
UINT8 BOOT_CONFIG_PROT; // Boot config protection [178:178]
|
||||
UINT8 PARTITION_CONFIG; // Partition config [179:179]
|
||||
UINT8 RESERVED_9; // Reserved [180:180]
|
||||
UINT8 ERASED_MEM_CONT; // Erased memory content [181:181]
|
||||
UINT8 RESERVED_10; // Reserved [182:182]
|
||||
UINT8 BUS_WIDTH; // Bus width mode [183:183]
|
||||
UINT8 RESERVED_11; // Reserved [184:184]
|
||||
UINT8 HS_TIMING; // High-speed interface timing [185:185]
|
||||
UINT8 RESERVED_12; // Reserved [186:186]
|
||||
UINT8 POWER_CLASS; // Power class [187:187]
|
||||
UINT8 RESERVED_13; // Reserved [188:188]
|
||||
UINT8 CMD_SET_REV; // Command set revision [189:189]
|
||||
UINT8 RESERVED_14; // Reserved [190:190]
|
||||
UINT8 CMD_SET; // Command set [191:191]
|
||||
UINT8 EXT_CSD_REV; // Extended CSD revision [192:192]
|
||||
UINT8 RESERVED_15; // Reserved [193:193]
|
||||
UINT8 CSD_STRUCTURE; // CSD Structure [194:194]
|
||||
UINT8 RESERVED_16; // Reserved [195:195]
|
||||
UINT8 DEVICE_TYPE; // Device type [196:196]
|
||||
UINT8 DRIVER_STRENGTH; // I/O Driver strength [197:197]
|
||||
UINT8 OUT_OF_INTERRUPT_TIME; // Out-of-interrupt busy timing [198:198]
|
||||
UINT8 PARTITION_SWITCH_TIME; // Partition switching timing [199:199]
|
||||
UINT8 PWR_CL_52_195; // Power class for 52MHz at 1.95V 1 R [200:200]
|
||||
UINT8 PWR_CL_26_195; // Power class for 26MHz at 1.95V 1 R [201:201]
|
||||
UINT8 PWR_CL_52_360; // Power class for 52MHz at 3.6V 1 R [202:202]
|
||||
UINT8 PWR_CL_26_360; // Power class for 26MHz at 3.6V 1 R [203:203]
|
||||
UINT8 RESERVED_17; // Reserved [204:204]
|
||||
UINT8 MIN_PERF_R_4_26; // Minimum read performance for 4bit at 26MHz [205:205]
|
||||
UINT8 MIN_PERF_W_4_26; // Minimum write performance for 4bit at 26MHz [206:206]
|
||||
UINT8 MIN_PERF_R_8_26_4_52; // Minimum read performance for 8bit at 26MHz, for 4bit at 52MHz [207:207]
|
||||
UINT8 MIN_PERF_W_8_26_4_52; // Minimum write performance for 8bit at 26MHz, for 4bit at 52MHz [208:208]
|
||||
UINT8 MIN_PERF_R_8_52; // Minimum read performance for 8bit at 52MHz [209:209]
|
||||
UINT8 MIN_PERF_W_8_52; // Minimum write performance for 8bit at 52MHz [210:210]
|
||||
UINT8 RESERVED_18; // Reserved [211:211]
|
||||
UINT32 SECTOR_COUNT; // Sector count [215:212]
|
||||
UINT8 SLEEP_NOTIFICATION_TIME; // Sleep notification timeout [216:216]
|
||||
UINT8 S_A_TIMEOUT; // Sleep/awake timeout [217:217]
|
||||
UINT8 PRODUCTION_STATE_AWARENESS_TIMEOUT; // Production state awareness timeout [218:218]
|
||||
UINT8 S_C_VCCQ; // Sleep current (VCCQ) [219:219]
|
||||
UINT8 S_C_VCC; // Sleep current (VCC) [220:220]
|
||||
UINT8 HC_WP_GRP_SIZE; // High-capacity write protect group size [221:221]
|
||||
UINT8 REL_WR_SECTOR_C; // Reliable write sector count [222:222]
|
||||
UINT8 ERASE_TIMEOUT_MULT; // High-capacity erase timeout [223:223]
|
||||
UINT8 HC_ERASE_GRP_SIZE; // High-capacity erase unit size [224:224]
|
||||
UINT8 ACC_SIZE; // Access size [225:225]
|
||||
UINT8 BOOT_SIZE_MULTI; // Boot partition size [226:226]
|
||||
UINT8 RESERVED_19; // Reserved [227:227]
|
||||
UINT8 BOOT_INFO; // Boot information [228:228]
|
||||
UINT8 SECURE_TRIM_MULT; // Secure TRIM Multiplier [229:229]
|
||||
UINT8 SECURE_ERASE_MULT; // Secure Erase Multiplier [230:230]
|
||||
UINT8 SECURE_FEATURE_SUPPORT; // Secure Feature Support [231:231]
|
||||
UINT8 TRIM_MULT; // TRIM Multiplier [232:232]
|
||||
UINT8 RESERVED_20; // Reserved [233:233]
|
||||
UINT8 MIN_PREF_DDR_R_8_52; // Minimum read performance for 8bit at 52MHz in DDR mode [234:234]
|
||||
UINT8 MIN_PREF_DDR_W_8_52; // Minimum write performance for 8bit at 52MHz in DDR mode [235:235]
|
||||
UINT8 PWR_CL_200_130; // Power class for 200MHz at VCCQ=1.3V, VCC=3.6V [236:236]
|
||||
UINT8 PWR_CL_200_195; // Power class for 200MHz at VCCQ=1.95V, VCC=3.6V [237:237]
|
||||
UINT8 PWR_CL_DDR_52_195; // Power class for 52MHz, DDR at 1.95V [238:238]
|
||||
UINT8 PWR_CL_DDR_52_360; // Power class for 52Mhz, DDR at 3.6V [239:239]
|
||||
UINT8 RESERVED_21; // Reserved [240:240]
|
||||
UINT8 INI_TIMEOUT_AP; // 1st initialization time after partitioning [241:241]
|
||||
UINT8 CORRECTLY_PRG_SECTORS_NUM[4]; // Number of correctly programmed sectors [245:242]
|
||||
UINT8 BKOPS_STATUS; // Background operations status [246:246]
|
||||
UINT8 POWER_OFF_LONG_TIME; // Power off notification (long) timeout [247:247]
|
||||
UINT8 GENERIC_CMD6_TIME; // Generic CMD6 timeout [248:248]
|
||||
UINT8 CACHE_SIZE[4]; // Cache size [252:249]
|
||||
UINT8 PWR_CL_DDR_200_360; // Power class for 200MHz, DDR at VCC=3.6V [253:253]
|
||||
UINT8 FIRMWARE_VERSION[8]; // Firmware version [261:254]
|
||||
UINT8 DEVICE_VERSION[2]; // Device version [263:262]
|
||||
UINT8 OPTIMAL_TRIM_UNIT_SIZE; // Optimal trim unit size [264:264]
|
||||
UINT8 OPTIMAL_WRITE_SIZE; // Optimal write size [265:265]
|
||||
UINT8 OPTIMAL_READ_SIZE; // Optimal read size [266:266]
|
||||
UINT8 PRE_EOL_INFO; // Pre EOL information [267:267]
|
||||
UINT8 DEVICE_LIFE_TIME_EST_TYP_A; // Device life time estimation type A [268:268]
|
||||
UINT8 DEVICE_LIFE_TIME_EST_TYP_B; // Device life time estimation type B [269:269]
|
||||
UINT8 VENDOR_PROPRIETARY_HEALTH_REPORT[32]; // Vendor proprietary health report [301:270]
|
||||
UINT8 NUMBER_OF_FW_SECTORS_CORRECTLY_PROGRAMMED[4]; // Number of FW sectors correctly programmed [305:302]
|
||||
UINT8 RESERVED_22[181]; // Reserved [486:306]
|
||||
UINT8 FFU_ARG[4]; // FFU argument [490:487]
|
||||
UINT8 OPERATION_CODE_TIMEOUT; // Operation codes timeout [491:491]
|
||||
UINT8 FFU_FEATURES; // FFU features [492:492]
|
||||
UINT8 SUPPORTED_MODES; // Supported modes [493:493]
|
||||
UINT8 EXT_SUPPORT; // Extended partitions attribute support [494:494]
|
||||
UINT8 LARGE_UNIT_SIZE_M1; // Large unit size [495:495]
|
||||
UINT8 CONTEXT_CAPABILITIES; // Context management capabilities [496:496]
|
||||
UINT8 TAG_RES_SIZE; // Tag resource size [497:497]
|
||||
UINT8 TAG_UNIT_SIZE; // Tag unit size [498:498]
|
||||
UINT8 DATA_TAG_SUPPORT; // Data tag support [499:499]
|
||||
UINT8 MAX_PACKED_WRITES; // Max packed write commands [500:500]
|
||||
UINT8 MAX_PACKED_READS; // Max packed read commands [501:501]
|
||||
UINT8 BKOPS_SUPPORT; // Background operations support [502:502]
|
||||
UINT8 HPI_FEATURES; // HPI features [503:503]
|
||||
UINT8 S_CMD_SET; // Supported command sets [504:504]
|
||||
UINT8 EXT_SECURITY_ERR; // Extended security commands error [505:505]
|
||||
UINT8 RESERVED_23[6]; // Reserved [511:506]
|
||||
} ECSD;
|
||||
|
||||
typedef struct {
|
||||
UINT16 RCA;
|
||||
CARD_TYPE CardType;
|
||||
OCR OCRData;
|
||||
CID CIDData;
|
||||
CSD CSDData;
|
||||
ECSD *ECSDData; // MMC V4 extended card specific
|
||||
UINT16 RCA;
|
||||
CARD_TYPE CardType;
|
||||
OCR OCRData;
|
||||
CID CIDData;
|
||||
CSD CSDData;
|
||||
ECSD *ECSDData; // MMC V4 extended card specific
|
||||
} CARD_INFO;
|
||||
|
||||
typedef struct _MMC_HOST_INSTANCE {
|
||||
UINTN Signature;
|
||||
LIST_ENTRY Link;
|
||||
EFI_HANDLE MmcHandle;
|
||||
EFI_DEVICE_PATH_PROTOCOL *DevicePath;
|
||||
UINTN Signature;
|
||||
LIST_ENTRY Link;
|
||||
EFI_HANDLE MmcHandle;
|
||||
EFI_DEVICE_PATH_PROTOCOL *DevicePath;
|
||||
|
||||
MMC_STATE State;
|
||||
EFI_BLOCK_IO_PROTOCOL BlockIo;
|
||||
CARD_INFO CardInfo;
|
||||
EFI_MMC_HOST_PROTOCOL *MmcHost;
|
||||
MMC_STATE State;
|
||||
EFI_BLOCK_IO_PROTOCOL BlockIo;
|
||||
CARD_INFO CardInfo;
|
||||
EFI_MMC_HOST_PROTOCOL *MmcHost;
|
||||
|
||||
BOOLEAN Initialized;
|
||||
BOOLEAN Initialized;
|
||||
} MMC_HOST_INSTANCE;
|
||||
|
||||
#define MMC_HOST_INSTANCE_SIGNATURE SIGNATURE_32('m', 'm', 'c', 'h')
|
||||
#define MMC_HOST_INSTANCE_FROM_BLOCK_IO_THIS(a) CR (a, MMC_HOST_INSTANCE, BlockIo, MMC_HOST_INSTANCE_SIGNATURE)
|
||||
#define MMC_HOST_INSTANCE_FROM_LINK(a) CR (a, MMC_HOST_INSTANCE, Link, MMC_HOST_INSTANCE_SIGNATURE)
|
||||
|
||||
#define MMC_HOST_INSTANCE_SIGNATURE SIGNATURE_32('m', 'm', 'c', 'h')
|
||||
#define MMC_HOST_INSTANCE_FROM_BLOCK_IO_THIS(a) CR (a, MMC_HOST_INSTANCE, BlockIo, MMC_HOST_INSTANCE_SIGNATURE)
|
||||
#define MMC_HOST_INSTANCE_FROM_LINK(a) CR (a, MMC_HOST_INSTANCE, Link, MMC_HOST_INSTANCE_SIGNATURE)
|
||||
|
||||
EFI_STATUS
|
||||
EFIAPI
|
||||
@@ -356,19 +355,19 @@ MmcGetDriverName (
|
||||
EFI_STATUS
|
||||
EFIAPI
|
||||
MmcGetControllerName (
|
||||
IN EFI_COMPONENT_NAME_PROTOCOL *This,
|
||||
IN EFI_HANDLE ControllerHandle,
|
||||
IN EFI_HANDLE ChildHandle OPTIONAL,
|
||||
IN CHAR8 *Language,
|
||||
OUT CHAR16 **ControllerName
|
||||
IN EFI_COMPONENT_NAME_PROTOCOL *This,
|
||||
IN EFI_HANDLE ControllerHandle,
|
||||
IN EFI_HANDLE ChildHandle OPTIONAL,
|
||||
IN CHAR8 *Language,
|
||||
OUT CHAR16 **ControllerName
|
||||
);
|
||||
|
||||
extern EFI_COMPONENT_NAME_PROTOCOL gMmcComponentName;
|
||||
extern EFI_COMPONENT_NAME2_PROTOCOL gMmcComponentName2;
|
||||
extern EFI_COMPONENT_NAME_PROTOCOL gMmcComponentName;
|
||||
extern EFI_COMPONENT_NAME2_PROTOCOL gMmcComponentName2;
|
||||
|
||||
extern EFI_DRIVER_DIAGNOSTICS2_PROTOCOL gMmcDriverDiagnostics2;
|
||||
extern EFI_DRIVER_DIAGNOSTICS2_PROTOCOL gMmcDriverDiagnostics2;
|
||||
|
||||
extern LIST_ENTRY mMmcHostPool;
|
||||
extern LIST_ENTRY mMmcHostPool;
|
||||
|
||||
/**
|
||||
Reset the block device.
|
||||
@@ -388,8 +387,8 @@ extern LIST_ENTRY mMmcHostPool;
|
||||
EFI_STATUS
|
||||
EFIAPI
|
||||
MmcReset (
|
||||
IN EFI_BLOCK_IO_PROTOCOL *This,
|
||||
IN BOOLEAN ExtendedVerification
|
||||
IN EFI_BLOCK_IO_PROTOCOL *This,
|
||||
IN BOOLEAN ExtendedVerification
|
||||
);
|
||||
|
||||
/**
|
||||
@@ -419,11 +418,11 @@ MmcReset (
|
||||
EFI_STATUS
|
||||
EFIAPI
|
||||
MmcReadBlocks (
|
||||
IN EFI_BLOCK_IO_PROTOCOL *This,
|
||||
IN UINT32 MediaId,
|
||||
IN EFI_LBA Lba,
|
||||
IN UINTN BufferSize,
|
||||
OUT VOID *Buffer
|
||||
IN EFI_BLOCK_IO_PROTOCOL *This,
|
||||
IN UINT32 MediaId,
|
||||
IN EFI_LBA Lba,
|
||||
IN UINTN BufferSize,
|
||||
OUT VOID *Buffer
|
||||
);
|
||||
|
||||
/**
|
||||
@@ -454,11 +453,11 @@ MmcReadBlocks (
|
||||
EFI_STATUS
|
||||
EFIAPI
|
||||
MmcWriteBlocks (
|
||||
IN EFI_BLOCK_IO_PROTOCOL *This,
|
||||
IN UINT32 MediaId,
|
||||
IN EFI_LBA Lba,
|
||||
IN UINTN BufferSize,
|
||||
IN VOID *Buffer
|
||||
IN EFI_BLOCK_IO_PROTOCOL *This,
|
||||
IN UINT32 MediaId,
|
||||
IN EFI_LBA Lba,
|
||||
IN UINTN BufferSize,
|
||||
IN VOID *Buffer
|
||||
);
|
||||
|
||||
/**
|
||||
@@ -479,45 +478,45 @@ MmcFlushBlocks (
|
||||
|
||||
EFI_STATUS
|
||||
MmcNotifyState (
|
||||
IN MMC_HOST_INSTANCE *MmcHostInstance,
|
||||
IN MMC_STATE State
|
||||
IN MMC_HOST_INSTANCE *MmcHostInstance,
|
||||
IN MMC_STATE State
|
||||
);
|
||||
|
||||
EFI_STATUS
|
||||
InitializeMmcDevice (
|
||||
IN MMC_HOST_INSTANCE *MmcHost
|
||||
IN MMC_HOST_INSTANCE *MmcHost
|
||||
);
|
||||
|
||||
VOID
|
||||
EFIAPI
|
||||
CheckCardsCallback (
|
||||
IN EFI_EVENT Event,
|
||||
IN VOID *Context
|
||||
IN EFI_EVENT Event,
|
||||
IN VOID *Context
|
||||
);
|
||||
|
||||
VOID
|
||||
PrintCSD (
|
||||
IN UINT32* Csd
|
||||
IN UINT32 *Csd
|
||||
);
|
||||
|
||||
VOID
|
||||
PrintRCA (
|
||||
IN UINT32 Rca
|
||||
IN UINT32 Rca
|
||||
);
|
||||
|
||||
VOID
|
||||
PrintOCR (
|
||||
IN UINT32 Ocr
|
||||
IN UINT32 Ocr
|
||||
);
|
||||
|
||||
VOID
|
||||
PrintResponseR1 (
|
||||
IN UINT32 Response
|
||||
IN UINT32 Response
|
||||
);
|
||||
|
||||
VOID
|
||||
PrintCID (
|
||||
IN UINT32* Cid
|
||||
IN UINT32 *Cid
|
||||
);
|
||||
|
||||
#endif
|
||||
|
@@ -12,8 +12,8 @@
|
||||
|
||||
EFI_STATUS
|
||||
MmcNotifyState (
|
||||
IN MMC_HOST_INSTANCE *MmcHostInstance,
|
||||
IN MMC_STATE State
|
||||
IN MMC_HOST_INSTANCE *MmcHostInstance,
|
||||
IN MMC_STATE State
|
||||
)
|
||||
{
|
||||
MmcHostInstance->State = State;
|
||||
@@ -23,23 +23,24 @@ MmcNotifyState (
|
||||
EFI_STATUS
|
||||
EFIAPI
|
||||
MmcGetCardStatus (
|
||||
IN MMC_HOST_INSTANCE *MmcHostInstance
|
||||
IN MMC_HOST_INSTANCE *MmcHostInstance
|
||||
)
|
||||
{
|
||||
EFI_STATUS Status;
|
||||
UINT32 Response[4];
|
||||
UINTN CmdArg;
|
||||
EFI_MMC_HOST_PROTOCOL *MmcHost;
|
||||
EFI_STATUS Status;
|
||||
UINT32 Response[4];
|
||||
UINTN CmdArg;
|
||||
EFI_MMC_HOST_PROTOCOL *MmcHost;
|
||||
|
||||
Status = EFI_SUCCESS;
|
||||
Status = EFI_SUCCESS;
|
||||
MmcHost = MmcHostInstance->MmcHost;
|
||||
CmdArg = 0;
|
||||
CmdArg = 0;
|
||||
|
||||
if (MmcHost == NULL) {
|
||||
return EFI_INVALID_PARAMETER;
|
||||
}
|
||||
|
||||
if (MmcHostInstance->State != MmcHwInitializationState) {
|
||||
//Get the Status of the card.
|
||||
// Get the Status of the card.
|
||||
CmdArg = MmcHostInstance->CardInfo.RCA << 16;
|
||||
Status = MmcHost->SendCommand (MmcHost, MMC_CMD13, CmdArg);
|
||||
if (EFI_ERROR (Status)) {
|
||||
@@ -47,7 +48,7 @@ MmcGetCardStatus (
|
||||
return Status;
|
||||
}
|
||||
|
||||
//Read Response
|
||||
// Read Response
|
||||
MmcHost->ReceiveResponse (MmcHost, MMC_RESPONSE_TYPE_R1, Response);
|
||||
PrintResponseR1 (Response[0]);
|
||||
}
|
||||
@@ -58,11 +59,11 @@ MmcGetCardStatus (
|
||||
EFI_STATUS
|
||||
EFIAPI
|
||||
MmcReset (
|
||||
IN EFI_BLOCK_IO_PROTOCOL *This,
|
||||
IN BOOLEAN ExtendedVerification
|
||||
IN EFI_BLOCK_IO_PROTOCOL *This,
|
||||
IN BOOLEAN ExtendedVerification
|
||||
)
|
||||
{
|
||||
MMC_HOST_INSTANCE *MmcHostInstance;
|
||||
MMC_HOST_INSTANCE *MmcHostInstance;
|
||||
|
||||
MmcHostInstance = MMC_HOST_INSTANCE_FROM_BLOCK_IO_THIS (This);
|
||||
|
||||
@@ -91,7 +92,7 @@ MmcReset (
|
||||
|
||||
EFI_STATUS
|
||||
MmcDetectCard (
|
||||
EFI_MMC_HOST_PROTOCOL *MmcHost
|
||||
EFI_MMC_HOST_PROTOCOL *MmcHost
|
||||
)
|
||||
{
|
||||
if (!MmcHost->IsCardPresent (MmcHost)) {
|
||||
@@ -103,58 +104,61 @@ MmcDetectCard (
|
||||
|
||||
EFI_STATUS
|
||||
MmcStopTransmission (
|
||||
EFI_MMC_HOST_PROTOCOL *MmcHost
|
||||
EFI_MMC_HOST_PROTOCOL *MmcHost
|
||||
)
|
||||
{
|
||||
EFI_STATUS Status;
|
||||
UINT32 Response[4];
|
||||
EFI_STATUS Status;
|
||||
UINT32 Response[4];
|
||||
|
||||
// Command 12 - Stop transmission (ends read or write)
|
||||
// Normally only needed for streaming transfers or after error.
|
||||
Status = MmcHost->SendCommand (MmcHost, MMC_CMD12, 0);
|
||||
if (!EFI_ERROR (Status)) {
|
||||
MmcHost->ReceiveResponse (MmcHost, MMC_RESPONSE_TYPE_R1b, Response);
|
||||
}
|
||||
|
||||
return Status;
|
||||
}
|
||||
|
||||
#define MMCI0_BLOCKLEN 512
|
||||
#define MMCI0_TIMEOUT 10000
|
||||
#define MMCI0_BLOCKLEN 512
|
||||
#define MMCI0_TIMEOUT 10000
|
||||
|
||||
STATIC
|
||||
EFI_STATUS
|
||||
MmcTransferBlock (
|
||||
IN EFI_BLOCK_IO_PROTOCOL *This,
|
||||
IN UINTN Cmd,
|
||||
IN UINTN Transfer,
|
||||
IN UINT32 MediaId,
|
||||
IN EFI_LBA Lba,
|
||||
IN UINTN BufferSize,
|
||||
OUT VOID *Buffer
|
||||
IN EFI_BLOCK_IO_PROTOCOL *This,
|
||||
IN UINTN Cmd,
|
||||
IN UINTN Transfer,
|
||||
IN UINT32 MediaId,
|
||||
IN EFI_LBA Lba,
|
||||
IN UINTN BufferSize,
|
||||
OUT VOID *Buffer
|
||||
)
|
||||
{
|
||||
EFI_STATUS Status;
|
||||
UINTN CmdArg;
|
||||
INTN Timeout;
|
||||
UINT32 Response[4];
|
||||
MMC_HOST_INSTANCE *MmcHostInstance;
|
||||
EFI_MMC_HOST_PROTOCOL *MmcHost;
|
||||
EFI_STATUS Status;
|
||||
UINTN CmdArg;
|
||||
INTN Timeout;
|
||||
UINT32 Response[4];
|
||||
MMC_HOST_INSTANCE *MmcHostInstance;
|
||||
EFI_MMC_HOST_PROTOCOL *MmcHost;
|
||||
|
||||
MmcHostInstance = MMC_HOST_INSTANCE_FROM_BLOCK_IO_THIS (This);
|
||||
MmcHost = MmcHostInstance->MmcHost;
|
||||
MmcHost = MmcHostInstance->MmcHost;
|
||||
|
||||
if (MmcHostInstance->CardInfo.CardType != EMMC_CARD) {
|
||||
//Set command argument based on the card capacity
|
||||
//if 0 : SDSC card
|
||||
//if 1 : SDXC/SDHC
|
||||
// Set command argument based on the card capacity
|
||||
// if 0 : SDSC card
|
||||
// if 1 : SDXC/SDHC
|
||||
if (MmcHostInstance->CardInfo.OCRData.AccessMode & SD_CARD_CAPACITY) {
|
||||
CmdArg = Lba;
|
||||
} else {
|
||||
CmdArg = MultU64x32 (Lba, This->Media->BlockSize);
|
||||
}
|
||||
} else {
|
||||
//Set command argument based on the card access mode (Byte mode or Block mode)
|
||||
// Set command argument based on the card access mode (Byte mode or Block mode)
|
||||
if ((MmcHostInstance->CardInfo.OCRData.AccessMode & MMC_OCR_ACCESS_MASK) ==
|
||||
MMC_OCR_ACCESS_SECTOR) {
|
||||
MMC_OCR_ACCESS_SECTOR)
|
||||
{
|
||||
CmdArg = Lba;
|
||||
} else {
|
||||
CmdArg = MultU64x32 (Lba, This->Media->BlockSize);
|
||||
@@ -175,6 +179,7 @@ MmcTransferBlock (
|
||||
MmcStopTransmission (MmcHost);
|
||||
return Status;
|
||||
}
|
||||
|
||||
Status = MmcNotifyState (MmcHostInstance, MmcProgrammingState);
|
||||
if (EFI_ERROR (Status)) {
|
||||
DEBUG ((DEBUG_ERROR, "%a() : Error MmcProgrammingState\n", __func__));
|
||||
@@ -191,12 +196,13 @@ MmcTransferBlock (
|
||||
}
|
||||
|
||||
// Command 13 - Read status and wait for programming to complete (return to tran)
|
||||
Timeout = MMCI0_TIMEOUT;
|
||||
CmdArg = MmcHostInstance->CardInfo.RCA << 16;
|
||||
Timeout = MMCI0_TIMEOUT;
|
||||
CmdArg = MmcHostInstance->CardInfo.RCA << 16;
|
||||
Response[0] = 0;
|
||||
while(!(Response[0] & MMC_R0_READY_FOR_DATA)
|
||||
while ( !(Response[0] & MMC_R0_READY_FOR_DATA)
|
||||
&& (MMC_R0_CURRENTSTATE (Response) != MMC_R0_STATE_TRAN)
|
||||
&& Timeout--) {
|
||||
&& Timeout--)
|
||||
{
|
||||
Status = MmcHost->SendCommand (MmcHost, MMC_CMD13, CmdArg);
|
||||
if (!EFI_ERROR (Status)) {
|
||||
MmcHost->ReceiveResponse (MmcHost, MMC_RESPONSE_TYPE_R1, Response);
|
||||
@@ -211,6 +217,7 @@ MmcTransferBlock (
|
||||
if (EFI_ERROR (Status)) {
|
||||
DEBUG ((DEBUG_BLKIO, "%a(): Error and Status:%r\n", __func__, Status));
|
||||
}
|
||||
|
||||
MmcHost->ReceiveResponse (MmcHost, MMC_RESPONSE_TYPE_R1b, Response);
|
||||
}
|
||||
|
||||
@@ -219,33 +226,34 @@ MmcTransferBlock (
|
||||
DEBUG ((DEBUG_ERROR, "MmcIoBlocks() : Error MmcTransferState\n"));
|
||||
return Status;
|
||||
}
|
||||
|
||||
return Status;
|
||||
}
|
||||
|
||||
EFI_STATUS
|
||||
MmcIoBlocks (
|
||||
IN EFI_BLOCK_IO_PROTOCOL *This,
|
||||
IN UINTN Transfer,
|
||||
IN UINT32 MediaId,
|
||||
IN EFI_LBA Lba,
|
||||
IN UINTN BufferSize,
|
||||
OUT VOID *Buffer
|
||||
IN EFI_BLOCK_IO_PROTOCOL *This,
|
||||
IN UINTN Transfer,
|
||||
IN UINT32 MediaId,
|
||||
IN EFI_LBA Lba,
|
||||
IN UINTN BufferSize,
|
||||
OUT VOID *Buffer
|
||||
)
|
||||
{
|
||||
UINT32 Response[4];
|
||||
EFI_STATUS Status;
|
||||
UINTN CmdArg;
|
||||
INTN Timeout;
|
||||
UINTN Cmd;
|
||||
MMC_HOST_INSTANCE *MmcHostInstance;
|
||||
EFI_MMC_HOST_PROTOCOL *MmcHost;
|
||||
UINTN BytesRemainingToBeTransfered;
|
||||
UINTN BlockCount;
|
||||
UINTN ConsumeSize;
|
||||
UINT32 MaxBlock;
|
||||
UINTN RemainingBlock;
|
||||
UINT32 Response[4];
|
||||
EFI_STATUS Status;
|
||||
UINTN CmdArg;
|
||||
INTN Timeout;
|
||||
UINTN Cmd;
|
||||
MMC_HOST_INSTANCE *MmcHostInstance;
|
||||
EFI_MMC_HOST_PROTOCOL *MmcHost;
|
||||
UINTN BytesRemainingToBeTransfered;
|
||||
UINTN BlockCount;
|
||||
UINTN ConsumeSize;
|
||||
UINT32 MaxBlock;
|
||||
UINTN RemainingBlock;
|
||||
|
||||
BlockCount = 1;
|
||||
BlockCount = 1;
|
||||
MmcHostInstance = MMC_HOST_INSTANCE_FROM_BLOCK_IO_THIS (This);
|
||||
ASSERT (MmcHostInstance != NULL);
|
||||
MmcHost = MmcHostInstance->MmcHost;
|
||||
@@ -274,7 +282,7 @@ MmcIoBlocks (
|
||||
return EFI_BAD_BUFFER_SIZE;
|
||||
}
|
||||
|
||||
if (MMC_HOST_HAS_ISMULTIBLOCK(MmcHost) && MmcHost->IsMultiBlock(MmcHost)) {
|
||||
if (MMC_HOST_HAS_ISMULTIBLOCK (MmcHost) && MmcHost->IsMultiBlock (MmcHost)) {
|
||||
BlockCount = BufferSize / This->Media->BlockSize;
|
||||
}
|
||||
|
||||
@@ -293,11 +301,10 @@ MmcIoBlocks (
|
||||
}
|
||||
|
||||
// Max block number in single cmd is 65535 blocks.
|
||||
MaxBlock = 0xFFFF;
|
||||
RemainingBlock = BlockCount;
|
||||
MaxBlock = 0xFFFF;
|
||||
RemainingBlock = BlockCount;
|
||||
BytesRemainingToBeTransfered = BufferSize;
|
||||
while (BytesRemainingToBeTransfered > 0) {
|
||||
|
||||
if (RemainingBlock <= MaxBlock) {
|
||||
BlockCount = RemainingBlock;
|
||||
} else {
|
||||
@@ -305,12 +312,13 @@ MmcIoBlocks (
|
||||
}
|
||||
|
||||
// Check if the Card is in Ready status
|
||||
CmdArg = MmcHostInstance->CardInfo.RCA << 16;
|
||||
CmdArg = MmcHostInstance->CardInfo.RCA << 16;
|
||||
Response[0] = 0;
|
||||
Timeout = 20;
|
||||
while( (!(Response[0] & MMC_R0_READY_FOR_DATA))
|
||||
Timeout = 20;
|
||||
while ( (!(Response[0] & MMC_R0_READY_FOR_DATA))
|
||||
&& (MMC_R0_CURRENTSTATE (Response) != MMC_R0_STATE_TRAN)
|
||||
&& Timeout--) {
|
||||
&& Timeout--)
|
||||
{
|
||||
Status = MmcHost->SendCommand (MmcHost, MMC_CMD13, CmdArg);
|
||||
if (!EFI_ERROR (Status)) {
|
||||
MmcHost->ReceiveResponse (MmcHost, MMC_RESPONSE_TYPE_R1, Response);
|
||||
@@ -327,16 +335,16 @@ MmcIoBlocks (
|
||||
// Read a single block
|
||||
Cmd = MMC_CMD17;
|
||||
} else {
|
||||
// Read multiple blocks
|
||||
Cmd = MMC_CMD18;
|
||||
// Read multiple blocks
|
||||
Cmd = MMC_CMD18;
|
||||
}
|
||||
} else {
|
||||
if (BlockCount == 1) {
|
||||
// Write a single block
|
||||
Cmd = MMC_CMD24;
|
||||
} else {
|
||||
// Write multiple blocks
|
||||
Cmd = MMC_CMD25;
|
||||
// Write multiple blocks
|
||||
Cmd = MMC_CMD25;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -344,15 +352,16 @@ MmcIoBlocks (
|
||||
if (BytesRemainingToBeTransfered < ConsumeSize) {
|
||||
ConsumeSize = BytesRemainingToBeTransfered;
|
||||
}
|
||||
|
||||
Status = MmcTransferBlock (This, Cmd, Transfer, MediaId, Lba, ConsumeSize, Buffer);
|
||||
if (EFI_ERROR (Status)) {
|
||||
DEBUG ((DEBUG_ERROR, "%a(): Failed to transfer block and Status:%r\n", __func__, Status));
|
||||
}
|
||||
|
||||
RemainingBlock -= BlockCount;
|
||||
RemainingBlock -= BlockCount;
|
||||
BytesRemainingToBeTransfered -= ConsumeSize;
|
||||
if (BytesRemainingToBeTransfered > 0) {
|
||||
Lba += BlockCount;
|
||||
Lba += BlockCount;
|
||||
Buffer = (UINT8 *)Buffer + ConsumeSize;
|
||||
}
|
||||
}
|
||||
@@ -363,11 +372,11 @@ MmcIoBlocks (
|
||||
EFI_STATUS
|
||||
EFIAPI
|
||||
MmcReadBlocks (
|
||||
IN EFI_BLOCK_IO_PROTOCOL *This,
|
||||
IN UINT32 MediaId,
|
||||
IN EFI_LBA Lba,
|
||||
IN UINTN BufferSize,
|
||||
OUT VOID *Buffer
|
||||
IN EFI_BLOCK_IO_PROTOCOL *This,
|
||||
IN UINT32 MediaId,
|
||||
IN EFI_LBA Lba,
|
||||
IN UINTN BufferSize,
|
||||
OUT VOID *Buffer
|
||||
)
|
||||
{
|
||||
return MmcIoBlocks (This, MMC_IOBLOCKS_READ, MediaId, Lba, BufferSize, Buffer);
|
||||
@@ -376,11 +385,11 @@ MmcReadBlocks (
|
||||
EFI_STATUS
|
||||
EFIAPI
|
||||
MmcWriteBlocks (
|
||||
IN EFI_BLOCK_IO_PROTOCOL *This,
|
||||
IN UINT32 MediaId,
|
||||
IN EFI_LBA Lba,
|
||||
IN UINTN BufferSize,
|
||||
IN VOID *Buffer
|
||||
IN EFI_BLOCK_IO_PROTOCOL *This,
|
||||
IN UINT32 MediaId,
|
||||
IN EFI_LBA Lba,
|
||||
IN UINTN BufferSize,
|
||||
IN VOID *Buffer
|
||||
)
|
||||
{
|
||||
return MmcIoBlocks (This, MMC_IOBLOCKS_WRITE, MediaId, Lba, BufferSize, Buffer);
|
||||
|
@@ -8,33 +8,36 @@
|
||||
|
||||
#include "Mmc.h"
|
||||
|
||||
#if !defined(MDEPKG_NDEBUG)
|
||||
CONST CHAR8* mStrUnit[] = { "100kbit/s", "1Mbit/s", "10Mbit/s", "100MBit/s",
|
||||
"Unknown", "Unknown", "Unknown", "Unknown" };
|
||||
CONST CHAR8* mStrValue[] = { "1.0", "1.2", "1.3", "1.5", "2.0", "2.5", "3.0", "3.5", "4.0", "4.5", "5.0",
|
||||
"Unknown", "Unknown", "Unknown", "Unknown" };
|
||||
#if !defined (MDEPKG_NDEBUG)
|
||||
CONST CHAR8 *mStrUnit[] = {
|
||||
"100kbit/s", "1Mbit/s", "10Mbit/s", "100MBit/s",
|
||||
"Unknown", "Unknown", "Unknown", "Unknown"
|
||||
};
|
||||
CONST CHAR8 *mStrValue[] = {
|
||||
"1.0", "1.2", "1.3", "1.5", "2.0", "2.5", "3.0", "3.5", "4.0", "4.5", "5.0",
|
||||
"Unknown", "Unknown", "Unknown", "Unknown"
|
||||
};
|
||||
#endif
|
||||
|
||||
VOID
|
||||
PrintCID (
|
||||
IN UINT32* Cid
|
||||
IN UINT32 *Cid
|
||||
)
|
||||
{
|
||||
DEBUG ((DEBUG_ERROR, "- PrintCID\n"));
|
||||
DEBUG ((DEBUG_ERROR, "\t- Manufacturing date: %d/%d\n", (Cid[0] >> 8) & 0xF, (Cid[0] >> 12) & 0xFF));
|
||||
DEBUG ((DEBUG_ERROR, "\t- Product serial number: 0x%X%X\n", Cid[1] & 0xFFFFFF, (Cid[0] >> 24) & 0xFF));
|
||||
DEBUG ((DEBUG_ERROR, "\t- Product revision: %d\n", Cid[1] >> 24));
|
||||
//DEBUG ((DEBUG_ERROR, "\t- Product name: %s\n", (char*)(Cid + 2)));
|
||||
// DEBUG ((DEBUG_ERROR, "\t- Product name: %s\n", (char*)(Cid + 2)));
|
||||
DEBUG ((DEBUG_ERROR, "\t- OEM ID: %c%c\n", (Cid[3] >> 8) & 0xFF, (Cid[3] >> 16) & 0xFF));
|
||||
}
|
||||
|
||||
|
||||
VOID
|
||||
PrintCSD (
|
||||
IN UINT32* Csd
|
||||
IN UINT32 *Csd
|
||||
)
|
||||
{
|
||||
UINTN Value;
|
||||
UINTN Value;
|
||||
|
||||
if (((Csd[2] >> 30) & 0x3) == 0) {
|
||||
DEBUG ((DEBUG_ERROR, "- PrintCSD Version 1.01-1.10/Version 2.00/Standard Capacity\n"));
|
||||
@@ -45,9 +48,9 @@ PrintCSD (
|
||||
}
|
||||
|
||||
DEBUG ((DEBUG_ERROR, "\t- Supported card command class: 0x%X\n", MMC_CSD_GET_CCC (Csd)));
|
||||
DEBUG ((DEBUG_ERROR, "\t- Speed: %a %a\n",mStrValue[(MMC_CSD_GET_TRANSPEED (Csd) >> 3) & 0xF],mStrUnit[MMC_CSD_GET_TRANSPEED (Csd) & 7]));
|
||||
DEBUG ((DEBUG_ERROR, "\t- Maximum Read Data Block: %d\n",2 << (MMC_CSD_GET_READBLLEN (Csd)-1)));
|
||||
DEBUG ((DEBUG_ERROR, "\t- Maximum Write Data Block: %d\n",2 << (MMC_CSD_GET_WRITEBLLEN (Csd)-1)));
|
||||
DEBUG ((DEBUG_ERROR, "\t- Speed: %a %a\n", mStrValue[(MMC_CSD_GET_TRANSPEED (Csd) >> 3) & 0xF], mStrUnit[MMC_CSD_GET_TRANSPEED (Csd) & 7]));
|
||||
DEBUG ((DEBUG_ERROR, "\t- Maximum Read Data Block: %d\n", 2 << (MMC_CSD_GET_READBLLEN (Csd)-1)));
|
||||
DEBUG ((DEBUG_ERROR, "\t- Maximum Write Data Block: %d\n", 2 << (MMC_CSD_GET_WRITEBLLEN (Csd)-1)));
|
||||
|
||||
if (!MMC_CSD_GET_FILEFORMATGRP (Csd)) {
|
||||
Value = MMC_CSD_GET_FILEFORMAT (Csd);
|
||||
@@ -67,7 +70,7 @@ PrintCSD (
|
||||
|
||||
VOID
|
||||
PrintRCA (
|
||||
IN UINT32 Rca
|
||||
IN UINT32 Rca
|
||||
)
|
||||
{
|
||||
DEBUG ((DEBUG_ERROR, "- PrintRCA: 0x%X\n", Rca));
|
||||
@@ -77,13 +80,13 @@ PrintRCA (
|
||||
|
||||
VOID
|
||||
PrintOCR (
|
||||
IN UINT32 Ocr
|
||||
IN UINT32 Ocr
|
||||
)
|
||||
{
|
||||
UINTN MinV;
|
||||
UINTN MaxV;
|
||||
UINTN Volts;
|
||||
UINTN Loop;
|
||||
UINTN MinV;
|
||||
UINTN MaxV;
|
||||
UINTN Volts;
|
||||
UINTN Loop;
|
||||
|
||||
MinV = 36; // 3.6
|
||||
MaxV = 20; // 2.0
|
||||
@@ -95,14 +98,16 @@ PrintOCR (
|
||||
if (MinV > Volts) {
|
||||
MinV = Volts;
|
||||
}
|
||||
|
||||
if (MaxV < Volts) {
|
||||
MaxV = Volts + 1;
|
||||
}
|
||||
}
|
||||
|
||||
Volts++;
|
||||
}
|
||||
|
||||
DEBUG ((DEBUG_ERROR, "- PrintOCR Ocr (0x%X)\n",Ocr));
|
||||
DEBUG ((DEBUG_ERROR, "- PrintOCR Ocr (0x%X)\n", Ocr));
|
||||
DEBUG ((DEBUG_ERROR, "\t- Card operating voltage: %d.%d to %d.%d\n", MinV/10, MinV % 10, MaxV/10, MaxV % 10));
|
||||
if (((Ocr >> 29) & 3) == 0) {
|
||||
DEBUG ((DEBUG_ERROR, "\t- AccessMode: Byte Mode\n"));
|
||||
@@ -119,7 +124,7 @@ PrintOCR (
|
||||
|
||||
VOID
|
||||
PrintResponseR1 (
|
||||
IN UINT32 Response
|
||||
IN UINT32 Response
|
||||
)
|
||||
{
|
||||
DEBUG ((DEBUG_INFO, "Response: 0x%X\n", Response));
|
||||
@@ -128,35 +133,35 @@ PrintResponseR1 (
|
||||
}
|
||||
|
||||
switch ((Response >> 9) & 0xF) {
|
||||
case 0:
|
||||
DEBUG ((DEBUG_INFO, "\t- State: Idle\n"));
|
||||
break;
|
||||
case 1:
|
||||
DEBUG ((DEBUG_INFO, "\t- State: Ready\n"));
|
||||
break;
|
||||
case 2:
|
||||
DEBUG ((DEBUG_INFO, "\t- State: Ident\n"));
|
||||
break;
|
||||
case 3:
|
||||
DEBUG ((DEBUG_INFO, "\t- State: StandBy\n"));
|
||||
break;
|
||||
case 4:
|
||||
DEBUG ((DEBUG_INFO, "\t- State: Tran\n"));
|
||||
break;
|
||||
case 5:
|
||||
DEBUG ((DEBUG_INFO, "\t- State: Data\n"));
|
||||
break;
|
||||
case 6:
|
||||
DEBUG ((DEBUG_INFO, "\t- State: Rcv\n"));
|
||||
break;
|
||||
case 7:
|
||||
DEBUG ((DEBUG_INFO, "\t- State: Prg\n"));
|
||||
break;
|
||||
case 8:
|
||||
DEBUG ((DEBUG_INFO, "\t- State: Dis\n"));
|
||||
break;
|
||||
default:
|
||||
DEBUG ((DEBUG_INFO, "\t- State: Reserved\n"));
|
||||
break;
|
||||
case 0:
|
||||
DEBUG ((DEBUG_INFO, "\t- State: Idle\n"));
|
||||
break;
|
||||
case 1:
|
||||
DEBUG ((DEBUG_INFO, "\t- State: Ready\n"));
|
||||
break;
|
||||
case 2:
|
||||
DEBUG ((DEBUG_INFO, "\t- State: Ident\n"));
|
||||
break;
|
||||
case 3:
|
||||
DEBUG ((DEBUG_INFO, "\t- State: StandBy\n"));
|
||||
break;
|
||||
case 4:
|
||||
DEBUG ((DEBUG_INFO, "\t- State: Tran\n"));
|
||||
break;
|
||||
case 5:
|
||||
DEBUG ((DEBUG_INFO, "\t- State: Data\n"));
|
||||
break;
|
||||
case 6:
|
||||
DEBUG ((DEBUG_INFO, "\t- State: Rcv\n"));
|
||||
break;
|
||||
case 7:
|
||||
DEBUG ((DEBUG_INFO, "\t- State: Prg\n"));
|
||||
break;
|
||||
case 8:
|
||||
DEBUG ((DEBUG_INFO, "\t- State: Dis\n"));
|
||||
break;
|
||||
default:
|
||||
DEBUG ((DEBUG_INFO, "\t- State: Reserved\n"));
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
@@ -13,38 +13,38 @@
|
||||
#include "Mmc.h"
|
||||
|
||||
typedef union {
|
||||
UINT32 Raw;
|
||||
OCR Ocr;
|
||||
UINT32 Raw;
|
||||
OCR Ocr;
|
||||
} OCR_RESPONSE;
|
||||
|
||||
#define MAX_RETRY_COUNT 1000
|
||||
#define CMD_RETRY_COUNT 20
|
||||
#define RCA_SHIFT_OFFSET 16
|
||||
#define EMMC_CARD_SIZE 512
|
||||
#define EMMC_ECSD_SIZE_OFFSET 53
|
||||
#define MAX_RETRY_COUNT 1000
|
||||
#define CMD_RETRY_COUNT 20
|
||||
#define RCA_SHIFT_OFFSET 16
|
||||
#define EMMC_CARD_SIZE 512
|
||||
#define EMMC_ECSD_SIZE_OFFSET 53
|
||||
|
||||
#define EXTCSD_BUS_WIDTH 183
|
||||
#define EXTCSD_HS_TIMING 185
|
||||
#define EXTCSD_BUS_WIDTH 183
|
||||
#define EXTCSD_HS_TIMING 185
|
||||
|
||||
#define EMMC_TIMING_BACKWARD 0
|
||||
#define EMMC_TIMING_HS 1
|
||||
#define EMMC_TIMING_HS200 2
|
||||
#define EMMC_TIMING_HS400 3
|
||||
#define EMMC_TIMING_BACKWARD 0
|
||||
#define EMMC_TIMING_HS 1
|
||||
#define EMMC_TIMING_HS200 2
|
||||
#define EMMC_TIMING_HS400 3
|
||||
|
||||
#define EMMC_BUS_WIDTH_1BIT 0
|
||||
#define EMMC_BUS_WIDTH_4BIT 1
|
||||
#define EMMC_BUS_WIDTH_8BIT 2
|
||||
#define EMMC_BUS_WIDTH_DDR_4BIT 5
|
||||
#define EMMC_BUS_WIDTH_DDR_8BIT 6
|
||||
#define EMMC_BUS_WIDTH_1BIT 0
|
||||
#define EMMC_BUS_WIDTH_4BIT 1
|
||||
#define EMMC_BUS_WIDTH_8BIT 2
|
||||
#define EMMC_BUS_WIDTH_DDR_4BIT 5
|
||||
#define EMMC_BUS_WIDTH_DDR_8BIT 6
|
||||
|
||||
#define EMMC_SWITCH_ERROR (1 << 7)
|
||||
#define EMMC_SWITCH_ERROR (1 << 7)
|
||||
|
||||
#define SD_BUS_WIDTH_1BIT (1 << 0)
|
||||
#define SD_BUS_WIDTH_4BIT (1 << 2)
|
||||
#define SD_BUS_WIDTH_1BIT (1 << 0)
|
||||
#define SD_BUS_WIDTH_4BIT (1 << 2)
|
||||
|
||||
#define SD_CCC_SWITCH (1 << 10)
|
||||
#define SD_CCC_SWITCH (1 << 10)
|
||||
|
||||
#define DEVICE_STATE(x) (((x) >> 9) & 0xf)
|
||||
#define DEVICE_STATE(x) (((x) >> 9) & 0xf)
|
||||
typedef enum _EMMC_DEVICE_STATE {
|
||||
EMMC_IDLE_STATE = 0,
|
||||
EMMC_READY_STATE,
|
||||
@@ -59,41 +59,44 @@ typedef enum _EMMC_DEVICE_STATE {
|
||||
EMMC_SLP_STATE
|
||||
} EMMC_DEVICE_STATE;
|
||||
|
||||
UINT32 mEmmcRcaCount = 0;
|
||||
UINT32 mEmmcRcaCount = 0;
|
||||
|
||||
STATIC
|
||||
EFI_STATUS
|
||||
EFIAPI
|
||||
EmmcGetDeviceState (
|
||||
IN MMC_HOST_INSTANCE *MmcHostInstance,
|
||||
OUT EMMC_DEVICE_STATE *State
|
||||
IN MMC_HOST_INSTANCE *MmcHostInstance,
|
||||
OUT EMMC_DEVICE_STATE *State
|
||||
)
|
||||
{
|
||||
EFI_MMC_HOST_PROTOCOL *Host;
|
||||
EFI_STATUS Status;
|
||||
UINT32 Data, RCA;
|
||||
EFI_MMC_HOST_PROTOCOL *Host;
|
||||
EFI_STATUS Status;
|
||||
UINT32 Data, RCA;
|
||||
|
||||
if (State == NULL) {
|
||||
return EFI_INVALID_PARAMETER;
|
||||
}
|
||||
|
||||
Host = MmcHostInstance->MmcHost;
|
||||
RCA = MmcHostInstance->CardInfo.RCA << RCA_SHIFT_OFFSET;
|
||||
Host = MmcHostInstance->MmcHost;
|
||||
RCA = MmcHostInstance->CardInfo.RCA << RCA_SHIFT_OFFSET;
|
||||
Status = Host->SendCommand (Host, MMC_CMD13, RCA);
|
||||
if (EFI_ERROR (Status)) {
|
||||
DEBUG ((DEBUG_ERROR, "EmmcGetDeviceState(): Failed to get card status, Status=%r.\n", Status));
|
||||
return Status;
|
||||
}
|
||||
|
||||
Status = Host->ReceiveResponse (Host, MMC_RESPONSE_TYPE_R1, &Data);
|
||||
if (EFI_ERROR (Status)) {
|
||||
DEBUG ((DEBUG_ERROR, "EmmcGetDeviceState(): Failed to get response of CMD13, Status=%r.\n", Status));
|
||||
return Status;
|
||||
}
|
||||
|
||||
if (Data & EMMC_SWITCH_ERROR) {
|
||||
DEBUG ((DEBUG_ERROR, "EmmcGetDeviceState(): Failed to switch expected mode, Status=%r.\n", Status));
|
||||
return EFI_DEVICE_ERROR;
|
||||
}
|
||||
*State = DEVICE_STATE(Data);
|
||||
|
||||
*State = DEVICE_STATE (Data);
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
|
||||
@@ -101,24 +104,25 @@ STATIC
|
||||
EFI_STATUS
|
||||
EFIAPI
|
||||
EmmcSetEXTCSD (
|
||||
IN MMC_HOST_INSTANCE *MmcHostInstance,
|
||||
UINT32 ExtCmdIndex,
|
||||
UINT32 Value
|
||||
IN MMC_HOST_INSTANCE *MmcHostInstance,
|
||||
UINT32 ExtCmdIndex,
|
||||
UINT32 Value
|
||||
)
|
||||
{
|
||||
EFI_MMC_HOST_PROTOCOL *Host;
|
||||
EMMC_DEVICE_STATE State;
|
||||
EFI_STATUS Status;
|
||||
UINT32 Argument;
|
||||
EFI_MMC_HOST_PROTOCOL *Host;
|
||||
EMMC_DEVICE_STATE State;
|
||||
EFI_STATUS Status;
|
||||
UINT32 Argument;
|
||||
|
||||
Host = MmcHostInstance->MmcHost;
|
||||
Argument = EMMC_CMD6_ARG_ACCESS(3) | EMMC_CMD6_ARG_INDEX(ExtCmdIndex) |
|
||||
EMMC_CMD6_ARG_VALUE(Value) | EMMC_CMD6_ARG_CMD_SET(1);
|
||||
Host = MmcHostInstance->MmcHost;
|
||||
Argument = EMMC_CMD6_ARG_ACCESS (3) | EMMC_CMD6_ARG_INDEX (ExtCmdIndex) |
|
||||
EMMC_CMD6_ARG_VALUE (Value) | EMMC_CMD6_ARG_CMD_SET (1);
|
||||
Status = Host->SendCommand (Host, MMC_CMD6, Argument);
|
||||
if (EFI_ERROR (Status)) {
|
||||
DEBUG ((DEBUG_ERROR, "EmmcSetEXTCSD(): Failed to send CMD6, Status=%r.\n", Status));
|
||||
return Status;
|
||||
}
|
||||
|
||||
// Make sure device exiting prog mode
|
||||
do {
|
||||
Status = EmmcGetDeviceState (MmcHostInstance, &State);
|
||||
@@ -127,6 +131,7 @@ EmmcSetEXTCSD (
|
||||
return Status;
|
||||
}
|
||||
} while (State == EMMC_PRG_STATE);
|
||||
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
|
||||
@@ -134,15 +139,15 @@ STATIC
|
||||
EFI_STATUS
|
||||
EFIAPI
|
||||
EmmcIdentificationMode (
|
||||
IN MMC_HOST_INSTANCE *MmcHostInstance,
|
||||
IN OCR_RESPONSE Response
|
||||
IN MMC_HOST_INSTANCE *MmcHostInstance,
|
||||
IN OCR_RESPONSE Response
|
||||
)
|
||||
{
|
||||
EFI_MMC_HOST_PROTOCOL *Host;
|
||||
EFI_BLOCK_IO_MEDIA *Media;
|
||||
EFI_STATUS Status;
|
||||
EMMC_DEVICE_STATE State;
|
||||
UINT32 RCA;
|
||||
EFI_MMC_HOST_PROTOCOL *Host;
|
||||
EFI_BLOCK_IO_MEDIA *Media;
|
||||
EFI_STATUS Status;
|
||||
EMMC_DEVICE_STATE State;
|
||||
UINT32 RCA;
|
||||
|
||||
Host = MmcHostInstance->MmcHost;
|
||||
Media = MmcHostInstance->BlockIo.Media;
|
||||
@@ -162,8 +167,8 @@ EmmcIdentificationMode (
|
||||
|
||||
// Assign a relative address value to the card
|
||||
MmcHostInstance->CardInfo.RCA = ++mEmmcRcaCount; // TODO: might need a more sophisticated way of doing this
|
||||
RCA = MmcHostInstance->CardInfo.RCA << RCA_SHIFT_OFFSET;
|
||||
Status = Host->SendCommand (Host, MMC_CMD3, RCA);
|
||||
RCA = MmcHostInstance->CardInfo.RCA << RCA_SHIFT_OFFSET;
|
||||
Status = Host->SendCommand (Host, MMC_CMD3, RCA);
|
||||
if (EFI_ERROR (Status)) {
|
||||
DEBUG ((DEBUG_ERROR, "EmmcIdentificationMode(): RCA set error, Status=%r.\n", Status));
|
||||
return Status;
|
||||
@@ -188,7 +193,7 @@ EmmcIdentificationMode (
|
||||
DEBUG ((DEBUG_ERROR, "EmmcIdentificationMode(): Card selection error, Status=%r.\n", Status));
|
||||
}
|
||||
|
||||
if (MMC_HOST_HAS_SETIOS(Host)) {
|
||||
if (MMC_HOST_HAS_SETIOS (Host)) {
|
||||
// Set 1-bit bus width
|
||||
Status = Host->SetIos (Host, 0, 1, EMMCBACKWARD);
|
||||
if (EFI_ERROR (Status)) {
|
||||
@@ -209,6 +214,7 @@ EmmcIdentificationMode (
|
||||
if (MmcHostInstance->CardInfo.ECSDData == NULL) {
|
||||
return EFI_OUT_OF_RESOURCES;
|
||||
}
|
||||
|
||||
Status = Host->SendCommand (Host, MMC_CMD8, 0);
|
||||
if (EFI_ERROR (Status)) {
|
||||
DEBUG ((DEBUG_ERROR, "EmmcIdentificationMode(): ECSD fetch error, Status=%r.\n", Status));
|
||||
@@ -230,11 +236,11 @@ EmmcIdentificationMode (
|
||||
} while (State == EMMC_DATA_STATE);
|
||||
|
||||
// Set up media
|
||||
Media->BlockSize = EMMC_CARD_SIZE; // 512-byte support is mandatory for eMMC cards
|
||||
Media->MediaId = MmcHostInstance->CardInfo.CIDData.PSN;
|
||||
Media->ReadOnly = MmcHostInstance->CardInfo.CSDData.PERM_WRITE_PROTECT;
|
||||
Media->BlockSize = EMMC_CARD_SIZE; // 512-byte support is mandatory for eMMC cards
|
||||
Media->MediaId = MmcHostInstance->CardInfo.CIDData.PSN;
|
||||
Media->ReadOnly = MmcHostInstance->CardInfo.CSDData.PERM_WRITE_PROTECT;
|
||||
Media->LogicalBlocksPerPhysicalBlock = 1;
|
||||
Media->IoAlign = 4;
|
||||
Media->IoAlign = 4;
|
||||
// Compute last block using bits [215:212] of the ECSD
|
||||
Media->LastBlock = MmcHostInstance->CardInfo.ECSDData->SECTOR_COUNT - 1; // eMMC isn't supposed to report this for
|
||||
// Cards <2GB in size, but the model does.
|
||||
@@ -251,23 +257,25 @@ FreePageExit:
|
||||
STATIC
|
||||
EFI_STATUS
|
||||
InitializeEmmcDevice (
|
||||
IN MMC_HOST_INSTANCE *MmcHostInstance
|
||||
IN MMC_HOST_INSTANCE *MmcHostInstance
|
||||
)
|
||||
{
|
||||
EFI_MMC_HOST_PROTOCOL *Host;
|
||||
EFI_STATUS Status = EFI_SUCCESS;
|
||||
ECSD *ECSDData;
|
||||
UINT32 BusClockFreq, Idx, BusMode;
|
||||
UINT32 TimingMode[4] = {EMMCHS52DDR1V2, EMMCHS52DDR1V8, EMMCHS52, EMMCHS26};
|
||||
EFI_MMC_HOST_PROTOCOL *Host;
|
||||
EFI_STATUS Status = EFI_SUCCESS;
|
||||
ECSD *ECSDData;
|
||||
UINT32 BusClockFreq, Idx, BusMode;
|
||||
UINT32 TimingMode[4] = { EMMCHS52DDR1V2, EMMCHS52DDR1V8, EMMCHS52, EMMCHS26 };
|
||||
|
||||
Host = MmcHostInstance->MmcHost;
|
||||
Host = MmcHostInstance->MmcHost;
|
||||
ECSDData = MmcHostInstance->CardInfo.ECSDData;
|
||||
if (ECSDData->DEVICE_TYPE == EMMCBACKWARD)
|
||||
return EFI_SUCCESS;
|
||||
|
||||
if (!MMC_HOST_HAS_SETIOS(Host)) {
|
||||
if (ECSDData->DEVICE_TYPE == EMMCBACKWARD) {
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
|
||||
if (!MMC_HOST_HAS_SETIOS (Host)) {
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
|
||||
Status = EmmcSetEXTCSD (MmcHostInstance, EXTCSD_HS_TIMING, EMMC_TIMING_HS);
|
||||
if (EFI_ERROR (Status)) {
|
||||
DEBUG ((DEBUG_ERROR, "InitializeEmmcDevice(): Failed to switch high speed mode, Status:%r.\n", Status));
|
||||
@@ -276,52 +284,56 @@ InitializeEmmcDevice (
|
||||
|
||||
for (Idx = 0; Idx < 4; Idx++) {
|
||||
switch (TimingMode[Idx]) {
|
||||
case EMMCHS52DDR1V2:
|
||||
case EMMCHS52DDR1V8:
|
||||
case EMMCHS52:
|
||||
BusClockFreq = 52000000;
|
||||
break;
|
||||
case EMMCHS26:
|
||||
BusClockFreq = 26000000;
|
||||
break;
|
||||
default:
|
||||
return EFI_UNSUPPORTED;
|
||||
}
|
||||
Status = Host->SetIos (Host, BusClockFreq, 8, TimingMode[Idx]);
|
||||
if (!EFI_ERROR (Status)) {
|
||||
switch (TimingMode[Idx]) {
|
||||
case EMMCHS52DDR1V2:
|
||||
case EMMCHS52DDR1V8:
|
||||
BusMode = EMMC_BUS_WIDTH_DDR_8BIT;
|
||||
break;
|
||||
case EMMCHS52:
|
||||
BusClockFreq = 52000000;
|
||||
break;
|
||||
case EMMCHS26:
|
||||
BusMode = EMMC_BUS_WIDTH_8BIT;
|
||||
BusClockFreq = 26000000;
|
||||
break;
|
||||
default:
|
||||
return EFI_UNSUPPORTED;
|
||||
}
|
||||
|
||||
Status = Host->SetIos (Host, BusClockFreq, 8, TimingMode[Idx]);
|
||||
if (!EFI_ERROR (Status)) {
|
||||
switch (TimingMode[Idx]) {
|
||||
case EMMCHS52DDR1V2:
|
||||
case EMMCHS52DDR1V8:
|
||||
BusMode = EMMC_BUS_WIDTH_DDR_8BIT;
|
||||
break;
|
||||
case EMMCHS52:
|
||||
case EMMCHS26:
|
||||
BusMode = EMMC_BUS_WIDTH_8BIT;
|
||||
break;
|
||||
default:
|
||||
return EFI_UNSUPPORTED;
|
||||
}
|
||||
|
||||
Status = EmmcSetEXTCSD (MmcHostInstance, EXTCSD_BUS_WIDTH, BusMode);
|
||||
if (EFI_ERROR (Status)) {
|
||||
DEBUG ((DEBUG_ERROR, "InitializeEmmcDevice(): Failed to set EXTCSD bus width, Status:%r\n", Status));
|
||||
}
|
||||
|
||||
return Status;
|
||||
}
|
||||
}
|
||||
|
||||
return Status;
|
||||
}
|
||||
|
||||
STATIC
|
||||
UINT32
|
||||
CreateSwitchCmdArgument (
|
||||
IN UINT32 Mode,
|
||||
IN UINT8 Group,
|
||||
IN UINT8 Value
|
||||
IN UINT32 Mode,
|
||||
IN UINT8 Group,
|
||||
IN UINT8 Value
|
||||
)
|
||||
{
|
||||
UINT32 Argument;
|
||||
UINT32 Argument;
|
||||
|
||||
Argument = Mode << 31 | 0x00FFFFFF;
|
||||
Argument = Mode << 31 | 0x00FFFFFF;
|
||||
Argument &= ~(0xF << (Group * 4));
|
||||
Argument |= Value << (Group * 4);
|
||||
|
||||
@@ -331,51 +343,52 @@ CreateSwitchCmdArgument (
|
||||
STATIC
|
||||
EFI_STATUS
|
||||
InitializeSdMmcDevice (
|
||||
IN MMC_HOST_INSTANCE *MmcHostInstance
|
||||
IN MMC_HOST_INSTANCE *MmcHostInstance
|
||||
)
|
||||
{
|
||||
UINT32 CmdArg;
|
||||
UINT32 Response[4];
|
||||
UINT32 Buffer[128];
|
||||
UINT32 Speed;
|
||||
UINTN BlockSize;
|
||||
UINTN CardSize;
|
||||
UINTN NumBlocks;
|
||||
BOOLEAN CccSwitch;
|
||||
SCR Scr;
|
||||
EFI_STATUS Status;
|
||||
EFI_MMC_HOST_PROTOCOL *MmcHost;
|
||||
UINT32 CmdArg;
|
||||
UINT32 Response[4];
|
||||
UINT32 Buffer[128];
|
||||
UINT32 Speed;
|
||||
UINTN BlockSize;
|
||||
UINTN CardSize;
|
||||
UINTN NumBlocks;
|
||||
BOOLEAN CccSwitch;
|
||||
SCR Scr;
|
||||
EFI_STATUS Status;
|
||||
EFI_MMC_HOST_PROTOCOL *MmcHost;
|
||||
|
||||
Speed = SD_DEFAULT_SPEED;
|
||||
Speed = SD_DEFAULT_SPEED;
|
||||
MmcHost = MmcHostInstance->MmcHost;
|
||||
|
||||
// Send a command to get Card specific data
|
||||
CmdArg = MmcHostInstance->CardInfo.RCA << 16;
|
||||
Status = MmcHost->SendCommand (MmcHost, MMC_CMD9, CmdArg);
|
||||
if (EFI_ERROR (Status)) {
|
||||
DEBUG((DEBUG_ERROR, "InitializeSdMmcDevice(MMC_CMD9): Error, Status=%r\n", Status));
|
||||
DEBUG ((DEBUG_ERROR, "InitializeSdMmcDevice(MMC_CMD9): Error, Status=%r\n", Status));
|
||||
return Status;
|
||||
}
|
||||
|
||||
// Read Response
|
||||
Status = MmcHost->ReceiveResponse (MmcHost, MMC_RESPONSE_TYPE_CSD, Response);
|
||||
if (EFI_ERROR (Status)) {
|
||||
DEBUG((DEBUG_ERROR, "InitializeSdMmcDevice(): Failed to receive CSD, Status=%r\n", Status));
|
||||
DEBUG ((DEBUG_ERROR, "InitializeSdMmcDevice(): Failed to receive CSD, Status=%r\n", Status));
|
||||
return Status;
|
||||
}
|
||||
|
||||
PrintCSD (Response);
|
||||
if (MMC_CSD_GET_CCC(Response) & SD_CCC_SWITCH) {
|
||||
if (MMC_CSD_GET_CCC (Response) & SD_CCC_SWITCH) {
|
||||
CccSwitch = TRUE;
|
||||
} else {
|
||||
CccSwitch = FALSE;
|
||||
}
|
||||
|
||||
if (MmcHostInstance->CardInfo.CardType == SD_CARD_2_HIGH) {
|
||||
CardSize = HC_MMC_CSD_GET_DEVICESIZE (Response);
|
||||
CardSize = HC_MMC_CSD_GET_DEVICESIZE (Response);
|
||||
NumBlocks = ((CardSize + 1) * 1024);
|
||||
BlockSize = 1 << MMC_CSD_GET_READBLLEN (Response);
|
||||
} else {
|
||||
CardSize = MMC_CSD_GET_DEVICESIZE (Response);
|
||||
CardSize = MMC_CSD_GET_DEVICESIZE (Response);
|
||||
NumBlocks = (CardSize + 1) * (1 << (MMC_CSD_GET_DEVICESIZEMULT (Response) + 2));
|
||||
BlockSize = 1 << MMC_CSD_GET_READBLLEN (Response);
|
||||
}
|
||||
@@ -395,7 +408,7 @@ InitializeSdMmcDevice (
|
||||
CmdArg = MmcHostInstance->CardInfo.RCA << 16;
|
||||
Status = MmcHost->SendCommand (MmcHost, MMC_CMD7, CmdArg);
|
||||
if (EFI_ERROR (Status)) {
|
||||
DEBUG((DEBUG_ERROR, "InitializeSdMmcDevice(MMC_CMD7): Error and Status = %r\n", Status));
|
||||
DEBUG ((DEBUG_ERROR, "InitializeSdMmcDevice(MMC_CMD7): Error and Status = %r\n", Status));
|
||||
return Status;
|
||||
}
|
||||
|
||||
@@ -404,11 +417,13 @@ InitializeSdMmcDevice (
|
||||
DEBUG ((DEBUG_ERROR, "%a (MMC_CMD55): Error and Status = %r\n", __FUNCTION__, Status));
|
||||
return Status;
|
||||
}
|
||||
|
||||
Status = MmcHost->ReceiveResponse (MmcHost, MMC_RESPONSE_TYPE_R1, Response);
|
||||
if (EFI_ERROR (Status)) {
|
||||
DEBUG ((DEBUG_ERROR, "%a (MMC_CMD55): Error and Status = %r\n", __FUNCTION__, Status));
|
||||
return Status;
|
||||
}
|
||||
|
||||
if ((Response[0] & MMC_STATUS_APP_CMD) == 0) {
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
@@ -424,40 +439,42 @@ InitializeSdMmcDevice (
|
||||
DEBUG ((DEBUG_ERROR, "%a(MMC_ACMD51): ReadBlockData Error and Status = %r\n", __func__, Status));
|
||||
return Status;
|
||||
}
|
||||
|
||||
CopyMem (&Scr, Buffer, 8);
|
||||
if (Scr.SD_SPEC == 2) {
|
||||
if (Scr.SD_SPEC3 == 1) {
|
||||
if (Scr.SD_SPEC4 == 1) {
|
||||
if (Scr.SD_SPEC4 == 1) {
|
||||
DEBUG ((DEBUG_INFO, "Found SD Card for Spec Version 4.xx\n"));
|
||||
} else {
|
||||
} else {
|
||||
DEBUG ((DEBUG_INFO, "Found SD Card for Spec Version 3.0x\n"));
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if (Scr.SD_SPEC4 == 0) {
|
||||
if (Scr.SD_SPEC4 == 0) {
|
||||
DEBUG ((DEBUG_INFO, "Found SD Card for Spec Version 2.0\n"));
|
||||
} else {
|
||||
DEBUG ((DEBUG_ERROR, "Found invalid SD Card\n"));
|
||||
}
|
||||
} else {
|
||||
DEBUG ((DEBUG_ERROR, "Found invalid SD Card\n"));
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if ((Scr.SD_SPEC3 == 0) && (Scr.SD_SPEC4 == 0)) {
|
||||
if (Scr.SD_SPEC == 1) {
|
||||
DEBUG ((DEBUG_INFO, "Found SD Card for Spec Version 1.10\n"));
|
||||
} else {
|
||||
DEBUG ((DEBUG_INFO, "Found SD Card for Spec Version 1.0\n"));
|
||||
}
|
||||
DEBUG ((DEBUG_INFO, "Found SD Card for Spec Version 1.10\n"));
|
||||
} else {
|
||||
DEBUG ((DEBUG_INFO, "Found SD Card for Spec Version 1.0\n"));
|
||||
}
|
||||
} else {
|
||||
DEBUG ((DEBUG_ERROR, "Found invalid SD Card\n"));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (CccSwitch) {
|
||||
/* SD Switch, Mode:0, Group:0, Value:0 */
|
||||
CmdArg = CreateSwitchCmdArgument(0, 0, 0);
|
||||
CmdArg = CreateSwitchCmdArgument (0, 0, 0);
|
||||
Status = MmcHost->SendCommand (MmcHost, MMC_CMD6, CmdArg);
|
||||
if (EFI_ERROR (Status)) {
|
||||
DEBUG ((DEBUG_ERROR, "%a (MMC_CMD6): Error and Status = %r\n", __FUNCTION__, Status));
|
||||
return Status;
|
||||
return Status;
|
||||
} else {
|
||||
Status = MmcHost->ReadBlockData (MmcHost, 0, SWITCH_CMD_DATA_LENGTH, Buffer);
|
||||
if (EFI_ERROR (Status)) {
|
||||
@@ -472,7 +489,7 @@ InitializeSdMmcDevice (
|
||||
Speed = SD_HIGH_SPEED;
|
||||
|
||||
/* SD Switch, Mode:1, Group:0, Value:1 */
|
||||
CmdArg = CreateSwitchCmdArgument(1, 0, 1);
|
||||
CmdArg = CreateSwitchCmdArgument (1, 0, 1);
|
||||
Status = MmcHost->SendCommand (MmcHost, MMC_CMD6, CmdArg);
|
||||
if (EFI_ERROR (Status)) {
|
||||
DEBUG ((DEBUG_ERROR, "%a (MMC_CMD6): Error and Status = %r\n", __FUNCTION__, Status));
|
||||
@@ -485,12 +502,13 @@ InitializeSdMmcDevice (
|
||||
}
|
||||
|
||||
if ((Buffer[4] & SWITCH_CMD_SUCCESS_MASK) != 0x01000000) {
|
||||
DEBUG((DEBUG_ERROR, "Problem switching SD card into high-speed mode\n"));
|
||||
DEBUG ((DEBUG_ERROR, "Problem switching SD card into high-speed mode\n"));
|
||||
return Status;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (Scr.SD_BUS_WIDTHS & SD_BUS_WIDTH_4BIT) {
|
||||
CmdArg = MmcHostInstance->CardInfo.RCA << 16;
|
||||
Status = MmcHost->SendCommand (MmcHost, MMC_CMD55, CmdArg);
|
||||
@@ -498,6 +516,7 @@ InitializeSdMmcDevice (
|
||||
DEBUG ((DEBUG_ERROR, "%a (MMC_CMD55): Error and Status = %r\n", __FUNCTION__, Status));
|
||||
return Status;
|
||||
}
|
||||
|
||||
/* Width: 4 */
|
||||
Status = MmcHost->SendCommand (MmcHost, MMC_CMD6, 2);
|
||||
if (EFI_ERROR (Status)) {
|
||||
@@ -505,13 +524,15 @@ InitializeSdMmcDevice (
|
||||
return Status;
|
||||
}
|
||||
}
|
||||
if (MMC_HOST_HAS_SETIOS(MmcHost)) {
|
||||
|
||||
if (MMC_HOST_HAS_SETIOS (MmcHost)) {
|
||||
Status = MmcHost->SetIos (MmcHost, Speed, BUSWIDTH_4, EMMCBACKWARD);
|
||||
if (EFI_ERROR (Status)) {
|
||||
DEBUG ((DEBUG_ERROR, "%a (SetIos): Error and Status = %r\n", __FUNCTION__, Status));
|
||||
return Status;
|
||||
}
|
||||
}
|
||||
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
|
||||
@@ -519,20 +540,20 @@ STATIC
|
||||
EFI_STATUS
|
||||
EFIAPI
|
||||
MmcIdentificationMode (
|
||||
IN MMC_HOST_INSTANCE *MmcHostInstance
|
||||
IN MMC_HOST_INSTANCE *MmcHostInstance
|
||||
)
|
||||
{
|
||||
EFI_STATUS Status;
|
||||
UINT32 Response[4];
|
||||
UINTN Timeout;
|
||||
UINTN CmdArg;
|
||||
BOOLEAN IsHCS;
|
||||
EFI_MMC_HOST_PROTOCOL *MmcHost;
|
||||
OCR_RESPONSE OcrResponse;
|
||||
EFI_STATUS Status;
|
||||
UINT32 Response[4];
|
||||
UINTN Timeout;
|
||||
UINTN CmdArg;
|
||||
BOOLEAN IsHCS;
|
||||
EFI_MMC_HOST_PROTOCOL *MmcHost;
|
||||
OCR_RESPONSE OcrResponse;
|
||||
|
||||
MmcHost = MmcHostInstance->MmcHost;
|
||||
CmdArg = 0;
|
||||
IsHCS = FALSE;
|
||||
CmdArg = 0;
|
||||
IsHCS = FALSE;
|
||||
|
||||
if (MmcHost == NULL) {
|
||||
return EFI_INVALID_PARAMETER;
|
||||
@@ -553,6 +574,7 @@ MmcIdentificationMode (
|
||||
DEBUG ((DEBUG_ERROR, "MmcIdentificationMode(MMC_CMD0): Error, Status=%r.\n", Status));
|
||||
return Status;
|
||||
}
|
||||
|
||||
Status = MmcNotifyState (MmcHostInstance, MmcIdleState);
|
||||
if (EFI_ERROR (Status)) {
|
||||
DEBUG ((DEBUG_ERROR, "MmcIdentificationMode() : Error MmcIdleState, Status=%r.\n", Status));
|
||||
@@ -564,30 +586,36 @@ MmcIdentificationMode (
|
||||
Timeout = MAX_RETRY_COUNT;
|
||||
do {
|
||||
Status = MmcHost->SendCommand (MmcHost, MMC_CMD1, EMMC_CMD1_CAPACITY_GREATER_THAN_2GB);
|
||||
if (EFI_ERROR (Status))
|
||||
if (EFI_ERROR (Status)) {
|
||||
break;
|
||||
}
|
||||
|
||||
Status = MmcHost->ReceiveResponse (MmcHost, MMC_RESPONSE_TYPE_OCR, (UINT32 *)&OcrResponse);
|
||||
if (EFI_ERROR (Status)) {
|
||||
DEBUG ((DEBUG_ERROR, "MmcIdentificationMode() : Failed to receive OCR, Status=%r.\n", Status));
|
||||
return Status;
|
||||
}
|
||||
|
||||
Timeout--;
|
||||
} while (!OcrResponse.Ocr.PowerUp && (Timeout > 0));
|
||||
|
||||
if (Status == EFI_SUCCESS) {
|
||||
if (!OcrResponse.Ocr.PowerUp) {
|
||||
DEBUG ((DEBUG_ERROR, "MmcIdentificationMode(MMC_CMD1): Card initialisation failure, Status=%r.\n", Status));
|
||||
return EFI_DEVICE_ERROR;
|
||||
}
|
||||
|
||||
OcrResponse.Ocr.PowerUp = 0;
|
||||
if (OcrResponse.Raw == EMMC_CMD1_CAPACITY_GREATER_THAN_2GB) {
|
||||
MmcHostInstance->CardInfo.OCRData.AccessMode = BIT1;
|
||||
}
|
||||
else {
|
||||
} else {
|
||||
MmcHostInstance->CardInfo.OCRData.AccessMode = 0x0;
|
||||
}
|
||||
|
||||
// Check whether MMC or eMMC
|
||||
if (OcrResponse.Raw == EMMC_CMD1_CAPACITY_GREATER_THAN_2GB ||
|
||||
OcrResponse.Raw == EMMC_CMD1_CAPACITY_LESS_THAN_2GB) {
|
||||
if ((OcrResponse.Raw == EMMC_CMD1_CAPACITY_GREATER_THAN_2GB) ||
|
||||
(OcrResponse.Raw == EMMC_CMD1_CAPACITY_LESS_THAN_2GB))
|
||||
{
|
||||
return EmmcIdentificationMode (MmcHostInstance, OcrResponse);
|
||||
}
|
||||
}
|
||||
@@ -604,12 +632,13 @@ MmcIdentificationMode (
|
||||
Status = MmcHost->SendCommand (MmcHost, MMC_CMD8, CmdArg);
|
||||
if (Status == EFI_SUCCESS) {
|
||||
DEBUG ((DEBUG_ERROR, "Card is SD2.0 => Supports high capacity\n"));
|
||||
IsHCS = TRUE;
|
||||
IsHCS = TRUE;
|
||||
Status = MmcHost->ReceiveResponse (MmcHost, MMC_RESPONSE_TYPE_R7, Response);
|
||||
if (EFI_ERROR (Status)) {
|
||||
DEBUG ((DEBUG_ERROR, "MmcIdentificationMode() : Failed to receive response to CMD8, Status=%r.\n", Status));
|
||||
return Status;
|
||||
}
|
||||
|
||||
PrintResponseR1 (Response[0]);
|
||||
// Check if it is valid response
|
||||
if (Response[0] != CmdArg) {
|
||||
@@ -634,10 +663,11 @@ MmcIdentificationMode (
|
||||
}
|
||||
|
||||
// Note: The first time CmdArg will be zero
|
||||
CmdArg = ((UINTN *) &(MmcHostInstance->CardInfo.OCRData))[0];
|
||||
CmdArg = ((UINTN *)&(MmcHostInstance->CardInfo.OCRData))[0];
|
||||
if (IsHCS) {
|
||||
CmdArg |= BIT30;
|
||||
}
|
||||
|
||||
Status = MmcHost->SendCommand (MmcHost, MMC_ACMD41, CmdArg);
|
||||
if (!EFI_ERROR (Status)) {
|
||||
Status = MmcHost->ReceiveResponse (MmcHost, MMC_RESPONSE_TYPE_OCR, Response);
|
||||
@@ -645,7 +675,8 @@ MmcIdentificationMode (
|
||||
DEBUG ((DEBUG_ERROR, "MmcIdentificationMode() : Failed to receive OCR, Status=%r.\n", Status));
|
||||
return Status;
|
||||
}
|
||||
((UINT32 *) &(MmcHostInstance->CardInfo.OCRData))[0] = Response[0];
|
||||
|
||||
((UINT32 *)&(MmcHostInstance->CardInfo.OCRData))[0] = Response[0];
|
||||
}
|
||||
} else {
|
||||
DEBUG ((DEBUG_INFO, "Card should be MMC\n"));
|
||||
@@ -658,7 +689,8 @@ MmcIdentificationMode (
|
||||
DEBUG ((DEBUG_ERROR, "MmcIdentificationMode() : Failed to receive OCR, Status=%r.\n", Status));
|
||||
return Status;
|
||||
}
|
||||
((UINT32 *) &(MmcHostInstance->CardInfo.OCRData))[0] = Response[0];
|
||||
|
||||
((UINT32 *)&(MmcHostInstance->CardInfo.OCRData))[0] = Response[0];
|
||||
}
|
||||
}
|
||||
|
||||
@@ -671,6 +703,7 @@ MmcIdentificationMode (
|
||||
MmcHostInstance->CardInfo.CardType = SD_CARD_2_HIGH;
|
||||
DEBUG ((DEBUG_ERROR, "High capacity card.\n"));
|
||||
}
|
||||
|
||||
break; // The MMC/SD card is ready. Continue the Identification Mode
|
||||
}
|
||||
} else {
|
||||
@@ -697,6 +730,7 @@ MmcIdentificationMode (
|
||||
DEBUG ((DEBUG_ERROR, "MmcIdentificationMode(MMC_CMD2): Error\n"));
|
||||
return Status;
|
||||
}
|
||||
|
||||
Status = MmcHost->ReceiveResponse (MmcHost, MMC_RESPONSE_TYPE_CID, Response);
|
||||
if (EFI_ERROR (Status)) {
|
||||
DEBUG ((DEBUG_ERROR, "MmcIdentificationMode() : Failed to receive CID, Status=%r.\n", Status));
|
||||
@@ -728,6 +762,7 @@ MmcIdentificationMode (
|
||||
DEBUG ((DEBUG_ERROR, "MmcIdentificationMode() : Failed to receive RCA, Status=%r.\n", Status));
|
||||
return Status;
|
||||
}
|
||||
|
||||
PrintRCA (Response[0]);
|
||||
|
||||
// For MMC card, RCA is assigned by CMD3 while CMD3 dumps the RCA for SD card
|
||||
@@ -736,6 +771,7 @@ MmcIdentificationMode (
|
||||
} else {
|
||||
MmcHostInstance->CardInfo.RCA = CmdArg;
|
||||
}
|
||||
|
||||
Status = MmcNotifyState (MmcHostInstance, MmcStandByState);
|
||||
if (EFI_ERROR (Status)) {
|
||||
DEBUG ((DEBUG_ERROR, "MmcIdentificationMode() : Error MmcStandByState\n"));
|
||||
@@ -747,25 +783,25 @@ MmcIdentificationMode (
|
||||
|
||||
EFI_STATUS
|
||||
InitializeMmcDevice (
|
||||
IN MMC_HOST_INSTANCE *MmcHostInstance
|
||||
IN MMC_HOST_INSTANCE *MmcHostInstance
|
||||
)
|
||||
{
|
||||
EFI_STATUS Status;
|
||||
EFI_MMC_HOST_PROTOCOL *MmcHost;
|
||||
UINTN BlockCount;
|
||||
EFI_STATUS Status;
|
||||
EFI_MMC_HOST_PROTOCOL *MmcHost;
|
||||
UINTN BlockCount;
|
||||
|
||||
BlockCount = 1;
|
||||
MmcHost = MmcHostInstance->MmcHost;
|
||||
MmcHost = MmcHostInstance->MmcHost;
|
||||
|
||||
Status = MmcIdentificationMode (MmcHostInstance);
|
||||
if (EFI_ERROR (Status)) {
|
||||
DEBUG((DEBUG_ERROR, "InitializeMmcDevice(): Error in Identification Mode, Status=%r\n", Status));
|
||||
DEBUG ((DEBUG_ERROR, "InitializeMmcDevice(): Error in Identification Mode, Status=%r\n", Status));
|
||||
return Status;
|
||||
}
|
||||
|
||||
Status = MmcNotifyState (MmcHostInstance, MmcTransferState);
|
||||
if (EFI_ERROR (Status)) {
|
||||
DEBUG((DEBUG_ERROR, "InitializeMmcDevice(): Error MmcTransferState, Status=%r\n", Status));
|
||||
DEBUG ((DEBUG_ERROR, "InitializeMmcDevice(): Error MmcTransferState, Status=%r\n", Status));
|
||||
return Status;
|
||||
}
|
||||
|
||||
@@ -774,6 +810,7 @@ InitializeMmcDevice (
|
||||
} else {
|
||||
Status = InitializeEmmcDevice (MmcHostInstance);
|
||||
}
|
||||
|
||||
if (EFI_ERROR (Status)) {
|
||||
return Status;
|
||||
}
|
||||
@@ -781,8 +818,12 @@ InitializeMmcDevice (
|
||||
// Set Block Length
|
||||
Status = MmcHost->SendCommand (MmcHost, MMC_CMD16, MmcHostInstance->BlockIo.Media->BlockSize);
|
||||
if (EFI_ERROR (Status)) {
|
||||
DEBUG((DEBUG_ERROR, "InitializeMmcDevice(MMC_CMD16): Error MmcHostInstance->BlockIo.Media->BlockSize: %d and Error = %r\n",
|
||||
MmcHostInstance->BlockIo.Media->BlockSize, Status));
|
||||
DEBUG ((
|
||||
DEBUG_ERROR,
|
||||
"InitializeMmcDevice(MMC_CMD16): Error MmcHostInstance->BlockIo.Media->BlockSize: %d and Error = %r\n",
|
||||
MmcHostInstance->BlockIo.Media->BlockSize,
|
||||
Status
|
||||
));
|
||||
return Status;
|
||||
}
|
||||
|
||||
@@ -790,7 +831,7 @@ InitializeMmcDevice (
|
||||
if (MmcHostInstance->CardInfo.CardType == MMC_CARD) {
|
||||
Status = MmcHost->SendCommand (MmcHost, MMC_CMD23, BlockCount);
|
||||
if (EFI_ERROR (Status)) {
|
||||
DEBUG((DEBUG_ERROR, "InitializeMmcDevice(MMC_CMD23): Error, Status=%r\n", Status));
|
||||
DEBUG ((DEBUG_ERROR, "InitializeMmcDevice(MMC_CMD23): Error, Status=%r\n", Status));
|
||||
return Status;
|
||||
}
|
||||
}
|
||||
|
Reference in New Issue
Block a user