3 * Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.
4 * Copyright (c) 2011, ARM Limited. All rights reserved.
6 * This program and the accompanying materials
7 * are licensed and made available under the terms and conditions of the BSD License
8 * which accompanies this distribution. The full text of the license may be found at
9 * http://opensource.org/licenses/bsd-license.php
11 * THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
16 #include "MmcHostDxe.h"
18 EMBEDDED_EXTERNAL_DEVICE
*gTPS65950
;
19 UINT8 mMaxDataTransferRate
= 0;
21 BOOLEAN mBitModeSet
= FALSE
;
25 VENDOR_DEVICE_PATH Mmc
;
29 MMCHS_DEVICE_PATH gMMCDevicePath
= {
33 (UINT8
)(sizeof(VENDOR_DEVICE_PATH
)),
34 (UINT8
)((sizeof(VENDOR_DEVICE_PATH
)) >> 8),
35 0xb615f1f5, 0x5088, 0x43cd, 0x80, 0x9c, 0xa1, 0x6e, 0x52, 0x48, 0x7d, 0x00
39 END_ENTIRE_DEVICE_PATH_SUBTYPE
,
40 sizeof (EFI_DEVICE_PATH_PROTOCOL
),
96 Translation
= 0x113A0014;//CMD17;
99 Translation
= CMD24
| 4;
105 Translation
= ACMD41
;
108 Translation
= Command
;
116 UINTN
*ClockFrequencySelect
119 UINTN TransferRateValue
= 0;
120 UINTN TimeValue
= 0 ;
123 DEBUG ((DEBUG_BLKIO
, "CalculateCardCLKD()\n"));
125 // For SD Cards we would need to send CMD6 to set
126 // speeds abouve 25MHz. High Speed mode 50 MHz and up
128 // Calculate Transfer rate unit (Bits 2:0 of TRAN_SPEED)
129 switch (mMaxDataTransferRate
& 0x7) { // 2
131 TransferRateValue
= 100 * 1000;
135 TransferRateValue
= 1 * 1000 * 1000;
139 TransferRateValue
= 10 * 1000 * 1000;
143 TransferRateValue
= 100 * 1000 * 1000;
147 DEBUG ((DEBUG_BLKIO
, "Invalid parameter.\n"));
152 //Calculate Time value (Bits 6:3 of TRAN_SPEED)
153 switch ((mMaxDataTransferRate
>> 3) & 0xF) { // 6
215 DEBUG ((DEBUG_BLKIO
, "Invalid parameter.\n"));
220 Frequency
= TransferRateValue
* TimeValue
/10;
222 // Calculate Clock divider value to program in MMCHS_SYSCTL[CLKD] field.
223 *ClockFrequencySelect
= ((MMC_REFERENCE_CLK
/Frequency
) + 1);
225 DEBUG ((DEBUG_BLKIO
, "mMaxDataTransferRate: 0x%x, Frequency: %d KHz, ClockFrequencySelect: %x\n", mMaxDataTransferRate
, Frequency
/1000, *ClockFrequencySelect
));
229 UpdateMMCHSClkFrequency (
233 DEBUG ((DEBUG_BLKIO
, "UpdateMMCHSClkFrequency()\n"));
235 // Set Clock enable to 0x0 to not provide the clock to the card
236 MmioAnd32 (MMCHS_SYSCTL
, ~CEN
);
238 // Set new clock frequency.
239 MmioAndThenOr32 (MMCHS_SYSCTL
, ~CLKD_MASK
, NewCLKD
<< 6);
241 // Poll till Internal Clock Stable
242 while ((MmioRead32 (MMCHS_SYSCTL
) & ICS_MASK
) != ICS
);
244 // Set Clock enable to 0x1 to provide the clock to the card
245 MmioOr32 (MMCHS_SYSCTL
, CEN
);
256 DEBUG ((DEBUG_BLKIO
, "InitializeMMCHS()\n"));
258 // Select Device group to belong to P1 device group in Power IC.
260 Status
= gTPS65950
->Write (gTPS65950
, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID4
, VMMC1_DEV_GRP
), 1, &Data
);
261 ASSERT_EFI_ERROR(Status
);
263 // Configure voltage regulator for MMC1 in Power IC to output 3.0 voltage.
265 Status
= gTPS65950
->Write (gTPS65950
, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID4
, VMMC1_DEDICATED_REG
), 1, &Data
);
266 ASSERT_EFI_ERROR(Status
);
268 // After ramping up voltage, set VDDS stable bit to indicate that voltage level is stable.
269 MmioOr32 (CONTROL_PBIAS_LITE
, (PBIASLITEVMODE0
| PBIASLITEPWRDNZ0
| PBIASSPEEDCTRL0
| PBIASLITEVMODE1
| PBIASLITEWRDNZ1
));
272 MmioAndThenOr32 (GPIO1_BASE
+ GPIO_OE
, ~BIT23
, BIT23
);
274 // Enable Card Detect
275 Data
= CARD_DETECT_ENABLE
;
276 gTPS65950
->Write (gTPS65950
, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID2
, TPS65950_GPIO_CTRL
), 1, &Data
);
290 // Card detect is a GPIO0 on the TPS65950
292 Status
= gTPS65950
->Read (gTPS65950
, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID2
, GPIODATAIN1
), 1, &Data
);
293 if (EFI_ERROR (Status
)) {
297 return !(Data
& CARD_DETECT_BIT
);
306 * On our BeagleBoard the SD card WP pin is always read as TRUE.
307 * Probably something wrong with GPIO configuration.
308 * BeagleBoard-xM uses microSD cards so there is no write protect at all.
309 * Hence commenting out SD card WP pin read status.
311 //return (MmioRead32 (GPIO1_BASE + GPIO_DATAIN) & BIT23) == BIT23;
317 EFI_GUID mPL180MciDevicePathGuid
= EFI_CALLER_ID_GUID
;
321 IN EFI_DEVICE_PATH_PROTOCOL
**DevicePath
324 EFI_DEVICE_PATH_PROTOCOL
*NewDevicePathNode
;
326 NewDevicePathNode
= CreateDeviceNode(HARDWARE_DEVICE_PATH
,HW_VENDOR_DP
,sizeof(VENDOR_DEVICE_PATH
));
327 CopyGuid(&((VENDOR_DEVICE_PATH
*)NewDevicePathNode
)->Guid
,&mPL180MciDevicePathGuid
);
328 *DevicePath
= NewDevicePathNode
;
339 UINTN RetryCount
= 0;
341 if (IgnoreCommand(MmcCmd
))
344 MmcCmd
= TranslateCommand(MmcCmd
);
346 //DEBUG ((EFI_D_ERROR, "MMCSendCommand(%d)\n", MmcCmd));
348 // Check if command line is in use or not. Poll till command line is available.
349 while ((MmioRead32 (MMCHS_PSTATE
) & DATI_MASK
) == DATI_NOT_ALLOWED
);
351 // Provide the block size.
352 MmioWrite32 (MMCHS_BLK
, BLEN_512BYTES
);
354 // Setting Data timeout counter value to max value.
355 MmioAndThenOr32 (MMCHS_SYSCTL
, ~DTO_MASK
, DTO_VAL
);
357 // Clear Status register.
358 MmioWrite32 (MMCHS_STAT
, 0xFFFFFFFF);
360 // Set command argument register
361 MmioWrite32 (MMCHS_ARG
, Argument
);
364 //Enable interrupt enable events to occur
365 //MmioWrite32 (MMCHS_IE, CmdInterruptEnableVal);
368 MmioWrite32 (MMCHS_CMD
, MmcCmd
);
370 // Check for the command status.
371 while (RetryCount
< MAX_RETRY_COUNT
) {
373 MmcStatus
= MmioRead32 (MMCHS_STAT
);
374 } while (MmcStatus
== 0);
376 // Read status of command response
377 if ((MmcStatus
& ERRI
) != 0) {
379 // Perform soft-reset for mmci_cmd line.
380 MmioOr32 (MMCHS_SYSCTL
, SRC
);
381 while ((MmioRead32 (MMCHS_SYSCTL
) & SRC
));
383 //DEBUG ((EFI_D_INFO, "MmcStatus: 0x%x\n", MmcStatus));
384 return EFI_DEVICE_ERROR
;
387 // Check if command is completed.
388 if ((MmcStatus
& CC
) == CC
) {
389 MmioWrite32 (MMCHS_STAT
, CC
);
396 if (RetryCount
== MAX_RETRY_COUNT
) {
397 DEBUG ((DEBUG_BLKIO
, "MMCSendCommand: Timeout\n"));
413 case MmcInvalidState
:
416 case MmcHwInitializationState
:
419 DEBUG ((DEBUG_BLKIO
, "MMCHwInitializationState()\n"));
420 Status
= InitializeMMCHS ();
421 if (EFI_ERROR(Status
)) {
422 DEBUG ((DEBUG_BLKIO
, "Initialize MMC host controller fails. Status: %x\n", Status
));
426 // Software reset of the MMCHS host controller.
427 MmioWrite32 (MMCHS_SYSCONFIG
, SOFTRESET
);
429 while ((MmioRead32 (MMCHS_SYSSTATUS
) & RESETDONE_MASK
) != RESETDONE
);
431 // Soft reset for all.
432 MmioWrite32 (MMCHS_SYSCTL
, SRA
);
434 while ((MmioRead32 (MMCHS_SYSCTL
) & SRA
) != 0x0);
436 //Voltage capabilities initialization. Activate VS18 and VS30.
437 MmioOr32 (MMCHS_CAPA
, (VS30
| VS18
));
439 // Wakeup configuration
440 MmioOr32 (MMCHS_SYSCONFIG
, ENAWAKEUP
);
441 MmioOr32 (MMCHS_HCTL
, IWE
);
443 // MMCHS Controller default initialization
444 MmioOr32 (MMCHS_CON
, (OD
| DW8_1_4_BIT
| CEATA_OFF
));
446 MmioWrite32 (MMCHS_HCTL
, (SDVS_3_0_V
| DTW_1_BIT
| SDBP_OFF
));
448 // Enable internal clock
449 MmioOr32 (MMCHS_SYSCTL
, ICE
);
451 // Set the clock frequency to 80KHz.
452 UpdateMMCHSClkFrequency (CLKD_80KHZ
);
454 // Enable SD bus power.
455 MmioOr32 (MMCHS_HCTL
, (SDBP_ON
));
457 // Poll till SD bus power bit is set.
458 while ((MmioRead32 (MMCHS_HCTL
) & SDBP_MASK
) != SDBP_ON
);
460 // Enable interrupts.
461 MmioWrite32 (MMCHS_IE
, (BADA_EN
| CERR_EN
| DEB_EN
| DCRC_EN
| DTO_EN
| CIE_EN
|
462 CEB_EN
| CCRC_EN
| CTO_EN
| BRR_EN
| BWR_EN
| TC_EN
| CC_EN
));
464 // Controller INIT procedure start.
465 MmioOr32 (MMCHS_CON
, INIT
);
466 MmioWrite32 (MMCHS_CMD
, 0x00000000);
467 while (!(MmioRead32 (MMCHS_STAT
) & CC
));
472 // Set CC bit to 0x1 to clear the flag
473 MmioOr32 (MMCHS_STAT
, CC
);
475 // Retry INIT procedure.
476 MmioWrite32 (MMCHS_CMD
, 0x00000000);
477 while (!(MmioRead32 (MMCHS_STAT
) & CC
));
479 // End initialization sequence
480 MmioAnd32 (MMCHS_CON
, ~INIT
);
482 MmioOr32 (MMCHS_HCTL
, (SDVS_3_0_V
| DTW_1_BIT
| SDBP_ON
));
484 // Change clock frequency to 400KHz to fit protocol
485 UpdateMMCHSClkFrequency(CLKD_400KHZ
);
487 MmioOr32 (MMCHS_CON
, OD
);
493 case MmcIdentificationState
:
495 case MmcStandByState
:
496 CalculateCardCLKD (&FreqSel
);
497 UpdateMMCHSClkFrequency (FreqSel
);
499 case MmcTransferState
:
501 Status
= MMCSendCommand (This
, CMD55
, mRca
<< 16);
502 if (!EFI_ERROR (Status
)) {
503 // Set device into 4-bit data bus mode
504 Status
= MMCSendCommand (This
, ACMD6
, 0x2);
505 if (!EFI_ERROR (Status
)) {
506 // Set host controler into 4-bit mode
507 MmioOr32 (MMCHS_HCTL
, DTW_4_BIT
);
508 DEBUG ((DEBUG_BLKIO
, "SD Memory Card set to 4-bit mode\n"));
514 case MmcSendingDataState
:
516 case MmcReceiveDataState
:
518 case MmcProgrammingState
:
520 case MmcDisconnectState
:
529 IN MMC_RESPONSE_TYPE Type
,
533 if (Buffer
== NULL
) {
534 return EFI_INVALID_PARAMETER
;
537 if (Type
== MMC_RESPONSE_TYPE_R2
) {
538 Buffer
[0] = MmioRead32 (MMCHS_RSP10
);
539 Buffer
[1] = MmioRead32 (MMCHS_RSP32
);
540 Buffer
[2] = MmioRead32 (MMCHS_RSP54
);
541 Buffer
[3] = MmioRead32 (MMCHS_RSP76
);
543 Buffer
[0] = MmioRead32 (MMCHS_RSP10
);
546 if (Type
== MMC_RESPONSE_TYPE_CSD
) {
547 mMaxDataTransferRate
= Buffer
[3] & 0xFF;
548 } else if (Type
== MMC_RESPONSE_TYPE_RCA
) {
549 mRca
= Buffer
[0] >> 16;
564 UINTN RetryCount
= 0;
566 DEBUG ((DEBUG_BLKIO
, "MMCReadBlockData(LBA: 0x%x, Length: 0x%x, Buffer: 0x%x)\n", Lba
, Length
, Buffer
));
568 // Check controller status to make sure there is no error.
569 while (RetryCount
< MAX_RETRY_COUNT
) {
572 MmcStatus
= MmioRead32 (MMCHS_STAT
);
573 } while(MmcStatus
== 0);
575 // Check if Buffer read ready (BRR) bit is set?
576 if (MmcStatus
& BRR
) {
579 MmioOr32 (MMCHS_STAT
, BRR
);
581 for (Count
= 0; Count
< Length
/ 4; Count
++) {
582 *Buffer
++ = MmioRead32(MMCHS_DATA
);
589 if (RetryCount
== MAX_RETRY_COUNT
) {
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
= {
650 IN EFI_HANDLE ImageHandle
,
651 IN EFI_SYSTEM_TABLE
*SystemTable
655 EFI_HANDLE Handle
= NULL
;
657 DEBUG ((DEBUG_BLKIO
, "MMCInitialize()\n"));
659 Status
= gBS
->LocateProtocol (&gEmbeddedExternalDeviceProtocolGuid
, NULL
, (VOID
**)&gTPS65950
);
660 ASSERT_EFI_ERROR(Status
);
662 Status
= gBS
->InstallMultipleProtocolInterfaces (
664 &gEfiMmcHostProtocolGuid
, &gMMCHost
,
667 ASSERT_EFI_ERROR (Status
);