[mirror_edk2.git] / Omap35xxPkg / MmcHostDxe / MmcHostDxe.c

/** @file
*
*  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.
*  Copyright (c) 2011, ARM Limited. All rights reserved.
*  
*  This program and the accompanying materials                          
*  are licensed and made available under the terms and conditions of the BSD License         
*  which accompanies this distribution.  The full text of the license may be found at        
*  http://opensource.org/licenses/bsd-license.php                                            
*
*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     
*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             
*
**/

#include "MmcHostDxe.h"

EMBEDDED_EXTERNAL_DEVICE   *gTPS65950;
UINT8                      MaxDataTransferRate = 0;
UINT32                     Rca = 0;
BOOLEAN                    BitModeSet = FALSE;


typedef struct {
  VENDOR_DEVICE_PATH  Mmc;
  EFI_DEVICE_PATH     End;
} MMCHS_DEVICE_PATH;

MMCHS_DEVICE_PATH gMMCDevicePath = {
  {
    HARDWARE_DEVICE_PATH,
    HW_VENDOR_DP,
    (UINT8)(sizeof(VENDOR_DEVICE_PATH)),
    (UINT8)((sizeof(VENDOR_DEVICE_PATH)) >> 8),
    0xb615f1f5, 0x5088, 0x43cd, 0x80, 0x9c, 0xa1, 0x6e, 0x52, 0x48, 0x7d, 0x00 
  },
  {
    END_DEVICE_PATH_TYPE,
    END_ENTIRE_DEVICE_PATH_SUBTYPE,
    sizeof (EFI_DEVICE_PATH_PROTOCOL),
    0
  }
};

BOOLEAN
IgnoreCommand (
  UINT32 Command
  )
{
  switch(Command) {
    case MMC_CMD12:
      return TRUE;
    case MMC_CMD13:
      return TRUE;
    default:
      return FALSE;
  }
}

UINT32
TranslateCommand (
  UINT32 Command
  )
{
  UINT32 Translation;

  switch(Command) {
    case MMC_CMD2:
      Translation = CMD2;
      break;
    case MMC_CMD3:
      Translation = CMD3;
      break;
    /*case MMC_CMD6:
      Translation = CMD6;
      break;*/
    case MMC_CMD7:
      Translation = CMD7;
      break;
    case MMC_CMD8:
      Translation = CMD8;
      break;
    case MMC_CMD9:
      Translation = CMD9;
      break;
    /*case MMC_CMD12:
      Translation = CMD12;
      break;
    case MMC_CMD13:
      Translation = CMD13;
      break;*/
    case MMC_CMD16:
      Translation = CMD16;
      break;
    case MMC_CMD17:
      Translation = 0x113A0014;//CMD17;
      break;
    case MMC_CMD24:
      Translation = CMD24 | 4;
      break;
    case MMC_CMD55:
      Translation = CMD55;
      break;
    case MMC_ACMD41:
      Translation = ACMD41;
      break;
    default:
      Translation = Command;
  }

  return Translation;
}

VOID
CalculateCardCLKD (
  UINTN *ClockFrequencySelect
  )
{
  DEBUG((EFI_D_ERROR, "CalculateCardCLKD()\n"));
  UINTN    TransferRateValue = 0;
  UINTN    TimeValue = 0 ;
  UINTN    Frequency = 0;

  // For SD Cards  we would need to send CMD6 to set
  // speeds abouve 25MHz. High Speed mode 50 MHz and up

  //Calculate Transfer rate unit (Bits 2:0 of TRAN_SPEED)
  switch (MaxDataTransferRate & 0x7) { // 2
    case 0:
      TransferRateValue = 100 * 1000;
      break;

    case 1:
      TransferRateValue = 1 * 1000 * 1000;
      break;

    case 2:
      TransferRateValue = 10 * 1000 * 1000;
      break;

    case 3:
      TransferRateValue = 100 * 1000 * 1000;
      break;

    default:
      DEBUG((EFI_D_ERROR, "Invalid parameter.\n"));
      ASSERT(FALSE);
  }

  //Calculate Time value (Bits 6:3 of TRAN_SPEED)
  switch ((MaxDataTransferRate >> 3) & 0xF) { // 6
    case 1:
      TimeValue = 10;
      break;

    case 2:
      TimeValue = 12;
      break;

    case 3:
      TimeValue = 13;
      break;

    case 4:
      TimeValue = 15;
      break;

    case 5:
      TimeValue = 20;
      break;

    case 6:
      TimeValue = 25;
      break;

    case 7:
      TimeValue = 30;
      break;

    case 8:
      TimeValue = 35;
      break;

    case 9:
      TimeValue = 40;
      break;

    case 10:
      TimeValue = 45;
      break;

    case 11:
      TimeValue = 50;
      break;

    case 12:
      TimeValue = 55;
      break;

    case 13:
      TimeValue = 60;
      break;

    case 14:
      TimeValue = 70;
      break;

    case 15:
      TimeValue = 80;
      break;

    default:
      DEBUG((EFI_D_ERROR, "Invalid parameter.\n"));
      ASSERT(FALSE);
  }

  Frequency = TransferRateValue * TimeValue/10;

  //Calculate Clock divider value to program in MMCHS_SYSCTL[CLKD] field.
  *ClockFrequencySelect = ((MMC_REFERENCE_CLK/Frequency) + 1);

  DEBUG ((EFI_D_INFO, "MaxDataTransferRate: 0x%x, Frequency: %d KHz, ClockFrequencySelect: %x\n", MaxDataTransferRate, Frequency/1000, *ClockFrequencySelect));
}

VOID
UpdateMMCHSClkFrequency (
  UINTN NewCLKD
  )
{
  DEBUG((EFI_D_ERROR, "UpdateMMCHSClkFrequency()\n"));
  //Set Clock enable to 0x0 to not provide the clock to the card
  MmioAnd32 (MMCHS_SYSCTL, ~CEN);

  //Set new clock frequency.
  MmioAndThenOr32 (MMCHS_SYSCTL, ~CLKD_MASK, NewCLKD << 6); 

  //Poll till Internal Clock Stable
  while ((MmioRead32 (MMCHS_SYSCTL) & ICS_MASK) != ICS);

  //Set Clock enable to 0x1 to provide the clock to the card
  MmioOr32 (MMCHS_SYSCTL, CEN);
}

EFI_STATUS
InitializeMMCHS (
  VOID
  )
{
  DEBUG((EFI_D_ERROR, "InitializeMMCHS()\n"));
  UINT8      Data = 0;
  EFI_STATUS Status;

  //Select Device group to belong to P1 device group in Power IC.
  Data = DEV_GRP_P1;
  Status = gTPS65950->Write (gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID4, VMMC1_DEV_GRP), 1, &Data);
  ASSERT_EFI_ERROR(Status);

  //Configure voltage regulator for MMC1 in Power IC to output 3.0 voltage.
  Data = VSEL_3_00V;
  Status = gTPS65950->Write (gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID4, VMMC1_DEDICATED_REG), 1, &Data);
  ASSERT_EFI_ERROR(Status);
  
  //After ramping up voltage, set VDDS stable bit to indicate that voltage level is stable.
  MmioOr32 (CONTROL_PBIAS_LITE, (PBIASLITEVMODE0 | PBIASLITEPWRDNZ0 | PBIASSPEEDCTRL0 | PBIASLITEVMODE1 | PBIASLITEWRDNZ1));

  // Enable WP GPIO
  MmioAndThenOr32 (GPIO1_BASE + GPIO_OE, ~BIT23, BIT23);

  // Enable Card Detect
  Data = CARD_DETECT_ENABLE;
  gTPS65950->Write (gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID2, TPS65950_GPIO_CTRL), 1, &Data);


  return Status;
}

BOOLEAN
MMCIsCardPresent (
  VOID
  )
{
  //DEBUG((EFI_D_ERROR, "MMCIsCardPresent()\n"));
  EFI_STATUS  Status;
  UINT8       Data;

  //
  // Card detect is a GPIO0 on the TPS65950
  //
  Status = gTPS65950->Read (gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID2, GPIODATAIN1), 1, &Data);
  if (EFI_ERROR (Status)) {
    return FALSE;
  }

  return !(Data & CARD_DETECT_BIT);
}

BOOLEAN
MMCIsReadOnly (
  VOID
  )
{
  /* Note:
   * On our BeagleBoard the SD card WP pin is always read as TRUE. 
   * Probably something wrong with GPIO configuration.
   * BeagleBoard-xM uses microSD cards so there is no write protect at all.
   * Hence commenting out SD card WP pin read status.  
   */
  //return (MmioRead32 (GPIO1_BASE + GPIO_DATAIN) & BIT23) == BIT23;
  return 0;

}

// TODO
EFI_GUID mPL180MciDevicePathGuid = EFI_CALLER_ID_GUID;

EFI_STATUS
MMCBuildDevicePath (
  IN EFI_DEVICE_PATH_PROTOCOL **DevicePath
  )
{
  EFI_DEVICE_PATH_PROTOCOL    *NewDevicePathNode;

  NewDevicePathNode = CreateDeviceNode(HARDWARE_DEVICE_PATH,HW_VENDOR_DP,sizeof(VENDOR_DEVICE_PATH));
  CopyGuid(&((VENDOR_DEVICE_PATH*)NewDevicePathNode)->Guid,&mPL180MciDevicePathGuid);
  *DevicePath = NewDevicePathNode;
  return EFI_SUCCESS;
}

EFI_STATUS
MMCSendCommand (
  IN MMC_CMD MmcCmd,
  IN UINT32 Argument
  )
{
  if (IgnoreCommand(MmcCmd))
    return EFI_SUCCESS;

  MmcCmd = TranslateCommand(MmcCmd);

  //DEBUG((EFI_D_ERROR, "MMCSendCommand(%d)\n", MmcCmd));
  UINTN MmcStatus;
  UINTN RetryCount = 0;

  //Check if command line is in use or not. Poll till command line is available.
  while ((MmioRead32 (MMCHS_PSTATE) & DATI_MASK) == DATI_NOT_ALLOWED);

  //Provide the block size.
  MmioWrite32 (MMCHS_BLK, BLEN_512BYTES);

  //Setting Data timeout counter value to max value.
  MmioAndThenOr32 (MMCHS_SYSCTL, ~DTO_MASK, DTO_VAL);

  //Clear Status register.
  MmioWrite32 (MMCHS_STAT, 0xFFFFFFFF);

  //Set command argument register
  MmioWrite32 (MMCHS_ARG, Argument);

  //TODO: fix this
  //Enable interrupt enable events to occur
  //MmioWrite32 (MMCHS_IE, CmdInterruptEnableVal);

  //Send a command
  MmioWrite32 (MMCHS_CMD, MmcCmd);

  //Check for the command status.
  while (RetryCount < MAX_RETRY_COUNT) {
    do {
      MmcStatus = MmioRead32 (MMCHS_STAT);
    } while (MmcStatus == 0);

    //Read status of command response
    if ((MmcStatus & ERRI) != 0) {

      //Perform soft-reset for mmci_cmd line.
      MmioOr32 (MMCHS_SYSCTL, SRC);
      while ((MmioRead32 (MMCHS_SYSCTL) & SRC));

      //DEBUG ((EFI_D_INFO, "MmcStatus: 0x%x\n", MmcStatus));
      return EFI_DEVICE_ERROR;
    }

    //Check if command is completed.
    if ((MmcStatus & CC) == CC) {
      MmioWrite32 (MMCHS_STAT, CC);
      break;
    }

    RetryCount++;
  }

  if (RetryCount == MAX_RETRY_COUNT) {
    DEBUG((EFI_D_ERROR, "MMCSendCommand: Timeout\n"));
    return EFI_TIMEOUT;
  }

  return EFI_SUCCESS;
}

EFI_STATUS
MMCNotifyState (
  IN MMC_STATE State
  )
{
  EFI_STATUS              Status;
  UINTN freqSel;
  switch(State) {
    case MmcInvalidState:
      ASSERT(0);
      break;
    case MmcHwInitializationState:
      BitModeSet = FALSE;

      DEBUG((EFI_D_ERROR, "MMCHwInitializationState()\n"));
      Status = InitializeMMCHS ();
      if (EFI_ERROR(Status)) {
        DEBUG ((EFI_D_ERROR, "Initialize MMC host controller fails. Status: %x\n", Status));
        return Status;
      }

      //Software reset of the MMCHS host controller.
      MmioWrite32 (MMCHS_SYSCONFIG, SOFTRESET);
      gBS->Stall(1000);
      while ((MmioRead32 (MMCHS_SYSSTATUS) & RESETDONE_MASK) != RESETDONE);

      //Soft reset for all.
      MmioWrite32 (MMCHS_SYSCTL, SRA);
      gBS->Stall(1000);
      while ((MmioRead32 (MMCHS_SYSCTL) & SRA) != 0x0);

      //Voltage capabilities initialization. Activate VS18 and VS30.
      MmioOr32 (MMCHS_CAPA, (VS30 | VS18));

      //Wakeup configuration
      MmioOr32 (MMCHS_SYSCONFIG, ENAWAKEUP);
      MmioOr32 (MMCHS_HCTL, IWE);

      //MMCHS Controller default initialization
      MmioOr32 (MMCHS_CON, (OD | DW8_1_4_BIT | CEATA_OFF));

      MmioWrite32 (MMCHS_HCTL, (SDVS_3_0_V | DTW_1_BIT | SDBP_OFF));

      //Enable internal clock
      MmioOr32 (MMCHS_SYSCTL, ICE);

      //Set the clock frequency to 80KHz.
      UpdateMMCHSClkFrequency (CLKD_80KHZ);

      //Enable SD bus power.
      MmioOr32 (MMCHS_HCTL, (SDBP_ON));

      //Poll till SD bus power bit is set.
      while ((MmioRead32 (MMCHS_HCTL) & SDBP_MASK) != SDBP_ON);

      //Enable interrupts.
      MmioWrite32 (MMCHS_IE, (BADA_EN | CERR_EN | DEB_EN | DCRC_EN | DTO_EN | CIE_EN |
        CEB_EN | CCRC_EN | CTO_EN | BRR_EN | BWR_EN | TC_EN | CC_EN));

      //Controller INIT procedure start.
      MmioOr32 (MMCHS_CON, INIT);
      MmioWrite32 (MMCHS_CMD, 0x00000000);
      while (!(MmioRead32 (MMCHS_STAT) & CC));

      //Wait for 1 ms
      gBS->Stall(1000);

      //Set CC bit to 0x1 to clear the flag
      MmioOr32 (MMCHS_STAT, CC);

      //Retry INIT procedure.
      MmioWrite32 (MMCHS_CMD, 0x00000000);
      while (!(MmioRead32 (MMCHS_STAT) & CC));

      //End initialization sequence
      MmioAnd32 (MMCHS_CON, ~INIT);

      MmioOr32 (MMCHS_HCTL, (SDVS_3_0_V | DTW_1_BIT | SDBP_ON));

      //Change clock frequency to 400KHz to fit protocol
      UpdateMMCHSClkFrequency(CLKD_400KHZ);

      MmioOr32 (MMCHS_CON, OD);
      break;
    case MmcIdleState:
      break;
    case MmcReadyState:
      break;
    case MmcIdentificationState:
      break;
    case MmcStandByState:
      CalculateCardCLKD(&freqSel);
      UpdateMMCHSClkFrequency(freqSel);
      break;
    case MmcTransferState:
      if (!BitModeSet) {
        Status = MMCSendCommand (CMD55, Rca << 16);
        if (!EFI_ERROR (Status)) {
          // set device into 4-bit data bus mode
          Status = MMCSendCommand (ACMD6, 0x2);
          if (!EFI_ERROR (Status)) {
          // Set host controler into 4-bit mode
            MmioOr32 (MMCHS_HCTL, DTW_4_BIT);
            DEBUG ((EFI_D_INFO, "SD Memory Card set to 4-bit mode\n"));
            BitModeSet = TRUE;
          }
        }
      }
      break;
    case MmcSendingDataState:
      break;
    case MmcReceiveDataState:
      break;
    case MmcProgrammingState:
      break;
    case MmcDisconnectState:
    default:
      ASSERT(0);
  }
  return EFI_SUCCESS;
}

EFI_STATUS
MMCReceiveResponse (
  IN MMC_RESPONSE_TYPE Type,
  IN UINT32* Buffer
  )
{
  //DEBUG((EFI_D_ERROR, "MMCReceiveResponse()\n"));
  if (Buffer == NULL) {
    DEBUG((EFI_D_ERROR, "Buffer was NULL\n"));
    return EFI_INVALID_PARAMETER;
  }

  if (Type == MMC_RESPONSE_TYPE_R2) {
    Buffer[0] = MmioRead32 (MMCHS_RSP10);
    Buffer[1] = MmioRead32 (MMCHS_RSP32);
    Buffer[2] = MmioRead32 (MMCHS_RSP54);
    Buffer[3] = MmioRead32 (MMCHS_RSP76);
  } else {
    Buffer[0] = MmioRead32 (MMCHS_RSP10);
  }

  if (Type == MMC_RESPONSE_TYPE_CSD) {
    MaxDataTransferRate = Buffer[3] & 0xFF;
  } else if (Type == MMC_RESPONSE_TYPE_RCA) {
    Rca = Buffer[0] >> 16;
  }

  return EFI_SUCCESS;
}

EFI_STATUS
MMCReadBlockData (
  IN EFI_LBA Lba,
  IN UINTN Length,
  IN UINT32* Buffer
  )
{
  //DEBUG((EFI_D_ERROR, "MMCReadBlockData(LBA: 0x%x, ", Lba));
  //DEBUG((EFI_D_ERROR, "Length: 0x%x, ", Length));
  //DEBUG((EFI_D_ERROR, "Buffer: 0x%x)\n", Buffer));
  UINTN MmcStatus;
  UINTN Count;
  UINTN RetryCount = 0;

  //Check controller status to make sure there is no error.
  while (RetryCount < MAX_RETRY_COUNT) {
    do {
      //Read Status.
      MmcStatus = MmioRead32 (MMCHS_STAT);
    } while(MmcStatus == 0);

    //Check if Buffer read ready (BRR) bit is set?
    if (MmcStatus & BRR) {

      //Clear BRR bit
      MmioOr32 (MMCHS_STAT, BRR);

      for (Count = 0; Count < Length / 4; Count++) {
        *Buffer++ = MmioRead32(MMCHS_DATA);
      }
      break;
    }
    RetryCount++;
  }

  if (RetryCount == MAX_RETRY_COUNT) {
    return EFI_TIMEOUT;
  }

  return EFI_SUCCESS;
}

EFI_STATUS
MMCWriteBlockData (
  IN EFI_LBA Lba,
  IN UINTN Length,
  IN UINT32* Buffer
  )
{
  UINTN MmcStatus;
  UINTN Count;
  UINTN RetryCount = 0;

  //Check controller status to make sure there is no error.
  while (RetryCount < MAX_RETRY_COUNT) {
    do {
      //Read Status.
      MmcStatus = MmioRead32 (MMCHS_STAT);
    } while(MmcStatus == 0);

    //Check if Buffer write ready (BWR) bit is set?
    if (MmcStatus & BWR) {

      //Clear BWR bit
      MmioOr32 (MMCHS_STAT, BWR);

      //Write block worth of data.
      for (Count = 0; Count < Length / 4; Count++) {
        MmioWrite32 (MMCHS_DATA, *Buffer++);
      }

      break;
    }
    RetryCount++;
  }

  if (RetryCount == MAX_RETRY_COUNT) {
    return EFI_TIMEOUT;
  }

  return EFI_SUCCESS;
}

EFI_MMC_HOST_PROTOCOL gMMCHost = {
  MMCIsCardPresent,
  MMCIsReadOnly,
  MMCBuildDevicePath,
  MMCNotifyState,
  MMCSendCommand,
  MMCReceiveResponse,
  MMCReadBlockData,
  MMCWriteBlockData
};

EFI_STATUS
MMCInitialize (
  IN EFI_HANDLE         ImageHandle,
  IN EFI_SYSTEM_TABLE   *SystemTable
  )
{
  DEBUG((EFI_D_ERROR, "MMCInitialize()\n"));
  EFI_STATUS    Status;
  EFI_HANDLE    Handle = NULL;

  Status = gBS->LocateProtocol (&gEmbeddedExternalDeviceProtocolGuid, NULL, (VOID **)&gTPS65950);
  ASSERT_EFI_ERROR(Status);

  Status = gBS->InstallMultipleProtocolInterfaces (
                  &Handle, 
                  &gEfiMmcHostProtocolGuid,         &gMMCHost,
                  NULL
                  );
  ASSERT_EFI_ERROR (Status);

  return Status;
}
Commit	Line	Data
5ec65e96	1	/** @file
	2	*
	3	* Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.
	4	* Copyright (c) 2011, ARM Limited. All rights reserved.
	5	*
	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
	10	*
	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.
	13	*
	14	**/
	15
	16	#include "MmcHostDxe.h"
	17
	18	EMBEDDED_EXTERNAL_DEVICE *gTPS65950;
	19	UINT8 MaxDataTransferRate = 0;
	20	UINT32 Rca = 0;
	21	BOOLEAN BitModeSet = FALSE;
	22
	23
	24	typedef struct {
	25	VENDOR_DEVICE_PATH Mmc;
	26	EFI_DEVICE_PATH End;
	27	} MMCHS_DEVICE_PATH;
	28
	29	MMCHS_DEVICE_PATH gMMCDevicePath = {
	30	{
	31	HARDWARE_DEVICE_PATH,
	32	HW_VENDOR_DP,
	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
	36	},
	37	{
	38	END_DEVICE_PATH_TYPE,
	39	END_ENTIRE_DEVICE_PATH_SUBTYPE,
	40	sizeof (EFI_DEVICE_PATH_PROTOCOL),
	41	0
	42	}
	43	};
	44
	45	BOOLEAN
	46	IgnoreCommand (
	47	UINT32 Command
	48	)
	49	{
	50	switch(Command) {
	51	case MMC_CMD12:
	52	return TRUE;
	53	case MMC_CMD13:
	54	return TRUE;
	55	default:
	56	return FALSE;
	57	}
	58	}
	59
	60	UINT32
	61	TranslateCommand (
	62	UINT32 Command
	63	)
	64	{
65	UINT32 Translation;
66
67	switch(Command) {
68	case MMC_CMD2:
69	Translation = CMD2;
70	break;
71	case MMC_CMD3:
72	Translation = CMD3;
73	break;
74	/*case MMC_CMD6:
75	Translation = CMD6;
76	break;*/
77	case MMC_CMD7:
78	Translation = CMD7;
79	break;
80	case MMC_CMD8:
81	Translation = CMD8;
82	break;
83	case MMC_CMD9:
84	Translation = CMD9;
85	break;
86	/*case MMC_CMD12:
87	Translation = CMD12;
88	break;
89	case MMC_CMD13:
90	Translation = CMD13;
91	break;*/
92	case MMC_CMD16:
93	Translation = CMD16;
94	break;
95	case MMC_CMD17:
96	Translation = 0x113A0014;//CMD17;
97	break;
98	case MMC_CMD24:
99	Translation = CMD24 \| 4;
100	break;
101	case MMC_CMD55:
102	Translation = CMD55;
103	break;
104	case MMC_ACMD41:
105	Translation = ACMD41;
106	break;
107	default:
108	Translation = Command;
109	}
110
111	return Translation;
112	}
113
114	VOID
115	CalculateCardCLKD (
116	UINTN *ClockFrequencySelect
117	)
118	{
119	DEBUG((EFI_D_ERROR, "CalculateCardCLKD()\n"));
120	UINTN TransferRateValue = 0;
121	UINTN TimeValue = 0 ;
122	UINTN Frequency = 0;
123
124	// For SD Cards we would need to send CMD6 to set
125	// speeds abouve 25MHz. High Speed mode 50 MHz and up
126
127	//Calculate Transfer rate unit (Bits 2:0 of TRAN_SPEED)
128	switch (MaxDataTransferRate & 0x7) { // 2
129	case 0:
130	TransferRateValue = 100 * 1000;
131	break;
132
133	case 1:
134	TransferRateValue = 1 * 1000 * 1000;
135	break;
136
137	case 2:
138	TransferRateValue = 10 * 1000 * 1000;
139	break;
140
141	case 3:
142	TransferRateValue = 100 * 1000 * 1000;
143	break;
144
145	default:
146	DEBUG((EFI_D_ERROR, "Invalid parameter.\n"));
147	ASSERT(FALSE);
148	}
149
150	//Calculate Time value (Bits 6:3 of TRAN_SPEED)
151	switch ((MaxDataTransferRate >> 3) & 0xF) { // 6
152	case 1:
153	TimeValue = 10;
154	break;
155
156	case 2:
157	TimeValue = 12;
158	break;
159
160	case 3:
161	TimeValue = 13;
162	break;
163
164	case 4:
165	TimeValue = 15;
166	break;
167
168	case 5:
169	TimeValue = 20;
170	break;
171
172	case 6:
173	TimeValue = 25;
174	break;
175
176	case 7:
177	TimeValue = 30;
178	break;
179
180	case 8:
181	TimeValue = 35;
182	break;
183
184	case 9:
185	TimeValue = 40;
186	break;
187
188	case 10:
189	TimeValue = 45;
190	break;
191
192	case 11:
193	TimeValue = 50;
194	break;
195
196	case 12:
197	TimeValue = 55;
198	break;
199
200	case 13:
201	TimeValue = 60;
202	break;
203
204	case 14:
205	TimeValue = 70;
206	break;
207
208	case 15:
209	TimeValue = 80;
210	break;
211
212	default:
213	DEBUG((EFI_D_ERROR, "Invalid parameter.\n"));
214	ASSERT(FALSE);
215	}
216
217	Frequency = TransferRateValue * TimeValue/10;
218
219	//Calculate Clock divider value to program in MMCHS_SYSCTL[CLKD] field.
220	*ClockFrequencySelect = ((MMC_REFERENCE_CLK/Frequency) + 1);
221
222	DEBUG ((EFI_D_INFO, "MaxDataTransferRate: 0x%x, Frequency: %d KHz, ClockFrequencySelect: %x\n", MaxDataTransferRate, Frequency/1000, *ClockFrequencySelect));
223	}
224
225	VOID
226	UpdateMMCHSClkFrequency (
227	UINTN NewCLKD
228	)
229	{
230	DEBUG((EFI_D_ERROR, "UpdateMMCHSClkFrequency()\n"));
231	//Set Clock enable to 0x0 to not provide the clock to the card
232	MmioAnd32 (MMCHS_SYSCTL, ~CEN);
233
234	//Set new clock frequency.
235	MmioAndThenOr32 (MMCHS_SYSCTL, ~CLKD_MASK, NewCLKD << 6);
236
237	//Poll till Internal Clock Stable
238	while ((MmioRead32 (MMCHS_SYSCTL) & ICS_MASK) != ICS);
239
240	//Set Clock enable to 0x1 to provide the clock to the card
241	MmioOr32 (MMCHS_SYSCTL, CEN);
242	}
243
244	EFI_STATUS
245	InitializeMMCHS (
246	VOID
247	)
248	{
249	DEBUG((EFI_D_ERROR, "InitializeMMCHS()\n"));
250	UINT8 Data = 0;
251	EFI_STATUS Status;
252
253	//Select Device group to belong to P1 device group in Power IC.
254	Data = DEV_GRP_P1;
255	Status = gTPS65950->Write (gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID4, VMMC1_DEV_GRP), 1, &Data);
256	ASSERT_EFI_ERROR(Status);
257
258	//Configure voltage regulator for MMC1 in Power IC to output 3.0 voltage.
259	Data = VSEL_3_00V;
260	Status = gTPS65950->Write (gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID4, VMMC1_DEDICATED_REG), 1, &Data);
261	ASSERT_EFI_ERROR(Status);
262
263	//After ramping up voltage, set VDDS stable bit to indicate that voltage level is stable.
264	MmioOr32 (CONTROL_PBIAS_LITE, (PBIASLITEVMODE0 \| PBIASLITEPWRDNZ0 \| PBIASSPEEDCTRL0 \| PBIASLITEVMODE1 \| PBIASLITEWRDNZ1));
265
266	// Enable WP GPIO
267	MmioAndThenOr32 (GPIO1_BASE + GPIO_OE, ~BIT23, BIT23);
268
269	// Enable Card Detect
270	Data = CARD_DETECT_ENABLE;
271	gTPS65950->Write (gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID2, TPS65950_GPIO_CTRL), 1, &Data);
272
273
274	return Status;
275	}
276
277	BOOLEAN
278	MMCIsCardPresent (
279	VOID
280	)
281	{
282	//DEBUG((EFI_D_ERROR, "MMCIsCardPresent()\n"));
283	EFI_STATUS Status;
284	UINT8 Data;
285
286	//
287	// Card detect is a GPIO0 on the TPS65950
288	//
289	Status = gTPS65950->Read (gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID2, GPIODATAIN1), 1, &Data);
290	if (EFI_ERROR (Status)) {
291	return FALSE;
292	}
293
294	return !(Data & CARD_DETECT_BIT);
295	}
296
297	BOOLEAN
298	MMCIsReadOnly (
299	VOID
300	)
301	{
302	/* Note:
303	* On our BeagleBoard the SD card WP pin is always read as TRUE.
304	* Probably something wrong with GPIO configuration.
305	* BeagleBoard-xM uses microSD cards so there is no write protect at all.
306	* Hence commenting out SD card WP pin read status.
307	*/
308	//return (MmioRead32 (GPIO1_BASE + GPIO_DATAIN) & BIT23) == BIT23;
309	return 0;
310
311	}
312
313	// TODO
314	EFI_GUID mPL180MciDevicePathGuid = EFI_CALLER_ID_GUID;
315
316	EFI_STATUS
317	MMCBuildDevicePath (
318	IN EFI_DEVICE_PATH_PROTOCOL **DevicePath
319	)
320	{
321	EFI_DEVICE_PATH_PROTOCOL *NewDevicePathNode;
322
323	NewDevicePathNode = CreateDeviceNode(HARDWARE_DEVICE_PATH,HW_VENDOR_DP,sizeof(VENDOR_DEVICE_PATH));
324	CopyGuid(&((VENDOR_DEVICE_PATH*)NewDevicePathNode)->Guid,&mPL180MciDevicePathGuid);
325	*DevicePath = NewDevicePathNode;
326	return EFI_SUCCESS;
327	}
328
329	EFI_STATUS
330	MMCSendCommand (
331	IN MMC_CMD MmcCmd,
332	IN UINT32 Argument
333	)
334	{
335	if (IgnoreCommand(MmcCmd))
336	return EFI_SUCCESS;
337
338	MmcCmd = TranslateCommand(MmcCmd);
339
340	//DEBUG((EFI_D_ERROR, "MMCSendCommand(%d)\n", MmcCmd));
341	UINTN MmcStatus;
342	UINTN RetryCount = 0;
343
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);
346
347	//Provide the block size.
348	MmioWrite32 (MMCHS_BLK, BLEN_512BYTES);
349
350	//Setting Data timeout counter value to max value.
351	MmioAndThenOr32 (MMCHS_SYSCTL, ~DTO_MASK, DTO_VAL);
352
353	//Clear Status register.
354	MmioWrite32 (MMCHS_STAT, 0xFFFFFFFF);
355
356	//Set command argument register
357	MmioWrite32 (MMCHS_ARG, Argument);
358
359	//TODO: fix this
360	//Enable interrupt enable events to occur
361	//MmioWrite32 (MMCHS_IE, CmdInterruptEnableVal);
362
363	//Send a command
364	MmioWrite32 (MMCHS_CMD, MmcCmd);
365
366	//Check for the command status.
367	while (RetryCount < MAX_RETRY_COUNT) {
368	do {
369	MmcStatus = MmioRead32 (MMCHS_STAT);
370	} while (MmcStatus == 0);
371
372	//Read status of command response
373	if ((MmcStatus & ERRI) != 0) {
374
375	//Perform soft-reset for mmci_cmd line.
376	MmioOr32 (MMCHS_SYSCTL, SRC);
377	while ((MmioRead32 (MMCHS_SYSCTL) & SRC));
378
379	//DEBUG ((EFI_D_INFO, "MmcStatus: 0x%x\n", MmcStatus));
380	return EFI_DEVICE_ERROR;
381	}
382
383	//Check if command is completed.
384	if ((MmcStatus & CC) == CC) {
385	MmioWrite32 (MMCHS_STAT, CC);
386	break;
387	}
388
389	RetryCount++;
390	}
391
392	if (RetryCount == MAX_RETRY_COUNT) {
393	DEBUG((EFI_D_ERROR, "MMCSendCommand: Timeout\n"));
394	return EFI_TIMEOUT;
395	}
396
397	return EFI_SUCCESS;
398	}
399
400	EFI_STATUS
401	MMCNotifyState (
402	IN MMC_STATE State
403	)
404	{
405	EFI_STATUS Status;
406	UINTN freqSel;
407	switch(State) {
408	case MmcInvalidState:
409	ASSERT(0);
410	break;
411	case MmcHwInitializationState:
412	BitModeSet = FALSE;
413
414	DEBUG((EFI_D_ERROR, "MMCHwInitializationState()\n"));
415	Status = InitializeMMCHS ();
416	if (EFI_ERROR(Status)) {
417	DEBUG ((EFI_D_ERROR, "Initialize MMC host controller fails. Status: %x\n", Status));
418	return Status;
419	}
420
421	//Software reset of the MMCHS host controller.
422	MmioWrite32 (MMCHS_SYSCONFIG, SOFTRESET);
423	gBS->Stall(1000);
424	while ((MmioRead32 (MMCHS_SYSSTATUS) & RESETDONE_MASK) != RESETDONE);
425
426	//Soft reset for all.
427	MmioWrite32 (MMCHS_SYSCTL, SRA);
428	gBS->Stall(1000);
429	while ((MmioRead32 (MMCHS_SYSCTL) & SRA) != 0x0);
430
431	//Voltage capabilities initialization. Activate VS18 and VS30.
432	MmioOr32 (MMCHS_CAPA, (VS30 \| VS18));
433
434	//Wakeup configuration
435	MmioOr32 (MMCHS_SYSCONFIG, ENAWAKEUP);
436	MmioOr32 (MMCHS_HCTL, IWE);
437
438	//MMCHS Controller default initialization
439	MmioOr32 (MMCHS_CON, (OD \| DW8_1_4_BIT \| CEATA_OFF));
440
441	MmioWrite32 (MMCHS_HCTL, (SDVS_3_0_V \| DTW_1_BIT \| SDBP_OFF));
442
443	//Enable internal clock
444	MmioOr32 (MMCHS_SYSCTL, ICE);
445
446	//Set the clock frequency to 80KHz.
447	UpdateMMCHSClkFrequency (CLKD_80KHZ);
448
449	//Enable SD bus power.
450	MmioOr32 (MMCHS_HCTL, (SDBP_ON));
451
452	//Poll till SD bus power bit is set.
453	while ((MmioRead32 (MMCHS_HCTL) & SDBP_MASK) != SDBP_ON);
454
455	//Enable interrupts.
456	MmioWrite32 (MMCHS_IE, (BADA_EN \| CERR_EN \| DEB_EN \| DCRC_EN \| DTO_EN \| CIE_EN \|
457	CEB_EN \| CCRC_EN \| CTO_EN \| BRR_EN \| BWR_EN \| TC_EN \| CC_EN));
458
459	//Controller INIT procedure start.
460	MmioOr32 (MMCHS_CON, INIT);
461	MmioWrite32 (MMCHS_CMD, 0x00000000);
462	while (!(MmioRead32 (MMCHS_STAT) & CC));
463
464	//Wait for 1 ms
465	gBS->Stall(1000);
466
467	//Set CC bit to 0x1 to clear the flag
468	MmioOr32 (MMCHS_STAT, CC);
469
470	//Retry INIT procedure.
471	MmioWrite32 (MMCHS_CMD, 0x00000000);
472	while (!(MmioRead32 (MMCHS_STAT) & CC));
473
474	//End initialization sequence
475	MmioAnd32 (MMCHS_CON, ~INIT);
476
477	MmioOr32 (MMCHS_HCTL, (SDVS_3_0_V \| DTW_1_BIT \| SDBP_ON));
478
479	//Change clock frequency to 400KHz to fit protocol
480	UpdateMMCHSClkFrequency(CLKD_400KHZ);
481
482	MmioOr32 (MMCHS_CON, OD);
483	break;
484	case MmcIdleState:
485	break;
486	case MmcReadyState:
487	break;
488	case MmcIdentificationState:
489	break;
490	case MmcStandByState:
491	CalculateCardCLKD(&freqSel);
492	UpdateMMCHSClkFrequency(freqSel);
493	break;
494	case MmcTransferState:
495	if (!BitModeSet) {
496	Status = MMCSendCommand (CMD55, Rca << 16);
497	if (!EFI_ERROR (Status)) {
498	// set device into 4-bit data bus mode
499	Status = MMCSendCommand (ACMD6, 0x2);
500	if (!EFI_ERROR (Status)) {
501	// Set host controler into 4-bit mode
502	MmioOr32 (MMCHS_HCTL, DTW_4_BIT);
503	DEBUG ((EFI_D_INFO, "SD Memory Card set to 4-bit mode\n"));
504	BitModeSet = TRUE;
505	}
506	}
507	}
508	break;
509	case MmcSendingDataState:
510	break;
511	case MmcReceiveDataState:
512	break;
513	case MmcProgrammingState:
514	break;
515	case MmcDisconnectState:
516	default:
517	ASSERT(0);
518	}
519	return EFI_SUCCESS;
520	}
521
522	EFI_STATUS
523	MMCReceiveResponse (
524	IN MMC_RESPONSE_TYPE Type,
525	IN UINT32* Buffer
526	)
527	{
528	//DEBUG((EFI_D_ERROR, "MMCReceiveResponse()\n"));
529	if (Buffer == NULL) {
530	DEBUG((EFI_D_ERROR, "Buffer was NULL\n"));
531	return EFI_INVALID_PARAMETER;
532	}
533
534	if (Type == MMC_RESPONSE_TYPE_R2) {
535	Buffer[0] = MmioRead32 (MMCHS_RSP10);
536	Buffer[1] = MmioRead32 (MMCHS_RSP32);
537	Buffer[2] = MmioRead32 (MMCHS_RSP54);
538	Buffer[3] = MmioRead32 (MMCHS_RSP76);
539	} else {
540	Buffer[0] = MmioRead32 (MMCHS_RSP10);
541	}
542
543	if (Type == MMC_RESPONSE_TYPE_CSD) {
544	MaxDataTransferRate = Buffer[3] & 0xFF;
545	} else if (Type == MMC_RESPONSE_TYPE_RCA) {
546	Rca = Buffer[0] >> 16;
547	}
548
549	return EFI_SUCCESS;
550	}
551
552	EFI_STATUS
553	MMCReadBlockData (
554	IN EFI_LBA Lba,
555	IN UINTN Length,
556	IN UINT32* Buffer
557	)
558	{
559	//DEBUG((EFI_D_ERROR, "MMCReadBlockData(LBA: 0x%x, ", Lba));
560	//DEBUG((EFI_D_ERROR, "Length: 0x%x, ", Length));
561	//DEBUG((EFI_D_ERROR, "Buffer: 0x%x)\n", Buffer));
562	UINTN MmcStatus;
563	UINTN Count;
564	UINTN RetryCount = 0;
565
566	//Check controller status to make sure there is no error.
567	while (RetryCount < MAX_RETRY_COUNT) {
568	do {
569	//Read Status.
570	MmcStatus = MmioRead32 (MMCHS_STAT);
571	} while(MmcStatus == 0);
572
573	//Check if Buffer read ready (BRR) bit is set?
574	if (MmcStatus & BRR) {
575
576	//Clear BRR bit
577	MmioOr32 (MMCHS_STAT, BRR);
578
579	for (Count = 0; Count < Length / 4; Count++) {
580	*Buffer++ = MmioRead32(MMCHS_DATA);
581	}
582	break;
583	}
584	RetryCount++;
585	}
586
587	if (RetryCount == MAX_RETRY_COUNT) {
588	return EFI_TIMEOUT;
589	}
590
591	return EFI_SUCCESS;
592	}
593
594	EFI_STATUS
595	MMCWriteBlockData (
596	IN EFI_LBA Lba,
597	IN UINTN Length,
598	IN UINT32* Buffer
599	)
600	{
601	UINTN MmcStatus;
602	UINTN Count;
603	UINTN RetryCount = 0;
604
605	//Check controller status to make sure there is no error.
606	while (RetryCount < MAX_RETRY_COUNT) {
607	do {
608	//Read Status.
609	MmcStatus = MmioRead32 (MMCHS_STAT);
610	} while(MmcStatus == 0);
611
612	//Check if Buffer write ready (BWR) bit is set?
613	if (MmcStatus & BWR) {
614
615	//Clear BWR bit
616	MmioOr32 (MMCHS_STAT, BWR);
617
618	//Write block worth of data.
619	for (Count = 0; Count < Length / 4; Count++) {
620	MmioWrite32 (MMCHS_DATA, *Buffer++);
621	}
622
623	break;
624	}
625	RetryCount++;
626	}
627
628	if (RetryCount == MAX_RETRY_COUNT) {
629	return EFI_TIMEOUT;
630	}
631
632	return EFI_SUCCESS;
633	}
634
635	EFI_MMC_HOST_PROTOCOL gMMCHost = {
636	MMCIsCardPresent,
637	MMCIsReadOnly,
638	MMCBuildDevicePath,
639	MMCNotifyState,
640	MMCSendCommand,
641	MMCReceiveResponse,
642	MMCReadBlockData,
643	MMCWriteBlockData
644	};
645
646	EFI_STATUS
647	MMCInitialize (
648	IN EFI_HANDLE ImageHandle,
649	IN EFI_SYSTEM_TABLE *SystemTable
650	)
651	{
652	DEBUG((EFI_D_ERROR, "MMCInitialize()\n"));
653	EFI_STATUS Status;
654	EFI_HANDLE Handle = NULL;
655
656	Status = gBS->LocateProtocol (&gEmbeddedExternalDeviceProtocolGuid, NULL, (VOID **)&gTPS65950);
657	ASSERT_EFI_ERROR(Status);
658
659	Status = gBS->InstallMultipleProtocolInterfaces (
660	&Handle,
661	&gEfiMmcHostProtocolGuid, &gMMCHost,
662	NULL
663	);
664	ASSERT_EFI_ERROR (Status);
665
666	return Status;
667	}