[mirror_edk2.git] / Omap35xxPkg / MMCHSDxe / MMCHS.c

/** @file\r
  MMC/SD Card driver for OMAP 35xx (SDIO not supported)\r
\r
  This driver always produces a BlockIo protocol but it starts off with no Media\r
  present. A TimerCallBack detects when media is inserted or removed and after\r
  a media change event a call to BlockIo ReadBlocks/WriteBlocks will cause the\r
  media to be detected (or removed) and the BlockIo Media structure will get\r
  updated. No MMC/SD Card harward registers are updated until the first BlockIo\r
  ReadBlocks/WriteBlocks after media has been insterted (booting with a card\r
  plugged in counts as an insertion event).\r
\r
  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>\r
\r
  SPDX-License-Identifier: BSD-2-Clause-Patent\r
\r
**/\r
\r
#include "MMCHS.h"\r
\r
EFI_BLOCK_IO_MEDIA gMMCHSMedia = {\r
  SIGNATURE_32('s','d','i','o'),            // MediaId\r
  TRUE,                                     // RemovableMedia\r
  FALSE,                                    // MediaPresent\r
  FALSE,                                    // LogicalPartition\r
  FALSE,                                    // ReadOnly\r
  FALSE,                                    // WriteCaching\r
  512,                                      // BlockSize\r
  4,                                        // IoAlign\r
  0,                                        // Pad\r
  0                                         // LastBlock\r
};\r
\r
typedef struct {\r
  VENDOR_DEVICE_PATH  Mmc;\r
  EFI_DEVICE_PATH     End;\r
} MMCHS_DEVICE_PATH;\r
\r
MMCHS_DEVICE_PATH gMmcHsDevicePath = {\r
  {\r
    {\r
      HARDWARE_DEVICE_PATH,\r
      HW_VENDOR_DP,\r
      {\r
        (UINT8)(sizeof(VENDOR_DEVICE_PATH)),\r
        (UINT8)((sizeof(VENDOR_DEVICE_PATH)) >> 8),\r
      },\r
    },\r
    { 0xb615f1f5, 0x5088, 0x43cd, { 0x80, 0x9c, 0xa1, 0x6e, 0x52, 0x48, 0x7d, 0x00 } },\r
  },\r
  {\r
    END_DEVICE_PATH_TYPE,\r
    END_ENTIRE_DEVICE_PATH_SUBTYPE,\r
    { sizeof (EFI_DEVICE_PATH_PROTOCOL), 0 }\r
  }\r
};\r
\r
CARD_INFO                  gCardInfo;\r
EMBEDDED_EXTERNAL_DEVICE   *gTPS65950;\r
EFI_EVENT                  gTimerEvent;\r
BOOLEAN                    gMediaChange = FALSE;\r
\r
//\r
// Internal Functions\r
//\r
\r
\r
VOID\r
ParseCardCIDData (\r
  UINT32 Response0,\r
  UINT32 Response1,\r
  UINT32 Response2,\r
  UINT32 Response3\r
  )\r
{\r
  gCardInfo.CIDData.MDT = ((Response0 >> 8) & 0xFFF);\r
  gCardInfo.CIDData.PSN = (((Response0 >> 24) & 0xFF) | ((Response1 & 0xFFFFFF) << 8));\r
  gCardInfo.CIDData.PRV = ((Response1 >> 24) & 0xFF);\r
  gCardInfo.CIDData.PNM[4] = ((Response2) & 0xFF);\r
  gCardInfo.CIDData.PNM[3] = ((Response2 >> 8) & 0xFF);\r
  gCardInfo.CIDData.PNM[2] = ((Response2 >> 16) & 0xFF);\r
  gCardInfo.CIDData.PNM[1] = ((Response2 >> 24) & 0xFF);\r
  gCardInfo.CIDData.PNM[0] = ((Response3) & 0xFF);\r
  gCardInfo.CIDData.OID = ((Response3 >> 8) & 0xFFFF);\r
  gCardInfo.CIDData.MID = ((Response3 >> 24) & 0xFF);\r
}\r
\r
\r
VOID\r
UpdateMMCHSClkFrequency (\r
  UINTN NewCLKD\r
  )\r
{\r
  //Set Clock enable to 0x0 to not provide the clock to the card\r
  MmioAnd32 (MMCHS_SYSCTL, ~CEN);\r
\r
  //Set new clock frequency.\r
  MmioAndThenOr32 (MMCHS_SYSCTL, ~CLKD_MASK, NewCLKD << 6);\r
\r
  //Poll till Internal Clock Stable\r
  while ((MmioRead32 (MMCHS_SYSCTL) & ICS_MASK) != ICS);\r
\r
  //Set Clock enable to 0x1 to provide the clock to the card\r
  MmioOr32 (MMCHS_SYSCTL, CEN);\r
}\r
\r
\r
EFI_STATUS\r
SendCmd (\r
  UINTN Cmd,\r
  UINTN CmdInterruptEnableVal,\r
  UINTN CmdArgument\r
  )\r
{\r
  UINTN MmcStatus;\r
  UINTN RetryCount = 0;\r
\r
  //Check if command line is in use or not. Poll till command line is available.\r
  while ((MmioRead32 (MMCHS_PSTATE) & DATI_MASK) == DATI_NOT_ALLOWED);\r
\r
  //Provide the block size.\r
  MmioWrite32 (MMCHS_BLK, BLEN_512BYTES);\r
\r
  //Setting Data timeout counter value to max value.\r
  MmioAndThenOr32 (MMCHS_SYSCTL, ~DTO_MASK, DTO_VAL);\r
\r
  //Clear Status register.\r
  MmioWrite32 (MMCHS_STAT, 0xFFFFFFFF);\r
\r
  //Set command argument register\r
  MmioWrite32 (MMCHS_ARG, CmdArgument);\r
\r
  //Enable interrupt enable events to occur\r
  MmioWrite32 (MMCHS_IE, CmdInterruptEnableVal);\r
\r
  //Send a command\r
  MmioWrite32 (MMCHS_CMD, Cmd);\r
\r
  //Check for the command status.\r
  while (RetryCount < MAX_RETRY_COUNT) {\r
    do {\r
      MmcStatus = MmioRead32 (MMCHS_STAT);\r
    } while (MmcStatus == 0);\r
\r
    //Read status of command response\r
    if ((MmcStatus & ERRI) != 0) {\r
\r
      //Perform soft-reset for mmci_cmd line.\r
      MmioOr32 (MMCHS_SYSCTL, SRC);\r
      while ((MmioRead32 (MMCHS_SYSCTL) & SRC));\r
\r
      DEBUG ((EFI_D_INFO, "MmcStatus: %x\n", MmcStatus));\r
      return EFI_DEVICE_ERROR;\r
    }\r
\r
    //Check if command is completed.\r
    if ((MmcStatus & CC) == CC) {\r
      MmioWrite32 (MMCHS_STAT, CC);\r
      break;\r
    }\r
\r
    RetryCount++;\r
  }\r
\r
  if (RetryCount == MAX_RETRY_COUNT) {\r
    return EFI_TIMEOUT;\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
\r
VOID\r
GetBlockInformation (\r
  UINTN *BlockSize,\r
  UINTN *NumBlocks\r
  )\r
{\r
  CSD_SDV2 *CsdSDV2Data;\r
  UINTN    CardSize;\r
\r
  if (gCardInfo.CardType == SD_CARD_2_HIGH) {\r
    CsdSDV2Data = (CSD_SDV2 *)&gCardInfo.CSDData;\r
\r
    //Populate BlockSize.\r
    *BlockSize = (0x1UL << CsdSDV2Data->READ_BL_LEN);\r
\r
    //Calculate Total number of blocks.\r
    CardSize = CsdSDV2Data->C_SIZELow16 | (CsdSDV2Data->C_SIZEHigh6 << 2);\r
    *NumBlocks = ((CardSize + 1) * 1024);\r
  } else {\r
    //Populate BlockSize.\r
    *BlockSize = (0x1UL << gCardInfo.CSDData.READ_BL_LEN);\r
\r
    //Calculate Total number of blocks.\r
    CardSize = gCardInfo.CSDData.C_SIZELow2 | (gCardInfo.CSDData.C_SIZEHigh10 << 2);\r
    *NumBlocks = (CardSize + 1) * (1 << (gCardInfo.CSDData.C_SIZE_MULT + 2));\r
  }\r
\r
  //For >=2G card, BlockSize may be 1K, but the transfer size is 512 bytes.\r
  if (*BlockSize > 512) {\r
    *NumBlocks = MultU64x32(*NumBlocks, *BlockSize/2);\r
    *BlockSize = 512;\r
  }\r
\r
  DEBUG ((EFI_D_INFO, "Card type: %x, BlockSize: %x, NumBlocks: %x\n", gCardInfo.CardType, *BlockSize, *NumBlocks));\r
}\r
\r
\r
VOID\r
CalculateCardCLKD (\r
  UINTN *ClockFrequencySelect\r
  )\r
{\r
  UINT8    MaxDataTransferRate;\r
  UINTN    TransferRateValue = 0;\r
  UINTN    TimeValue = 0 ;\r
  UINTN    Frequency = 0;\r
\r
  MaxDataTransferRate = gCardInfo.CSDData.TRAN_SPEED;\r
\r
  // For SD Cards  we would need to send CMD6 to set\r
  // speeds abouve 25MHz. High Speed mode 50 MHz and up\r
\r
  //Calculate Transfer rate unit (Bits 2:0 of TRAN_SPEED)\r
  switch (MaxDataTransferRate & 0x7) {\r
    case 0:\r
      TransferRateValue = 100 * 1000;\r
      break;\r
\r
    case 1:\r
      TransferRateValue = 1 * 1000 * 1000;\r
      break;\r
\r
    case 2:\r
      TransferRateValue = 10 * 1000 * 1000;\r
      break;\r
\r
    case 3:\r
      TransferRateValue = 100 * 1000 * 1000;\r
      break;\r
\r
    default:\r
      DEBUG((EFI_D_ERROR, "Invalid parameter.\n"));\r
      ASSERT(FALSE);\r
  }\r
\r
  //Calculate Time value (Bits 6:3 of TRAN_SPEED)\r
  switch ((MaxDataTransferRate >> 3) & 0xF) {\r
    case 1:\r
      TimeValue = 10;\r
      break;\r
\r
    case 2:\r
      TimeValue = 12;\r
      break;\r
\r
    case 3:\r
      TimeValue = 13;\r
      break;\r
\r
    case 4:\r
      TimeValue = 15;\r
      break;\r
\r
    case 5:\r
      TimeValue = 20;\r
      break;\r
\r
    case 6:\r
      TimeValue = 25;\r
      break;\r
\r
    case 7:\r
      TimeValue = 30;\r
      break;\r
\r
    case 8:\r
      TimeValue = 35;\r
      break;\r
\r
    case 9:\r
      TimeValue = 40;\r
      break;\r
\r
    case 10:\r
      TimeValue = 45;\r
      break;\r
\r
    case 11:\r
      TimeValue = 50;\r
      break;\r
\r
    case 12:\r
      TimeValue = 55;\r
      break;\r
\r
    case 13:\r
      TimeValue = 60;\r
      break;\r
\r
    case 14:\r
      TimeValue = 70;\r
      break;\r
\r
    case 15:\r
      TimeValue = 80;\r
      break;\r
\r
    default:\r
      DEBUG((EFI_D_ERROR, "Invalid parameter.\n"));\r
      ASSERT(FALSE);\r
  }\r
\r
  Frequency = TransferRateValue * TimeValue/10;\r
\r
  //Calculate Clock divider value to program in MMCHS_SYSCTL[CLKD] field.\r
  *ClockFrequencySelect = ((MMC_REFERENCE_CLK/Frequency) + 1);\r
\r
  DEBUG ((EFI_D_INFO, "MaxDataTransferRate: 0x%x, Frequency: %d KHz, ClockFrequencySelect: %x\n", MaxDataTransferRate, Frequency/1000, *ClockFrequencySelect));\r
}\r
\r
\r
VOID\r
GetCardConfigurationData (\r
  VOID\r
  )\r
{\r
  UINTN  BlockSize;\r
  UINTN  NumBlocks;\r
  UINTN  ClockFrequencySelect;\r
\r
  //Calculate BlockSize and Total number of blocks in the detected card.\r
  GetBlockInformation(&BlockSize, &NumBlocks);\r
  gCardInfo.BlockSize = BlockSize;\r
  gCardInfo.NumBlocks = NumBlocks;\r
\r
  //Calculate Card clock divider value.\r
  CalculateCardCLKD(&ClockFrequencySelect);\r
  gCardInfo.ClockFrequencySelect = ClockFrequencySelect;\r
}\r
\r
\r
EFI_STATUS\r
InitializeMMCHS (\r
  VOID\r
  )\r
{\r
  UINT8      Data = 0;\r
  EFI_STATUS Status;\r
\r
  //Select Device group to belong to P1 device group in Power IC.\r
  Data = DEV_GRP_P1;\r
  Status = gTPS65950->Write (gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID4, VMMC1_DEV_GRP), 1, &Data);\r
  ASSERT_EFI_ERROR(Status);\r
\r
  //Configure voltage regulator for MMC1 in Power IC to output 3.0 voltage.\r
  Data = VSEL_3_00V;\r
  Status = gTPS65950->Write (gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID4, VMMC1_DEDICATED_REG), 1, &Data);\r
  ASSERT_EFI_ERROR(Status);\r
\r
  //After ramping up voltage, set VDDS stable bit to indicate that voltage level is stable.\r
  MmioOr32 (CONTROL_PBIAS_LITE, (PBIASLITEVMODE0 | PBIASLITEPWRDNZ0 | PBIASSPEEDCTRL0 | PBIASLITEVMODE1 | PBIASLITEWRDNZ1));\r
\r
  // Enable WP GPIO\r
  MmioAndThenOr32 (GPIO1_BASE + GPIO_OE, ~BIT23, BIT23);\r
\r
  // Enable Card Detect\r
  Data = CARD_DETECT_ENABLE;\r
  gTPS65950->Write (gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID2, TPS65950_GPIO_CTRL), 1, &Data);\r
\r
\r
  return Status;\r
}\r
\r
\r
EFI_STATUS\r
PerformCardIdenfication (\r
  VOID\r
  )\r
{\r
  EFI_STATUS Status;\r
  UINTN      CmdArgument = 0;\r
  UINTN      Response = 0;\r
  UINTN      RetryCount = 0;\r
  BOOLEAN    SDCmd8Supported = FALSE;\r
\r
  //Enable interrupts.\r
  MmioWrite32 (MMCHS_IE, (BADA_EN | CERR_EN | DEB_EN | DCRC_EN | DTO_EN | CIE_EN |\r
    CEB_EN | CCRC_EN | CTO_EN | BRR_EN | BWR_EN | TC_EN | CC_EN));\r
\r
  //Controller INIT procedure start.\r
  MmioOr32 (MMCHS_CON, INIT);\r
  MmioWrite32 (MMCHS_CMD, 0x00000000);\r
  while (!(MmioRead32 (MMCHS_STAT) & CC));\r
\r
  //Wait for 1 ms\r
  gBS->Stall(1000);\r
\r
  //Set CC bit to 0x1 to clear the flag\r
  MmioOr32 (MMCHS_STAT, CC);\r
\r
  //Retry INIT procedure.\r
  MmioWrite32 (MMCHS_CMD, 0x00000000);\r
  while (!(MmioRead32 (MMCHS_STAT) & CC));\r
\r
  //End initialization sequence\r
  MmioAnd32 (MMCHS_CON, ~INIT);\r
\r
  MmioOr32 (MMCHS_HCTL, (SDVS_3_0_V | DTW_1_BIT | SDBP_ON));\r
\r
  //Change clock frequency to 400KHz to fit protocol\r
  UpdateMMCHSClkFrequency(CLKD_400KHZ);\r
\r
  MmioOr32 (MMCHS_CON, OD);\r
\r
  //Send CMD0 command.\r
  Status = SendCmd (CMD0, CMD0_INT_EN, CmdArgument);\r
  if (EFI_ERROR(Status)) {\r
    DEBUG ((EFI_D_ERROR, "Cmd0 fails.\n"));\r
    return Status;\r
  }\r
\r
  DEBUG ((EFI_D_INFO, "CMD0 response: %x\n", MmioRead32 (MMCHS_RSP10)));\r
\r
  //Send CMD5 command.\r
  Status = SendCmd (CMD5, CMD5_INT_EN, CmdArgument);\r
  if (Status == EFI_SUCCESS) {\r
    DEBUG ((EFI_D_ERROR, "CMD5 Success. SDIO card. Follow SDIO card specification.\n"));\r
    DEBUG ((EFI_D_INFO, "CMD5 response: %x\n", MmioRead32 (MMCHS_RSP10)));\r
    //NOTE: Returning unsupported error for now. Need to implement SDIO specification.\r
    return EFI_UNSUPPORTED;\r
  } else {\r
    DEBUG ((EFI_D_INFO, "CMD5 fails. Not an SDIO card.\n"));\r
  }\r
\r
  MmioOr32 (MMCHS_SYSCTL, SRC);\r
  gBS->Stall(1000);\r
  while ((MmioRead32 (MMCHS_SYSCTL) & SRC));\r
\r
  //Send CMD8 command. (New v2.00 command for Voltage check)\r
  //Only 2.7V - 3.6V is supported for SD2.0, only SD 2.0 card can pass.\r
  //MMC & SD1.1 card will fail this command.\r
  CmdArgument = CMD8_ARG;\r
  Status = SendCmd (CMD8, CMD8_INT_EN, CmdArgument);\r
  if (Status == EFI_SUCCESS) {\r
    Response = MmioRead32 (MMCHS_RSP10);\r
    DEBUG ((EFI_D_INFO, "CMD8 success. CMD8 response: %x\n", Response));\r
    if (Response != CmdArgument) {\r
      return EFI_DEVICE_ERROR;\r
    }\r
    DEBUG ((EFI_D_INFO, "Card is SD2.0\n"));\r
    SDCmd8Supported = TRUE; //Supports high capacity.\r
  } else {\r
    DEBUG ((EFI_D_INFO, "CMD8 fails. Not an SD2.0 card.\n"));\r
  }\r
\r
  MmioOr32 (MMCHS_SYSCTL, SRC);\r
  gBS->Stall(1000);\r
  while ((MmioRead32 (MMCHS_SYSCTL) & SRC));\r
\r
  //Poll till card is busy\r
  while (RetryCount < MAX_RETRY_COUNT) {\r
    //Send CMD55 command.\r
    CmdArgument = 0;\r
    Status = SendCmd (CMD55, CMD55_INT_EN, CmdArgument);\r
    if (Status == EFI_SUCCESS) {\r
      DEBUG ((EFI_D_INFO, "CMD55 success. CMD55 response: %x\n", MmioRead32 (MMCHS_RSP10)));\r
      gCardInfo.CardType = SD_CARD;\r
    } else {\r
      DEBUG ((EFI_D_INFO, "CMD55 fails.\n"));\r
      gCardInfo.CardType = MMC_CARD;\r
    }\r
\r
    //Send appropriate command for the card type which got detected.\r
    if (gCardInfo.CardType == SD_CARD) {\r
      CmdArgument = ((UINTN *) &(gCardInfo.OCRData))[0];\r
\r
      //Set HCS bit.\r
      if (SDCmd8Supported) {\r
        CmdArgument |= HCS;\r
      }\r
\r
      Status = SendCmd (ACMD41, ACMD41_INT_EN, CmdArgument);\r
      if (EFI_ERROR(Status)) {\r
        DEBUG ((EFI_D_INFO, "ACMD41 fails.\n"));\r
        return Status;\r
      }\r
      ((UINT32 *) &(gCardInfo.OCRData))[0] = MmioRead32 (MMCHS_RSP10);\r
      DEBUG ((EFI_D_INFO, "SD card detected. ACMD41 OCR: %x\n", ((UINT32 *) &(gCardInfo.OCRData))[0]));\r
    } else if (gCardInfo.CardType == MMC_CARD) {\r
      CmdArgument = 0;\r
      Status = SendCmd (CMD1, CMD1_INT_EN, CmdArgument);\r
      if (EFI_ERROR(Status)) {\r
        DEBUG ((EFI_D_INFO, "CMD1 fails.\n"));\r
        return Status;\r
      }\r
      Response = MmioRead32 (MMCHS_RSP10);\r
      DEBUG ((EFI_D_INFO, "MMC card detected.. CMD1 response: %x\n", Response));\r
\r
      //NOTE: For now, I am skipping this since I only have an SD card.\r
      //Compare card OCR and host OCR (Section 22.6.1.3.2.4)\r
      return EFI_UNSUPPORTED; //For now, MMC is not supported.\r
    }\r
\r
    //Poll the card until it is out of its power-up sequence.\r
    if (gCardInfo.OCRData.Busy == 1) {\r
\r
      if (SDCmd8Supported) {\r
        gCardInfo.CardType = SD_CARD_2;\r
      }\r
\r
      //Card is ready. Check CCS (Card capacity status) bit (bit#30).\r
      //SD 2.0 standard card will response with CCS 0, SD high capacity card will respond with CCS 1.\r
      if (gCardInfo.OCRData.AccessMode & BIT1) {\r
        gCardInfo.CardType = SD_CARD_2_HIGH;\r
        DEBUG ((EFI_D_INFO, "High capacity card.\n"));\r
      } else {\r
        DEBUG ((EFI_D_INFO, "Standard capacity card.\n"));\r
      }\r
\r
      break;\r
    }\r
\r
    gBS->Stall(1000);\r
    RetryCount++;\r
  }\r
\r
  if (RetryCount == MAX_RETRY_COUNT) {\r
    DEBUG ((EFI_D_ERROR, "Timeout error. RetryCount: %d\n", RetryCount));\r
    return EFI_TIMEOUT;\r
  }\r
\r
  //Read CID data.\r
  CmdArgument = 0;\r
  Status = SendCmd (CMD2, CMD2_INT_EN, CmdArgument);\r
  if (EFI_ERROR(Status)) {\r
    DEBUG ((EFI_D_ERROR, "CMD2 fails. Status: %x\n", Status));\r
    return Status;\r
  }\r
\r
  DEBUG ((EFI_D_INFO, "CMD2 response: %x %x %x %x\n", MmioRead32 (MMCHS_RSP10), MmioRead32 (MMCHS_RSP32), MmioRead32 (MMCHS_RSP54), MmioRead32 (MMCHS_RSP76)));\r
\r
  //Parse CID register data.\r
  ParseCardCIDData(MmioRead32 (MMCHS_RSP10), MmioRead32 (MMCHS_RSP32), MmioRead32 (MMCHS_RSP54), MmioRead32 (MMCHS_RSP76));\r
\r
  //Read RCA\r
  CmdArgument = 0;\r
  Status = SendCmd (CMD3, CMD3_INT_EN, CmdArgument);\r
  if (EFI_ERROR(Status)) {\r
    DEBUG ((EFI_D_ERROR, "CMD3 fails. Status: %x\n", Status));\r
    return Status;\r
  }\r
\r
  //Set RCA for the detected card. RCA is CMD3 response.\r
  gCardInfo.RCA = (MmioRead32 (MMCHS_RSP10) >> 16);\r
  DEBUG ((EFI_D_INFO, "CMD3 response: RCA %x\n", gCardInfo.RCA));\r
\r
  //MMC Bus setting change after card identification.\r
  MmioAnd32 (MMCHS_CON, ~OD);\r
  MmioOr32 (MMCHS_HCTL, SDVS_3_0_V);\r
  UpdateMMCHSClkFrequency(CLKD_400KHZ); //Set the clock frequency to 400KHz.\r
\r
  return EFI_SUCCESS;\r
}\r
\r
\r
EFI_STATUS\r
GetCardSpecificData (\r
  VOID\r
  )\r
{\r
  EFI_STATUS Status;\r
  UINTN      CmdArgument;\r
\r
  //Send CMD9 to retrieve CSD.\r
  CmdArgument = gCardInfo.RCA << 16;\r
  Status = SendCmd (CMD9, CMD9_INT_EN, CmdArgument);\r
  if (EFI_ERROR(Status)) {\r
    DEBUG ((EFI_D_ERROR, "CMD9 fails. Status: %x\n", Status));\r
    return Status;\r
  }\r
\r
  //Populate 128-bit CSD register data.\r
  ((UINT32 *)&(gCardInfo.CSDData))[0] = MmioRead32 (MMCHS_RSP10);\r
  ((UINT32 *)&(gCardInfo.CSDData))[1] = MmioRead32 (MMCHS_RSP32);\r
  ((UINT32 *)&(gCardInfo.CSDData))[2] = MmioRead32 (MMCHS_RSP54);\r
  ((UINT32 *)&(gCardInfo.CSDData))[3] = MmioRead32 (MMCHS_RSP76);\r
\r
  DEBUG ((EFI_D_INFO, "CMD9 response: %x %x %x %x\n", MmioRead32 (MMCHS_RSP10), MmioRead32 (MMCHS_RSP32), MmioRead32 (MMCHS_RSP54), MmioRead32 (MMCHS_RSP76)));\r
\r
  //Calculate total number of blocks and max. data transfer rate supported by the detected card.\r
  GetCardConfigurationData();\r
\r
  return Status;\r
}\r
\r
\r
EFI_STATUS\r
PerformCardConfiguration (\r
  VOID\r
  )\r
{\r
  UINTN      CmdArgument = 0;\r
  EFI_STATUS Status;\r
\r
  //Send CMD7\r
  CmdArgument = gCardInfo.RCA << 16;\r
  Status = SendCmd (CMD7, CMD7_INT_EN, CmdArgument);\r
  if (EFI_ERROR(Status)) {\r
    DEBUG ((EFI_D_ERROR, "CMD7 fails. Status: %x\n", Status));\r
    return Status;\r
  }\r
\r
  if ((gCardInfo.CardType != UNKNOWN_CARD) && (gCardInfo.CardType != MMC_CARD)) {\r
    // We could read SCR register, but SD Card Phys spec stats any SD Card shall\r
    // set SCR.SD_BUS_WIDTHS to support 4-bit mode, so why bother?\r
\r
    // Send ACMD6 (application specific commands must be prefixed with CMD55)\r
    Status = SendCmd (CMD55, CMD55_INT_EN, CmdArgument);\r
    if (!EFI_ERROR (Status)) {\r
      // set device into 4-bit data bus mode\r
      Status = SendCmd (ACMD6, ACMD6_INT_EN, 0x2);\r
      if (!EFI_ERROR (Status)) {\r
        // Set host controler into 4-bit mode\r
        MmioOr32 (MMCHS_HCTL, DTW_4_BIT);\r
        DEBUG ((EFI_D_INFO, "SD Memory Card set to 4-bit mode\n"));\r
      }\r
    }\r
  }\r
\r
  //Send CMD16 to set the block length\r
  CmdArgument = gCardInfo.BlockSize;\r
  Status = SendCmd (CMD16, CMD16_INT_EN, CmdArgument);\r
  if (EFI_ERROR(Status)) {\r
    DEBUG ((EFI_D_ERROR, "CMD16 fails. Status: %x\n", Status));\r
    return Status;\r
  }\r
\r
  //Change MMCHS clock frequency to what detected card can support.\r
  UpdateMMCHSClkFrequency(gCardInfo.ClockFrequencySelect);\r
\r
  return EFI_SUCCESS;\r
}\r
\r
\r
EFI_STATUS\r
ReadBlockData (\r
  IN  EFI_BLOCK_IO_PROTOCOL       *This,\r
  OUT VOID                        *Buffer\r
  )\r
{\r
  UINTN MmcStatus;\r
  UINTN *DataBuffer = Buffer;\r
  UINTN DataSize = This->Media->BlockSize/4;\r
  UINTN Count;\r
  UINTN RetryCount = 0;\r
\r
  //Check controller status to make sure there is no error.\r
  while (RetryCount < MAX_RETRY_COUNT) {\r
    do {\r
      //Read Status.\r
      MmcStatus = MmioRead32 (MMCHS_STAT);\r
    } while(MmcStatus == 0);\r
\r
    //Check if Buffer read ready (BRR) bit is set?\r
    if (MmcStatus & BRR) {\r
\r
      //Clear BRR bit\r
      MmioOr32 (MMCHS_STAT, BRR);\r
\r
      //Read block worth of data.\r
      for (Count = 0; Count < DataSize; Count++) {\r
        *DataBuffer++ = MmioRead32 (MMCHS_DATA);\r
      }\r
      break;\r
    }\r
    RetryCount++;\r
  }\r
\r
  if (RetryCount == MAX_RETRY_COUNT) {\r
    return EFI_TIMEOUT;\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
\r
EFI_STATUS\r
WriteBlockData (\r
  IN  EFI_BLOCK_IO_PROTOCOL       *This,\r
  OUT VOID                        *Buffer\r
  )\r
{\r
  UINTN MmcStatus;\r
  UINTN *DataBuffer = Buffer;\r
  UINTN DataSize = This->Media->BlockSize/4;\r
  UINTN Count;\r
  UINTN RetryCount = 0;\r
\r
  //Check controller status to make sure there is no error.\r
  while (RetryCount < MAX_RETRY_COUNT) {\r
    do {\r
      //Read Status.\r
      MmcStatus = MmioRead32 (MMCHS_STAT);\r
    } while(MmcStatus == 0);\r
\r
    //Check if Buffer write ready (BWR) bit is set?\r
    if (MmcStatus & BWR) {\r
\r
      //Clear BWR bit\r
      MmioOr32 (MMCHS_STAT, BWR);\r
\r
      //Write block worth of data.\r
      for (Count = 0; Count < DataSize; Count++) {\r
        MmioWrite32 (MMCHS_DATA, *DataBuffer++);\r
      }\r
\r
      break;\r
    }\r
    RetryCount++;\r
  }\r
\r
  if (RetryCount == MAX_RETRY_COUNT) {\r
    return EFI_TIMEOUT;\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
EFI_STATUS\r
DmaBlocks (\r
  IN EFI_BLOCK_IO_PROTOCOL        *This,\r
  IN  UINTN                       Lba,\r
  IN OUT VOID                     *Buffer,\r
  IN  UINTN                       BlockCount,\r
  IN  OPERATION_TYPE              OperationType\r
  )\r
{\r
  EFI_STATUS            Status;\r
  UINTN                 DmaSize = 0;\r
  UINTN                 Cmd = 0;\r
  UINTN                 CmdInterruptEnable;\r
  UINTN                 CmdArgument;\r
  VOID                  *BufferMap;\r
  EFI_PHYSICAL_ADDRESS  BufferAddress;\r
  OMAP_DMA4             Dma4;\r
  DMA_MAP_OPERATION     DmaOperation;\r
  EFI_STATUS            MmcStatus;\r
  UINTN                 RetryCount = 0;\r
\r
CpuDeadLoop ();\r
  // Map passed in buffer for DMA xfer\r
  DmaSize = BlockCount * This->Media->BlockSize;\r
  Status = DmaMap (DmaOperation, Buffer, &DmaSize, &BufferAddress, &BufferMap);\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  ZeroMem (&DmaOperation, sizeof (DMA_MAP_OPERATION));\r
\r
\r
  Dma4.DataType = 2;                      // DMA4_CSDPi[1:0]   32-bit elements from MMCHS_DATA\r
\r
  Dma4.SourceEndiansim = 0;               // DMA4_CSDPi[21]\r
\r
  Dma4.DestinationEndianism = 0;          // DMA4_CSDPi[19]\r
\r
  Dma4.SourcePacked = 0;                  // DMA4_CSDPi[6]\r
\r
  Dma4.DestinationPacked = 0;             // DMA4_CSDPi[13]\r
\r
  Dma4.NumberOfElementPerFrame = This->Media->BlockSize/4; // DMA4_CENi  (TRM 4K is optimum value)\r
\r
  Dma4.NumberOfFramePerTransferBlock = BlockCount;         // DMA4_CFNi\r
\r
  Dma4.ReadPriority = 0;                  // DMA4_CCRi[6]      Low priority read\r
\r
  Dma4.WritePriority = 0;                 // DMA4_CCRi[23]     Prefetech disabled\r
\r
\r
  //Populate the command information based on the operation type.\r
  if (OperationType == READ) {\r
    Cmd = CMD18; //Multiple block read\r
    CmdInterruptEnable = CMD18_INT_EN;\r
    DmaOperation = MapOperationBusMasterCommonBuffer;\r
\r
    Dma4.ReadPortAccessType =0 ;            // DMA4_CSDPi[8:7]   Can not burst MMCHS_DATA reg\r
\r
    Dma4.WritePortAccessType = 3;           // DMA4_CSDPi[15:14] Memory burst 16x32\r
\r
    Dma4.WriteMode = 1;                     // DMA4_CSDPi[17:16] Write posted\r
\r
\r
\r
    Dma4.SourceStartAddress = MMCHS_DATA;                   // DMA4_CSSAi\r
\r
    Dma4.DestinationStartAddress = (UINT32)BufferAddress;   // DMA4_CDSAi\r
\r
    Dma4.SourceElementIndex = 1;                            // DMA4_CSEi\r
\r
    Dma4.SourceFrameIndex = 0x200;                          // DMA4_CSFi\r
\r
    Dma4.DestinationElementIndex = 1;                       // DMA4_CDEi\r
\r
    Dma4.DestinationFrameIndex = 0;                         // DMA4_CDFi\r
\r
\r
\r
    Dma4.ReadPortAccessMode = 0;            // DMA4_CCRi[13:12]  Always read MMCHS_DATA\r
\r
    Dma4.WritePortAccessMode = 1;           // DMA4_CCRi[15:14]  Post increment memory address\r
\r
    Dma4.ReadRequestNumber = 0x1e;          // DMA4_CCRi[4:0]    Syncro with MMCA_DMA_RX (61)\r
\r
    Dma4.WriteRequestNumber = 1;            // DMA4_CCRi[20:19]  Syncro upper 0x3e == 62 (one based)\r
\r
  } else if (OperationType == WRITE) {\r
    Cmd = CMD25; //Multiple block write\r
    CmdInterruptEnable = CMD25_INT_EN;\r
    DmaOperation = MapOperationBusMasterRead;\r
\r
    Dma4.ReadPortAccessType = 3;            // DMA4_CSDPi[8:7]   Memory burst 16x32\r
\r
    Dma4.WritePortAccessType = 0;           // DMA4_CSDPi[15:14] Can not burst MMCHS_DATA reg\r
\r
    Dma4.WriteMode = 1;                     // DMA4_CSDPi[17:16] Write posted ???\r
\r
\r
\r
    Dma4.SourceStartAddress = (UINT32)BufferAddress;        // DMA4_CSSAi\r
\r
    Dma4.DestinationStartAddress = MMCHS_DATA;              // DMA4_CDSAi\r
\r
    Dma4.SourceElementIndex = 1;                            // DMA4_CSEi\r
\r
    Dma4.SourceFrameIndex = 0x200;                          // DMA4_CSFi\r
\r
    Dma4.DestinationElementIndex = 1;                       // DMA4_CDEi\r
\r
    Dma4.DestinationFrameIndex = 0;                         // DMA4_CDFi\r
\r
\r
\r
    Dma4.ReadPortAccessMode = 1;            // DMA4_CCRi[13:12]  Post increment memory address\r
\r
    Dma4.WritePortAccessMode = 0;           // DMA4_CCRi[15:14]  Always write MMCHS_DATA\r
\r
    Dma4.ReadRequestNumber = 0x1d;          // DMA4_CCRi[4:0]    Syncro with MMCA_DMA_TX (60)\r
\r
    Dma4.WriteRequestNumber = 1;            // DMA4_CCRi[20:19]  Syncro upper 0x3d == 61 (one based)\r
\r
  } else {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
\r
  EnableDmaChannel (2, &Dma4);\r
\r
\r
  //Set command argument based on the card access mode (Byte mode or Block mode)\r
  if (gCardInfo.OCRData.AccessMode & BIT1) {\r
    CmdArgument = Lba;\r
  } else {\r
    CmdArgument = Lba * This->Media->BlockSize;\r
  }\r
\r
  //Send Command.\r
  Status = SendCmd (Cmd, CmdInterruptEnable, CmdArgument);\r
  if (EFI_ERROR (Status)) {\r
    DEBUG ((EFI_D_ERROR, "CMD fails. Status: %x\n", Status));\r
    return Status;\r
  }\r
\r
    //Check for the Transfer completion.\r
  while (RetryCount < MAX_RETRY_COUNT) {\r
    //Read Status\r
    do {\r
      MmcStatus = MmioRead32 (MMCHS_STAT);\r
    } while (MmcStatus == 0);\r
\r
    //Check if Transfer complete (TC) bit is set?\r
    if (MmcStatus & TC) {\r
      break;\r
    } else {\r
      DEBUG ((EFI_D_ERROR, "MmcStatus for TC: %x\n", MmcStatus));\r
      //Check if DEB, DCRC or DTO interrupt occured.\r
      if ((MmcStatus & DEB) | (MmcStatus & DCRC) | (MmcStatus & DTO)) {\r
        //There was an error during the data transfer.\r
\r
        //Set SRD bit to 1 and wait until it return to 0x0.\r
        MmioOr32 (MMCHS_SYSCTL, SRD);\r
        while((MmioRead32 (MMCHS_SYSCTL) & SRD) != 0x0);\r
\r
        DisableDmaChannel (2, DMA4_CSR_BLOCK, DMA4_CSR_ERR);\r
        DmaUnmap (BufferMap);\r
        return EFI_DEVICE_ERROR;\r
      }\r
    }\r
    RetryCount++;\r
  }\r
\r
  DisableDmaChannel (2, DMA4_CSR_BLOCK, DMA4_CSR_ERR);\r
  Status = DmaUnmap (BufferMap);\r
\r
  if (RetryCount == MAX_RETRY_COUNT) {\r
    DEBUG ((EFI_D_ERROR, "TransferBlockData timed out.\n"));\r
    return EFI_TIMEOUT;\r
  }\r
\r
  return Status;\r
}\r
\r
\r
EFI_STATUS\r
TransferBlock (\r
  IN EFI_BLOCK_IO_PROTOCOL        *This,\r
  IN  UINTN                       Lba,\r
  IN OUT VOID                     *Buffer,\r
  IN  OPERATION_TYPE              OperationType\r
  )\r
{\r
  EFI_STATUS Status;\r
  UINTN      MmcStatus;\r
  UINTN      RetryCount = 0;\r
  UINTN      Cmd = 0;\r
  UINTN      CmdInterruptEnable = 0;\r
  UINTN      CmdArgument = 0;\r
\r
\r
  //Populate the command information based on the operation type.\r
  if (OperationType == READ) {\r
    Cmd = CMD17; //Single block read\r
    CmdInterruptEnable = CMD18_INT_EN;\r
  } else if (OperationType == WRITE) {\r
    Cmd = CMD24; //Single block write\r
    CmdInterruptEnable = CMD24_INT_EN;\r
  }\r
\r
  //Set command argument based on the card access mode (Byte mode or Block mode)\r
  if (gCardInfo.OCRData.AccessMode & BIT1) {\r
    CmdArgument = Lba;\r
  } else {\r
    CmdArgument = Lba * This->Media->BlockSize;\r
  }\r
\r
  //Send Command.\r
  Status = SendCmd (Cmd, CmdInterruptEnable, CmdArgument);\r
  if (EFI_ERROR(Status)) {\r
    DEBUG ((EFI_D_ERROR, "CMD fails. Status: %x\n", Status));\r
    return Status;\r
  }\r
\r
  //Read or Write data.\r
  if (OperationType == READ) {\r
    Status = ReadBlockData (This, Buffer);\r
    if (EFI_ERROR(Status)) {\r
      DEBUG((EFI_D_ERROR, "ReadBlockData fails.\n"));\r
      return Status;\r
    }\r
  } else if (OperationType == WRITE) {\r
    Status = WriteBlockData (This, Buffer);\r
    if (EFI_ERROR(Status)) {\r
      DEBUG((EFI_D_ERROR, "WriteBlockData fails.\n"));\r
      return Status;\r
    }\r
  }\r
\r
  //Check for the Transfer completion.\r
  while (RetryCount < MAX_RETRY_COUNT) {\r
    //Read Status\r
    do {\r
      MmcStatus = MmioRead32 (MMCHS_STAT);\r
    } while (MmcStatus == 0);\r
\r
    //Check if Transfer complete (TC) bit is set?\r
    if (MmcStatus & TC) {\r
      break;\r
    } else {\r
      DEBUG ((EFI_D_ERROR, "MmcStatus for TC: %x\n", MmcStatus));\r
      //Check if DEB, DCRC or DTO interrupt occured.\r
      if ((MmcStatus & DEB) | (MmcStatus & DCRC) | (MmcStatus & DTO)) {\r
        //There was an error during the data transfer.\r
\r
        //Set SRD bit to 1 and wait until it return to 0x0.\r
        MmioOr32 (MMCHS_SYSCTL, SRD);\r
        while((MmioRead32 (MMCHS_SYSCTL) & SRD) != 0x0);\r
\r
        return EFI_DEVICE_ERROR;\r
      }\r
    }\r
    RetryCount++;\r
  }\r
\r
  if (RetryCount == MAX_RETRY_COUNT) {\r
    DEBUG ((EFI_D_ERROR, "TransferBlockData timed out.\n"));\r
    return EFI_TIMEOUT;\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
BOOLEAN\r
CardPresent (\r
  VOID\r
  )\r
{\r
  EFI_STATUS  Status;\r
  UINT8       Data;\r
\r
  //\r
  // Card detect is a GPIO0 on the TPS65950\r
  //\r
  Status = gTPS65950->Read (gTPS65950, EXTERNAL_DEVICE_REGISTER(I2C_ADDR_GRP_ID2, GPIODATAIN1), 1, &Data);\r
  if (EFI_ERROR (Status)) {\r
    return FALSE;\r
  }\r
\r
  if ((Data & CARD_DETECT_BIT) == CARD_DETECT_BIT) {\r
    // No Card present\r
    return FALSE;\r
  } else {\r
    return TRUE;\r
  }\r
}\r
\r
EFI_STATUS\r
DetectCard (\r
  VOID\r
  )\r
{\r
  EFI_STATUS    Status;\r
\r
  if (!CardPresent ()) {\r
    return EFI_NO_MEDIA;\r
  }\r
\r
  //Initialize MMC host controller clocks.\r
  Status = InitializeMMCHS ();\r
  if (EFI_ERROR(Status)) {\r
    DEBUG ((EFI_D_ERROR, "Initialize MMC host controller fails. Status: %x\n", Status));\r
    return Status;\r
  }\r
\r
  //Software reset of the MMCHS host controller.\r
  MmioWrite32 (MMCHS_SYSCONFIG, SOFTRESET);\r
  gBS->Stall(1000);\r
  while ((MmioRead32 (MMCHS_SYSSTATUS) & RESETDONE_MASK) != RESETDONE);\r
\r
  //Soft reset for all.\r
  MmioWrite32 (MMCHS_SYSCTL, SRA);\r
  gBS->Stall(1000);\r
  while ((MmioRead32 (MMCHS_SYSCTL) & SRA) != 0x0);\r
\r
  //Voltage capabilities initialization. Activate VS18 and VS30.\r
  MmioOr32 (MMCHS_CAPA, (VS30 | VS18));\r
\r
  //Wakeup configuration\r
  MmioOr32 (MMCHS_SYSCONFIG, ENAWAKEUP);\r
  MmioOr32 (MMCHS_HCTL, IWE);\r
\r
  //MMCHS Controller default initialization\r
  MmioOr32 (MMCHS_CON, (OD | DW8_1_4_BIT | CEATA_OFF));\r
\r
  MmioWrite32 (MMCHS_HCTL, (SDVS_3_0_V | DTW_1_BIT | SDBP_OFF));\r
\r
  //Enable internal clock\r
  MmioOr32 (MMCHS_SYSCTL, ICE);\r
\r
  //Set the clock frequency to 80KHz.\r
  UpdateMMCHSClkFrequency (CLKD_80KHZ);\r
\r
  //Enable SD bus power.\r
  MmioOr32 (MMCHS_HCTL, (SDBP_ON));\r
\r
  //Poll till SD bus power bit is set.\r
  while ((MmioRead32 (MMCHS_HCTL) & SDBP_MASK) != SDBP_ON);\r
\r
  //Card idenfication\r
  Status = PerformCardIdenfication ();\r
  if (EFI_ERROR(Status)) {\r
    DEBUG ((EFI_D_ERROR, "No MMC/SD card detected.\n"));\r
    return Status;\r
  }\r
\r
  //Get CSD (Card specific data) for the detected card.\r
  Status = GetCardSpecificData();\r
  if (EFI_ERROR(Status)) {\r
    return Status;\r
  }\r
\r
  //Configure the card in data transfer mode.\r
  Status = PerformCardConfiguration();\r
  if (EFI_ERROR(Status)) {\r
    return Status;\r
  }\r
\r
  //Patch the Media structure.\r
  gMMCHSMedia.LastBlock    = (gCardInfo.NumBlocks - 1);\r
  gMMCHSMedia.BlockSize    = gCardInfo.BlockSize;\r
  gMMCHSMedia.ReadOnly     = (MmioRead32 (GPIO1_BASE + GPIO_DATAIN) & BIT23) == BIT23;\r
  gMMCHSMedia.MediaPresent = TRUE;\r
  gMMCHSMedia.MediaId++;\r
\r
  DEBUG ((EFI_D_INFO, "SD Card Media Change on Handle 0x%08x\n", gImageHandle));\r
\r
  return Status;\r
}\r
\r
#define MAX_MMCHS_TRANSFER_SIZE  0x4000\r
\r
EFI_STATUS\r
SdReadWrite (\r
  IN EFI_BLOCK_IO_PROTOCOL    *This,\r
  IN  UINTN                   Lba,\r
  OUT VOID                    *Buffer,\r
  IN  UINTN                   BufferSize,\r
  IN  OPERATION_TYPE          OperationType\r
  )\r
{\r
  EFI_STATUS Status = EFI_SUCCESS;\r
  UINTN      RetryCount = 0;\r
  UINTN      BlockCount;\r
  UINTN      BytesToBeTranferedThisPass = 0;\r
  UINTN      BytesRemainingToBeTransfered;\r
  EFI_TPL    OldTpl;\r
\r
  BOOLEAN    Update;\r
\r
\r
\r
  Update               = FALSE;\r
\r
  if (gMediaChange) {\r
    Update = TRUE;\r
    Status = DetectCard  ();\r
    if (EFI_ERROR (Status)) {\r
      // We detected a removal\r
      gMMCHSMedia.MediaPresent = FALSE;\r
      gMMCHSMedia.LastBlock    = 0;\r
      gMMCHSMedia.BlockSize    = 512;  // Should be zero but there is a bug in DiskIo\r
      gMMCHSMedia.ReadOnly     = FALSE;\r
    }\r
    gMediaChange             = FALSE;\r
  } else if (!gMMCHSMedia.MediaPresent) {\r
    Status = EFI_NO_MEDIA;\r
    goto Done;\r
  }\r
\r
  if (Update) {\r
    DEBUG ((EFI_D_INFO, "SD Card ReinstallProtocolInterface ()\n"));\r
    gBS->ReinstallProtocolInterface (\r
          gImageHandle,\r
          &gEfiBlockIoProtocolGuid,\r
          &gBlockIo,\r
          &gBlockIo\r
          );\r
    return EFI_MEDIA_CHANGED;\r
  }\r
\r
  if (EFI_ERROR (Status)) {\r
    goto Done;\r
  }\r
\r
  if (Buffer == NULL) {\r
    Status = EFI_INVALID_PARAMETER;\r
    goto Done;\r
  }\r
\r
  if (Lba > This->Media->LastBlock) {\r
    Status = EFI_INVALID_PARAMETER;\r
    goto Done;\r
  }\r
\r
  if ((BufferSize % This->Media->BlockSize) != 0) {\r
    Status = EFI_BAD_BUFFER_SIZE;\r
    goto Done;\r
  }\r
\r
  //Check if the data lines are not in use.\r
  while ((RetryCount++ < MAX_RETRY_COUNT) && ((MmioRead32 (MMCHS_PSTATE) & DATI_MASK) != DATI_ALLOWED));\r
  if (RetryCount == MAX_RETRY_COUNT) {\r
    Status = EFI_TIMEOUT;\r
    goto Done;\r
  }\r
\r
  OldTpl = gBS->RaiseTPL (TPL_NOTIFY);\r
\r
  BytesRemainingToBeTransfered = BufferSize;\r
  while (BytesRemainingToBeTransfered > 0) {\r
\r
    if (gMediaChange) {\r
      Status = EFI_NO_MEDIA;\r
      DEBUG ((EFI_D_INFO, "SdReadWrite() EFI_NO_MEDIA due to gMediaChange\n"));\r
      goto DoneRestoreTPL;\r
    }\r
\r
    // Turn OFF DMA path until it is debugged\r
    // BytesToBeTranferedThisPass = (BytesToBeTranferedThisPass >= MAX_MMCHS_TRANSFER_SIZE) ? MAX_MMCHS_TRANSFER_SIZE : BytesRemainingToBeTransfered;\r
    BytesToBeTranferedThisPass   = This->Media->BlockSize;\r
\r
    BlockCount = BytesToBeTranferedThisPass/This->Media->BlockSize;\r
\r
    if (BlockCount > 1) {\r
      Status = DmaBlocks (This, Lba, Buffer, BlockCount, OperationType);\r
    } else {\r
      //Transfer a block worth of data.\r
      Status = TransferBlock (This, Lba, Buffer, OperationType);\r
    }\r
\r
    if (EFI_ERROR(Status)) {\r
      DEBUG ((EFI_D_ERROR, "TransferBlockData fails. %x\n", Status));\r
      goto DoneRestoreTPL;\r
    }\r
\r
    BytesRemainingToBeTransfered -= BytesToBeTranferedThisPass;\r
    Lba    += BlockCount;\r
    Buffer = (UINT8 *)Buffer + This->Media->BlockSize;\r
  }\r
\r
DoneRestoreTPL:\r
\r
  gBS->RestoreTPL (OldTpl);\r
\r
Done:\r
\r
  return Status;\r
\r
}\r
\r
\r
/**\r
\r
  Reset the Block Device.\r
\r
\r
\r
  @param  This                 Indicates a pointer to the calling context.\r
\r
  @param  ExtendedVerification Driver may perform diagnostics on reset.\r
\r
\r
\r
  @retval EFI_SUCCESS          The device was reset.\r
\r
  @retval EFI_DEVICE_ERROR     The device is not functioning properly and could\r
\r
                               not be reset.\r
\r
\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
MMCHSReset (\r
  IN EFI_BLOCK_IO_PROTOCOL          *This,\r
  IN BOOLEAN                        ExtendedVerification\r
  )\r
{\r
  return EFI_SUCCESS;\r
}\r
\r
\r
/**\r
\r
  Read BufferSize bytes from Lba into Buffer.\r
\r
\r
\r
  @param  This       Indicates a pointer to the calling context.\r
\r
  @param  MediaId    Id of the media, changes every time the media is replaced.\r
\r
  @param  Lba        The starting Logical Block Address to read from\r
\r
  @param  BufferSize Size of Buffer, must be a multiple of device block size.\r
\r
  @param  Buffer     A pointer to the destination buffer for the data. The caller is\r
\r
                     responsible for either having implicit or explicit ownership of the buffer.\r
\r
\r
\r
  @retval EFI_SUCCESS           The data was read correctly from the device.\r
\r
  @retval EFI_DEVICE_ERROR      The device reported an error while performing the read.\r
\r
  @retval EFI_NO_MEDIA          There is no media in the device.\r
\r
  @retval EFI_MEDIA_CHANGED     The MediaId does not matched the current device.\r
\r
  @retval EFI_BAD_BUFFER_SIZE   The Buffer was not a multiple of the block size of the device.\r
\r
  @retval EFI_INVALID_PARAMETER The read request contains LBAs that are not valid,\r
\r
                                or the buffer is not on proper alignment.\r
\r
EFI_STATUS\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
MMCHSReadBlocks (\r
  IN EFI_BLOCK_IO_PROTOCOL          *This,\r
  IN UINT32                         MediaId,\r
  IN EFI_LBA                        Lba,\r
  IN UINTN                          BufferSize,\r
  OUT VOID                          *Buffer\r
  )\r
{\r
  EFI_STATUS Status;\r
\r
  //Perform Read operation.\r
  Status = SdReadWrite (This, (UINTN)Lba, Buffer, BufferSize, READ);\r
\r
  return Status;\r
\r
}\r
\r
\r
/**\r
\r
  Write BufferSize bytes from Lba into Buffer.\r
\r
\r
\r
  @param  This       Indicates a pointer to the calling context.\r
\r
  @param  MediaId    The media ID that the write request is for.\r
\r
  @param  Lba        The starting logical block address to be written. The caller is\r
\r
                     responsible for writing to only legitimate locations.\r
\r
  @param  BufferSize Size of Buffer, must be a multiple of device block size.\r
\r
  @param  Buffer     A pointer to the source buffer for the data.\r
\r
\r
\r
  @retval EFI_SUCCESS           The data was written correctly to the device.\r
\r
  @retval EFI_WRITE_PROTECTED   The device can not be written to.\r
\r
  @retval EFI_DEVICE_ERROR      The device reported an error while performing the write.\r
\r
  @retval EFI_NO_MEDIA          There is no media in the device.\r
\r
  @retval EFI_MEDIA_CHNAGED     The MediaId does not matched the current device.\r
\r
  @retval EFI_BAD_BUFFER_SIZE   The Buffer was not a multiple of the block size of the device.\r
\r
  @retval EFI_INVALID_PARAMETER The write request contains LBAs that are not valid,\r
\r
                                or the buffer is not on proper alignment.\r
\r
\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
MMCHSWriteBlocks (\r
  IN EFI_BLOCK_IO_PROTOCOL          *This,\r
  IN UINT32                         MediaId,\r
  IN EFI_LBA                        Lba,\r
  IN UINTN                          BufferSize,\r
  IN VOID                           *Buffer\r
  )\r
{\r
  EFI_STATUS  Status;\r
\r
  //Perform write operation.\r
  Status = SdReadWrite (This, (UINTN)Lba, Buffer, BufferSize, WRITE);\r
\r
\r
  return Status;\r
\r
}\r
\r
\r
/**\r
\r
  Flush the Block Device.\r
\r
\r
\r
  @param  This              Indicates a pointer to the calling context.\r
\r
\r
\r
  @retval EFI_SUCCESS       All outstanding data was written to the device\r
\r
  @retval EFI_DEVICE_ERROR  The device reported an error while writting back the data\r
\r
  @retval EFI_NO_MEDIA      There is no media in the device.\r
\r
\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
MMCHSFlushBlocks (\r
  IN EFI_BLOCK_IO_PROTOCOL  *This\r
  )\r
{\r
  return EFI_SUCCESS;\r
}\r
\r
\r
EFI_BLOCK_IO_PROTOCOL gBlockIo = {\r
  EFI_BLOCK_IO_INTERFACE_REVISION,   // Revision\r
  &gMMCHSMedia,                      // *Media\r
  MMCHSReset,                        // Reset\r
  MMCHSReadBlocks,                   // ReadBlocks\r
  MMCHSWriteBlocks,                  // WriteBlocks\r
  MMCHSFlushBlocks                   // FlushBlocks\r
};\r
\r
\r
/**\r
\r
  Timer callback to convert card present hardware into a boolean that indicates\r
\r
  a media change event has happened. If you just check the GPIO you could see\r
\r
  card 1 and then check again after card 1 was removed and card 2 was inserted\r
\r
  and you would still see media present. Thus you need the timer tick to catch\r
\r
  the toggle event.\r
\r
\r
\r
  @param  Event                 Event whose notification function is being invoked.\r
\r
  @param  Context               The pointer to the notification function's context,\r
\r
                                which is implementation-dependent. Not used.\r
\r
\r
\r
**/\r
VOID\r
EFIAPI\r
TimerCallback (\r
  IN  EFI_EVENT   Event,\r
  IN  VOID        *Context\r
  )\r
{\r
  BOOLEAN Present;\r
\r
  Present = CardPresent ();\r
  if (gMMCHSMedia.MediaPresent) {\r
    if (!Present && !gMediaChange) {\r
      gMediaChange = TRUE;\r
    }\r
  } else {\r
    if (Present && !gMediaChange) {\r
      gMediaChange = TRUE;\r
    }\r
  }\r
}\r
\r
\r
EFI_STATUS\r
EFIAPI\r
MMCHSInitialize (\r
  IN EFI_HANDLE         ImageHandle,\r
  IN EFI_SYSTEM_TABLE   *SystemTable\r
  )\r
{\r
  EFI_STATUS  Status;\r
\r
  Status = gBS->LocateProtocol (&gEmbeddedExternalDeviceProtocolGuid, NULL, (VOID **)&gTPS65950);\r
  ASSERT_EFI_ERROR(Status);\r
\r
  ZeroMem (&gCardInfo, sizeof (CARD_INFO));\r
\r
  Status = gBS->CreateEvent (EVT_TIMER | EVT_NOTIFY_SIGNAL, TPL_CALLBACK, TimerCallback, NULL, &gTimerEvent);\r
  ASSERT_EFI_ERROR (Status);\r
\r
  Status = gBS->SetTimer (gTimerEvent, TimerPeriodic, FixedPcdGet32 (PcdMmchsTimerFreq100NanoSeconds));\r
  ASSERT_EFI_ERROR (Status);\r
\r
  //Publish BlockIO.\r
  Status = gBS->InstallMultipleProtocolInterfaces (\r
                  &ImageHandle,\r
                  &gEfiBlockIoProtocolGuid,    &gBlockIo,\r
                  &gEfiDevicePathProtocolGuid, &gMmcHsDevicePath,\r
                  NULL\r
                  );\r
  return Status;\r
}\r