sravan/system76-edk2
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

EmbeddedPkg: Apply uncrustify changes

Browse Source 
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:
Michael Kubacki
2021-12-05 14:53:56 -08:00
committed by mergify[bot]
parent 731c67e1d7
commit e7108d0e96
106 changed files with 9242 additions and 7648 deletions
Download Patch File Download Diff File Expand all files Collapse all files

22
EmbeddedPkg/Universal/MmcDxe/ComponentName.c
View File

@@ -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;

114
EmbeddedPkg/Universal/MmcDxe/Diagnostics.c
View File

@@ -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"
};

277
EmbeddedPkg/Universal/MmcDxe/Mmc.c
View File

@@ -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;

613
EmbeddedPkg/Universal/MmcDxe/Mmc.h
View File

@@ -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

181
EmbeddedPkg/Universal/MmcDxe/MmcBlockIo.c
View File

@@ -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);

107
EmbeddedPkg/Universal/MmcDxe/MmcDebug.c
View File

@@ -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;
}
}

347
EmbeddedPkg/Universal/MmcDxe/MmcIdentification.c
View File

@@ -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;
}
}