3 * Copyright (c) 2011-2014, ARM Limited. All rights reserved.
5 * This program and the accompanying materials
6 * are licensed and made available under the terms and conditions of the BSD License
7 * which accompanies this distribution. The full text of the license may be found at
8 * http://opensource.org/licenses/bsd-license.php
10 * THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
15 #include <Library/TimerLib.h>
24 #define MAX_RETRY_COUNT 1000
25 #define CMD_RETRY_COUNT 20
26 #define RCA_SHIFT_OFFSET 16
27 #define EMMC_CARD_SIZE 512
28 #define EMMC_ECSD_SIZE_OFFSET 53
30 UINT32 mEmmcRcaCount
= 0;
35 EmmcIdentificationMode (
36 IN MMC_HOST_INSTANCE
*MmcHostInstance
,
37 IN OCR_RESPONSE Response
40 EFI_MMC_HOST_PROTOCOL
*Host
;
41 EFI_BLOCK_IO_MEDIA
*Media
;
46 Host
= MmcHostInstance
->MmcHost
;
47 Media
= MmcHostInstance
->BlockIo
.Media
;
49 // Fetch card identity register
50 Status
= Host
->SendCommand (Host
, MMC_CMD2
, 0);
51 if (EFI_ERROR (Status
)) {
52 DEBUG ((EFI_D_ERROR
, "EmmcIdentificationMode(): Failed to send CMD2, Status=%r.\n", Status
));
56 Status
= Host
->ReceiveResponse (Host
, MMC_RESPONSE_TYPE_R2
, (UINT32
*)&(MmcHostInstance
->CardInfo
.CIDData
));
57 if (EFI_ERROR (Status
)) {
58 DEBUG ((EFI_D_ERROR
, "EmmcIdentificationMode(): CID retrieval error, Status=%r.\n", Status
));
62 // Assign a relative address value to the card
63 MmcHostInstance
->CardInfo
.RCA
= ++mEmmcRcaCount
; // TODO: might need a more sophisticated way of doing this
64 RCA
= MmcHostInstance
->CardInfo
.RCA
<< RCA_SHIFT_OFFSET
;
65 Status
= Host
->SendCommand (Host
, MMC_CMD3
, RCA
);
66 if (EFI_ERROR (Status
)) {
67 DEBUG ((EFI_D_ERROR
, "EmmcIdentificationMode(): RCA set error, Status=%r.\n", Status
));
71 // Fetch card specific data
72 Status
= Host
->SendCommand (Host
, MMC_CMD9
, RCA
);
73 if (EFI_ERROR (Status
)) {
74 DEBUG ((EFI_D_ERROR
, "EmmcIdentificationMode(): Failed to send CMD9, Status=%r.\n", Status
));
78 Status
= Host
->ReceiveResponse (Host
, MMC_RESPONSE_TYPE_R2
, (UINT32
*)&(MmcHostInstance
->CardInfo
.CSDData
));
79 if (EFI_ERROR (Status
)) {
80 DEBUG ((EFI_D_ERROR
, "EmmcIdentificationMode(): CSD retrieval error, Status=%r.\n", Status
));
85 Status
= Host
->SendCommand (Host
, MMC_CMD7
, RCA
);
86 if (EFI_ERROR (Status
)) {
87 DEBUG ((EFI_D_ERROR
, "EmmcIdentificationMode(): Card selection error, Status=%r.\n", Status
));
91 Status
= Host
->SendCommand (Host
, MMC_CMD8
, RCA
);
92 if (EFI_ERROR (Status
)) {
93 DEBUG ((EFI_D_ERROR
, "EmmcIdentificationMode(): ECSD fetch error, Status=%r.\n", Status
));
96 Status
= Host
->ReadBlockData (Host
, 0, 512, ECSD
);
97 if (EFI_ERROR (Status
)) {
98 DEBUG ((EFI_D_ERROR
, "EmmcIdentificationMode(): ECSD read error, Status=%r.\n", Status
));
103 Media
->BlockSize
= EMMC_CARD_SIZE
; // 512-byte support is mandatory for eMMC cards
104 Media
->MediaId
= MmcHostInstance
->CardInfo
.CIDData
.PSN
;
105 Media
->ReadOnly
= MmcHostInstance
->CardInfo
.CSDData
.PERM_WRITE_PROTECT
;
106 Media
->LogicalBlocksPerPhysicalBlock
= 1;
108 // Compute last block using bits [215:212] of the ECSD
109 Media
->LastBlock
= ECSD
[EMMC_ECSD_SIZE_OFFSET
] - 1; // eMMC isn't supposed to report this for
110 // Cards <2GB in size, but the model does.
113 MmcHostInstance
->CardInfo
.CardType
= EMMC_CARD
;
119 InitializeSdMmcDevice (
120 IN MMC_HOST_INSTANCE
*MmcHostInstance
129 EFI_MMC_HOST_PROTOCOL
*MmcHost
;
131 MmcHost
= MmcHostInstance
->MmcHost
;
133 // Send a command to get Card specific data
134 CmdArg
= MmcHostInstance
->CardInfo
.RCA
<< 16;
135 Status
= MmcHost
->SendCommand (MmcHost
, MMC_CMD9
, CmdArg
);
136 if (EFI_ERROR (Status
)) {
137 DEBUG((EFI_D_ERROR
, "InitializeSdMmcDevice(MMC_CMD9): Error, Status=%r\n", Status
));
142 Status
= MmcHost
->ReceiveResponse (MmcHost
, MMC_RESPONSE_TYPE_CSD
, Response
);
143 if (EFI_ERROR (Status
)) {
144 DEBUG((EFI_D_ERROR
, "InitializeSdMmcDevice(): Failed to receive CSD, Status=%r\n", Status
));
149 if (MmcHostInstance
->CardInfo
.CardType
== SD_CARD_2_HIGH
) {
150 CardSize
= HC_MMC_CSD_GET_DEVICESIZE (Response
);
151 NumBlocks
= ((CardSize
+ 1) * 1024);
152 BlockSize
= 1 << MMC_CSD_GET_READBLLEN (Response
);
154 CardSize
= MMC_CSD_GET_DEVICESIZE (Response
);
155 NumBlocks
= (CardSize
+ 1) * (1 << (MMC_CSD_GET_DEVICESIZEMULT (Response
) + 2));
156 BlockSize
= 1 << MMC_CSD_GET_READBLLEN (Response
);
159 // For >=2G card, BlockSize may be 1K, but the transfer size is 512 bytes.
160 if (BlockSize
> 512) {
161 NumBlocks
= MultU64x32 (NumBlocks
, BlockSize
/ 512);
165 MmcHostInstance
->BlockIo
.Media
->LastBlock
= (NumBlocks
- 1);
166 MmcHostInstance
->BlockIo
.Media
->BlockSize
= BlockSize
;
167 MmcHostInstance
->BlockIo
.Media
->ReadOnly
= MmcHost
->IsReadOnly (MmcHost
);
168 MmcHostInstance
->BlockIo
.Media
->MediaPresent
= TRUE
;
169 MmcHostInstance
->BlockIo
.Media
->MediaId
++;
171 CmdArg
= MmcHostInstance
->CardInfo
.RCA
<< 16;
172 Status
= MmcHost
->SendCommand (MmcHost
, MMC_CMD7
, CmdArg
);
173 if (EFI_ERROR (Status
)) {
174 DEBUG((EFI_D_ERROR
, "InitializeSdMmcDevice(MMC_CMD7): Error and Status = %r\n", Status
));
184 MmcIdentificationMode (
185 IN MMC_HOST_INSTANCE
*MmcHostInstance
193 EFI_MMC_HOST_PROTOCOL
*MmcHost
;
194 OCR_RESPONSE OcrResponse
;
196 MmcHost
= MmcHostInstance
->MmcHost
;
200 if (MmcHost
== NULL
) {
201 return EFI_INVALID_PARAMETER
;
204 // We can get into this function if we restart the identification mode
205 if (MmcHostInstance
->State
== MmcHwInitializationState
) {
206 // Initialize the MMC Host HW
207 Status
= MmcNotifyState (MmcHostInstance
, MmcHwInitializationState
);
208 if (EFI_ERROR (Status
)) {
209 DEBUG ((EFI_D_ERROR
, "MmcIdentificationMode() : Error MmcHwInitializationState, Status=%r.\n", Status
));
214 Status
= MmcHost
->SendCommand (MmcHost
, MMC_CMD0
, 0);
215 if (EFI_ERROR (Status
)) {
216 DEBUG ((EFI_D_ERROR
, "MmcIdentificationMode(MMC_CMD0): Error, Status=%r.\n", Status
));
219 Status
= MmcNotifyState (MmcHostInstance
, MmcIdleState
);
220 if (EFI_ERROR (Status
)) {
221 DEBUG ((EFI_D_ERROR
, "MmcIdentificationMode() : Error MmcIdleState, Status=%r.\n", Status
));
225 // Send CMD1 to get OCR (MMC)
226 // This command only valid for MMC and eMMC
227 Status
= MmcHost
->SendCommand (MmcHost
, MMC_CMD1
, EMMC_CMD1_CAPACITY_GREATER_THAN_2GB
);
228 if (Status
== EFI_SUCCESS
) {
229 Status
= MmcHost
->ReceiveResponse (MmcHost
, MMC_RESPONSE_TYPE_OCR
, (UINT32
*)&OcrResponse
);
230 if (EFI_ERROR (Status
)) {
231 DEBUG ((EFI_D_ERROR
, "MmcIdentificationMode() : Failed to receive OCR, Status=%r.\n", Status
));
235 if (!OcrResponse
.Ocr
.PowerUp
) {
236 DEBUG ((EFI_D_ERROR
, "MmcIdentificationMode(MMC_CMD1): Card initialisation failure, Status=%r.\n", Status
));
237 return EFI_DEVICE_ERROR
;
239 OcrResponse
.Ocr
.PowerUp
= 0;
240 if (OcrResponse
.Raw
== EMMC_CMD1_CAPACITY_GREATER_THAN_2GB
) {
241 MmcHostInstance
->CardInfo
.OCRData
.AccessMode
= BIT1
;
244 MmcHostInstance
->CardInfo
.OCRData
.AccessMode
= 0x0;
246 // Check whether MMC or eMMC
247 if (OcrResponse
.Raw
== EMMC_CMD1_CAPACITY_GREATER_THAN_2GB
||
248 OcrResponse
.Raw
== EMMC_CMD1_CAPACITY_LESS_THAN_2GB
) {
249 return EmmcIdentificationMode (MmcHostInstance
, OcrResponse
);
253 // Are we using SDIO ?
254 Status
= MmcHost
->SendCommand (MmcHost
, MMC_CMD5
, 0);
255 if (Status
== EFI_SUCCESS
) {
256 DEBUG ((EFI_D_ERROR
, "MmcIdentificationMode(MMC_CMD5): Error - SDIO not supported, Status=%r.\n", Status
));
257 return EFI_UNSUPPORTED
;
260 // Check which kind of card we are using. Ver2.00 or later SD Memory Card (PL180 is SD v1.1)
261 CmdArg
= (0x0UL
<< 12 | BIT8
| 0xCEUL
<< 0);
262 Status
= MmcHost
->SendCommand (MmcHost
, MMC_CMD8
, CmdArg
);
263 if (Status
== EFI_SUCCESS
) {
264 DEBUG ((EFI_D_ERROR
, "Card is SD2.0 => Supports high capacity\n"));
266 Status
= MmcHost
->ReceiveResponse (MmcHost
, MMC_RESPONSE_TYPE_R7
, Response
);
267 if (EFI_ERROR (Status
)) {
268 DEBUG ((EFI_D_ERROR
, "MmcIdentificationMode() : Failed to receive response to CMD8, Status=%r.\n", Status
));
271 PrintResponseR1 (Response
[0]);
272 // Check if it is valid response
273 if (Response
[0] != CmdArg
) {
274 DEBUG ((EFI_D_ERROR
, "The Card is not usable\n"));
275 return EFI_UNSUPPORTED
;
278 DEBUG ((EFI_D_ERROR
, "Not a SD2.0 Card\n"));
281 // We need to wait for the MMC or SD card is ready => (gCardInfo.OCRData.PowerUp == 1)
282 Timeout
= MAX_RETRY_COUNT
;
283 while (Timeout
> 0) {
284 // SD Card or MMC Card ? CMD55 indicates to the card that the next command is an application specific command
285 Status
= MmcHost
->SendCommand (MmcHost
, MMC_CMD55
, 0);
286 if (Status
== EFI_SUCCESS
) {
287 DEBUG ((EFI_D_INFO
, "Card should be SD\n"));
289 MmcHostInstance
->CardInfo
.CardType
= SD_CARD_2
;
291 MmcHostInstance
->CardInfo
.CardType
= SD_CARD
;
294 // Note: The first time CmdArg will be zero
295 CmdArg
= ((UINTN
*) &(MmcHostInstance
->CardInfo
.OCRData
))[0];
299 Status
= MmcHost
->SendCommand (MmcHost
, MMC_ACMD41
, CmdArg
);
300 if (!EFI_ERROR (Status
)) {
301 Status
= MmcHost
->ReceiveResponse (MmcHost
, MMC_RESPONSE_TYPE_OCR
, Response
);
302 if (EFI_ERROR (Status
)) {
303 DEBUG ((EFI_D_ERROR
, "MmcIdentificationMode() : Failed to receive OCR, Status=%r.\n", Status
));
306 ((UINT32
*) &(MmcHostInstance
->CardInfo
.OCRData
))[0] = Response
[0];
309 DEBUG ((EFI_D_INFO
, "Card should be MMC\n"));
310 MmcHostInstance
->CardInfo
.CardType
= MMC_CARD
;
312 Status
= MmcHost
->SendCommand (MmcHost
, MMC_CMD1
, 0x800000);
313 if (!EFI_ERROR (Status
)) {
314 Status
= MmcHost
->ReceiveResponse (MmcHost
, MMC_RESPONSE_TYPE_OCR
, Response
);
315 if (EFI_ERROR (Status
)) {
316 DEBUG ((EFI_D_ERROR
, "MmcIdentificationMode() : Failed to receive OCR, Status=%r.\n", Status
));
319 ((UINT32
*) &(MmcHostInstance
->CardInfo
.OCRData
))[0] = Response
[0];
323 if (!EFI_ERROR (Status
)) {
324 if (!MmcHostInstance
->CardInfo
.OCRData
.PowerUp
) {
325 MicroSecondDelay (1);
328 if ((MmcHostInstance
->CardInfo
.CardType
== SD_CARD_2
) && (MmcHostInstance
->CardInfo
.OCRData
.AccessMode
& BIT1
)) {
329 MmcHostInstance
->CardInfo
.CardType
= SD_CARD_2_HIGH
;
330 DEBUG ((EFI_D_ERROR
, "High capacity card.\n"));
332 break; // The MMC/SD card is ready. Continue the Identification Mode
335 MicroSecondDelay (1);
341 DEBUG ((EFI_D_ERROR
, "MmcIdentificationMode(): No Card\n"));
344 PrintOCR (Response
[0]);
347 Status
= MmcNotifyState (MmcHostInstance
, MmcReadyState
);
348 if (EFI_ERROR (Status
)) {
349 DEBUG ((EFI_D_ERROR
, "MmcIdentificationMode() : Error MmcReadyState\n"));
353 Status
= MmcHost
->SendCommand (MmcHost
, MMC_CMD2
, 0);
354 if (EFI_ERROR (Status
)) {
355 DEBUG ((EFI_D_ERROR
, "MmcIdentificationMode(MMC_CMD2): Error\n"));
358 Status
= MmcHost
->ReceiveResponse (MmcHost
, MMC_RESPONSE_TYPE_CID
, Response
);
359 if (EFI_ERROR (Status
)) {
360 DEBUG ((EFI_D_ERROR
, "MmcIdentificationMode() : Failed to receive CID, Status=%r.\n", Status
));
366 Status
= MmcHost
->NotifyState (MmcHost
, MmcIdentificationState
);
367 if (EFI_ERROR (Status
)) {
368 DEBUG ((EFI_D_ERROR
, "MmcIdentificationMode() : Error MmcIdentificationState\n"));
373 // Note, SD specifications say that "if the command execution causes a state change, it
374 // will be visible to the host in the response to the next command"
375 // The status returned for this CMD3 will be 2 - identification
378 Status
= MmcHost
->SendCommand (MmcHost
, MMC_CMD3
, CmdArg
);
379 if (EFI_ERROR (Status
)) {
380 DEBUG ((EFI_D_ERROR
, "MmcIdentificationMode(MMC_CMD3): Error\n"));
384 Status
= MmcHost
->ReceiveResponse (MmcHost
, MMC_RESPONSE_TYPE_RCA
, Response
);
385 if (EFI_ERROR (Status
)) {
386 DEBUG ((EFI_D_ERROR
, "MmcIdentificationMode() : Failed to receive RCA, Status=%r.\n", Status
));
389 PrintRCA (Response
[0]);
391 // For MMC card, RCA is assigned by CMD3 while CMD3 dumps the RCA for SD card
392 if (MmcHostInstance
->CardInfo
.CardType
!= MMC_CARD
) {
393 MmcHostInstance
->CardInfo
.RCA
= Response
[0] >> 16;
395 MmcHostInstance
->CardInfo
.RCA
= CmdArg
;
397 Status
= MmcNotifyState (MmcHostInstance
, MmcStandByState
);
398 if (EFI_ERROR (Status
)) {
399 DEBUG ((EFI_D_ERROR
, "MmcIdentificationMode() : Error MmcStandByState\n"));
407 InitializeMmcDevice (
408 IN MMC_HOST_INSTANCE
*MmcHostInstance
412 EFI_MMC_HOST_PROTOCOL
*MmcHost
;
416 MmcHost
= MmcHostInstance
->MmcHost
;
418 Status
= MmcIdentificationMode (MmcHostInstance
);
419 if (EFI_ERROR (Status
)) {
420 DEBUG((EFI_D_ERROR
, "InitializeMmcDevice(): Error in Identification Mode, Status=%r\n", Status
));
424 Status
= MmcNotifyState (MmcHostInstance
, MmcTransferState
);
425 if (EFI_ERROR (Status
)) {
426 DEBUG((EFI_D_ERROR
, "InitializeMmcDevice(): Error MmcTransferState, Status=%r\n", Status
));
430 if (MmcHostInstance
->CardInfo
.CardType
!= EMMC_CARD
) {
431 Status
= InitializeSdMmcDevice (MmcHostInstance
);
432 if (EFI_ERROR (Status
)) {
438 Status
= MmcHost
->SendCommand (MmcHost
, MMC_CMD16
, MmcHostInstance
->BlockIo
.Media
->BlockSize
);
439 if (EFI_ERROR (Status
)) {
440 DEBUG((EFI_D_ERROR
, "InitializeMmcDevice(MMC_CMD16): Error MmcHostInstance->BlockIo.Media->BlockSize: %d and Error = %r\n",
441 MmcHostInstance
->BlockIo
.Media
->BlockSize
, Status
));
445 // Block Count (not used). Could return an error for SD card
446 if (MmcHostInstance
->CardInfo
.CardType
== MMC_CARD
) {
447 Status
= MmcHost
->SendCommand (MmcHost
, MMC_CMD23
, BlockCount
);
448 if (EFI_ERROR (Status
)) {
449 DEBUG((EFI_D_ERROR
, "InitializeMmcDevice(MMC_CMD23): Error, Status=%r\n", Status
));