3 * Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.
4 * Copyright (c) 2011 - 2014, ARM Limited. All rights reserved.
6 * SPDX-License-Identifier: BSD-2-Clause-Patent
10 #include "MmcHostDxe.h"
12 EMBEDDED_EXTERNAL_DEVICE
*gTPS65950
;
13 UINT8 mMaxDataTransferRate
= 0;
15 BOOLEAN mBitModeSet
= FALSE
;
19 VENDOR_DEVICE_PATH Mmc
;
23 MMCHS_DEVICE_PATH gMMCDevicePath
= {
28 { (UINT8
)(sizeof(VENDOR_DEVICE_PATH
)), (UINT8
)((sizeof(VENDOR_DEVICE_PATH
)) >> 8) },
30 { 0xb615f1f5, 0x5088, 0x43cd, { 0x80, 0x9c, 0xa1, 0x6e, 0x52, 0x48, 0x7d, 0x00 } }
34 END_ENTIRE_DEVICE_PATH_SUBTYPE
,
35 { sizeof (EFI_DEVICE_PATH_PROTOCOL
), 0 }
90 Translation
= 0x113A0014;//CMD17;
93 Translation
= CMD24
| 4;
102 Translation
= Command
;
110 UINTN
*ClockFrequencySelect
113 UINTN TransferRateValue
= 0;
114 UINTN TimeValue
= 0 ;
117 DEBUG ((DEBUG_BLKIO
, "CalculateCardCLKD()\n"));
119 // For SD Cards we would need to send CMD6 to set
120 // speeds abouve 25MHz. High Speed mode 50 MHz and up
122 // Calculate Transfer rate unit (Bits 2:0 of TRAN_SPEED)
123 switch (mMaxDataTransferRate
& 0x7) { // 2
125 TransferRateValue
= 100 * 1000;
129 TransferRateValue
= 1 * 1000 * 1000;
133 TransferRateValue
= 10 * 1000 * 1000;
137 TransferRateValue
= 100 * 1000 * 1000;
141 DEBUG ((DEBUG_BLKIO
, "Invalid parameter.\n"));
146 //Calculate Time value (Bits 6:3 of TRAN_SPEED)
147 switch ((mMaxDataTransferRate
>> 3) & 0xF) { // 6
209 DEBUG ((DEBUG_BLKIO
, "Invalid parameter.\n"));
214 Frequency
= TransferRateValue
* TimeValue
/10;
216 // Calculate Clock divider value to program in MMCHS_SYSCTL[CLKD] field.
217 *ClockFrequencySelect
= ((MMC_REFERENCE_CLK
/Frequency
) + 1);
219 DEBUG ((DEBUG_BLKIO
, "mMaxDataTransferRate: 0x%x, Frequency: %d KHz, ClockFrequencySelect: %x\n", mMaxDataTransferRate
, Frequency
/1000, *ClockFrequencySelect
));
223 UpdateMMCHSClkFrequency (
227 DEBUG ((DEBUG_BLKIO
, "UpdateMMCHSClkFrequency()\n"));
229 // Set Clock enable to 0x0 to not provide the clock to the card
230 MmioAnd32 (MMCHS_SYSCTL
, ~CEN
);
232 // Set new clock frequency.
233 MmioAndThenOr32 (MMCHS_SYSCTL
, ~CLKD_MASK
, NewCLKD
<< 6);
235 // Poll till Internal Clock Stable
236 while ((MmioRead32 (MMCHS_SYSCTL
) & ICS_MASK
) != ICS
);
238 // Set Clock enable to 0x1 to provide the clock to the card
239 MmioOr32 (MMCHS_SYSCTL
, CEN
);
250 DEBUG ((DEBUG_BLKIO
, "InitializeMMCHS()\n"));
252 // Select Device group to belong to P1 device group in Power IC.
254 Status
= gTPS65950
->Write (gTPS65950
, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID4
, VMMC1_DEV_GRP
), 1, &Data
);
255 ASSERT_EFI_ERROR(Status
);
257 // Configure voltage regulator for MMC1 in Power IC to output 3.0 voltage.
259 Status
= gTPS65950
->Write (gTPS65950
, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID4
, VMMC1_DEDICATED_REG
), 1, &Data
);
260 ASSERT_EFI_ERROR(Status
);
262 // After ramping up voltage, set VDDS stable bit to indicate that voltage level is stable.
263 MmioOr32 (CONTROL_PBIAS_LITE
, (PBIASLITEVMODE0
| PBIASLITEPWRDNZ0
| PBIASSPEEDCTRL0
| PBIASLITEVMODE1
| PBIASLITEWRDNZ1
));
266 MmioAndThenOr32 (GPIO1_BASE
+ GPIO_OE
, ~BIT23
, BIT23
);
268 // Enable Card Detect
269 Data
= CARD_DETECT_ENABLE
;
270 gTPS65950
->Write (gTPS65950
, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID2
, TPS65950_GPIO_CTRL
), 1, &Data
);
277 IN EFI_MMC_HOST_PROTOCOL
*This
284 // Card detect is a GPIO0 on the TPS65950
286 Status
= gTPS65950
->Read (gTPS65950
, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID2
, GPIODATAIN1
), 1, &Data
);
287 if (EFI_ERROR (Status
)) {
291 return !(Data
& CARD_DETECT_BIT
);
296 IN EFI_MMC_HOST_PROTOCOL
*This
300 * On our BeagleBoard the SD card WP pin is always read as TRUE.
301 * Probably something wrong with GPIO configuration.
302 * BeagleBoard-xM uses microSD cards so there is no write protect at all.
303 * Hence commenting out SD card WP pin read status.
305 //return (MmioRead32 (GPIO1_BASE + GPIO_DATAIN) & BIT23) == BIT23;
311 EFI_GUID mPL180MciDevicePathGuid
= EFI_CALLER_ID_GUID
;
315 IN EFI_MMC_HOST_PROTOCOL
*This
,
316 IN EFI_DEVICE_PATH_PROTOCOL
**DevicePath
319 EFI_DEVICE_PATH_PROTOCOL
*NewDevicePathNode
;
321 NewDevicePathNode
= CreateDeviceNode(HARDWARE_DEVICE_PATH
,HW_VENDOR_DP
,sizeof(VENDOR_DEVICE_PATH
));
322 CopyGuid(&((VENDOR_DEVICE_PATH
*)NewDevicePathNode
)->Guid
,&mPL180MciDevicePathGuid
);
323 *DevicePath
= NewDevicePathNode
;
329 IN EFI_MMC_HOST_PROTOCOL
*This
,
335 UINTN RetryCount
= 0;
337 if (IgnoreCommand(MmcCmd
))
340 MmcCmd
= TranslateCommand(MmcCmd
);
342 //DEBUG ((EFI_D_ERROR, "MMCSendCommand(%d)\n", MmcCmd));
344 // Check if command line is in use or not. Poll till command line is available.
345 while ((MmioRead32 (MMCHS_PSTATE
) & DATI_MASK
) == DATI_NOT_ALLOWED
);
347 // Provide the block size.
348 MmioWrite32 (MMCHS_BLK
, BLEN_512BYTES
);
350 // Setting Data timeout counter value to max value.
351 MmioAndThenOr32 (MMCHS_SYSCTL
, ~DTO_MASK
, DTO_VAL
);
353 // Clear Status register.
354 MmioWrite32 (MMCHS_STAT
, 0xFFFFFFFF);
356 // Set command argument register
357 MmioWrite32 (MMCHS_ARG
, Argument
);
360 //Enable interrupt enable events to occur
361 //MmioWrite32 (MMCHS_IE, CmdInterruptEnableVal);
364 MmioWrite32 (MMCHS_CMD
, MmcCmd
);
366 // Check for the command status.
367 while (RetryCount
< MAX_RETRY_COUNT
) {
369 MmcStatus
= MmioRead32 (MMCHS_STAT
);
370 } while (MmcStatus
== 0);
372 // Read status of command response
373 if ((MmcStatus
& ERRI
) != 0) {
375 // Perform soft-reset for mmci_cmd line.
376 MmioOr32 (MMCHS_SYSCTL
, SRC
);
377 while ((MmioRead32 (MMCHS_SYSCTL
) & SRC
));
379 //DEBUG ((EFI_D_INFO, "MmcStatus: 0x%x\n", MmcStatus));
380 return EFI_DEVICE_ERROR
;
383 // Check if command is completed.
384 if ((MmcStatus
& CC
) == CC
) {
385 MmioWrite32 (MMCHS_STAT
, CC
);
392 if (RetryCount
== MAX_RETRY_COUNT
) {
393 DEBUG ((DEBUG_BLKIO
, "MMCSendCommand: Timeout\n"));
402 IN EFI_MMC_HOST_PROTOCOL
*This
,
410 case MmcInvalidState
:
413 case MmcHwInitializationState
:
416 DEBUG ((DEBUG_BLKIO
, "MMCHwInitializationState()\n"));
417 Status
= InitializeMMCHS ();
418 if (EFI_ERROR(Status
)) {
419 DEBUG ((DEBUG_BLKIO
, "Initialize MMC host controller fails. Status: %x\n", Status
));
423 // Software reset of the MMCHS host controller.
424 MmioWrite32 (MMCHS_SYSCONFIG
, SOFTRESET
);
426 while ((MmioRead32 (MMCHS_SYSSTATUS
) & RESETDONE_MASK
) != RESETDONE
);
428 // Soft reset for all.
429 MmioWrite32 (MMCHS_SYSCTL
, SRA
);
431 while ((MmioRead32 (MMCHS_SYSCTL
) & SRA
) != 0x0);
433 //Voltage capabilities initialization. Activate VS18 and VS30.
434 MmioOr32 (MMCHS_CAPA
, (VS30
| VS18
));
436 // Wakeup configuration
437 MmioOr32 (MMCHS_SYSCONFIG
, ENAWAKEUP
);
438 MmioOr32 (MMCHS_HCTL
, IWE
);
440 // MMCHS Controller default initialization
441 MmioOr32 (MMCHS_CON
, (OD
| DW8_1_4_BIT
| CEATA_OFF
));
443 MmioWrite32 (MMCHS_HCTL
, (SDVS_3_0_V
| DTW_1_BIT
| SDBP_OFF
));
445 // Enable internal clock
446 MmioOr32 (MMCHS_SYSCTL
, ICE
);
448 // Set the clock frequency to 80KHz.
449 UpdateMMCHSClkFrequency (CLKD_80KHZ
);
451 // Enable SD bus power.
452 MmioOr32 (MMCHS_HCTL
, (SDBP_ON
));
454 // Poll till SD bus power bit is set.
455 while ((MmioRead32 (MMCHS_HCTL
) & SDBP_MASK
) != SDBP_ON
);
457 // Enable interrupts.
458 MmioWrite32 (MMCHS_IE
, (BADA_EN
| CERR_EN
| DEB_EN
| DCRC_EN
| DTO_EN
| CIE_EN
|
459 CEB_EN
| CCRC_EN
| CTO_EN
| BRR_EN
| BWR_EN
| TC_EN
| CC_EN
));
461 // Controller INIT procedure start.
462 MmioOr32 (MMCHS_CON
, INIT
);
463 MmioWrite32 (MMCHS_CMD
, 0x00000000);
464 while (!(MmioRead32 (MMCHS_STAT
) & CC
));
469 // Set CC bit to 0x1 to clear the flag
470 MmioOr32 (MMCHS_STAT
, CC
);
472 // Retry INIT procedure.
473 MmioWrite32 (MMCHS_CMD
, 0x00000000);
474 while (!(MmioRead32 (MMCHS_STAT
) & CC
));
476 // End initialization sequence
477 MmioAnd32 (MMCHS_CON
, ~INIT
);
479 MmioOr32 (MMCHS_HCTL
, (SDVS_3_0_V
| DTW_1_BIT
| SDBP_ON
));
481 // Change clock frequency to 400KHz to fit protocol
482 UpdateMMCHSClkFrequency(CLKD_400KHZ
);
484 MmioOr32 (MMCHS_CON
, OD
);
490 case MmcIdentificationState
:
492 case MmcStandByState
:
493 CalculateCardCLKD (&FreqSel
);
494 UpdateMMCHSClkFrequency (FreqSel
);
496 case MmcTransferState
:
498 Status
= MMCSendCommand (This
, CMD55
, mRca
<< 16);
499 if (!EFI_ERROR (Status
)) {
500 // Set device into 4-bit data bus mode
501 Status
= MMCSendCommand (This
, ACMD6
, 0x2);
502 if (!EFI_ERROR (Status
)) {
503 // Set host controler into 4-bit mode
504 MmioOr32 (MMCHS_HCTL
, DTW_4_BIT
);
505 DEBUG ((DEBUG_BLKIO
, "SD Memory Card set to 4-bit mode\n"));
511 case MmcSendingDataState
:
513 case MmcReceiveDataState
:
515 case MmcProgrammingState
:
517 case MmcDisconnectState
:
526 IN EFI_MMC_HOST_PROTOCOL
*This
,
527 IN MMC_RESPONSE_TYPE Type
,
531 if (Buffer
== NULL
) {
532 return EFI_INVALID_PARAMETER
;
535 if (Type
== MMC_RESPONSE_TYPE_R2
) {
536 Buffer
[0] = MmioRead32 (MMCHS_RSP10
);
537 Buffer
[1] = MmioRead32 (MMCHS_RSP32
);
538 Buffer
[2] = MmioRead32 (MMCHS_RSP54
);
539 Buffer
[3] = MmioRead32 (MMCHS_RSP76
);
541 Buffer
[0] = MmioRead32 (MMCHS_RSP10
);
544 if (Type
== MMC_RESPONSE_TYPE_CSD
) {
545 mMaxDataTransferRate
= Buffer
[3] & 0xFF;
546 } else if (Type
== MMC_RESPONSE_TYPE_RCA
) {
547 mRca
= Buffer
[0] >> 16;
555 IN EFI_MMC_HOST_PROTOCOL
*This
,
563 UINTN RetryCount
= 0;
565 DEBUG ((DEBUG_BLKIO
, "MMCReadBlockData(LBA: 0x%x, Length: 0x%x, Buffer: 0x%x)\n", Lba
, Length
, Buffer
));
567 // Check controller status to make sure there is no error.
568 while (RetryCount
< MAX_RETRY_COUNT
) {
571 MmcStatus
= MmioRead32 (MMCHS_STAT
);
572 } while(MmcStatus
== 0);
574 // Check if Buffer read ready (BRR) bit is set?
575 if (MmcStatus
& BRR
) {
578 MmioOr32 (MMCHS_STAT
, BRR
);
580 for (Count
= 0; Count
< Length
/ 4; Count
++) {
581 *Buffer
++ = MmioRead32(MMCHS_DATA
);
588 if (RetryCount
== MAX_RETRY_COUNT
) {
597 IN EFI_MMC_HOST_PROTOCOL
*This
,
605 UINTN RetryCount
= 0;
607 // Check controller status to make sure there is no error.
608 while (RetryCount
< MAX_RETRY_COUNT
) {
611 MmcStatus
= MmioRead32 (MMCHS_STAT
);
612 } while(MmcStatus
== 0);
614 // Check if Buffer write ready (BWR) bit is set?
615 if (MmcStatus
& BWR
) {
618 MmioOr32 (MMCHS_STAT
, BWR
);
620 // Write block worth of data.
621 for (Count
= 0; Count
< Length
/ 4; Count
++) {
622 MmioWrite32 (MMCHS_DATA
, *Buffer
++);
630 if (RetryCount
== MAX_RETRY_COUNT
) {
637 EFI_MMC_HOST_PROTOCOL gMMCHost
= {
638 MMC_HOST_PROTOCOL_REVISION
,
651 IN EFI_HANDLE ImageHandle
,
652 IN EFI_SYSTEM_TABLE
*SystemTable
656 EFI_HANDLE Handle
= NULL
;
658 DEBUG ((DEBUG_BLKIO
, "MMCInitialize()\n"));
660 Status
= gBS
->LocateProtocol (&gEmbeddedExternalDeviceProtocolGuid
, NULL
, (VOID
**)&gTPS65950
);
661 ASSERT_EFI_ERROR(Status
);
663 Status
= gBS
->InstallMultipleProtocolInterfaces (
665 &gEfiMmcHostProtocolGuid
, &gMMCHost
,
668 ASSERT_EFI_ERROR (Status
);