SD Private Functions

Functions
static uint32_t	SD_InitCard (SD_HandleTypeDef *hsd)
	Initializes the sd card. More...
static uint32_t	SD_PowerON (SD_HandleTypeDef *hsd)
	Enquires cards about their operating voltage and configures clock controls and stores SD information that will be needed in future in the SD handle. More...
static uint32_t	SD_SendSDStatus (SD_HandleTypeDef *hsd, uint32_t *pSDstatus)
	Send Status info command. More...
static uint32_t	SD_SendStatus (SD_HandleTypeDef *hsd, uint32_t *pCardStatus)
	Returns the current card's status. More...
static uint32_t	SD_WideBus_Enable (SD_HandleTypeDef *hsd)
	Enables the SDMMC wide bus mode. More...
static uint32_t	SD_WideBus_Disable (SD_HandleTypeDef *hsd)
	Disables the SDMMC wide bus mode. More...
static uint32_t	SD_FindSCR (SD_HandleTypeDef *hsd, uint32_t *pSCR)
	Finds the SD card SCR register value. More...
static void	SD_PowerOFF (SD_HandleTypeDef *hsd)
	Turns the SDMMC output signals off. More...
static void	SD_Write_IT (SD_HandleTypeDef *hsd)
	Wrap up writing in non-blocking mode. More...
static void	SD_Read_IT (SD_HandleTypeDef *hsd)
	Wrap up reading in non-blocking mode. More...
static void	SD_DMATransmitCplt (DMA_HandleTypeDef *hdma)
	DMA SD transmit process complete callback. More...
static void	SD_DMAReceiveCplt (DMA_HandleTypeDef *hdma)
	DMA SD receive process complete callback. More...
static void	SD_DMAError (DMA_HandleTypeDef *hdma)
	DMA SD communication error callback. More...
static void	SD_DMATxAbort (DMA_HandleTypeDef *hdma)
	DMA SD Tx Abort callback. More...
static void	SD_DMARxAbort (DMA_HandleTypeDef *hdma)
	DMA SD Rx Abort callback. More...
uint32_t	SD_HighSpeed (SD_HandleTypeDef *hsd)
	Switches the SD card to High Speed mode. This API must be used after "Transfer State". More...
static uint32_t	SD_UltraHighSpeed (SD_HandleTypeDef *hsd)
	Switches the SD card to Ultra High Speed mode. This API must be used after "Transfer State". More...
static uint32_t	SD_DDR_Mode (SD_HandleTypeDef *hsd)
	Switches the SD card to Double Data Rate (DDR) mode. This API must be used after "Transfer State". More...
	while (((sta_reg &(SDMMC_FLAG_CCRCFAIL|SDMMC_FLAG_CMDREND|SDMMC_FLAG_CTIMEOUT))==0U)||((sta_reg &SDMMC_FLAG_CMDACT) !=0U))
	if (__SDMMC_GET_FLAG(SDMMCx, SDMMC_FLAG_CTIMEOUT))
else	if (__SDMMC_GET_FLAG(SDMMCx, SDMMC_FLAG_CCRCFAIL))
	if (SDMMC_GetCommandResponse(SDMMCx) !=SD_CMD)
	if ((response_r1 &SDMMC_OCR_ERRORBITS)==SDMMC_ALLZERO)
else	if ((response_r1 &SDMMC_OCR_ADDR_OUT_OF_RANGE)==SDMMC_OCR_ADDR_OUT_OF_RANGE)
else	if ((response_r1 &SDMMC_OCR_ADDR_MISALIGNED)==SDMMC_OCR_ADDR_MISALIGNED)
else	if ((response_r1 &SDMMC_OCR_BLOCK_LEN_ERR)==SDMMC_OCR_BLOCK_LEN_ERR)
else	if ((response_r1 &SDMMC_OCR_ERASE_SEQ_ERR)==SDMMC_OCR_ERASE_SEQ_ERR)
else	if ((response_r1 &SDMMC_OCR_BAD_ERASE_PARAM)==SDMMC_OCR_BAD_ERASE_PARAM)
else	if ((response_r1 &SDMMC_OCR_WRITE_PROT_VIOLATION)==SDMMC_OCR_WRITE_PROT_VIOLATION)
else	if ((response_r1 &SDMMC_OCR_LOCK_UNLOCK_FAILED)==SDMMC_OCR_LOCK_UNLOCK_FAILED)
else	if ((response_r1 &SDMMC_OCR_COM_CRC_FAILED)==SDMMC_OCR_COM_CRC_FAILED)
else	if ((response_r1 &SDMMC_OCR_ILLEGAL_CMD)==SDMMC_OCR_ILLEGAL_CMD)
else	if ((response_r1 &SDMMC_OCR_CARD_ECC_FAILED)==SDMMC_OCR_CARD_ECC_FAILED)
else	if ((response_r1 &SDMMC_OCR_CC_ERROR)==SDMMC_OCR_CC_ERROR)
else	if ((response_r1 &SDMMC_OCR_STREAM_READ_UNDERRUN)==SDMMC_OCR_STREAM_READ_UNDERRUN)
else	if ((response_r1 &SDMMC_OCR_STREAM_WRITE_OVERRUN)==SDMMC_OCR_STREAM_WRITE_OVERRUN)
else	if ((response_r1 &SDMMC_OCR_CID_CSD_OVERWRITE)==SDMMC_OCR_CID_CSD_OVERWRITE)
else	if ((response_r1 &SDMMC_OCR_WP_ERASE_SKIP)==SDMMC_OCR_WP_ERASE_SKIP)
else	if ((response_r1 &SDMMC_OCR_CARD_ECC_DISABLED)==SDMMC_OCR_CARD_ECC_DISABLED)
else	if ((response_r1 &SDMMC_OCR_ERASE_RESET)==SDMMC_OCR_ERASE_RESET)
else	if ((response_r1 &SDMMC_OCR_AKE_SEQ_ERROR)==SDMMC_OCR_AKE_SEQ_ERROR)

Variables
	else
	response_r1 = SDMMC_GetResponse(SDMMCx, SDMMC_RESP1)

Detailed Description

Function Documentation

if() [1/22]

if

(

__SDMMC_GET_FLAG(SDMMCx, SDMMC_FLAG_CTIMEOUT)

)

Definition at line 1292 of file stm32l4xx_ll_sdmmc.c.

  {
    __SDMMC_CLEAR_FLAG(SDMMCx, SDMMC_FLAG_CTIMEOUT);

    return SDMMC_ERROR_CMD_RSP_TIMEOUT;
  }

if() [2/22]

else if

(

__SDMMC_GET_FLAG(SDMMCx, SDMMC_FLAG_CCRCFAIL)

)

Definition at line 1298 of file stm32l4xx_ll_sdmmc.c.

  {
    __SDMMC_CLEAR_FLAG(SDMMCx, SDMMC_FLAG_CCRCFAIL);

    return SDMMC_ERROR_CMD_CRC_FAIL;
  }

if() [3/22]

if

(

SDMMC_GetCommandResponse(SDMMCx) !

= SD_CMD

)

Definition at line 1313 of file stm32l4xx_ll_sdmmc.c.

  {
    return SDMMC_ERROR_CMD_CRC_FAIL;
  }

if() [4/22]

if

(

(response_r1 &SDMMC_OCR_ERRORBITS)

= = SDMMC_ALLZERO

)

Definition at line 1321 of file stm32l4xx_ll_sdmmc.c.

  {
    return SDMMC_ERROR_NONE;
  }

if() [5/22]

else if

(

(response_r1 &SDMMC_OCR_ADDR_OUT_OF_RANGE)

= = SDMMC_OCR_ADDR_OUT_OF_RANGE

)

Definition at line 1325 of file stm32l4xx_ll_sdmmc.c.

  {
    return SDMMC_ERROR_ADDR_OUT_OF_RANGE;
  }

if() [6/22]

else if

(

(response_r1 &SDMMC_OCR_ADDR_MISALIGNED)

= = SDMMC_OCR_ADDR_MISALIGNED

)

Definition at line 1329 of file stm32l4xx_ll_sdmmc.c.

  {
    return SDMMC_ERROR_ADDR_MISALIGNED;
  }

if() [7/22]

else if

(

(response_r1 &SDMMC_OCR_BLOCK_LEN_ERR)

= = SDMMC_OCR_BLOCK_LEN_ERR

)

Definition at line 1333 of file stm32l4xx_ll_sdmmc.c.

  {
    return SDMMC_ERROR_BLOCK_LEN_ERR;
  }

if() [8/22]

else if

(

(response_r1 &SDMMC_OCR_ERASE_SEQ_ERR)

= = SDMMC_OCR_ERASE_SEQ_ERR

)

Definition at line 1337 of file stm32l4xx_ll_sdmmc.c.

  {
    return SDMMC_ERROR_ERASE_SEQ_ERR;
  }

if() [9/22]

else if

(

(response_r1 &SDMMC_OCR_BAD_ERASE_PARAM)

= = SDMMC_OCR_BAD_ERASE_PARAM

)

Definition at line 1341 of file stm32l4xx_ll_sdmmc.c.

  {
    return SDMMC_ERROR_BAD_ERASE_PARAM;
  }

if() [10/22]

else if

(

(response_r1 &SDMMC_OCR_WRITE_PROT_VIOLATION)

= = SDMMC_OCR_WRITE_PROT_VIOLATION

)

Definition at line 1345 of file stm32l4xx_ll_sdmmc.c.

  {
    return SDMMC_ERROR_WRITE_PROT_VIOLATION;
  }

if() [11/22]

else if

(

(response_r1 &SDMMC_OCR_LOCK_UNLOCK_FAILED)

= = SDMMC_OCR_LOCK_UNLOCK_FAILED

)

Definition at line 1349 of file stm32l4xx_ll_sdmmc.c.

  {
    return SDMMC_ERROR_LOCK_UNLOCK_FAILED;
  }

if() [12/22]

else if

(

(response_r1 &SDMMC_OCR_COM_CRC_FAILED)

= = SDMMC_OCR_COM_CRC_FAILED

)

Definition at line 1353 of file stm32l4xx_ll_sdmmc.c.

  {
    return SDMMC_ERROR_COM_CRC_FAILED;
  }

if() [13/22]

else if

(

(response_r1 &SDMMC_OCR_ILLEGAL_CMD)

= = SDMMC_OCR_ILLEGAL_CMD

)

Definition at line 1357 of file stm32l4xx_ll_sdmmc.c.

  {
    return SDMMC_ERROR_ILLEGAL_CMD;
  }

if() [14/22]

else if

(

(response_r1 &SDMMC_OCR_CARD_ECC_FAILED)

= = SDMMC_OCR_CARD_ECC_FAILED

)

Definition at line 1361 of file stm32l4xx_ll_sdmmc.c.

  {
    return SDMMC_ERROR_CARD_ECC_FAILED;
  }

if() [15/22]

else if

(

(response_r1 &SDMMC_OCR_CC_ERROR)

= = SDMMC_OCR_CC_ERROR

)

Definition at line 1365 of file stm32l4xx_ll_sdmmc.c.

  {
    return SDMMC_ERROR_CC_ERR;
  }

if() [16/22]

else if

(

(response_r1 &SDMMC_OCR_STREAM_READ_UNDERRUN)

= = SDMMC_OCR_STREAM_READ_UNDERRUN

)

Definition at line 1369 of file stm32l4xx_ll_sdmmc.c.

  {
    return SDMMC_ERROR_STREAM_READ_UNDERRUN;
  }

if() [17/22]

else if

(

(response_r1 &SDMMC_OCR_STREAM_WRITE_OVERRUN)

= = SDMMC_OCR_STREAM_WRITE_OVERRUN

)

Definition at line 1373 of file stm32l4xx_ll_sdmmc.c.

  {
    return SDMMC_ERROR_STREAM_WRITE_OVERRUN;
  }

if() [18/22]

else if

(

(response_r1 &SDMMC_OCR_CID_CSD_OVERWRITE)

= = SDMMC_OCR_CID_CSD_OVERWRITE

)

Definition at line 1377 of file stm32l4xx_ll_sdmmc.c.

  {
    return SDMMC_ERROR_CID_CSD_OVERWRITE;
  }

if() [19/22]

else if

(

(response_r1 &SDMMC_OCR_WP_ERASE_SKIP)

= = SDMMC_OCR_WP_ERASE_SKIP

)

Definition at line 1381 of file stm32l4xx_ll_sdmmc.c.

  {
    return SDMMC_ERROR_WP_ERASE_SKIP;
  }

if() [20/22]

else if

(

(response_r1 &SDMMC_OCR_CARD_ECC_DISABLED)

= = SDMMC_OCR_CARD_ECC_DISABLED

)

Definition at line 1385 of file stm32l4xx_ll_sdmmc.c.

  {
    return SDMMC_ERROR_CARD_ECC_DISABLED;
  }

if() [21/22]

else if

(

(response_r1 &SDMMC_OCR_ERASE_RESET)

= = SDMMC_OCR_ERASE_RESET

)

Definition at line 1389 of file stm32l4xx_ll_sdmmc.c.

  {
    return SDMMC_ERROR_ERASE_RESET;
  }

if() [22/22]

else if

(

(response_r1 &SDMMC_OCR_AKE_SEQ_ERROR)

= = SDMMC_OCR_AKE_SEQ_ERROR

)

Definition at line 1393 of file stm32l4xx_ll_sdmmc.c.

  {
    return SDMMC_ERROR_AKE_SEQ_ERR;
  }

SD_DDR_Mode()

static uint32_t SD_DDR_Mode ( SD_HandleTypeDef *  hsd )

static

Switches the SD card to Double Data Rate (DDR) mode. This API must be used after "Transfer State".

Note

This operation should be followed by the configuration of PLL to have SDMMCCK clock less than 50MHz

Parameters

hsd

SD handle

Return values

SD	Card error state

Definition at line 4290 of file stm32l4xx_hal_sd.c.

{
  uint32_t errorstate = HAL_SD_ERROR_NONE;
  SDMMC_DataInitTypeDef sdmmc_datainitstructure;
  uint32_t SD_hs[16]  = {0};
  uint32_t count, loop = 0 ;
  uint32_t Timeout = HAL_GetTick();

  if(hsd->SdCard.CardSpeed == CARD_NORMAL_SPEED)
  {
     /* Standard Speed Card <= 12.5Mhz  */
     return HAL_SD_ERROR_REQUEST_NOT_APPLICABLE;
  }

  if((hsd->SdCard.CardSpeed == CARD_ULTRA_HIGH_SPEED) &&
     (hsd->Init.Transceiver == SDMMC_TRANSCEIVER_ENABLE))
  {
    /* Initialize the Data control register */
    hsd->Instance->DCTRL = 0;
    errorstate = SDMMC_CmdBlockLength(hsd->Instance, 64);

    if (errorstate != HAL_SD_ERROR_NONE)
    {
      return errorstate;
    }

    /* Configure the SD DPSM (Data Path State Machine) */
    sdmmc_datainitstructure.DataTimeOut   = SDMMC_DATATIMEOUT;
    sdmmc_datainitstructure.DataLength    = 64;
    sdmmc_datainitstructure.DataBlockSize = SDMMC_DATABLOCK_SIZE_64B ;
    sdmmc_datainitstructure.TransferDir   = SDMMC_TRANSFER_DIR_TO_SDMMC;
    sdmmc_datainitstructure.TransferMode  = SDMMC_TRANSFER_MODE_BLOCK;
    sdmmc_datainitstructure.DPSM          = SDMMC_DPSM_ENABLE;

    if ( SDMMC_ConfigData(hsd->Instance, &sdmmc_datainitstructure) != HAL_OK)
    {
      return (HAL_SD_ERROR_GENERAL_UNKNOWN_ERR);
    }

    errorstate = SDMMC_CmdSwitch(hsd->Instance, SDMMC_DDR50_SWITCH_PATTERN);
    if(errorstate != HAL_SD_ERROR_NONE)
    {
      return errorstate;
    }

    while(!__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXOVERR | SDMMC_FLAG_DCRCFAIL | SDMMC_FLAG_DTIMEOUT | SDMMC_FLAG_DBCKEND| SDMMC_FLAG_DATAEND ))
    {
      if (__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXFIFOHF))
      {
        for (count = 0U; count < 8U; count++)
        {
          SD_hs[(8U*loop)+count]  = SDMMC_ReadFIFO(hsd->Instance);
        }
        loop ++;
      }

      if((HAL_GetTick()-Timeout) >=  SDMMC_DATATIMEOUT)
      {
        hsd->ErrorCode = HAL_SD_ERROR_TIMEOUT;
        hsd->State= HAL_SD_STATE_READY;
        return HAL_SD_ERROR_TIMEOUT;
      }
    }

    if (__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DTIMEOUT))
    {
      __HAL_SD_CLEAR_FLAG(hsd, SDMMC_FLAG_DTIMEOUT);

      errorstate = 0;

      return errorstate;
    }
    else if (__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DCRCFAIL))
    {
      __HAL_SD_CLEAR_FLAG(hsd, SDMMC_FLAG_DCRCFAIL);

      errorstate = SDMMC_ERROR_DATA_CRC_FAIL;

      return errorstate;
    }
    else if (__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXOVERR))
    {
      __HAL_SD_CLEAR_FLAG(hsd, SDMMC_FLAG_RXOVERR);

      errorstate = SDMMC_ERROR_RX_OVERRUN;

      return errorstate;
    }
    else
    {
      /* No error flag set */
    }

    /* Clear all the static flags */
    __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_DATA_FLAGS);

    /* Test if the switch mode  is ok */
    if ((((uint8_t*)SD_hs)[13] & 2U) != 2U)
    {
      errorstate = SDMMC_ERROR_UNSUPPORTED_FEATURE;
    }
    else
    {
#if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
      hsd->DriveTransceiver_1_8V_Callback(SET);
#else
      HAL_SDEx_DriveTransceiver_1_8V_Callback(SET);
#endif /* USE_HAL_SD_REGISTER_CALLBACKS */
#if defined (DLYB_SDMMC1) || defined (DLYB_SDMMC2)
      /* Enable DelayBlock Peripheral */
      /* SDMMC_FB_CLK tuned feedback clock selected as receive clock, for SDR104 */
      MODIFY_REG(hsd->Instance->CLKCR, SDMMC_CLKCR_SELCLKRX,SDMMC_CLKCR_SELCLKRX_1);
      if (DelayBlock_Enable(SD_GET_DLYB_INSTANCE(hsd->Instance)) != HAL_OK)
      {
        return (HAL_SD_ERROR_GENERAL_UNKNOWN_ERR);
      }
#endif /* (DLYB_SDMMC1) || (DLYB_SDMMC2) */
    }
  }

  return errorstate;
}

SD_DMAError()

static void SD_DMAError ( DMA_HandleTypeDef *  hdma )

static

DMA SD communication error callback.

Parameters

hdma	DMA handle

Return values

None

Definition at line 3218 of file stm32l4xx_hal_sd.c.

{
  SD_HandleTypeDef* hsd = (SD_HandleTypeDef* )(hdma->Parent);
  HAL_SD_CardStateTypeDef CardState;
  uint32_t RxErrorCode, TxErrorCode;

  RxErrorCode = hsd->hdmarx->ErrorCode;
  TxErrorCode = hsd->hdmatx->ErrorCode;
  if((RxErrorCode == HAL_DMA_ERROR_TE) || (TxErrorCode == HAL_DMA_ERROR_TE))
  {
    /* Clear All flags */
    __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);

    /* Disable All interrupts */
    __HAL_SD_DISABLE_IT(hsd, SDMMC_IT_DATAEND | SDMMC_IT_DCRCFAIL | SDMMC_IT_DTIMEOUT|\
      SDMMC_IT_TXUNDERR| SDMMC_IT_RXOVERR);

    hsd->ErrorCode |= HAL_SD_ERROR_DMA;
    CardState = HAL_SD_GetCardState(hsd);
    if((CardState == HAL_SD_CARD_RECEIVING) || (CardState == HAL_SD_CARD_SENDING))
    {
      hsd->ErrorCode |= SDMMC_CmdStopTransfer(hsd->Instance);
    }

    hsd->State= HAL_SD_STATE_READY;
    hsd->Context = SD_CONTEXT_NONE;
  }

#if (USE_HAL_SD_REGISTER_CALLBACKS == 1)
  hsd->ErrorCallback(hsd);
#else
  HAL_SD_ErrorCallback(hsd);
#endif
}

SD_DMAReceiveCplt()

static void SD_DMAReceiveCplt ( DMA_HandleTypeDef *  hdma )

static

DMA SD receive process complete callback.

Parameters

hdma	DMA handle

Return values

None

Definition at line 3176 of file stm32l4xx_hal_sd.c.

{
  SD_HandleTypeDef* hsd = (SD_HandleTypeDef* )(hdma->Parent);
  uint32_t errorstate;

  /* Send stop command in multiblock write */
  if(hsd->Context == (SD_CONTEXT_READ_MULTIPLE_BLOCK | SD_CONTEXT_DMA))
  {
    errorstate = SDMMC_CmdStopTransfer(hsd->Instance);
    if(errorstate != HAL_SD_ERROR_NONE)
    {
      hsd->ErrorCode |= errorstate;
#if (USE_HAL_SD_REGISTER_CALLBACKS == 1)
      hsd->ErrorCallback(hsd);
#else
      HAL_SD_ErrorCallback(hsd);
#endif
    }
  }

  /* Disable the DMA transfer for transmit request by setting the DMAEN bit
  in the SD DCTRL register */
  hsd->Instance->DCTRL &= (uint32_t)~((uint32_t)SDMMC_DCTRL_DMAEN);

  /* Clear all the static flags */
  __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_DATA_FLAGS);

  hsd->State = HAL_SD_STATE_READY;
  hsd->Context = SD_CONTEXT_NONE;

#if (USE_HAL_SD_REGISTER_CALLBACKS == 1)
  hsd->RxCpltCallback(hsd);
#else
  HAL_SD_RxCpltCallback(hsd);
#endif
}

SD_DMARxAbort()

static void SD_DMARxAbort ( DMA_HandleTypeDef *  hdma )

static

DMA SD Rx Abort callback.

Parameters

hdma	DMA handle

Return values

None

Definition at line 3297 of file stm32l4xx_hal_sd.c.

{
  SD_HandleTypeDef* hsd = (SD_HandleTypeDef* )(hdma->Parent);
  HAL_SD_CardStateTypeDef CardState;

  /* Clear All flags */
  __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_DATA_FLAGS);

  CardState = HAL_SD_GetCardState(hsd);
  hsd->State = HAL_SD_STATE_READY;
  hsd->Context = SD_CONTEXT_NONE;
  if((CardState == HAL_SD_CARD_RECEIVING) || (CardState == HAL_SD_CARD_SENDING))
  {
    hsd->ErrorCode |= SDMMC_CmdStopTransfer(hsd->Instance);
  }

  if(hsd->ErrorCode == HAL_SD_ERROR_NONE)
  {
#if (USE_HAL_SD_REGISTER_CALLBACKS == 1)
    hsd->AbortCpltCallback(hsd);
#else
    HAL_SD_AbortCallback(hsd);
#endif
  }
  else
  {
#if (USE_HAL_SD_REGISTER_CALLBACKS == 1)
    hsd->ErrorCallback(hsd);
#else
    HAL_SD_ErrorCallback(hsd);
#endif
  }
}

SD_DMATransmitCplt()

static void SD_DMATransmitCplt ( DMA_HandleTypeDef *  hdma )

static

DMA SD transmit process complete callback.

Parameters

hdma	DMA handle

Return values

None

Definition at line 3163 of file stm32l4xx_hal_sd.c.

{
  SD_HandleTypeDef* hsd = (SD_HandleTypeDef* )(hdma->Parent);

  /* Enable DATAEND Interrupt */
  __HAL_SD_ENABLE_IT(hsd, (SDMMC_IT_DATAEND));
}

SD_DMATxAbort()

static void SD_DMATxAbort ( DMA_HandleTypeDef *  hdma )

static

DMA SD Tx Abort callback.

Parameters

hdma	DMA handle

Return values

None

Definition at line 3258 of file stm32l4xx_hal_sd.c.

{
  SD_HandleTypeDef* hsd = (SD_HandleTypeDef* )(hdma->Parent);
  HAL_SD_CardStateTypeDef CardState;

  /* Clear All flags */
  __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_DATA_FLAGS);

  CardState = HAL_SD_GetCardState(hsd);
  hsd->State = HAL_SD_STATE_READY;
  hsd->Context = SD_CONTEXT_NONE;
  if((CardState == HAL_SD_CARD_RECEIVING) || (CardState == HAL_SD_CARD_SENDING))
  {
    hsd->ErrorCode |= SDMMC_CmdStopTransfer(hsd->Instance);
  }

  if(hsd->ErrorCode == HAL_SD_ERROR_NONE)
  {
#if (USE_HAL_SD_REGISTER_CALLBACKS == 1)
    hsd->AbortCpltCallback(hsd);
#else
    HAL_SD_AbortCallback(hsd);
#endif
  }
  else
  {
#if (USE_HAL_SD_REGISTER_CALLBACKS == 1)
    hsd->ErrorCallback(hsd);
#else
    HAL_SD_ErrorCallback(hsd);
#endif
  }
}

SD_FindSCR()

static uint32_t SD_FindSCR ( SD_HandleTypeDef *  hsd, uint32_t *  pSCR  )

static

Finds the SD card SCR register value.

Parameters

hsd	Pointer to SD handle
pSCR	pointer to the buffer that will contain the SCR value

Return values

error

state

Definition at line 3852 of file stm32l4xx_hal_sd.c.

{
  SDMMC_DataInitTypeDef config;
  uint32_t errorstate;
  uint32_t tickstart = HAL_GetTick();
  uint32_t index = 0U;
  uint32_t tempscr[2U] = {0U, 0U};
  uint32_t *scr = pSCR;

  /* Set Block Size To 8 Bytes */
  errorstate = SDMMC_CmdBlockLength(hsd->Instance, 8U);
  if(errorstate != HAL_SD_ERROR_NONE)
  {
    return errorstate;
  }

  /* Send CMD55 APP_CMD with argument as card's RCA */
  errorstate = SDMMC_CmdAppCommand(hsd->Instance, (uint32_t)((hsd->SdCard.RelCardAdd) << 16U));
  if(errorstate != HAL_SD_ERROR_NONE)
  {
    return errorstate;
  }

  config.DataTimeOut   = SDMMC_DATATIMEOUT;
  config.DataLength    = 8U;
  config.DataBlockSize = SDMMC_DATABLOCK_SIZE_8B;
  config.TransferDir   = SDMMC_TRANSFER_DIR_TO_SDMMC;
  config.TransferMode  = SDMMC_TRANSFER_MODE_BLOCK;
  config.DPSM          = SDMMC_DPSM_ENABLE;
  (void)SDMMC_ConfigData(hsd->Instance, &config);

  /* Send ACMD51 SD_APP_SEND_SCR with argument as 0 */
  errorstate = SDMMC_CmdSendSCR(hsd->Instance);
  if(errorstate != HAL_SD_ERROR_NONE)
  {
    return errorstate;
  }

#if defined(STM32L4R5xx) || defined(STM32L4R7xx) || defined(STM32L4R9xx) || defined(STM32L4S5xx) || defined(STM32L4S7xx) || defined(STM32L4S9xx)
  while(!__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXOVERR | SDMMC_FLAG_DCRCFAIL | SDMMC_FLAG_DTIMEOUT | SDMMC_FLAG_DBCKEND | SDMMC_FLAG_DATAEND))
  {
    if((!__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXFIFOE)) && (index == 0U))
    {
      tempscr[0] = SDMMC_ReadFIFO(hsd->Instance);
      tempscr[1] = SDMMC_ReadFIFO(hsd->Instance);
      index++;
    }


    if((HAL_GetTick() - tickstart) >=  SDMMC_DATATIMEOUT)
    {
      return HAL_SD_ERROR_TIMEOUT;
    }
  }
#else
  while(!__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXOVERR | SDMMC_FLAG_DCRCFAIL | SDMMC_FLAG_DTIMEOUT | SDMMC_FLAG_DBCKEND))
  {
    if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXDAVL))
    {
      *(tempscr + index) = SDMMC_ReadFIFO(hsd->Instance);
      index++;
    }

    if((HAL_GetTick() - tickstart) >=  SDMMC_DATATIMEOUT)
    {
      return HAL_SD_ERROR_TIMEOUT;
    }
  }
#endif /* STM32L4R5xx || STM32L4R7xx || STM32L4R9xx || STM32L4S5xx || STM32L4S7xx || STM32L4S9xx */

  if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DTIMEOUT))
  {
    __HAL_SD_CLEAR_FLAG(hsd, SDMMC_FLAG_DTIMEOUT);

    return HAL_SD_ERROR_DATA_TIMEOUT;
  }
  else if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DCRCFAIL))
  {
    __HAL_SD_CLEAR_FLAG(hsd, SDMMC_FLAG_DCRCFAIL);

    return HAL_SD_ERROR_DATA_CRC_FAIL;
  }
  else if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXOVERR))
  {
    __HAL_SD_CLEAR_FLAG(hsd, SDMMC_FLAG_RXOVERR);

    return HAL_SD_ERROR_RX_OVERRUN;
  }
  else
  {
    /* No error flag set */
    /* Clear all the static flags */
    __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_DATA_FLAGS);

    *scr = (((tempscr[1] & SDMMC_0TO7BITS) << 24)  | ((tempscr[1] & SDMMC_8TO15BITS) << 8) |\
            ((tempscr[1] & SDMMC_16TO23BITS) >> 8) | ((tempscr[1] & SDMMC_24TO31BITS) >> 24));
    scr++;
    *scr = (((tempscr[0] & SDMMC_0TO7BITS) << 24)  | ((tempscr[0] & SDMMC_8TO15BITS) << 8) |\
            ((tempscr[0] & SDMMC_16TO23BITS) >> 8) | ((tempscr[0] & SDMMC_24TO31BITS) >> 24));

  }

  return HAL_SD_ERROR_NONE;
}

SD_HighSpeed()

uint32_t SD_HighSpeed

(

SD_HandleTypeDef *

hsd

)

Switches the SD card to High Speed mode. This API must be used after "Transfer State".

Note

This operation should be followed by the configuration of PLL to have SDMMCCK clock between 50 and 120 MHz

Parameters

hsd

SD handle

Return values

SD	Card error state

Definition at line 4044 of file stm32l4xx_hal_sd.c.

{
  uint32_t errorstate = HAL_SD_ERROR_NONE;
  SDMMC_DataInitTypeDef sdmmc_datainitstructure;
  uint32_t SD_hs[16]  = {0};
  uint32_t count, loop = 0 ;
  uint32_t Timeout = HAL_GetTick();

  if(hsd->SdCard.CardSpeed == CARD_NORMAL_SPEED)
  {
     /* Standard Speed Card <= 12.5Mhz  */
     return HAL_SD_ERROR_REQUEST_NOT_APPLICABLE;
  }

  if(hsd->SdCard.CardSpeed == CARD_HIGH_SPEED)
  {
    /* Initialize the Data control register */
    hsd->Instance->DCTRL = 0;
    errorstate = SDMMC_CmdBlockLength(hsd->Instance, 64);

    if (errorstate != HAL_SD_ERROR_NONE)
    {
      return errorstate;
    }

    /* Configure the SD DPSM (Data Path State Machine) */
    sdmmc_datainitstructure.DataTimeOut   = SDMMC_DATATIMEOUT;
    sdmmc_datainitstructure.DataLength    = 64;
    sdmmc_datainitstructure.DataBlockSize = SDMMC_DATABLOCK_SIZE_64B ;
    sdmmc_datainitstructure.TransferDir   = SDMMC_TRANSFER_DIR_TO_SDMMC;
    sdmmc_datainitstructure.TransferMode  = SDMMC_TRANSFER_MODE_BLOCK;
    sdmmc_datainitstructure.DPSM          = SDMMC_DPSM_ENABLE;

    if ( SDMMC_ConfigData(hsd->Instance, &sdmmc_datainitstructure) != HAL_OK)
    {
      return (HAL_SD_ERROR_GENERAL_UNKNOWN_ERR);
    }


    errorstate = SDMMC_CmdSwitch(hsd->Instance,SDMMC_SDR25_SWITCH_PATTERN);
    if(errorstate != HAL_SD_ERROR_NONE)
    {
      return errorstate;
    }

    while(!__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXOVERR | SDMMC_FLAG_DCRCFAIL | SDMMC_FLAG_DTIMEOUT | SDMMC_FLAG_DBCKEND| SDMMC_FLAG_DATAEND ))
    {
      if (__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXFIFOHF))
      {
        for (count = 0U; count < 8U; count++)
        {
          SD_hs[(8U*loop)+count]  = SDMMC_ReadFIFO(hsd->Instance);
        }
        loop ++;
      }

      if((HAL_GetTick()-Timeout) >=  SDMMC_DATATIMEOUT)
      {
        hsd->ErrorCode = HAL_SD_ERROR_TIMEOUT;
        hsd->State= HAL_SD_STATE_READY;
        return HAL_SD_ERROR_TIMEOUT;
      }
    }

    if (__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DTIMEOUT))
    {
      __HAL_SD_CLEAR_FLAG(hsd, SDMMC_FLAG_DTIMEOUT);

      errorstate = 0;

      return errorstate;
    }
    else if (__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DCRCFAIL))
    {
      __HAL_SD_CLEAR_FLAG(hsd, SDMMC_FLAG_DCRCFAIL);

      errorstate = SDMMC_ERROR_DATA_CRC_FAIL;

      return errorstate;
    }
    else if (__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXOVERR))
    {
      __HAL_SD_CLEAR_FLAG(hsd, SDMMC_FLAG_RXOVERR);

      errorstate = SDMMC_ERROR_RX_OVERRUN;

      return errorstate;
    }
    else
    {
      /* No error flag set */
    }

    /* Clear all the static flags */
    __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_DATA_FLAGS);

    /* Test if the switch mode HS is ok */
    if ((((uint8_t*)SD_hs)[13] & 2U) != 2U)
    {
      errorstate = SDMMC_ERROR_UNSUPPORTED_FEATURE;
    }

  }

  return errorstate;
}

SD_InitCard()

static uint32_t SD_InitCard ( SD_HandleTypeDef *  hsd )

static

Initializes the sd card.

Parameters

hsd	Pointer to SD handle

Return values

SD	Card error state

Definition at line 3337 of file stm32l4xx_hal_sd.c.

{
  HAL_SD_CardCSDTypeDef CSD;
  uint32_t errorstate;
  uint16_t sd_rca = 1U;

  /* Check the power State */
  if(SDMMC_GetPowerState(hsd->Instance) == 0U)
  {
    /* Power off */
    return HAL_SD_ERROR_REQUEST_NOT_APPLICABLE;
  }

  if(hsd->SdCard.CardType != CARD_SECURED)
  {
    /* Send CMD2 ALL_SEND_CID */
    errorstate = SDMMC_CmdSendCID(hsd->Instance);
    if(errorstate != HAL_SD_ERROR_NONE)
    {
      return errorstate;
    }
    else
    {
      /* Get Card identification number data */
      hsd->CID[0U] = SDMMC_GetResponse(hsd->Instance, SDMMC_RESP1);
      hsd->CID[1U] = SDMMC_GetResponse(hsd->Instance, SDMMC_RESP2);
      hsd->CID[2U] = SDMMC_GetResponse(hsd->Instance, SDMMC_RESP3);
      hsd->CID[3U] = SDMMC_GetResponse(hsd->Instance, SDMMC_RESP4);
    }
  }

  if(hsd->SdCard.CardType != CARD_SECURED)
  {
    /* Send CMD3 SET_REL_ADDR with argument 0 */
    /* SD Card publishes its RCA. */
    errorstate = SDMMC_CmdSetRelAdd(hsd->Instance, &sd_rca);
    if(errorstate != HAL_SD_ERROR_NONE)
    {
      return errorstate;
    }
  }
  if(hsd->SdCard.CardType != CARD_SECURED)
  {
    /* Get the SD card RCA */
    hsd->SdCard.RelCardAdd = sd_rca;

    /* Send CMD9 SEND_CSD with argument as card's RCA */
    errorstate = SDMMC_CmdSendCSD(hsd->Instance, (uint32_t)(hsd->SdCard.RelCardAdd << 16U));
    if(errorstate != HAL_SD_ERROR_NONE)
    {
      return errorstate;
    }
    else
    {
      /* Get Card Specific Data */
      hsd->CSD[0U] = SDMMC_GetResponse(hsd->Instance, SDMMC_RESP1);
      hsd->CSD[1U] = SDMMC_GetResponse(hsd->Instance, SDMMC_RESP2);
      hsd->CSD[2U] = SDMMC_GetResponse(hsd->Instance, SDMMC_RESP3);
      hsd->CSD[3U] = SDMMC_GetResponse(hsd->Instance, SDMMC_RESP4);
    }
  }

  /* Get the Card Class */
  hsd->SdCard.Class = (SDMMC_GetResponse(hsd->Instance, SDMMC_RESP2) >> 20U);

  /* Get CSD parameters */
  if (HAL_SD_GetCardCSD(hsd, &CSD) != HAL_OK)
  {
    return HAL_SD_ERROR_UNSUPPORTED_FEATURE;
  }

  /* Select the Card */
  errorstate = SDMMC_CmdSelDesel(hsd->Instance, (uint32_t)(((uint32_t)hsd->SdCard.RelCardAdd) << 16U));
  if(errorstate != HAL_SD_ERROR_NONE)
  {
    return errorstate;
  }

#if !defined(STM32L4R5xx) && !defined(STM32L4R7xx) && !defined(STM32L4R9xx) && !defined(STM32L4S5xx) && !defined(STM32L4S7xx) && !defined(STM32L4S9xx)
  /* Configure SDMMC peripheral interface */
  (void)SDMMC_Init(hsd->Instance, hsd->Init);
#endif /* !STM32L4R5xx && !STM32L4R7xx && !STM32L4R9xx && !STM32L4S5xx && !STM32L4S7xx && !STM32L4S9xx */

  /* All cards are initialized */
  return HAL_SD_ERROR_NONE;
}

SD_PowerOFF()

static void SD_PowerOFF ( SD_HandleTypeDef *  hsd )

static

Turns the SDMMC output signals off.

Parameters

hsd	Pointer to SD handle

Return values

None

Definition at line 3602 of file stm32l4xx_hal_sd.c.

{
  /* Set Power State to OFF */
  (void)SDMMC_PowerState_OFF(hsd->Instance);
}

SD_PowerON()

static uint32_t SD_PowerON ( SD_HandleTypeDef *  hsd )

static

Enquires cards about their operating voltage and configures clock controls and stores SD information that will be needed in future in the SD handle.

Parameters

hsd	Pointer to SD handle

Return values

error

state

Definition at line 3431 of file stm32l4xx_hal_sd.c.

{
  __IO uint32_t count = 0U;
  uint32_t response = 0U, validvoltage = 0U;
  uint32_t errorstate;
#if defined(STM32L4R5xx) || defined(STM32L4R7xx) || defined(STM32L4R9xx) || defined(STM32L4S5xx) || defined(STM32L4S7xx) || defined(STM32L4S9xx)
  uint32_t tickstart = HAL_GetTick();
#endif /* STM32L4R5xx || STM32L4R7xx || STM32L4R9xx || STM32L4S5xx || STM32L4S7xx || STM32L4S9xx */

  /* CMD0: GO_IDLE_STATE */
  errorstate = SDMMC_CmdGoIdleState(hsd->Instance);
  if(errorstate != HAL_SD_ERROR_NONE)
  {
    return errorstate;
  }

  /* CMD8: SEND_IF_COND: Command available only on V2.0 cards */
  errorstate = SDMMC_CmdOperCond(hsd->Instance);
  if(errorstate != HAL_SD_ERROR_NONE)
  {
    hsd->SdCard.CardVersion = CARD_V1_X;
    /* CMD0: GO_IDLE_STATE */
    errorstate = SDMMC_CmdGoIdleState(hsd->Instance);
    if(errorstate != HAL_SD_ERROR_NONE)
    {
      return errorstate;
    }

  }
  else
  {
    hsd->SdCard.CardVersion = CARD_V2_X;
  }

  if( hsd->SdCard.CardVersion == CARD_V2_X)
  {
    /* SEND CMD55 APP_CMD with RCA as 0 */
    errorstate = SDMMC_CmdAppCommand(hsd->Instance, 0);
    if(errorstate != HAL_SD_ERROR_NONE)
    {
      return HAL_SD_ERROR_UNSUPPORTED_FEATURE;
    }
  }
  /* SD CARD */
  /* Send ACMD41 SD_APP_OP_COND with Argument 0x80100000 */
  while((count < SDMMC_MAX_VOLT_TRIAL) && (validvoltage == 0U))
  {
    /* SEND CMD55 APP_CMD with RCA as 0 */
    errorstate = SDMMC_CmdAppCommand(hsd->Instance, 0);
    if(errorstate != HAL_SD_ERROR_NONE)
    {
      return errorstate;
    }

    /* Send CMD41 */
    errorstate = SDMMC_CmdAppOperCommand(hsd->Instance, SDMMC_VOLTAGE_WINDOW_SD | SDMMC_HIGH_CAPACITY | SD_SWITCH_1_8V_CAPACITY);
    if(errorstate != HAL_SD_ERROR_NONE)
    {
      return HAL_SD_ERROR_UNSUPPORTED_FEATURE;
    }

    /* Get command response */
    response = SDMMC_GetResponse(hsd->Instance, SDMMC_RESP1);

    /* Get operating voltage*/
    validvoltage = (((response >> 31U) == 1U) ? 1U : 0U);

    count++;
  }

  if(count >= SDMMC_MAX_VOLT_TRIAL)
  {
    return HAL_SD_ERROR_INVALID_VOLTRANGE;
  }

  if((response & SDMMC_HIGH_CAPACITY) == SDMMC_HIGH_CAPACITY) /* (response &= SD_HIGH_CAPACITY) */
  {
    hsd->SdCard.CardType = CARD_SDHC_SDXC;
#if defined(STM32L4R5xx) || defined(STM32L4R7xx) || defined(STM32L4R9xx) || defined(STM32L4S5xx) || defined(STM32L4S7xx) || defined(STM32L4S9xx)
    if(hsd->Init.Transceiver == SDMMC_TRANSCEIVER_ENABLE)
    {
      if((response & SD_SWITCH_1_8V_CAPACITY) == SD_SWITCH_1_8V_CAPACITY)
      {
        hsd->SdCard.CardSpeed = CARD_ULTRA_HIGH_SPEED;

        /* Start switching procedue */
        hsd->Instance->POWER |= SDMMC_POWER_VSWITCHEN;

        /* Send CMD11 to switch 1.8V mode */
        errorstate = SDMMC_CmdVoltageSwitch(hsd->Instance);
        if(errorstate != HAL_SD_ERROR_NONE)
        {
          return errorstate;
        }

        /* Check to CKSTOP */
        while(( hsd->Instance->STA & SDMMC_FLAG_CKSTOP) != SDMMC_FLAG_CKSTOP)
        {
          if((HAL_GetTick() - tickstart) >=  SDMMC_DATATIMEOUT)
          {
            return HAL_SD_ERROR_TIMEOUT;
          }
        }

        /* Clear CKSTOP Flag */
        hsd->Instance->ICR = SDMMC_FLAG_CKSTOP;

        /* Check to BusyD0 */
        if(( hsd->Instance->STA & SDMMC_FLAG_BUSYD0) != SDMMC_FLAG_BUSYD0)
        {
          /* Error when activate Voltage Switch in SDMMC Peripheral */
          return SDMMC_ERROR_UNSUPPORTED_FEATURE;
        }
        else
        {
          /* Enable Transceiver Switch PIN */
#if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
          hsd->DriveTransceiver_1_8V_Callback(SET);
#else
          HAL_SDEx_DriveTransceiver_1_8V_Callback(SET);
#endif

          /* Switch ready */
          hsd->Instance->POWER |= SDMMC_POWER_VSWITCH;

          /* Check VSWEND Flag */
          while(( hsd->Instance->STA & SDMMC_FLAG_VSWEND) != SDMMC_FLAG_VSWEND)
          {
            if((HAL_GetTick() - tickstart) >=  SDMMC_DATATIMEOUT)
            {
              return HAL_SD_ERROR_TIMEOUT;
            }
          }

          /* Clear VSWEND Flag */
          hsd->Instance->ICR = SDMMC_FLAG_VSWEND;

          /* Check BusyD0 status */
          if(( hsd->Instance->STA & SDMMC_FLAG_BUSYD0) == SDMMC_FLAG_BUSYD0)
          {
            /* Error when enabling 1.8V mode */
            return HAL_SD_ERROR_INVALID_VOLTRANGE;
          }
          /* Switch to 1.8V OK */

          /* Disable VSWITCH FLAG from SDMMC Peripheral */
          hsd->Instance->POWER = 0x13U;

          /* Clean Status flags */
          hsd->Instance->ICR = 0xFFFFFFFFU;
        }

        hsd->SdCard.CardSpeed = CARD_ULTRA_HIGH_SPEED;
      }
    }
#endif /* STM32L4R5xx || STM32L4R7xx || STM32L4R9xx || STM32L4S5xx || STM32L4S7xx || STM32L4S9xx */
  }
  else
  {
    hsd->SdCard.CardType = CARD_SDSC;
  }


  return HAL_SD_ERROR_NONE;
}

SD_Read_IT()

static void SD_Read_IT ( SD_HandleTypeDef *  hsd )

static

Wrap up reading in non-blocking mode.

Parameters

hsd	pointer to a SD_HandleTypeDef structure that contains the configuration information.

Return values

None

Definition at line 3963 of file stm32l4xx_hal_sd.c.

{
  uint32_t count, data, dataremaining;
  uint8_t* tmp;

  tmp = hsd->pRxBuffPtr;
  dataremaining = hsd->RxXferSize;

  if (dataremaining > 0U)
  {
    /* Read data from SDMMC Rx FIFO */
    for(count = 0U; count < 8U; count++)
    {
      data = SDMMC_ReadFIFO(hsd->Instance);
      *tmp = (uint8_t)(data & 0xFFU);
      tmp++;
      dataremaining--;
      *tmp = (uint8_t)((data >> 8U) & 0xFFU);
      tmp++;
      dataremaining--;
      *tmp = (uint8_t)((data >> 16U) & 0xFFU);
      tmp++;
      dataremaining--;
      *tmp = (uint8_t)((data >> 24U) & 0xFFU);
      tmp++;
      dataremaining--;
    }

    hsd->pRxBuffPtr = tmp;
    hsd->RxXferSize = dataremaining;
  }
}

SD_SendSDStatus()

static uint32_t SD_SendSDStatus ( SD_HandleTypeDef *  hsd, uint32_t *  pSDstatus  )

static

Send Status info command.

Parameters

hsd	pointer to SD handle
pSDstatus	Pointer to the buffer that will contain the SD card status SD Status register)

Return values

error

state

Definition at line 3615 of file stm32l4xx_hal_sd.c.

{
  SDMMC_DataInitTypeDef config;
  uint32_t errorstate;
  uint32_t tickstart = HAL_GetTick();
  uint32_t count;
  uint32_t *pData = pSDstatus;

  /* Check SD response */
  if((SDMMC_GetResponse(hsd->Instance, SDMMC_RESP1) & SDMMC_CARD_LOCKED) == SDMMC_CARD_LOCKED)
  {
    return HAL_SD_ERROR_LOCK_UNLOCK_FAILED;
  }

  /* Set block size for card if it is not equal to current block size for card */
  errorstate = SDMMC_CmdBlockLength(hsd->Instance, 64U);
  if(errorstate != HAL_SD_ERROR_NONE)
  {
    hsd->ErrorCode |= HAL_SD_ERROR_NONE;
    return errorstate;
  }

  /* Send CMD55 */
  errorstate = SDMMC_CmdAppCommand(hsd->Instance, (uint32_t)(hsd->SdCard.RelCardAdd << 16U));
  if(errorstate != HAL_SD_ERROR_NONE)
  {
    hsd->ErrorCode |= HAL_SD_ERROR_NONE;
    return errorstate;
  }

  /* Configure the SD DPSM (Data Path State Machine) */
  config.DataTimeOut   = SDMMC_DATATIMEOUT;
  config.DataLength    = 64U;
  config.DataBlockSize = SDMMC_DATABLOCK_SIZE_64B;
  config.TransferDir   = SDMMC_TRANSFER_DIR_TO_SDMMC;
  config.TransferMode  = SDMMC_TRANSFER_MODE_BLOCK;
  config.DPSM          = SDMMC_DPSM_ENABLE;
  (void)SDMMC_ConfigData(hsd->Instance, &config);

  /* Send ACMD13 (SD_APP_STAUS)  with argument as card's RCA */
  errorstate = SDMMC_CmdStatusRegister(hsd->Instance);
  if(errorstate != HAL_SD_ERROR_NONE)
  {
    hsd->ErrorCode |= HAL_SD_ERROR_NONE;
    return errorstate;
  }

  /* Get status data */
#if defined(STM32L4R5xx) || defined(STM32L4R7xx) || defined(STM32L4R9xx) || defined(STM32L4S5xx) || defined(STM32L4S7xx) || defined(STM32L4S9xx)
  while(!__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXOVERR | SDMMC_FLAG_DCRCFAIL | SDMMC_FLAG_DTIMEOUT | SDMMC_FLAG_DATAEND))
#else
  while(!__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXOVERR | SDMMC_FLAG_DCRCFAIL | SDMMC_FLAG_DTIMEOUT | SDMMC_FLAG_DBCKEND))
#endif /* STM32L4R5xx || STM32L4R7xx || STM32L4R9xx || STM32L4S5xx || STM32L4S7xx || STM32L4S9xx */
  {
    if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXFIFOHF))
    {
      for(count = 0U; count < 8U; count++)
      {
        *pData = SDMMC_ReadFIFO(hsd->Instance);
        pData++;
      }
    }

    if((HAL_GetTick() - tickstart) >=  SDMMC_DATATIMEOUT)
    {
      return HAL_SD_ERROR_TIMEOUT;
    }
  }

  if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DTIMEOUT))
  {
    return HAL_SD_ERROR_DATA_TIMEOUT;
  }
  else if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DCRCFAIL))
  {
    return HAL_SD_ERROR_DATA_CRC_FAIL;
  }
  else if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXOVERR))
  {
    return HAL_SD_ERROR_RX_OVERRUN;
  }
  else
  {
    /* Nothing to do */
  }

#if defined(STM32L4R5xx) || defined(STM32L4R7xx) || defined(STM32L4R9xx) || defined(STM32L4S5xx) || defined(STM32L4S7xx) || defined(STM32L4S9xx)
  while ((__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DPSMACT)))
#else
  while ((__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXDAVL)))
#endif /* STM32L4R5xx || STM32L4R7xx || STM32L4R9xx || STM32L4S5xx || STM32L4S7xx || STM32L4S9xx */
  {
    *pData = SDMMC_ReadFIFO(hsd->Instance);
    pData++;

    if((HAL_GetTick() - tickstart) >=  SDMMC_DATATIMEOUT)
    {
      return HAL_SD_ERROR_TIMEOUT;
    }
  }

  /* Clear all the static status flags*/
  __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_DATA_FLAGS);

  return HAL_SD_ERROR_NONE;
}

SD_SendStatus()

static uint32_t SD_SendStatus ( SD_HandleTypeDef *  hsd, uint32_t *  pCardStatus  )

static

Returns the current card's status.

Parameters

hsd	Pointer to SD handle
pCardStatus	pointer to the buffer that will contain the SD card status (Card Status register)

Return values

error

state

Definition at line 3729 of file stm32l4xx_hal_sd.c.

{
  uint32_t errorstate;

  if(pCardStatus == NULL)
  {
    return HAL_SD_ERROR_PARAM;
  }

  /* Send Status command */
  errorstate = SDMMC_CmdSendStatus(hsd->Instance, (uint32_t)(hsd->SdCard.RelCardAdd << 16U));
  if(errorstate != HAL_SD_ERROR_NONE)
  {
    return errorstate;
  }

  /* Get SD card status */
  *pCardStatus = SDMMC_GetResponse(hsd->Instance, SDMMC_RESP1);

  return HAL_SD_ERROR_NONE;
}

SD_UltraHighSpeed()

static uint32_t SD_UltraHighSpeed ( SD_HandleTypeDef *  hsd )

static

Switches the SD card to Ultra High Speed mode. This API must be used after "Transfer State".

Note

This operation should be followed by the configuration of PLL to have SDMMCCK clock between 50 and 120 MHz

Parameters

hsd

SD handle

Return values

SD	Card error state

Definition at line 4159 of file stm32l4xx_hal_sd.c.

{
  uint32_t errorstate = HAL_SD_ERROR_NONE;
  SDMMC_DataInitTypeDef sdmmc_datainitstructure;
  uint32_t SD_hs[16]  = {0};
  uint32_t count, loop = 0 ;
  uint32_t Timeout = HAL_GetTick();

  if(hsd->SdCard.CardSpeed == CARD_NORMAL_SPEED)
  {
     /* Standard Speed Card <= 12.5Mhz  */
     return HAL_SD_ERROR_REQUEST_NOT_APPLICABLE;
  }

  if((hsd->SdCard.CardSpeed == CARD_ULTRA_HIGH_SPEED) &&
     (hsd->Init.Transceiver == SDMMC_TRANSCEIVER_ENABLE))
  {
    /* Initialize the Data control register */
    hsd->Instance->DCTRL = 0;
    errorstate = SDMMC_CmdBlockLength(hsd->Instance, 64);

    if (errorstate != HAL_SD_ERROR_NONE)
    {
      return errorstate;
    }

    /* Configure the SD DPSM (Data Path State Machine) */
    sdmmc_datainitstructure.DataTimeOut   = SDMMC_DATATIMEOUT;
    sdmmc_datainitstructure.DataLength    = 64;
    sdmmc_datainitstructure.DataBlockSize = SDMMC_DATABLOCK_SIZE_64B ;
    sdmmc_datainitstructure.TransferDir   = SDMMC_TRANSFER_DIR_TO_SDMMC;
    sdmmc_datainitstructure.TransferMode  = SDMMC_TRANSFER_MODE_BLOCK;
    sdmmc_datainitstructure.DPSM          = SDMMC_DPSM_ENABLE;

    if ( SDMMC_ConfigData(hsd->Instance, &sdmmc_datainitstructure) != HAL_OK)
    {
      return (HAL_SD_ERROR_GENERAL_UNKNOWN_ERR);
    }

    errorstate = SDMMC_CmdSwitch(hsd->Instance, SDMMC_SDR104_SWITCH_PATTERN);
    if(errorstate != HAL_SD_ERROR_NONE)
    {
      return errorstate;
    }

    while(!__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXOVERR | SDMMC_FLAG_DCRCFAIL | SDMMC_FLAG_DTIMEOUT | SDMMC_FLAG_DBCKEND| SDMMC_FLAG_DATAEND ))
    {
      if (__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXFIFOHF))
      {
        for (count = 0U; count < 8U; count++)
        {
          SD_hs[(8U*loop)+count]  = SDMMC_ReadFIFO(hsd->Instance);
        }
        loop ++;
      }

      if((HAL_GetTick()-Timeout) >=  SDMMC_DATATIMEOUT)
      {
        hsd->ErrorCode = HAL_SD_ERROR_TIMEOUT;
        hsd->State= HAL_SD_STATE_READY;
        return HAL_SD_ERROR_TIMEOUT;
      }
    }

    if (__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DTIMEOUT))
    {
      __HAL_SD_CLEAR_FLAG(hsd, SDMMC_FLAG_DTIMEOUT);

      errorstate = 0;

      return errorstate;
    }
    else if (__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DCRCFAIL))
    {
      __HAL_SD_CLEAR_FLAG(hsd, SDMMC_FLAG_DCRCFAIL);

      errorstate = SDMMC_ERROR_DATA_CRC_FAIL;

      return errorstate;
    }
    else if (__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXOVERR))
    {
      __HAL_SD_CLEAR_FLAG(hsd, SDMMC_FLAG_RXOVERR);

      errorstate = SDMMC_ERROR_RX_OVERRUN;

      return errorstate;
    }
    else
    {
      /* No error flag set */
    }

    /* Clear all the static flags */
    __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_DATA_FLAGS);

    /* Test if the switch mode HS is ok */
    if ((((uint8_t*)SD_hs)[13] & 2U) != 2U)
    {
      errorstate = SDMMC_ERROR_UNSUPPORTED_FEATURE;
    }
    else
    {
#if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
      hsd->DriveTransceiver_1_8V_Callback(SET);
#else
      HAL_SDEx_DriveTransceiver_1_8V_Callback(SET);
#endif /* USE_HAL_SD_REGISTER_CALLBACKS */
#if defined (DLYB_SDMMC1) || defined (DLYB_SDMMC2)
      /* Enable DelayBlock Peripheral */
      /* SDMMC_FB_CLK tuned feedback clock selected as receive clock, for SDR104 */
      MODIFY_REG(hsd->Instance->CLKCR, SDMMC_CLKCR_SELCLKRX,SDMMC_CLKCR_SELCLKRX_1);
      if (DelayBlock_Enable(SD_GET_DLYB_INSTANCE(hsd->Instance)) != HAL_OK)
      {
        return (HAL_SD_ERROR_GENERAL_UNKNOWN_ERR);
      }
#endif /* (DLYB_SDMMC1) || (DLYB_SDMMC2) */
    }
  }

  return errorstate;
}

SD_WideBus_Disable()

static uint32_t SD_WideBus_Disable ( SD_HandleTypeDef *  hsd )

static

Disables the SDMMC wide bus mode.

Parameters

hsd	Pointer to SD handle

Return values

error

state

Definition at line 3803 of file stm32l4xx_hal_sd.c.

{
  uint32_t scr[2U] = {0U, 0U};
  uint32_t errorstate;

  if((SDMMC_GetResponse(hsd->Instance, SDMMC_RESP1) & SDMMC_CARD_LOCKED) == SDMMC_CARD_LOCKED)
  {
    return HAL_SD_ERROR_LOCK_UNLOCK_FAILED;
  }

  /* Get SCR Register */
  errorstate = SD_FindSCR(hsd, scr);
  if(errorstate != HAL_SD_ERROR_NONE)
  {
    return errorstate;
  }

  /* If requested card supports 1 bit mode operation */
  if((scr[1U] & SDMMC_SINGLE_BUS_SUPPORT) != SDMMC_ALLZERO)
  {
    /* Send CMD55 APP_CMD with argument as card's RCA */
    errorstate = SDMMC_CmdAppCommand(hsd->Instance, (uint32_t)(hsd->SdCard.RelCardAdd << 16U));
    if(errorstate != HAL_SD_ERROR_NONE)
    {
      return errorstate;
    }

    /* Send ACMD6 APP_CMD with argument as 0 for single bus mode */
    errorstate = SDMMC_CmdBusWidth(hsd->Instance, 0U);
    if(errorstate != HAL_SD_ERROR_NONE)
    {
      return errorstate;
    }

    return HAL_SD_ERROR_NONE;
  }
  else
  {
    return HAL_SD_ERROR_REQUEST_NOT_APPLICABLE;
  }
}

SD_WideBus_Enable()

static uint32_t SD_WideBus_Enable ( SD_HandleTypeDef *  hsd )

static

Enables the SDMMC wide bus mode.

Parameters

hsd	pointer to SD handle

Return values

error

state

Definition at line 3756 of file stm32l4xx_hal_sd.c.

{
  uint32_t scr[2U] = {0U, 0U};
  uint32_t errorstate;

  if((SDMMC_GetResponse(hsd->Instance, SDMMC_RESP1) & SDMMC_CARD_LOCKED) == SDMMC_CARD_LOCKED)
  {
    return HAL_SD_ERROR_LOCK_UNLOCK_FAILED;
  }

  /* Get SCR Register */
  errorstate = SD_FindSCR(hsd, scr);
  if(errorstate != HAL_SD_ERROR_NONE)
  {
    return errorstate;
  }

  /* If requested card supports wide bus operation */
  if((scr[1U] & SDMMC_WIDE_BUS_SUPPORT) != SDMMC_ALLZERO)
  {
    /* Send CMD55 APP_CMD with argument as card's RCA.*/
    errorstate = SDMMC_CmdAppCommand(hsd->Instance, (uint32_t)(hsd->SdCard.RelCardAdd << 16U));
    if(errorstate != HAL_SD_ERROR_NONE)
    {
      return errorstate;
    }

    /* Send ACMD6 APP_CMD with argument as 2 for wide bus mode */
    errorstate = SDMMC_CmdBusWidth(hsd->Instance, 2U);
    if(errorstate != HAL_SD_ERROR_NONE)
    {
      return errorstate;
    }

    return HAL_SD_ERROR_NONE;
  }
  else
  {
    return HAL_SD_ERROR_REQUEST_NOT_APPLICABLE;
  }
}

SD_Write_IT()

static void SD_Write_IT ( SD_HandleTypeDef *  hsd )

static

Wrap up writing in non-blocking mode.

Parameters

hsd	pointer to a SD_HandleTypeDef structure that contains the configuration information.

Return values

None

Definition at line 4002 of file stm32l4xx_hal_sd.c.

{
  uint32_t count, data, dataremaining;
  uint8_t* tmp;

  tmp = hsd->pTxBuffPtr;
  dataremaining = hsd->TxXferSize;

  if (dataremaining > 0U)
  {
    /* Write data to SDMMC Tx FIFO */
    for(count = 0U; count < 8U; count++)
    {
      data = (uint32_t)(*tmp);
      tmp++;
      dataremaining--;
      data |= ((uint32_t)(*tmp) << 8U);
      tmp++;
      dataremaining--;
      data |= ((uint32_t)(*tmp) << 16U);
      tmp++;
      dataremaining--;
      data |= ((uint32_t)(*tmp) << 24U);
      tmp++;
      dataremaining--;
      (void)SDMMC_WriteFIFO(hsd->Instance, &data);
    }

    hsd->pTxBuffPtr = tmp;
    hsd->TxXferSize = dataremaining;
  }
}

while()

while

(

((sta_reg &(SDMMC_FLAG_CCRCFAIL|SDMMC_FLAG_CMDREND|SDMMC_FLAG_CTIMEOUT))==0U)||((sta_reg &SDMMC_FLAG_CMDACT) !=0U)

)

Variable Documentation

else

else

Initial value:

{
    
  }

  
  __SDMMC_CLEAR_FLAG(SDMMCx, SDMMC_STATIC_CMD_FLAGS)

Definition at line 1305 of file stm32l4xx_ll_sdmmc.c.

response_r1

response_r1 = SDMMC_GetResponse(SDMMCx, SDMMC_RESP1)

Definition at line 1319 of file stm32l4xx_ll_sdmmc.c.