diff options
| author | Michael Kubacki <michael.kubacki@microsoft.com> | 2021-12-05 14:53:56 -0800 |
|---|---|---|
| committer | mergify[bot] <37929162+mergify[bot]@users.noreply.github.com> | 2021-12-07 17:24:28 +0000 |
| commit | e7108d0e9655b1795c94ac372b0449f28dd907df (patch) | |
| tree | b153716589979b9e42e9b85281ff8b7511ba272f /EmbeddedPkg/Universal/MmcDxe | |
| parent | 731c67e1d77b7741a91762d17659fc9fbcb9e305 (diff) | |
| download | edk2-e7108d0e9655b1795c94ac372b0449f28dd907df.tar.gz edk2-e7108d0e9655b1795c94ac372b0449f28dd907df.tar.bz2 edk2-e7108d0e9655b1795c94ac372b0449f28dd907df.zip | |
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>
Diffstat (limited to 'EmbeddedPkg/Universal/MmcDxe')
| -rw-r--r-- | EmbeddedPkg/Universal/MmcDxe/ComponentName.c | 22 | ||||
| -rw-r--r-- | EmbeddedPkg/Universal/MmcDxe/Diagnostics.c | 114 | ||||
| -rw-r--r-- | EmbeddedPkg/Universal/MmcDxe/Mmc.c | 279 | ||||
| -rw-r--r-- | EmbeddedPkg/Universal/MmcDxe/Mmc.h | 625 | ||||
| -rw-r--r-- | EmbeddedPkg/Universal/MmcDxe/MmcBlockIo.c | 183 | ||||
| -rw-r--r-- | EmbeddedPkg/Universal/MmcDxe/MmcDebug.c | 107 | ||||
| -rwxr-xr-x | EmbeddedPkg/Universal/MmcDxe/MmcIdentification.c | 347 |
7 files changed, 875 insertions, 802 deletions
diff --git a/EmbeddedPkg/Universal/MmcDxe/ComponentName.c b/EmbeddedPkg/Universal/MmcDxe/ComponentName.c index f5db121782..94ed690028 100644 --- a/EmbeddedPkg/Universal/MmcDxe/ComponentName.c +++ b/EmbeddedPkg/Universal/MmcDxe/ComponentName.c @@ -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;
diff --git a/EmbeddedPkg/Universal/MmcDxe/Diagnostics.c b/EmbeddedPkg/Universal/MmcDxe/Diagnostics.c index 54ab95dbd3..0b27f9dcda 100644 --- a/EmbeddedPkg/Universal/MmcDxe/Diagnostics.c +++ b/EmbeddedPkg/Universal/MmcDxe/Diagnostics.c @@ -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"
};
diff --git a/EmbeddedPkg/Universal/MmcDxe/Mmc.c b/EmbeddedPkg/Universal/MmcDxe/Mmc.c index d33f7f0a49..7f4df56fc8 100644 --- a/EmbeddedPkg/Universal/MmcDxe/Mmc.c +++ b/EmbeddedPkg/Universal/MmcDxe/Mmc.c @@ -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)
- );
-
- if (EFI_ERROR(Status)) {
- Print(L"MMC Card: Error reinstalling BlockIo interface\n");
+ (MmcHostInstance->MmcHandle),
+ &gEfiBlockIoProtocolGuid,
+ &(MmcHostInstance->BlockIo),
+ &(MmcHostInstance->BlockIo)
+ );
+
+ 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;
diff --git a/EmbeddedPkg/Universal/MmcDxe/Mmc.h b/EmbeddedPkg/Universal/MmcDxe/Mmc.h index ad9804bb9a..23cabb7cf5 100644 --- a/EmbeddedPkg/Universal/MmcDxe/Mmc.h +++ b/EmbeddedPkg/Universal/MmcDxe/Mmc.h @@ -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 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]
-
- 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]
-
- 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 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]
+
+ 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 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 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
diff --git a/EmbeddedPkg/Universal/MmcDxe/MmcBlockIo.c b/EmbeddedPkg/Universal/MmcDxe/MmcBlockIo.c index 7614ecdf0a..d695e25571 100644 --- a/EmbeddedPkg/Universal/MmcDxe/MmcBlockIo.c +++ b/EmbeddedPkg/Universal/MmcDxe/MmcBlockIo.c @@ -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;
-
- BlockCount = 1;
+ 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;
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);
diff --git a/EmbeddedPkg/Universal/MmcDxe/MmcDebug.c b/EmbeddedPkg/Universal/MmcDxe/MmcDebug.c index 3f23a13c8b..cf1b97fb9e 100644 --- a/EmbeddedPkg/Universal/MmcDxe/MmcDebug.c +++ b/EmbeddedPkg/Universal/MmcDxe/MmcDebug.c @@ -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;
}
}
diff --git a/EmbeddedPkg/Universal/MmcDxe/MmcIdentification.c b/EmbeddedPkg/Universal/MmcDxe/MmcIdentification.c index 0df948426f..86eb55800e 100755 --- a/EmbeddedPkg/Universal/MmcDxe/MmcIdentification.c +++ b/EmbeddedPkg/Universal/MmcDxe/MmcIdentification.c @@ -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;
-
- 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);
+ 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);
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)
+ if (ECSDData->DEVICE_TYPE == EMMCBACKWARD) {
return EFI_SUCCESS;
+ }
- if (!MMC_HOST_HAS_SETIOS(Host)) {
+ 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;
-
- Speed = SD_DEFAULT_SPEED;
+ 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;
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;
}
}
|