STM32L4xx_HAL_Driver  1.14.0
stm32l4xx_hal_sd.c
Go to the documentation of this file.
1 
271 /* Includes ------------------------------------------------------------------*/
272 #include "stm32l4xx_hal.h"
273 
274 #if defined(SDMMC1)
275 
284 #ifdef HAL_SD_MODULE_ENABLED
285 
286 /* Private typedef -----------------------------------------------------------*/
287 /* Private define ------------------------------------------------------------*/
296 /* Private macro -------------------------------------------------------------*/
297 /* Private variables ---------------------------------------------------------*/
298 /* Private function prototypes -----------------------------------------------*/
299 /* Private functions ---------------------------------------------------------*/
303 static uint32_t SD_InitCard (SD_HandleTypeDef *hsd);
304 static uint32_t SD_PowerON (SD_HandleTypeDef *hsd);
305 static uint32_t SD_SendSDStatus (SD_HandleTypeDef *hsd, uint32_t *pSDstatus);
306 static uint32_t SD_SendStatus (SD_HandleTypeDef *hsd, uint32_t *pCardStatus);
307 static uint32_t SD_WideBus_Enable (SD_HandleTypeDef *hsd);
308 static uint32_t SD_WideBus_Disable(SD_HandleTypeDef *hsd);
309 static uint32_t SD_FindSCR (SD_HandleTypeDef *hsd, uint32_t *pSCR);
310 static void SD_PowerOFF (SD_HandleTypeDef *hsd);
311 static void SD_Write_IT (SD_HandleTypeDef *hsd);
312 static void SD_Read_IT (SD_HandleTypeDef *hsd);
313 #if !defined(STM32L4R5xx) && !defined(STM32L4R7xx) && !defined(STM32L4R9xx) && !defined(STM32L4S5xx) && !defined(STM32L4S7xx) && !defined(STM32L4S9xx)
314 static void SD_DMATransmitCplt(DMA_HandleTypeDef *hdma);
315 static void SD_DMAReceiveCplt (DMA_HandleTypeDef *hdma);
316 static void SD_DMAError (DMA_HandleTypeDef *hdma);
317 static void SD_DMATxAbort (DMA_HandleTypeDef *hdma);
318 static void SD_DMARxAbort (DMA_HandleTypeDef *hdma);
319 #else
320 uint32_t SD_HighSpeed (SD_HandleTypeDef *hsd);
321 static uint32_t SD_UltraHighSpeed (SD_HandleTypeDef *hsd);
322 static uint32_t SD_DDR_Mode (SD_HandleTypeDef *hsd);
323 #endif /* !STM32L4R5xx && !STM32L4R7xx && !STM32L4R9xx && !STM32L4S5xx && !STM32L4S7xx && !STM32L4S9xx */
324 
328 /* Exported functions --------------------------------------------------------*/
354 HAL_StatusTypeDef HAL_SD_Init(SD_HandleTypeDef *hsd)
355 {
356 #if defined(STM32L4R5xx) || defined(STM32L4R7xx) || defined(STM32L4R9xx) || defined(STM32L4S5xx) || defined(STM32L4S7xx) || defined(STM32L4S9xx)
357  HAL_SD_CardStatusTypeDef CardStatus;
358  uint32_t speedgrade, unitsize;
359  uint32_t tickstart;
360 #endif
361 
362  /* Check the SD handle allocation */
363  if(hsd == NULL)
364  {
365  return HAL_ERROR;
366  }
367 
368  /* Check the parameters */
369  assert_param(IS_SDMMC_ALL_INSTANCE(hsd->Instance));
370  assert_param(IS_SDMMC_CLOCK_EDGE(hsd->Init.ClockEdge));
371 #if !defined(STM32L4R5xx) && !defined(STM32L4R7xx) && !defined(STM32L4R9xx) && !defined(STM32L4S5xx) && !defined(STM32L4S7xx) && !defined(STM32L4S9xx)
372  assert_param(IS_SDMMC_CLOCK_BYPASS(hsd->Init.ClockBypass));
373 #endif /* !STM32L4R5xx && !STM32L4R7xx && !STM32L4R9xx && !STM32L4S5xx && !STM32L4S7xx && !STM32L4S9xx */
374  assert_param(IS_SDMMC_CLOCK_POWER_SAVE(hsd->Init.ClockPowerSave));
375  assert_param(IS_SDMMC_BUS_WIDE(hsd->Init.BusWide));
376  assert_param(IS_SDMMC_HARDWARE_FLOW_CONTROL(hsd->Init.HardwareFlowControl));
377  assert_param(IS_SDMMC_CLKDIV(hsd->Init.ClockDiv));
378 
379  if(hsd->State == HAL_SD_STATE_RESET)
380  {
381  /* Allocate lock resource and initialize it */
382  hsd->Lock = HAL_UNLOCKED;
383 #if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
384  /* Reset Callback pointers in HAL_SD_STATE_RESET only */
385  hsd->TxCpltCallback = HAL_SD_TxCpltCallback;
386  hsd->RxCpltCallback = HAL_SD_RxCpltCallback;
387  hsd->ErrorCallback = HAL_SD_ErrorCallback;
388  hsd->AbortCpltCallback = HAL_SD_AbortCallback;
389 #if defined(STM32L4R5xx) || defined(STM32L4R7xx) || defined(STM32L4R9xx) || defined(STM32L4S5xx) || defined(STM32L4S7xx) || defined(STM32L4S9xx)
390  hsd->Read_DMADblBuf0CpltCallback = HAL_SDEx_Read_DMADoubleBuffer0CpltCallback;
391  hsd->Read_DMADblBuf1CpltCallback = HAL_SDEx_Read_DMADoubleBuffer1CpltCallback;
392  hsd->Write_DMADblBuf0CpltCallback = HAL_SDEx_Write_DMADoubleBuffer0CpltCallback;
393  hsd->Write_DMADblBuf1CpltCallback = HAL_SDEx_Write_DMADoubleBuffer1CpltCallback;
394  hsd->DriveTransceiver_1_8V_Callback = HAL_SDEx_DriveTransceiver_1_8V_Callback;
395 #endif
396 
397  if(hsd->MspInitCallback == NULL)
398  {
399  hsd->MspInitCallback = HAL_SD_MspInit;
400  }
401 
402  /* Init the low level hardware */
403  hsd->MspInitCallback(hsd);
404 #else
405  /* Init the low level hardware : GPIO, CLOCK, CORTEX...etc */
406  HAL_SD_MspInit(hsd);
407 #endif /* USE_HAL_SD_REGISTER_CALLBACKS */
408  }
409 
410  hsd->State = HAL_SD_STATE_BUSY;
411 
412  /* Initialize the Card parameters */
413  if (HAL_SD_InitCard(hsd) != HAL_OK)
414  {
415  return HAL_ERROR;
416  }
417 
418 #if defined(STM32L4R5xx) || defined(STM32L4R7xx) || defined(STM32L4R9xx) || defined(STM32L4S5xx) || defined(STM32L4S7xx) || defined(STM32L4S9xx)
419  if( HAL_SD_GetCardStatus(hsd, &CardStatus) != HAL_OK)
420  {
421  return HAL_ERROR;
422  }
423  /* Get Initial Card Speed from Card Status*/
424  speedgrade = CardStatus.UhsSpeedGrade;
425  unitsize = CardStatus.UhsAllocationUnitSize;
426  if ((hsd->SdCard.CardType == CARD_SDHC_SDXC) && ((speedgrade != 0U) || (unitsize != 0U)))
427  {
428  hsd->SdCard.CardSpeed = CARD_ULTRA_HIGH_SPEED;
429  }
430  else
431  {
432  if (hsd->SdCard.CardType == CARD_SDHC_SDXC)
433  {
434  hsd->SdCard.CardSpeed = CARD_HIGH_SPEED;
435  }
436  else
437  {
438  hsd->SdCard.CardSpeed = CARD_NORMAL_SPEED;
439  }
440 
441  }
442  /* Configure the bus wide */
443  if(HAL_SD_ConfigWideBusOperation(hsd, hsd->Init.BusWide) != HAL_OK)
444  {
445  return HAL_ERROR;
446  }
447 
448  /* Verify that SD card is ready to use after Initialization */
449  tickstart = HAL_GetTick();
450  while((HAL_SD_GetCardState(hsd) != HAL_SD_CARD_TRANSFER))
451  {
452  if((HAL_GetTick()-tickstart) >= SDMMC_DATATIMEOUT)
453  {
454  hsd->ErrorCode = HAL_SD_ERROR_TIMEOUT;
455  hsd->State= HAL_SD_STATE_READY;
456  return HAL_TIMEOUT;
457  }
458  }
459 #endif /* STM32L4R5xx || STM32L4R7xx || STM32L4R9xx || STM32L4S5xx || STM32L4S7xx || STM32L4S9xx */
460 
461  /* Initialize the error code */
462  hsd->ErrorCode = HAL_SD_ERROR_NONE;
463 
464  /* Initialize the SD operation */
465  hsd->Context = SD_CONTEXT_NONE;
466 
467  /* Initialize the SD state */
468  hsd->State = HAL_SD_STATE_READY;
469 
470  return HAL_OK;
471 }
472 
480 HAL_StatusTypeDef HAL_SD_InitCard(SD_HandleTypeDef *hsd)
481 {
482  uint32_t errorstate;
483  HAL_StatusTypeDef status;
484  SD_InitTypeDef Init;
485 
486  /* Default SDMMC peripheral configuration for SD card initialization */
487  Init.ClockEdge = SDMMC_CLOCK_EDGE_RISING;
488 #if !defined(STM32L4R5xx) && !defined(STM32L4R7xx) && !defined(STM32L4R9xx) && !defined(STM32L4S5xx) && !defined(STM32L4S7xx) && !defined(STM32L4S9xx)
489  Init.ClockBypass = SDMMC_CLOCK_BYPASS_DISABLE;
490 #endif /* !STM32L4R5xx && !STM32L4R7xx && !STM32L4R9xx && !STM32L4S5xx && !STM32L4S7xx && !STM32L4S9xx */
491  Init.ClockPowerSave = SDMMC_CLOCK_POWER_SAVE_DISABLE;
492  Init.BusWide = SDMMC_BUS_WIDE_1B;
493  Init.HardwareFlowControl = SDMMC_HARDWARE_FLOW_CONTROL_DISABLE;
494  Init.ClockDiv = SDMMC_INIT_CLK_DIV;
495 
496 #if defined(STM32L4R5xx) || defined(STM32L4R7xx) || defined(STM32L4R9xx) || defined(STM32L4S5xx) || defined(STM32L4S7xx) || defined(STM32L4S9xx)
497  if(hsd->Init.Transceiver == SDMMC_TRANSCEIVER_ENABLE)
498  {
499  /* Set Transceiver polarity */
500  hsd->Instance->POWER |= SDMMC_POWER_DIRPOL;
501  }
502 #endif /* STM32L4R5xx || STM32L4R7xx || STM32L4R9xx || STM32L4S5xx || STM32L4S7xx || STM32L4S9xx */
503 
504  /* Initialize SDMMC peripheral interface with default configuration */
505  status = SDMMC_Init(hsd->Instance, Init);
506  if(status != HAL_OK)
507  {
508  return HAL_ERROR;
509  }
510 
511 #if !defined(STM32L4R5xx) && !defined(STM32L4R7xx) && !defined(STM32L4R9xx) && !defined(STM32L4S5xx) && !defined(STM32L4S7xx) && !defined(STM32L4S9xx)
512  /* Disable SDMMC Clock */
513  __HAL_SD_DISABLE(hsd);
514 #endif /* !STM32L4R5xx && !STM32L4R7xx && !STM32L4R9xx && !STM32L4S5xx && !STM32L4S7xx && !STM32L4S9xx */
515 
516  /* Set Power State to ON */
517  status = SDMMC_PowerState_ON(hsd->Instance);
518  if(status != HAL_OK)
519  {
520  return HAL_ERROR;
521  }
522 
523 #if !defined(STM32L4R5xx) && !defined(STM32L4R7xx) && !defined(STM32L4R9xx) && !defined(STM32L4S5xx) && !defined(STM32L4S7xx) && !defined(STM32L4S9xx)
524  /* Enable SDMMC Clock */
525  __HAL_SD_ENABLE(hsd);
526 #endif /* !STM32L4R5xx && !STM32L4R7xx && !STM32L4R9xx && !STM32L4S5xx && !STM32L4S7xx && !STM32L4S9xx */
527 
528  /* Identify card operating voltage */
529  errorstate = SD_PowerON(hsd);
530  if(errorstate != HAL_SD_ERROR_NONE)
531  {
532  hsd->State = HAL_SD_STATE_READY;
533  hsd->ErrorCode |= errorstate;
534  return HAL_ERROR;
535  }
536 
537  /* Card initialization */
538  errorstate = SD_InitCard(hsd);
539  if(errorstate != HAL_SD_ERROR_NONE)
540  {
541  hsd->State = HAL_SD_STATE_READY;
542  hsd->ErrorCode |= errorstate;
543  return HAL_ERROR;
544  }
545 
546  return HAL_OK;
547 }
548 
554 HAL_StatusTypeDef HAL_SD_DeInit(SD_HandleTypeDef *hsd)
555 {
556  /* Check the SD handle allocation */
557  if(hsd == NULL)
558  {
559  return HAL_ERROR;
560  }
561 
562  /* Check the parameters */
563  assert_param(IS_SDMMC_ALL_INSTANCE(hsd->Instance));
564 
565  hsd->State = HAL_SD_STATE_BUSY;
566 
567 #if defined(STM32L4R5xx) || defined(STM32L4R7xx) || defined(STM32L4R9xx) || defined(STM32L4S5xx) || defined(STM32L4S7xx) || defined(STM32L4S9xx)
568  /* Desactivate the 1.8V Mode */
569  if(hsd->Init.Transceiver == SDMMC_TRANSCEIVER_ENABLE)
570  {
571 #if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
572  if(hsd->DriveTransceiver_1_8V_Callback == NULL)
573  {
574  hsd->DriveTransceiver_1_8V_Callback = HAL_SDEx_DriveTransceiver_1_8V_Callback;
575  }
576  hsd->DriveTransceiver_1_8V_Callback(RESET);
577 #else
578  HAL_SDEx_DriveTransceiver_1_8V_Callback(RESET);
579 #endif /* USE_HAL_SD_REGISTER_CALLBACKS */
580  }
581 #endif
582 
583  /* Set SD power state to off */
584  SD_PowerOFF(hsd);
585 
586 #if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
587  if(hsd->MspDeInitCallback == NULL)
588  {
589  hsd->MspDeInitCallback = HAL_SD_MspDeInit;
590  }
591 
592  /* DeInit the low level hardware */
593  hsd->MspDeInitCallback(hsd);
594 #else
595  /* De-Initialize the MSP layer */
596  HAL_SD_MspDeInit(hsd);
597 #endif /* USE_HAL_SD_REGISTER_CALLBACKS */
598 
599  hsd->ErrorCode = HAL_SD_ERROR_NONE;
600  hsd->State = HAL_SD_STATE_RESET;
601 
602  return HAL_OK;
603 }
604 
605 
611 __weak void HAL_SD_MspInit(SD_HandleTypeDef *hsd)
612 {
613  /* Prevent unused argument(s) compilation warning */
614  UNUSED(hsd);
615 
616  /* NOTE : This function should not be modified, when the callback is needed,
617  the HAL_SD_MspInit could be implemented in the user file
618  */
619 }
620 
626 __weak void HAL_SD_MspDeInit(SD_HandleTypeDef *hsd)
627 {
628  /* Prevent unused argument(s) compilation warning */
629  UNUSED(hsd);
630 
631  /* NOTE : This function should not be modified, when the callback is needed,
632  the HAL_SD_MspDeInit could be implemented in the user file
633  */
634 }
635 
667 HAL_StatusTypeDef HAL_SD_ReadBlocks(SD_HandleTypeDef *hsd, uint8_t *pData, uint32_t BlockAdd, uint32_t NumberOfBlocks, uint32_t Timeout)
668 {
669  SDMMC_DataInitTypeDef config;
670  uint32_t errorstate;
671  uint32_t tickstart = HAL_GetTick();
672  uint32_t count, data, dataremaining;
673  uint32_t add = BlockAdd;
674  uint8_t *tempbuff = pData;
675 
676  if(NULL == pData)
677  {
678  hsd->ErrorCode |= HAL_SD_ERROR_PARAM;
679  return HAL_ERROR;
680  }
681 
682  if(hsd->State == HAL_SD_STATE_READY)
683  {
684  hsd->ErrorCode = HAL_SD_ERROR_NONE;
685 
686  if((add + NumberOfBlocks) > (hsd->SdCard.LogBlockNbr))
687  {
688  hsd->ErrorCode |= HAL_SD_ERROR_ADDR_OUT_OF_RANGE;
689  return HAL_ERROR;
690  }
691 
692  hsd->State = HAL_SD_STATE_BUSY;
693 
694  /* Initialize data control register */
695  hsd->Instance->DCTRL = 0U;
696 
697  if(hsd->SdCard.CardType != CARD_SDHC_SDXC)
698  {
699  add *= 512U;
700  }
701 
702  /* Set Block Size for Card */
703  errorstate = SDMMC_CmdBlockLength(hsd->Instance, BLOCKSIZE);
704  if(errorstate != HAL_SD_ERROR_NONE)
705  {
706  /* Clear all the static flags */
707  __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
708  hsd->ErrorCode |= errorstate;
709  hsd->State = HAL_SD_STATE_READY;
710  return HAL_ERROR;
711  }
712 
713  /* Configure the SD DPSM (Data Path State Machine) */
714  config.DataTimeOut = SDMMC_DATATIMEOUT;
715  config.DataLength = NumberOfBlocks * BLOCKSIZE;
716  config.DataBlockSize = SDMMC_DATABLOCK_SIZE_512B;
717  config.TransferDir = SDMMC_TRANSFER_DIR_TO_SDMMC;
718  config.TransferMode = SDMMC_TRANSFER_MODE_BLOCK;
719 #if defined(STM32L4R5xx) || defined(STM32L4R7xx) || defined(STM32L4R9xx) || defined(STM32L4S5xx) || defined(STM32L4S7xx) || defined(STM32L4S9xx)
720  config.DPSM = SDMMC_DPSM_DISABLE;
721 #else
722  config.DPSM = SDMMC_DPSM_ENABLE;
723 #endif /* STM32L4R5xx || STM32L4R7xx || STM32L4R9xx || STM32L4S5xx || STM32L4S7xx || STM32L4S9xx */
724  (void)SDMMC_ConfigData(hsd->Instance, &config);
725 #if defined(STM32L4R5xx) || defined(STM32L4R7xx) || defined(STM32L4R9xx) || defined(STM32L4S5xx) || defined(STM32L4S7xx) || defined(STM32L4S9xx)
726  __SDMMC_CMDTRANS_ENABLE( hsd->Instance);
727 #endif /* STM32L4R5xx || STM32L4R7xx || STM32L4R9xx || STM32L4S5xx || STM32L4S7xx || STM32L4S9xx */
728 
729  /* Read block(s) in polling mode */
730  if(NumberOfBlocks > 1U)
731  {
732  hsd->Context = SD_CONTEXT_READ_MULTIPLE_BLOCK;
733 
734  /* Read Multi Block command */
735  errorstate = SDMMC_CmdReadMultiBlock(hsd->Instance, add);
736  }
737  else
738  {
739  hsd->Context = SD_CONTEXT_READ_SINGLE_BLOCK;
740 
741  /* Read Single Block command */
742  errorstate = SDMMC_CmdReadSingleBlock(hsd->Instance, add);
743  }
744  if(errorstate != HAL_SD_ERROR_NONE)
745  {
746  /* Clear all the static flags */
747  __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
748  hsd->ErrorCode |= errorstate;
749  hsd->State = HAL_SD_STATE_READY;
750  hsd->Context = SD_CONTEXT_NONE;
751  return HAL_ERROR;
752  }
753 
754  /* Poll on SDMMC flags */
755  dataremaining = config.DataLength;
756  while(!__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXOVERR | SDMMC_FLAG_DCRCFAIL | SDMMC_FLAG_DTIMEOUT | SDMMC_FLAG_DATAEND))
757  {
758  if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXFIFOHF) && (dataremaining > 0U))
759  {
760  /* Read data from SDMMC Rx FIFO */
761  for(count = 0U; count < 8U; count++)
762  {
763  data = SDMMC_ReadFIFO(hsd->Instance);
764  *tempbuff = (uint8_t)(data & 0xFFU);
765  tempbuff++;
766  dataremaining--;
767  *tempbuff = (uint8_t)((data >> 8U) & 0xFFU);
768  tempbuff++;
769  dataremaining--;
770  *tempbuff = (uint8_t)((data >> 16U) & 0xFFU);
771  tempbuff++;
772  dataremaining--;
773  *tempbuff = (uint8_t)((data >> 24U) & 0xFFU);
774  tempbuff++;
775  dataremaining--;
776  }
777  }
778 
779  if(((HAL_GetTick()-tickstart) >= Timeout) || (Timeout == 0U))
780  {
781  /* Clear all the static flags */
782  __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
783  hsd->ErrorCode |= HAL_SD_ERROR_TIMEOUT;
784  hsd->State= HAL_SD_STATE_READY;
785  hsd->Context = SD_CONTEXT_NONE;
786  return HAL_TIMEOUT;
787  }
788  }
789 #if defined(STM32L4R5xx) || defined(STM32L4R7xx) || defined(STM32L4R9xx) || defined(STM32L4S5xx) || defined(STM32L4S7xx) || defined(STM32L4S9xx)
790  __SDMMC_CMDTRANS_DISABLE( hsd->Instance);
791 #endif /* STM32L4R5xx || STM32L4R7xx || STM32L4R9xx || STM32L4S5xx || STM32L4S7xx || STM32L4S9xx */
792 
793  /* Send stop transmission command in case of multiblock read */
794  if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DATAEND) && (NumberOfBlocks > 1U))
795  {
796  if(hsd->SdCard.CardType != CARD_SECURED)
797  {
798  /* Send stop transmission command */
799  errorstate = SDMMC_CmdStopTransfer(hsd->Instance);
800  if(errorstate != HAL_SD_ERROR_NONE)
801  {
802  /* Clear all the static flags */
803  __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
804  hsd->ErrorCode |= errorstate;
805  hsd->State = HAL_SD_STATE_READY;
806  hsd->Context = SD_CONTEXT_NONE;
807  return HAL_ERROR;
808  }
809  }
810  }
811 
812  /* Get error state */
813  if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DTIMEOUT))
814  {
815  /* Clear all the static flags */
816  __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
817  hsd->ErrorCode |= HAL_SD_ERROR_DATA_TIMEOUT;
818  hsd->State = HAL_SD_STATE_READY;
819  hsd->Context = SD_CONTEXT_NONE;
820  return HAL_ERROR;
821  }
822  else if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DCRCFAIL))
823  {
824  /* Clear all the static flags */
825  __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
826  hsd->ErrorCode |= HAL_SD_ERROR_DATA_CRC_FAIL;
827  hsd->State = HAL_SD_STATE_READY;
828  hsd->Context = SD_CONTEXT_NONE;
829  return HAL_ERROR;
830  }
831  else if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXOVERR))
832  {
833  /* Clear all the static flags */
834  __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
835  hsd->ErrorCode |= HAL_SD_ERROR_RX_OVERRUN;
836  hsd->State = HAL_SD_STATE_READY;
837  hsd->Context = SD_CONTEXT_NONE;
838  return HAL_ERROR;
839  }
840  else
841  {
842  /* Nothing to do */
843  }
844 
845 #if !defined(STM32L4R5xx) && !defined(STM32L4R7xx) && !defined(STM32L4R9xx) && !defined(STM32L4S5xx) && !defined(STM32L4S7xx) && !defined(STM32L4S9xx)
846  /* Empty FIFO if there is still any data */
847  while ((__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXDAVL)) && (dataremaining > 0U))
848  {
849  data = SDMMC_ReadFIFO(hsd->Instance);
850  *tempbuff = (uint8_t)(data & 0xFFU);
851  tempbuff++;
852  dataremaining--;
853  *tempbuff = (uint8_t)((data >> 8U) & 0xFFU);
854  tempbuff++;
855  dataremaining--;
856  *tempbuff = (uint8_t)((data >> 16U) & 0xFFU);
857  tempbuff++;
858  dataremaining--;
859  *tempbuff = (uint8_t)((data >> 24U) & 0xFFU);
860  tempbuff++;
861  dataremaining--;
862 
863  if(((HAL_GetTick()-tickstart) >= Timeout) || (Timeout == 0U))
864  {
865  /* Clear all the static flags */
866  __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
867  hsd->ErrorCode |= HAL_SD_ERROR_TIMEOUT;
868  hsd->State= HAL_SD_STATE_READY;
869  hsd->Context = SD_CONTEXT_NONE;
870  return HAL_ERROR;
871  }
872  }
873 #endif /* !STM32L4R5xx && !STM32L4R7xx && !STM32L4R9xx && !STM32L4S5xx && !STM32L4S7xx && !STM32L4S9xx */
874 
875  /* Clear all the static flags */
876  __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_DATA_FLAGS);
877 
878  hsd->State = HAL_SD_STATE_READY;
879 
880  return HAL_OK;
881  }
882  else
883  {
884  hsd->ErrorCode |= HAL_SD_ERROR_BUSY;
885  return HAL_ERROR;
886  }
887 }
888 
901 HAL_StatusTypeDef HAL_SD_WriteBlocks(SD_HandleTypeDef *hsd, uint8_t *pData, uint32_t BlockAdd, uint32_t NumberOfBlocks, uint32_t Timeout)
902 {
903  SDMMC_DataInitTypeDef config;
904  uint32_t errorstate;
905  uint32_t tickstart = HAL_GetTick();
906  uint32_t count, data, dataremaining;
907  uint32_t add = BlockAdd;
908  uint8_t *tempbuff = pData;
909 
910  if(NULL == pData)
911  {
912  hsd->ErrorCode |= HAL_SD_ERROR_PARAM;
913  return HAL_ERROR;
914  }
915 
916  if(hsd->State == HAL_SD_STATE_READY)
917  {
918  hsd->ErrorCode = HAL_SD_ERROR_NONE;
919 
920  if((add + NumberOfBlocks) > (hsd->SdCard.LogBlockNbr))
921  {
922  hsd->ErrorCode |= HAL_SD_ERROR_ADDR_OUT_OF_RANGE;
923  return HAL_ERROR;
924  }
925 
926  hsd->State = HAL_SD_STATE_BUSY;
927 
928  /* Initialize data control register */
929  hsd->Instance->DCTRL = 0U;
930 
931  if(hsd->SdCard.CardType != CARD_SDHC_SDXC)
932  {
933  add *= 512U;
934  }
935 
936  /* Set Block Size for Card */
937  errorstate = SDMMC_CmdBlockLength(hsd->Instance, BLOCKSIZE);
938  if(errorstate != HAL_SD_ERROR_NONE)
939  {
940  /* Clear all the static flags */
941  __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
942  hsd->ErrorCode |= errorstate;
943  hsd->State = HAL_SD_STATE_READY;
944  return HAL_ERROR;
945  }
946 
947  /* Configure the SD DPSM (Data Path State Machine) */
948  config.DataTimeOut = SDMMC_DATATIMEOUT;
949  config.DataLength = NumberOfBlocks * BLOCKSIZE;
950  config.DataBlockSize = SDMMC_DATABLOCK_SIZE_512B;
951  config.TransferDir = SDMMC_TRANSFER_DIR_TO_CARD;
952  config.TransferMode = SDMMC_TRANSFER_MODE_BLOCK;
953 #if defined(STM32L4R5xx) || defined(STM32L4R7xx) || defined(STM32L4R9xx) || defined(STM32L4S5xx) || defined(STM32L4S7xx) || defined(STM32L4S9xx)
954  config.DPSM = SDMMC_DPSM_DISABLE;
955 #else
956  config.DPSM = SDMMC_DPSM_ENABLE;
957 #endif /* STM32L4R5xx || STM32L4R7xx || STM32L4R9xx || STM32L4S5xx || STM32L4S7xx || STM32L4S9xx */
958  (void)SDMMC_ConfigData(hsd->Instance, &config);
959 #if defined(STM32L4R5xx) || defined(STM32L4R7xx) || defined(STM32L4R9xx) || defined(STM32L4S5xx) || defined(STM32L4S7xx) || defined(STM32L4S9xx)
960  __SDMMC_CMDTRANS_ENABLE( hsd->Instance);
961 #endif /* STM32L4R5xx || STM32L4R7xx || STM32L4R9xx || STM32L4S5xx || STM32L4S7xx || STM32L4S9xx */
962 
963  /* Write Blocks in Polling mode */
964  if(NumberOfBlocks > 1U)
965  {
966  hsd->Context = SD_CONTEXT_WRITE_MULTIPLE_BLOCK;
967 
968  /* Write Multi Block command */
969  errorstate = SDMMC_CmdWriteMultiBlock(hsd->Instance, add);
970  }
971  else
972  {
973  hsd->Context = SD_CONTEXT_WRITE_SINGLE_BLOCK;
974 
975  /* Write Single Block command */
976  errorstate = SDMMC_CmdWriteSingleBlock(hsd->Instance, add);
977  }
978  if(errorstate != HAL_SD_ERROR_NONE)
979  {
980  /* Clear all the static flags */
981  __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
982  hsd->ErrorCode |= errorstate;
983  hsd->State = HAL_SD_STATE_READY;
984  hsd->Context = SD_CONTEXT_NONE;
985  return HAL_ERROR;
986  }
987 
988  /* Write block(s) in polling mode */
989  dataremaining = config.DataLength;
990  while(!__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_TXUNDERR | SDMMC_FLAG_DCRCFAIL | SDMMC_FLAG_DTIMEOUT | SDMMC_FLAG_DATAEND))
991  {
992  if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_TXFIFOHE) && (dataremaining > 0U))
993  {
994  /* Write data to SDMMC Tx FIFO */
995  for(count = 0U; count < 8U; count++)
996  {
997  data = (uint32_t)(*tempbuff);
998  tempbuff++;
999  dataremaining--;
1000  data |= ((uint32_t)(*tempbuff) << 8U);
1001  tempbuff++;
1002  dataremaining--;
1003  data |= ((uint32_t)(*tempbuff) << 16U);
1004  tempbuff++;
1005  dataremaining--;
1006  data |= ((uint32_t)(*tempbuff) << 24U);
1007  tempbuff++;
1008  dataremaining--;
1009  (void)SDMMC_WriteFIFO(hsd->Instance, &data);
1010  }
1011  }
1012 
1013  if(((HAL_GetTick()-tickstart) >= Timeout) || (Timeout == 0U))
1014  {
1015  /* Clear all the static flags */
1016  __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
1017  hsd->ErrorCode |= errorstate;
1018  hsd->State = HAL_SD_STATE_READY;
1019  hsd->Context = SD_CONTEXT_NONE;
1020  return HAL_TIMEOUT;
1021  }
1022  }
1023 #if defined(STM32L4R5xx) || defined(STM32L4R7xx) || defined(STM32L4R9xx) || defined(STM32L4S5xx) || defined(STM32L4S7xx) || defined(STM32L4S9xx)
1024  __SDMMC_CMDTRANS_DISABLE( hsd->Instance);
1025 #endif /* STM32L4R5xx || STM32L4R7xx || STM32L4R9xx || STM32L4S5xx || STM32L4S7xx || STM32L4S9xx */
1026 
1027  /* Send stop transmission command in case of multiblock write */
1028  if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DATAEND) && (NumberOfBlocks > 1U))
1029  {
1030  if(hsd->SdCard.CardType != CARD_SECURED)
1031  {
1032  /* Send stop transmission command */
1033  errorstate = SDMMC_CmdStopTransfer(hsd->Instance);
1034  if(errorstate != HAL_SD_ERROR_NONE)
1035  {
1036  /* Clear all the static flags */
1037  __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
1038  hsd->ErrorCode |= errorstate;
1039  hsd->State = HAL_SD_STATE_READY;
1040  hsd->Context = SD_CONTEXT_NONE;
1041  return HAL_ERROR;
1042  }
1043  }
1044  }
1045 
1046  /* Get error state */
1047  if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DTIMEOUT))
1048  {
1049  /* Clear all the static flags */
1050  __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
1051  hsd->ErrorCode |= HAL_SD_ERROR_DATA_TIMEOUT;
1052  hsd->State = HAL_SD_STATE_READY;
1053  hsd->Context = SD_CONTEXT_NONE;
1054  return HAL_ERROR;
1055  }
1056  else if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DCRCFAIL))
1057  {
1058  /* Clear all the static flags */
1059  __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
1060  hsd->ErrorCode |= HAL_SD_ERROR_DATA_CRC_FAIL;
1061  hsd->State = HAL_SD_STATE_READY;
1062  hsd->Context = SD_CONTEXT_NONE;
1063  return HAL_ERROR;
1064  }
1065  else if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_TXUNDERR))
1066  {
1067  /* Clear all the static flags */
1068  __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
1069  hsd->ErrorCode |= HAL_SD_ERROR_TX_UNDERRUN;
1070  hsd->State = HAL_SD_STATE_READY;
1071  hsd->Context = SD_CONTEXT_NONE;
1072  return HAL_ERROR;
1073  }
1074  else
1075  {
1076  /* Nothing to do */
1077  }
1078 
1079  /* Clear all the static flags */
1080  __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_DATA_FLAGS);
1081 
1082  hsd->State = HAL_SD_STATE_READY;
1083 
1084  return HAL_OK;
1085  }
1086  else
1087  {
1088  hsd->ErrorCode |= HAL_SD_ERROR_BUSY;
1089  return HAL_ERROR;
1090  }
1091 }
1092 
1106 HAL_StatusTypeDef HAL_SD_ReadBlocks_IT(SD_HandleTypeDef *hsd, uint8_t *pData, uint32_t BlockAdd, uint32_t NumberOfBlocks)
1107 {
1108  SDMMC_DataInitTypeDef config;
1109  uint32_t errorstate;
1110  uint32_t add = BlockAdd;
1111 
1112  if(NULL == pData)
1113  {
1114  hsd->ErrorCode |= HAL_SD_ERROR_PARAM;
1115  return HAL_ERROR;
1116  }
1117 
1118  if(hsd->State == HAL_SD_STATE_READY)
1119  {
1120  hsd->ErrorCode = HAL_SD_ERROR_NONE;
1121 
1122  if((add + NumberOfBlocks) > (hsd->SdCard.LogBlockNbr))
1123  {
1124  hsd->ErrorCode |= HAL_SD_ERROR_ADDR_OUT_OF_RANGE;
1125  return HAL_ERROR;
1126  }
1127 
1128  hsd->State = HAL_SD_STATE_BUSY;
1129 
1130  /* Initialize data control register */
1131  hsd->Instance->DCTRL = 0U;
1132 
1133  hsd->pRxBuffPtr = pData;
1134  hsd->RxXferSize = BLOCKSIZE * NumberOfBlocks;
1135 
1136  __HAL_SD_ENABLE_IT(hsd, (SDMMC_IT_DCRCFAIL | SDMMC_IT_DTIMEOUT | SDMMC_IT_RXOVERR | SDMMC_IT_DATAEND | SDMMC_FLAG_RXFIFOHF));
1137 
1138  if(hsd->SdCard.CardType != CARD_SDHC_SDXC)
1139  {
1140  add *= 512U;
1141  }
1142 
1143  /* Set Block Size for Card */
1144  errorstate = SDMMC_CmdBlockLength(hsd->Instance, BLOCKSIZE);
1145  if(errorstate != HAL_SD_ERROR_NONE)
1146  {
1147  /* Clear all the static flags */
1148  __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
1149  hsd->ErrorCode |= errorstate;
1150  hsd->State = HAL_SD_STATE_READY;
1151  return HAL_ERROR;
1152  }
1153 
1154  /* Configure the SD DPSM (Data Path State Machine) */
1155  config.DataTimeOut = SDMMC_DATATIMEOUT;
1156  config.DataLength = BLOCKSIZE * NumberOfBlocks;
1157  config.DataBlockSize = SDMMC_DATABLOCK_SIZE_512B;
1158  config.TransferDir = SDMMC_TRANSFER_DIR_TO_SDMMC;
1159  config.TransferMode = SDMMC_TRANSFER_MODE_BLOCK;
1160 #if defined(STM32L4R5xx) || defined(STM32L4R7xx) || defined(STM32L4R9xx) || defined(STM32L4S5xx) || defined(STM32L4S7xx) || defined(STM32L4S9xx)
1161  config.DPSM = SDMMC_DPSM_DISABLE;
1162 #else
1163  config.DPSM = SDMMC_DPSM_ENABLE;
1164 #endif /* STM32L4R5xx || STM32L4R7xx || STM32L4R9xx || STM32L4S5xx || STM32L4S7xx || STM32L4S9xx */
1165  (void)SDMMC_ConfigData(hsd->Instance, &config);
1166 #if defined(STM32L4R5xx) || defined(STM32L4R7xx) || defined(STM32L4R9xx) || defined(STM32L4S5xx) || defined(STM32L4S7xx) || defined(STM32L4S9xx)
1167  __SDMMC_CMDTRANS_ENABLE( hsd->Instance);
1168 #endif /* STM32L4R5xx || STM32L4R7xx || STM32L4R9xx || STM32L4S5xx || STM32L4S7xx || STM32L4S9xx */
1169 
1170  /* Read Blocks in IT mode */
1171  if(NumberOfBlocks > 1U)
1172  {
1173  hsd->Context = (SD_CONTEXT_READ_MULTIPLE_BLOCK | SD_CONTEXT_IT);
1174 
1175  /* Read Multi Block command */
1176  errorstate = SDMMC_CmdReadMultiBlock(hsd->Instance, add);
1177  }
1178  else
1179  {
1180  hsd->Context = (SD_CONTEXT_READ_SINGLE_BLOCK | SD_CONTEXT_IT);
1181 
1182  /* Read Single Block command */
1183  errorstate = SDMMC_CmdReadSingleBlock(hsd->Instance, add);
1184  }
1185  if(errorstate != HAL_SD_ERROR_NONE)
1186  {
1187  /* Clear all the static flags */
1188  __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
1189  hsd->ErrorCode |= errorstate;
1190  hsd->State = HAL_SD_STATE_READY;
1191  hsd->Context = SD_CONTEXT_NONE;
1192  return HAL_ERROR;
1193  }
1194 
1195  return HAL_OK;
1196  }
1197  else
1198  {
1199  return HAL_BUSY;
1200  }
1201 }
1202 
1216 HAL_StatusTypeDef HAL_SD_WriteBlocks_IT(SD_HandleTypeDef *hsd, uint8_t *pData, uint32_t BlockAdd, uint32_t NumberOfBlocks)
1217 {
1218  SDMMC_DataInitTypeDef config;
1219  uint32_t errorstate;
1220  uint32_t add = BlockAdd;
1221 
1222  if(NULL == pData)
1223  {
1224  hsd->ErrorCode |= HAL_SD_ERROR_PARAM;
1225  return HAL_ERROR;
1226  }
1227 
1228  if(hsd->State == HAL_SD_STATE_READY)
1229  {
1230  hsd->ErrorCode = HAL_SD_ERROR_NONE;
1231 
1232  if((add + NumberOfBlocks) > (hsd->SdCard.LogBlockNbr))
1233  {
1234  hsd->ErrorCode |= HAL_SD_ERROR_ADDR_OUT_OF_RANGE;
1235  return HAL_ERROR;
1236  }
1237 
1238  hsd->State = HAL_SD_STATE_BUSY;
1239 
1240  /* Initialize data control register */
1241  hsd->Instance->DCTRL = 0U;
1242 
1243  hsd->pTxBuffPtr = pData;
1244  hsd->TxXferSize = BLOCKSIZE * NumberOfBlocks;
1245 
1246  /* Enable transfer interrupts */
1247  __HAL_SD_ENABLE_IT(hsd, (SDMMC_IT_DCRCFAIL | SDMMC_IT_DTIMEOUT | SDMMC_IT_TXUNDERR | SDMMC_IT_DATAEND | SDMMC_FLAG_TXFIFOHE));
1248 
1249  if(hsd->SdCard.CardType != CARD_SDHC_SDXC)
1250  {
1251  add *= 512U;
1252  }
1253 
1254  /* Set Block Size for Card */
1255  errorstate = SDMMC_CmdBlockLength(hsd->Instance, BLOCKSIZE);
1256  if(errorstate != HAL_SD_ERROR_NONE)
1257  {
1258  /* Clear all the static flags */
1259  __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
1260  hsd->ErrorCode |= errorstate;
1261  hsd->State = HAL_SD_STATE_READY;
1262  return HAL_ERROR;
1263  }
1264 
1265 #if defined(STM32L4R5xx) || defined(STM32L4R7xx) || defined(STM32L4R9xx) || defined(STM32L4S5xx) || defined(STM32L4S7xx) || defined(STM32L4S9xx)
1266  /* Configure the SD DPSM (Data Path State Machine) */
1267  config.DataTimeOut = SDMMC_DATATIMEOUT;
1268  config.DataLength = BLOCKSIZE * NumberOfBlocks;
1269  config.DataBlockSize = SDMMC_DATABLOCK_SIZE_512B;
1270  config.TransferDir = SDMMC_TRANSFER_DIR_TO_CARD;
1271  config.TransferMode = SDMMC_TRANSFER_MODE_BLOCK;
1272  config.DPSM = SDMMC_DPSM_DISABLE;
1273  (void)SDMMC_ConfigData(hsd->Instance, &config);
1274 
1275  __SDMMC_CMDTRANS_ENABLE( hsd->Instance);
1276 #endif /* STM32L4R5xx || STM32L4R7xx || STM32L4R9xx || STM32L4S5xx || STM32L4S7xx || STM32L4S9xx */
1277 
1278  /* Write Blocks in Polling mode */
1279  if(NumberOfBlocks > 1U)
1280  {
1281  hsd->Context = (SD_CONTEXT_WRITE_MULTIPLE_BLOCK| SD_CONTEXT_IT);
1282 
1283  /* Write Multi Block command */
1284  errorstate = SDMMC_CmdWriteMultiBlock(hsd->Instance, add);
1285  }
1286  else
1287  {
1288  hsd->Context = (SD_CONTEXT_WRITE_SINGLE_BLOCK | SD_CONTEXT_IT);
1289 
1290  /* Write Single Block command */
1291  errorstate = SDMMC_CmdWriteSingleBlock(hsd->Instance, add);
1292  }
1293  if(errorstate != HAL_SD_ERROR_NONE)
1294  {
1295  /* Clear all the static flags */
1296  __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
1297  hsd->ErrorCode |= errorstate;
1298  hsd->State = HAL_SD_STATE_READY;
1299  hsd->Context = SD_CONTEXT_NONE;
1300  return HAL_ERROR;
1301  }
1302 
1303 #if !defined(STM32L4R5xx) && !defined(STM32L4R7xx) && !defined(STM32L4R9xx) && !defined(STM32L4S5xx) && !defined(STM32L4S7xx) && !defined(STM32L4S9xx)
1304  /* Configure the SD DPSM (Data Path State Machine) */
1305  config.DataTimeOut = SDMMC_DATATIMEOUT;
1306  config.DataLength = BLOCKSIZE * NumberOfBlocks;
1307  config.DataBlockSize = SDMMC_DATABLOCK_SIZE_512B;
1308  config.TransferDir = SDMMC_TRANSFER_DIR_TO_CARD;
1309  config.TransferMode = SDMMC_TRANSFER_MODE_BLOCK;
1310  config.DPSM = SDMMC_DPSM_ENABLE;
1311  (void)SDMMC_ConfigData(hsd->Instance, &config);
1312 #endif /* !STM32L4R5xx && !STM32L4R7xx && !STM32L4R9xx && !STM32L4S5xx && !STM32L4S7xx && !STM32L4S9xx */
1313 
1314  return HAL_OK;
1315  }
1316  else
1317  {
1318  return HAL_BUSY;
1319  }
1320 }
1321 
1335 HAL_StatusTypeDef HAL_SD_ReadBlocks_DMA(SD_HandleTypeDef *hsd, uint8_t *pData, uint32_t BlockAdd, uint32_t NumberOfBlocks)
1336 {
1337  SDMMC_DataInitTypeDef config;
1338  uint32_t errorstate;
1339  uint32_t add = BlockAdd;
1340 
1341  if(NULL == pData)
1342  {
1343  hsd->ErrorCode |= HAL_SD_ERROR_PARAM;
1344  return HAL_ERROR;
1345  }
1346 
1347  if(hsd->State == HAL_SD_STATE_READY)
1348  {
1349  hsd->ErrorCode = HAL_SD_ERROR_NONE;
1350 
1351  if((add + NumberOfBlocks) > (hsd->SdCard.LogBlockNbr))
1352  {
1353  hsd->ErrorCode |= HAL_SD_ERROR_ADDR_OUT_OF_RANGE;
1354  return HAL_ERROR;
1355  }
1356 
1357  hsd->State = HAL_SD_STATE_BUSY;
1358 
1359  /* Initialize data control register */
1360  hsd->Instance->DCTRL = 0U;
1361 
1362 #if !defined(STM32L4R5xx) && !defined(STM32L4R7xx) && !defined(STM32L4R9xx) && !defined(STM32L4S5xx) && !defined(STM32L4S7xx) && !defined(STM32L4S9xx)
1363  __HAL_SD_ENABLE_IT(hsd, (SDMMC_IT_DCRCFAIL | SDMMC_IT_DTIMEOUT | SDMMC_IT_RXOVERR | SDMMC_IT_DATAEND));
1364 
1365  /* Set the DMA transfer complete callback */
1366  hsd->hdmarx->XferCpltCallback = SD_DMAReceiveCplt;
1367 
1368  /* Set the DMA error callback */
1369  hsd->hdmarx->XferErrorCallback = SD_DMAError;
1370 
1371  /* Set the DMA Abort callback */
1372  hsd->hdmarx->XferAbortCallback = NULL;
1373 
1374  /* Enable the DMA Channel */
1375  if(HAL_DMA_Start_IT(hsd->hdmarx, (uint32_t)&hsd->Instance->FIFO, (uint32_t)pData, (uint32_t)(BLOCKSIZE * NumberOfBlocks)/4U) != HAL_OK)
1376  {
1377  __HAL_SD_DISABLE_IT(hsd, (SDMMC_IT_DCRCFAIL | SDMMC_IT_DTIMEOUT | SDMMC_IT_RXOVERR | SDMMC_IT_DATAEND));
1378  __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
1379  hsd->ErrorCode |= HAL_SD_ERROR_DMA;
1380  hsd->State = HAL_SD_STATE_READY;
1381  return HAL_ERROR;
1382  }
1383  else
1384  {
1385  /* Enable SD DMA transfer */
1386  __HAL_SD_DMA_ENABLE(hsd);
1387 #else
1388  hsd->pRxBuffPtr = pData;
1389  hsd->RxXferSize = BLOCKSIZE * NumberOfBlocks;
1390 #endif /* !STM32L4R5xx && !STM32L4R7xx && !STM32L4R9xx && !STM32L4S5xx && !STM32L4S7xx && !STM32L4S9xx */
1391 
1392  if(hsd->SdCard.CardType != CARD_SDHC_SDXC)
1393  {
1394  add *= 512U;
1395  }
1396 
1397  /* Set Block Size for Card */
1398  errorstate = SDMMC_CmdBlockLength(hsd->Instance, BLOCKSIZE);
1399  if(errorstate != HAL_SD_ERROR_NONE)
1400  {
1401  /* Clear all the static flags */
1402  __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
1403  hsd->ErrorCode |= errorstate;
1404  hsd->State = HAL_SD_STATE_READY;
1405  return HAL_ERROR;
1406  }
1407 
1408  /* Configure the SD DPSM (Data Path State Machine) */
1409  config.DataTimeOut = SDMMC_DATATIMEOUT;
1410  config.DataLength = BLOCKSIZE * NumberOfBlocks;
1411  config.DataBlockSize = SDMMC_DATABLOCK_SIZE_512B;
1412  config.TransferDir = SDMMC_TRANSFER_DIR_TO_SDMMC;
1413  config.TransferMode = SDMMC_TRANSFER_MODE_BLOCK;
1414 #if defined(STM32L4R5xx) || defined(STM32L4R7xx) || defined(STM32L4R9xx) || defined(STM32L4S5xx) || defined(STM32L4S7xx) || defined(STM32L4S9xx)
1415  config.DPSM = SDMMC_DPSM_DISABLE;
1416 #else
1417  config.DPSM = SDMMC_DPSM_ENABLE;
1418 #endif /* STM32L4R5xx || STM32L4R7xx || STM32L4R9xx || STM32L4S5xx || STM32L4S7xx || STM32L4S9xx */
1419  (void)SDMMC_ConfigData(hsd->Instance, &config);
1420 
1421 #if defined(STM32L4R5xx) || defined(STM32L4R7xx) || defined(STM32L4R9xx) || defined(STM32L4S5xx) || defined(STM32L4S7xx) || defined(STM32L4S9xx)
1422  /* Enable transfer interrupts */
1423  __HAL_SD_ENABLE_IT(hsd, (SDMMC_IT_DCRCFAIL | SDMMC_IT_DTIMEOUT | SDMMC_IT_RXOVERR | SDMMC_IT_DATAEND));
1424 
1425  __SDMMC_CMDTRANS_ENABLE( hsd->Instance);
1426  hsd->Instance->IDMABASE0 = (uint32_t) pData ;
1427  hsd->Instance->IDMACTRL = SDMMC_ENABLE_IDMA_SINGLE_BUFF;
1428 #endif /* STM32L4R5xx || STM32L4R7xx || STM32L4R9xx || STM32L4S5xx || STM32L4S7xx || STM32L4S9xx */
1429 
1430  /* Read Blocks in DMA mode */
1431  if(NumberOfBlocks > 1U)
1432  {
1433  hsd->Context = (SD_CONTEXT_READ_MULTIPLE_BLOCK | SD_CONTEXT_DMA);
1434 
1435  /* Read Multi Block command */
1436  errorstate = SDMMC_CmdReadMultiBlock(hsd->Instance, add);
1437  }
1438  else
1439  {
1440  hsd->Context = (SD_CONTEXT_READ_SINGLE_BLOCK | SD_CONTEXT_DMA);
1441 
1442  /* Read Single Block command */
1443  errorstate = SDMMC_CmdReadSingleBlock(hsd->Instance, add);
1444  }
1445  if(errorstate != HAL_SD_ERROR_NONE)
1446  {
1447  /* Clear all the static flags */
1448  __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
1449 #if defined(STM32L4R5xx) || defined(STM32L4R7xx) || defined(STM32L4R9xx) || defined(STM32L4S5xx) || defined(STM32L4S7xx) || defined(STM32L4S9xx)
1450  __HAL_SD_DISABLE_IT(hsd, (SDMMC_IT_DCRCFAIL | SDMMC_IT_DTIMEOUT | SDMMC_IT_RXOVERR | SDMMC_IT_DATAEND));
1451 #endif /* STM32L4R5xx || STM32L4R7xx || STM32L4R9xx || STM32L4S5xx || STM32L4S7xx || STM32L4S9xx */
1452  hsd->ErrorCode |= errorstate;
1453  hsd->State = HAL_SD_STATE_READY;
1454  hsd->Context = SD_CONTEXT_NONE;
1455  return HAL_ERROR;
1456  }
1457 
1458  return HAL_OK;
1459 #if !defined(STM32L4R5xx) && !defined(STM32L4R7xx) && !defined(STM32L4R9xx) && !defined(STM32L4S5xx) && !defined(STM32L4S7xx) && !defined(STM32L4S9xx)
1460  }
1461 #endif
1462  }
1463  else
1464  {
1465  return HAL_BUSY;
1466  }
1467 }
1468 
1482 HAL_StatusTypeDef HAL_SD_WriteBlocks_DMA(SD_HandleTypeDef *hsd, uint8_t *pData, uint32_t BlockAdd, uint32_t NumberOfBlocks)
1483 {
1484  SDMMC_DataInitTypeDef config;
1485  uint32_t errorstate;
1486  uint32_t add = BlockAdd;
1487 
1488  if(NULL == pData)
1489  {
1490  hsd->ErrorCode |= HAL_SD_ERROR_PARAM;
1491  return HAL_ERROR;
1492  }
1493 
1494  if(hsd->State == HAL_SD_STATE_READY)
1495  {
1496  hsd->ErrorCode = HAL_SD_ERROR_NONE;
1497 
1498  if((add + NumberOfBlocks) > (hsd->SdCard.LogBlockNbr))
1499  {
1500  hsd->ErrorCode |= HAL_SD_ERROR_ADDR_OUT_OF_RANGE;
1501  return HAL_ERROR;
1502  }
1503 
1504  hsd->State = HAL_SD_STATE_BUSY;
1505 
1506  /* Initialize data control register */
1507  hsd->Instance->DCTRL = 0U;
1508 
1509 #if defined(STM32L4R5xx) || defined(STM32L4R7xx) || defined(STM32L4R9xx) || defined(STM32L4S5xx) || defined(STM32L4S7xx) || defined(STM32L4S9xx)
1510  hsd->pTxBuffPtr = pData;
1511  hsd->TxXferSize = BLOCKSIZE * NumberOfBlocks;
1512 #else
1513  /* Enable SD Error interrupts */
1514  __HAL_SD_ENABLE_IT(hsd, (SDMMC_IT_DCRCFAIL | SDMMC_IT_DTIMEOUT | SDMMC_IT_TXUNDERR));
1515 
1516  /* Set the DMA transfer complete callback */
1517  hsd->hdmatx->XferCpltCallback = SD_DMATransmitCplt;
1518 
1519  /* Set the DMA error callback */
1520  hsd->hdmatx->XferErrorCallback = SD_DMAError;
1521 
1522  /* Set the DMA Abort callback */
1523  hsd->hdmatx->XferAbortCallback = NULL;
1524 #endif /* STM32L4R5xx || STM32L4R7xx || STM32L4R9xx || STM32L4S5xx || STM32L4S7xx || STM32L4S9xx */
1525 
1526  if(hsd->SdCard.CardType != CARD_SDHC_SDXC)
1527  {
1528  add *= 512U;
1529  }
1530 
1531  /* Set Block Size for Card */
1532  errorstate = SDMMC_CmdBlockLength(hsd->Instance, BLOCKSIZE);
1533  if(errorstate != HAL_SD_ERROR_NONE)
1534  {
1535  /* Clear all the static flags */
1536  __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
1537  hsd->ErrorCode |= errorstate;
1538  hsd->State = HAL_SD_STATE_READY;
1539  return HAL_ERROR;
1540  }
1541 #if defined(STM32L4R5xx) || defined(STM32L4R7xx) || defined(STM32L4R9xx) || defined(STM32L4S5xx) || defined(STM32L4S7xx) || defined(STM32L4S9xx)
1542  /* Configure the SD DPSM (Data Path State Machine) */
1543  config.DataTimeOut = SDMMC_DATATIMEOUT;
1544  config.DataLength = BLOCKSIZE * NumberOfBlocks;
1545  config.DataBlockSize = SDMMC_DATABLOCK_SIZE_512B;
1546  config.TransferDir = SDMMC_TRANSFER_DIR_TO_CARD;
1547  config.TransferMode = SDMMC_TRANSFER_MODE_BLOCK;
1548  config.DPSM = SDMMC_DPSM_DISABLE;
1549  (void)SDMMC_ConfigData(hsd->Instance, &config);
1550 
1551  /* Enable transfer interrupts */
1552  __HAL_SD_ENABLE_IT(hsd, (SDMMC_IT_DCRCFAIL | SDMMC_IT_DTIMEOUT | SDMMC_IT_TXUNDERR | SDMMC_IT_DATAEND));
1553 
1554  __SDMMC_CMDTRANS_ENABLE( hsd->Instance);
1555 
1556  hsd->Instance->IDMABASE0 = (uint32_t) pData ;
1557  hsd->Instance->IDMACTRL = SDMMC_ENABLE_IDMA_SINGLE_BUFF;
1558 #endif /* STM32L4R5xx || STM32L4R7xx || STM32L4R9xx || STM32L4S5xx || STM32L4S7xx || STM32L4S9xx */
1559 
1560  /* Write Blocks in Polling mode */
1561  if(NumberOfBlocks > 1U)
1562  {
1563  hsd->Context = (SD_CONTEXT_WRITE_MULTIPLE_BLOCK | SD_CONTEXT_DMA);
1564 
1565  /* Write Multi Block command */
1566  errorstate = SDMMC_CmdWriteMultiBlock(hsd->Instance, add);
1567  }
1568  else
1569  {
1570  hsd->Context = (SD_CONTEXT_WRITE_SINGLE_BLOCK | SD_CONTEXT_DMA);
1571 
1572  /* Write Single Block command */
1573  errorstate = SDMMC_CmdWriteSingleBlock(hsd->Instance, add);
1574  }
1575  if(errorstate != HAL_SD_ERROR_NONE)
1576  {
1577  /* Clear all the static flags */
1578  __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
1579 #if defined(STM32L4R5xx) || defined(STM32L4R7xx) || defined(STM32L4R9xx) || defined(STM32L4S5xx) || defined(STM32L4S7xx) || defined(STM32L4S9xx)
1580  __HAL_SD_DISABLE_IT(hsd, (SDMMC_IT_DCRCFAIL | SDMMC_IT_DTIMEOUT | SDMMC_IT_TXUNDERR | SDMMC_IT_DATAEND));
1581 #endif /* STM32L4R5xx || STM32L4R7xx || STM32L4R9xx || STM32L4S5xx || STM32L4S7xx || STM32L4S9xx */
1582  hsd->ErrorCode |= errorstate;
1583  hsd->State = HAL_SD_STATE_READY;
1584  hsd->Context = SD_CONTEXT_NONE;
1585  return HAL_ERROR;
1586  }
1587 
1588 #if !defined(STM32L4R5xx) && !defined(STM32L4R7xx) && !defined(STM32L4R9xx) && !defined(STM32L4S5xx) && !defined(STM32L4S7xx) && !defined(STM32L4S9xx)
1589  /* Enable SDMMC DMA transfer */
1590  __HAL_SD_DMA_ENABLE(hsd);
1591 
1592  /* Enable the DMA Channel */
1593  if(HAL_DMA_Start_IT(hsd->hdmatx, (uint32_t)pData, (uint32_t)&hsd->Instance->FIFO, (uint32_t)(BLOCKSIZE * NumberOfBlocks)/4U) != HAL_OK)
1594  {
1595  __HAL_SD_DISABLE_IT(hsd, (SDMMC_IT_DCRCFAIL | SDMMC_IT_DTIMEOUT | SDMMC_IT_TXUNDERR));
1596  __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
1597  hsd->ErrorCode |= HAL_SD_ERROR_DMA;
1598  hsd->State = HAL_SD_STATE_READY;
1599  hsd->Context = SD_CONTEXT_NONE;
1600  return HAL_ERROR;
1601  }
1602  else
1603  {
1604  /* Configure the SD DPSM (Data Path State Machine) */
1605  config.DataTimeOut = SDMMC_DATATIMEOUT;
1606  config.DataLength = BLOCKSIZE * NumberOfBlocks;
1607  config.DataBlockSize = SDMMC_DATABLOCK_SIZE_512B;
1608  config.TransferDir = SDMMC_TRANSFER_DIR_TO_CARD;
1609  config.TransferMode = SDMMC_TRANSFER_MODE_BLOCK;
1610  config.DPSM = SDMMC_DPSM_ENABLE;
1611  (void)SDMMC_ConfigData(hsd->Instance, &config);
1612 #endif /* !STM32L4R5xx && !STM32L4R7xx && !STM32L4R9xx && !STM32L4S5xx && !STM32L4S7xx && !STM32L4S9xx */
1613 
1614  return HAL_OK;
1615 #if !defined(STM32L4R5xx) && !defined(STM32L4R7xx) && !defined(STM32L4R9xx) && !defined(STM32L4S5xx) && !defined(STM32L4S7xx) && !defined(STM32L4S9xx)
1616  }
1617 #endif
1618  }
1619  else
1620  {
1621  return HAL_BUSY;
1622  }
1623 }
1624 
1634 HAL_StatusTypeDef HAL_SD_Erase(SD_HandleTypeDef *hsd, uint32_t BlockStartAdd, uint32_t BlockEndAdd)
1635 {
1636  uint32_t errorstate;
1637  uint32_t start_add = BlockStartAdd;
1638  uint32_t end_add = BlockEndAdd;
1639 
1640  if(hsd->State == HAL_SD_STATE_READY)
1641  {
1642  hsd->ErrorCode = HAL_SD_ERROR_NONE;
1643 
1644  if(end_add < start_add)
1645  {
1646  hsd->ErrorCode |= HAL_SD_ERROR_PARAM;
1647  return HAL_ERROR;
1648  }
1649 
1650  if(end_add > (hsd->SdCard.LogBlockNbr))
1651  {
1652  hsd->ErrorCode |= HAL_SD_ERROR_ADDR_OUT_OF_RANGE;
1653  return HAL_ERROR;
1654  }
1655 
1656  hsd->State = HAL_SD_STATE_BUSY;
1657 
1658  /* Check if the card command class supports erase command */
1659  if(((hsd->SdCard.Class) & SDMMC_CCCC_ERASE) == 0U)
1660  {
1661  /* Clear all the static flags */
1662  __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
1663  hsd->ErrorCode |= HAL_SD_ERROR_REQUEST_NOT_APPLICABLE;
1664  hsd->State = HAL_SD_STATE_READY;
1665  return HAL_ERROR;
1666  }
1667 
1668  if((SDMMC_GetResponse(hsd->Instance, SDMMC_RESP1) & SDMMC_CARD_LOCKED) == SDMMC_CARD_LOCKED)
1669  {
1670  /* Clear all the static flags */
1671  __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
1672  hsd->ErrorCode |= HAL_SD_ERROR_LOCK_UNLOCK_FAILED;
1673  hsd->State = HAL_SD_STATE_READY;
1674  return HAL_ERROR;
1675  }
1676 
1677  /* Get start and end block for high capacity cards */
1678  if(hsd->SdCard.CardType != CARD_SDHC_SDXC)
1679  {
1680  start_add *= 512U;
1681  end_add *= 512U;
1682  }
1683 
1684  /* According to sd-card spec 1.0 ERASE_GROUP_START (CMD32) and erase_group_end(CMD33) */
1685  if(hsd->SdCard.CardType != CARD_SECURED)
1686  {
1687  /* Send CMD32 SD_ERASE_GRP_START with argument as addr */
1688  errorstate = SDMMC_CmdSDEraseStartAdd(hsd->Instance, start_add);
1689  if(errorstate != HAL_SD_ERROR_NONE)
1690  {
1691  /* Clear all the static flags */
1692  __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
1693  hsd->ErrorCode |= errorstate;
1694  hsd->State = HAL_SD_STATE_READY;
1695  return HAL_ERROR;
1696  }
1697 
1698  /* Send CMD33 SD_ERASE_GRP_END with argument as addr */
1699  errorstate = SDMMC_CmdSDEraseEndAdd(hsd->Instance, end_add);
1700  if(errorstate != HAL_SD_ERROR_NONE)
1701  {
1702  /* Clear all the static flags */
1703  __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
1704  hsd->ErrorCode |= errorstate;
1705  hsd->State = HAL_SD_STATE_READY;
1706  return HAL_ERROR;
1707  }
1708  }
1709 
1710  /* Send CMD38 ERASE */
1711  errorstate = SDMMC_CmdErase(hsd->Instance);
1712  if(errorstate != HAL_SD_ERROR_NONE)
1713  {
1714  /* Clear all the static flags */
1715  __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
1716  hsd->ErrorCode |= errorstate;
1717  hsd->State = HAL_SD_STATE_READY;
1718  return HAL_ERROR;
1719  }
1720 
1721  hsd->State = HAL_SD_STATE_READY;
1722 
1723  return HAL_OK;
1724  }
1725  else
1726  {
1727  return HAL_BUSY;
1728  }
1729 }
1730 
1736 void HAL_SD_IRQHandler(SD_HandleTypeDef *hsd)
1737 {
1738  uint32_t errorstate;
1739  uint32_t context = hsd->Context;
1740 
1741  /* Check for SDMMC interrupt flags */
1742  if((__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXFIFOHF) != RESET) && ((context & SD_CONTEXT_IT) != 0U))
1743  {
1744  SD_Read_IT(hsd);
1745  }
1746 
1747  else if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DATAEND) != RESET)
1748  {
1749  __HAL_SD_CLEAR_FLAG(hsd, SDMMC_FLAG_DATAEND);
1750 
1751  __HAL_SD_DISABLE_IT(hsd, SDMMC_IT_DATAEND | SDMMC_IT_DCRCFAIL | SDMMC_IT_DTIMEOUT |\
1752  SDMMC_IT_TXUNDERR | SDMMC_IT_RXOVERR | SDMMC_IT_TXFIFOHE |\
1753  SDMMC_IT_RXFIFOHF);
1754 
1755 #if defined(STM32L4R5xx) || defined(STM32L4R7xx) || defined(STM32L4R9xx) || defined(STM32L4S5xx) || defined(STM32L4S7xx) || defined(STM32L4S9xx)
1756  __HAL_SD_DISABLE_IT(hsd, SDMMC_IT_IDMABTC);
1757  __SDMMC_CMDTRANS_DISABLE( hsd->Instance);
1758 #else
1759  hsd->Instance->DCTRL &= ~(SDMMC_DCTRL_DTEN);
1760 #endif /* STM32L4R5xx || STM32L4R7xx || STM32L4R9xx || STM32L4S5xx || STM32L4S7xx || STM32L4S9xx */
1761 
1762  if((context & SD_CONTEXT_IT) != 0U)
1763  {
1764  if(((context & SD_CONTEXT_READ_MULTIPLE_BLOCK) != 0U) || ((context & SD_CONTEXT_WRITE_MULTIPLE_BLOCK) != 0U))
1765  {
1766  errorstate = SDMMC_CmdStopTransfer(hsd->Instance);
1767  if(errorstate != HAL_SD_ERROR_NONE)
1768  {
1769  hsd->ErrorCode |= errorstate;
1770 #if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
1771  hsd->ErrorCallback(hsd);
1772 #else
1773  HAL_SD_ErrorCallback(hsd);
1774 #endif /* USE_HAL_SD_REGISTER_CALLBACKS */
1775  }
1776  }
1777 
1778  /* Clear all the static flags */
1779  __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_DATA_FLAGS);
1780 
1781  hsd->State = HAL_SD_STATE_READY;
1782  hsd->Context = SD_CONTEXT_NONE;
1783  if(((context & SD_CONTEXT_READ_SINGLE_BLOCK) != 0U) || ((context & SD_CONTEXT_READ_MULTIPLE_BLOCK) != 0U))
1784  {
1785 #if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
1786  hsd->RxCpltCallback(hsd);
1787 #else
1788  HAL_SD_RxCpltCallback(hsd);
1789 #endif /* USE_HAL_SD_REGISTER_CALLBACKS */
1790  }
1791  else
1792  {
1793 #if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
1794  hsd->TxCpltCallback(hsd);
1795 #else
1796  HAL_SD_TxCpltCallback(hsd);
1797 #endif /* USE_HAL_SD_REGISTER_CALLBACKS */
1798  }
1799  }
1800  else if((context & SD_CONTEXT_DMA) != 0U)
1801  {
1802 #if defined(STM32L4R5xx) || defined(STM32L4R7xx) || defined(STM32L4R9xx) || defined(STM32L4S5xx) || defined(STM32L4S7xx) || defined(STM32L4S9xx)
1803  hsd->Instance->DLEN = 0;
1804  hsd->Instance->DCTRL = 0;
1805  hsd->Instance->IDMACTRL = SDMMC_DISABLE_IDMA;
1806 
1807  /* Stop Transfer for Write Multi blocks or Read Multi blocks */
1808  if(((context & SD_CONTEXT_READ_MULTIPLE_BLOCK) != 0U) || ((context & SD_CONTEXT_WRITE_MULTIPLE_BLOCK) != 0U))
1809  {
1810  errorstate = SDMMC_CmdStopTransfer(hsd->Instance);
1811  if(errorstate != HAL_SD_ERROR_NONE)
1812  {
1813  hsd->ErrorCode |= errorstate;
1814 #if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
1815  hsd->ErrorCallback(hsd);
1816 #else
1817  HAL_SD_ErrorCallback(hsd);
1818 #endif /* USE_HAL_SD_REGISTER_CALLBACKS */
1819  }
1820  }
1821 
1822  hsd->State = HAL_SD_STATE_READY;
1823  hsd->Context = SD_CONTEXT_NONE;
1824  if(((context & SD_CONTEXT_WRITE_SINGLE_BLOCK) != 0U) || ((context & SD_CONTEXT_WRITE_MULTIPLE_BLOCK) != 0U))
1825  {
1826 #if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
1827  hsd->TxCpltCallback(hsd);
1828 #else
1829  HAL_SD_TxCpltCallback(hsd);
1830 #endif /* USE_HAL_SD_REGISTER_CALLBACKS */
1831  }
1832  if(((context & SD_CONTEXT_READ_SINGLE_BLOCK) != 0U) || ((context & SD_CONTEXT_READ_MULTIPLE_BLOCK) != 0U))
1833  {
1834 #if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
1835  hsd->RxCpltCallback(hsd);
1836 #else
1837  HAL_SD_RxCpltCallback(hsd);
1838 #endif /* USE_HAL_SD_REGISTER_CALLBACKS */
1839  }
1840 #else
1841  if((context & SD_CONTEXT_WRITE_MULTIPLE_BLOCK) != 0U)
1842  {
1843  errorstate = SDMMC_CmdStopTransfer(hsd->Instance);
1844  if(errorstate != HAL_SD_ERROR_NONE)
1845  {
1846  hsd->ErrorCode |= errorstate;
1847 #if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
1848  hsd->ErrorCallback(hsd);
1849 #else
1850  HAL_SD_ErrorCallback(hsd);
1851 #endif /* USE_HAL_SD_REGISTER_CALLBACKS */
1852  }
1853  }
1854  if(((context & SD_CONTEXT_READ_SINGLE_BLOCK) == 0U) && ((context & SD_CONTEXT_READ_MULTIPLE_BLOCK) == 0U))
1855  {
1856  /* Disable the DMA transfer for transmit request by setting the DMAEN bit
1857  in the SD DCTRL register */
1858  hsd->Instance->DCTRL &= (uint32_t)~((uint32_t)SDMMC_DCTRL_DMAEN);
1859 
1860  hsd->State = HAL_SD_STATE_READY;
1861 
1862 #if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
1863  hsd->TxCpltCallback(hsd);
1864 #else
1865  HAL_SD_TxCpltCallback(hsd);
1866 #endif /* USE_HAL_SD_REGISTER_CALLBACKS */
1867  }
1868 #endif /* STM32L4R5xx || STM32L4R7xx || STM32L4R9xx || STM32L4S5xx || STM32L4S7xx || STM32L4S9xx */
1869  }
1870  else
1871  {
1872  /* Nothing to do */
1873  }
1874  }
1875 
1876  else if((__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_TXFIFOHE) != RESET) && ((context & SD_CONTEXT_IT) != 0U))
1877  {
1878  SD_Write_IT(hsd);
1879  }
1880 
1881  else if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DCRCFAIL | SDMMC_FLAG_DTIMEOUT | SDMMC_FLAG_RXOVERR | SDMMC_FLAG_TXUNDERR) != RESET)
1882  {
1883  /* Set Error code */
1884  if(__HAL_SD_GET_FLAG(hsd, SDMMC_IT_DCRCFAIL) != RESET)
1885  {
1886  hsd->ErrorCode |= HAL_SD_ERROR_DATA_CRC_FAIL;
1887  }
1888  if(__HAL_SD_GET_FLAG(hsd, SDMMC_IT_DTIMEOUT) != RESET)
1889  {
1890  hsd->ErrorCode |= HAL_SD_ERROR_DATA_TIMEOUT;
1891  }
1892  if(__HAL_SD_GET_FLAG(hsd, SDMMC_IT_RXOVERR) != RESET)
1893  {
1894  hsd->ErrorCode |= HAL_SD_ERROR_RX_OVERRUN;
1895  }
1896  if(__HAL_SD_GET_FLAG(hsd, SDMMC_IT_TXUNDERR) != RESET)
1897  {
1898  hsd->ErrorCode |= HAL_SD_ERROR_TX_UNDERRUN;
1899  }
1900 
1901  /* Clear All flags */
1902  __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_DATA_FLAGS);
1903 
1904  /* Disable all interrupts */
1905  __HAL_SD_DISABLE_IT(hsd, SDMMC_IT_DATAEND | SDMMC_IT_DCRCFAIL | SDMMC_IT_DTIMEOUT|\
1906  SDMMC_IT_TXUNDERR| SDMMC_IT_RXOVERR);
1907 
1908 #if defined(STM32L4R5xx) || defined(STM32L4R7xx) || defined(STM32L4R9xx) || defined(STM32L4S5xx) || defined(STM32L4S7xx) || defined(STM32L4S9xx)
1909  __SDMMC_CMDTRANS_DISABLE( hsd->Instance);
1910  hsd->Instance->DCTRL |= SDMMC_DCTRL_FIFORST;
1911  hsd->Instance->CMD |= SDMMC_CMD_CMDSTOP;
1912 #endif /* STM32L4R5xx || STM32L4R7xx || STM32L4R9xx || STM32L4S5xx || STM32L4S7xx || STM32L4S9xx */
1913  hsd->ErrorCode |= SDMMC_CmdStopTransfer(hsd->Instance);
1914 #if defined(STM32L4R5xx) || defined(STM32L4R7xx) || defined(STM32L4R9xx) || defined(STM32L4S5xx) || defined(STM32L4S7xx) || defined(STM32L4S9xx)
1915  hsd->Instance->CMD &= ~(SDMMC_CMD_CMDSTOP);
1916  __HAL_SD_CLEAR_FLAG(hsd, SDMMC_FLAG_DABORT);
1917 #endif /* STM32L4R5xx || STM32L4R7xx || STM32L4R9xx || STM32L4S5xx || STM32L4S7xx || STM32L4S9xx */
1918 
1919  if((context & SD_CONTEXT_IT) != 0U)
1920  {
1921  /* Set the SD state to ready to be able to start again the process */
1922  hsd->State = HAL_SD_STATE_READY;
1923  hsd->Context = SD_CONTEXT_NONE;
1924 #if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
1925  hsd->ErrorCallback(hsd);
1926 #else
1927  HAL_SD_ErrorCallback(hsd);
1928 #endif /* USE_HAL_SD_REGISTER_CALLBACKS */
1929  }
1930  else if((context & SD_CONTEXT_DMA) != 0U)
1931  {
1932 #if defined(STM32L4R5xx) || defined(STM32L4R7xx) || defined(STM32L4R9xx) || defined(STM32L4S5xx) || defined(STM32L4S7xx) || defined(STM32L4S9xx)
1933  if(hsd->ErrorCode != HAL_SD_ERROR_NONE)
1934  {
1935  /* Disable Internal DMA */
1936  __HAL_SD_DISABLE_IT(hsd, SDMMC_IT_IDMABTC);
1937  hsd->Instance->IDMACTRL = SDMMC_DISABLE_IDMA;
1938 
1939  /* Set the SD state to ready to be able to start again the process */
1940  hsd->State = HAL_SD_STATE_READY;
1941 #if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
1942  hsd->ErrorCallback(hsd);
1943 #else
1944  HAL_SD_ErrorCallback(hsd);
1945 #endif /* USE_HAL_SD_REGISTER_CALLBACKS */
1946  }
1947 #else
1948  /* Abort the SD DMA channel */
1949  if(((context & SD_CONTEXT_WRITE_SINGLE_BLOCK) != 0U) || ((context & SD_CONTEXT_WRITE_MULTIPLE_BLOCK) != 0U))
1950  {
1951  /* Set the DMA Tx abort callback */
1952  hsd->hdmatx->XferAbortCallback = SD_DMATxAbort;
1953  /* Abort DMA in IT mode */
1954  if(HAL_DMA_Abort_IT(hsd->hdmatx) != HAL_OK)
1955  {
1956  SD_DMATxAbort(hsd->hdmatx);
1957  }
1958  }
1959  else if(((context & SD_CONTEXT_READ_SINGLE_BLOCK) != 0U) || ((context & SD_CONTEXT_READ_MULTIPLE_BLOCK) != 0U))
1960  {
1961  /* Set the DMA Rx abort callback */
1962  hsd->hdmarx->XferAbortCallback = SD_DMARxAbort;
1963  /* Abort DMA in IT mode */
1964  if(HAL_DMA_Abort_IT(hsd->hdmarx) != HAL_OK)
1965  {
1966  SD_DMARxAbort(hsd->hdmarx);
1967  }
1968  }
1969  else
1970  {
1971  hsd->ErrorCode = HAL_SD_ERROR_NONE;
1972  hsd->State = HAL_SD_STATE_READY;
1973  hsd->Context = SD_CONTEXT_NONE;
1974 #if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
1975  hsd->AbortCpltCallback(hsd);
1976 #else
1977  HAL_SD_AbortCallback(hsd);
1978 #endif /* USE_HAL_SD_REGISTER_CALLBACKS */
1979  }
1980 #endif /* STM32L4R5xx || STM32L4R7xx || STM32L4R9xx || STM32L4S5xx || STM32L4S7xx || STM32L4S9xx */
1981  }
1982  else
1983  {
1984  /* Nothing to do */
1985  }
1986  }
1987 
1988 #if defined(STM32L4R5xx) || defined(STM32L4R7xx) || defined(STM32L4R9xx) || defined(STM32L4S5xx) || defined(STM32L4S7xx) || defined(STM32L4S9xx)
1989  else if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_IDMABTC) != RESET)
1990  {
1991  __HAL_SD_CLEAR_FLAG(hsd, SDMMC_FLAG_IDMABTC);
1992  if(READ_BIT(hsd->Instance->IDMACTRL, SDMMC_IDMA_IDMABACT) == 0U)
1993  {
1994  /* Current buffer is buffer0, Transfer complete for buffer1 */
1995  if((context & SD_CONTEXT_WRITE_MULTIPLE_BLOCK) != 0U)
1996  {
1997 #if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
1998  hsd->Write_DMADblBuf1CpltCallback(hsd);
1999 #else
2000  HAL_SDEx_Write_DMADoubleBuffer1CpltCallback(hsd);
2001 #endif /* USE_HAL_SD_REGISTER_CALLBACKS */
2002  }
2003  else /* SD_CONTEXT_READ_MULTIPLE_BLOCK */
2004  {
2005 #if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
2006  hsd->Read_DMADblBuf1CpltCallback(hsd);
2007 #else
2008  HAL_SDEx_Read_DMADoubleBuffer1CpltCallback(hsd);
2009 #endif /* USE_HAL_SD_REGISTER_CALLBACKS */
2010  }
2011  }
2012  else /* SD_DMA_BUFFER1 */
2013  {
2014  /* Current buffer is buffer1, Transfer complete for buffer0 */
2015  if((context & SD_CONTEXT_WRITE_MULTIPLE_BLOCK) != 0U)
2016  {
2017 #if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
2018  hsd->Write_DMADblBuf0CpltCallback(hsd);
2019 #else
2020  HAL_SDEx_Write_DMADoubleBuffer0CpltCallback(hsd);
2021 #endif /* USE_HAL_SD_REGISTER_CALLBACKS */
2022  }
2023  else /* SD_CONTEXT_READ_MULTIPLE_BLOCK */
2024  {
2025 #if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
2026  hsd->Read_DMADblBuf0CpltCallback(hsd);
2027 #else
2028  HAL_SDEx_Read_DMADoubleBuffer0CpltCallback(hsd);
2029 #endif /* USE_HAL_SD_REGISTER_CALLBACKS */
2030  }
2031  }
2032  }
2033 #endif /* STM32L4R5xx || STM32L4R7xx || STM32L4R9xx || STM32L4S5xx || STM32L4S7xx || STM32L4S9xx */
2034  else
2035  {
2036  /* Nothing to do */
2037  }
2038 }
2039 
2045 HAL_SD_StateTypeDef HAL_SD_GetState(SD_HandleTypeDef *hsd)
2046 {
2047  return hsd->State;
2048 }
2049 
2056 uint32_t HAL_SD_GetError(SD_HandleTypeDef *hsd)
2057 {
2058  return hsd->ErrorCode;
2059 }
2060 
2066 __weak void HAL_SD_TxCpltCallback(SD_HandleTypeDef *hsd)
2067 {
2068  /* Prevent unused argument(s) compilation warning */
2069  UNUSED(hsd);
2070 
2071  /* NOTE : This function should not be modified, when the callback is needed,
2072  the HAL_SD_TxCpltCallback can be implemented in the user file
2073  */
2074 }
2075 
2081 __weak void HAL_SD_RxCpltCallback(SD_HandleTypeDef *hsd)
2082 {
2083  /* Prevent unused argument(s) compilation warning */
2084  UNUSED(hsd);
2085 
2086  /* NOTE : This function should not be modified, when the callback is needed,
2087  the HAL_SD_RxCpltCallback can be implemented in the user file
2088  */
2089 }
2090 
2096 __weak void HAL_SD_ErrorCallback(SD_HandleTypeDef *hsd)
2097 {
2098  /* Prevent unused argument(s) compilation warning */
2099  UNUSED(hsd);
2100 
2101  /* NOTE : This function should not be modified, when the callback is needed,
2102  the HAL_SD_ErrorCallback can be implemented in the user file
2103  */
2104 }
2105 
2111 __weak void HAL_SD_AbortCallback(SD_HandleTypeDef *hsd)
2112 {
2113  /* Prevent unused argument(s) compilation warning */
2114  UNUSED(hsd);
2115 
2116  /* NOTE : This function should not be modified, when the callback is needed,
2117  the HAL_SD_AbortCallback can be implemented in the user file
2118  */
2119 }
2120 
2121 #if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
2122 
2141 HAL_StatusTypeDef HAL_SD_RegisterCallback(SD_HandleTypeDef *hsd, HAL_SD_CallbackIDTypeDef CallbackID, pSD_CallbackTypeDef pCallback)
2142 {
2143  HAL_StatusTypeDef status = HAL_OK;
2144 
2145  if(pCallback == NULL)
2146  {
2147  /* Update the error code */
2148  hsd->ErrorCode |= HAL_SD_ERROR_INVALID_CALLBACK;
2149  return HAL_ERROR;
2150  }
2151 
2152  /* Process locked */
2153  __HAL_LOCK(hsd);
2154 
2155  if(hsd->State == HAL_SD_STATE_READY)
2156  {
2157  switch (CallbackID)
2158  {
2159  case HAL_SD_TX_CPLT_CB_ID :
2160  hsd->TxCpltCallback = pCallback;
2161  break;
2162  case HAL_SD_RX_CPLT_CB_ID :
2163  hsd->RxCpltCallback = pCallback;
2164  break;
2165  case HAL_SD_ERROR_CB_ID :
2166  hsd->ErrorCallback = pCallback;
2167  break;
2168  case HAL_SD_ABORT_CB_ID :
2169  hsd->AbortCpltCallback = pCallback;
2170  break;
2171 #if defined(STM32L4R5xx) || defined(STM32L4R7xx) || defined(STM32L4R9xx) || defined(STM32L4S5xx) || defined(STM32L4S7xx) || defined(STM32L4S9xx)
2172  case HAL_SD_READ_DMA_DBL_BUF0_CPLT_CB_ID :
2173  hsd->Read_DMADblBuf0CpltCallback = pCallback;
2174  break;
2175  case HAL_SD_READ_DMA_DBL_BUF1_CPLT_CB_ID :
2176  hsd->Read_DMADblBuf1CpltCallback = pCallback;
2177  break;
2178  case HAL_SD_WRITE_DMA_DBL_BUF0_CPLT_CB_ID :
2179  hsd->Write_DMADblBuf0CpltCallback = pCallback;
2180  break;
2181  case HAL_SD_WRITE_DMA_DBL_BUF1_CPLT_CB_ID :
2182  hsd->Write_DMADblBuf1CpltCallback = pCallback;
2183  break;
2184 #endif
2185  case HAL_SD_MSP_INIT_CB_ID :
2186  hsd->MspInitCallback = pCallback;
2187  break;
2188  case HAL_SD_MSP_DEINIT_CB_ID :
2189  hsd->MspDeInitCallback = pCallback;
2190  break;
2191  default :
2192  /* Update the error code */
2193  hsd->ErrorCode |= HAL_SD_ERROR_INVALID_CALLBACK;
2194  /* update return status */
2195  status = HAL_ERROR;
2196  break;
2197  }
2198  }
2199  else if (hsd->State == HAL_SD_STATE_RESET)
2200  {
2201  switch (CallbackID)
2202  {
2203  case HAL_SD_MSP_INIT_CB_ID :
2204  hsd->MspInitCallback = pCallback;
2205  break;
2206  case HAL_SD_MSP_DEINIT_CB_ID :
2207  hsd->MspDeInitCallback = pCallback;
2208  break;
2209  default :
2210  /* Update the error code */
2211  hsd->ErrorCode |= HAL_SD_ERROR_INVALID_CALLBACK;
2212  /* update return status */
2213  status = HAL_ERROR;
2214  break;
2215  }
2216  }
2217  else
2218  {
2219  /* Update the error code */
2220  hsd->ErrorCode |= HAL_SD_ERROR_INVALID_CALLBACK;
2221  /* update return status */
2222  status = HAL_ERROR;
2223  }
2224 
2225  /* Release Lock */
2226  __HAL_UNLOCK(hsd);
2227  return status;
2228 }
2229 
2248 HAL_StatusTypeDef HAL_SD_UnRegisterCallback(SD_HandleTypeDef *hsd, HAL_SD_CallbackIDTypeDef CallbackID)
2249 {
2250  HAL_StatusTypeDef status = HAL_OK;
2251 
2252  /* Process locked */
2253  __HAL_LOCK(hsd);
2254 
2255  if(hsd->State == HAL_SD_STATE_READY)
2256  {
2257  switch (CallbackID)
2258  {
2259  case HAL_SD_TX_CPLT_CB_ID :
2260  hsd->TxCpltCallback = HAL_SD_TxCpltCallback;
2261  break;
2262  case HAL_SD_RX_CPLT_CB_ID :
2263  hsd->RxCpltCallback = HAL_SD_RxCpltCallback;
2264  break;
2265  case HAL_SD_ERROR_CB_ID :
2266  hsd->ErrorCallback = HAL_SD_ErrorCallback;
2267  break;
2268  case HAL_SD_ABORT_CB_ID :
2269  hsd->AbortCpltCallback = HAL_SD_AbortCallback;
2270  break;
2271 #if defined(STM32L4R5xx) || defined(STM32L4R7xx) || defined(STM32L4R9xx) || defined(STM32L4S5xx) || defined(STM32L4S7xx) || defined(STM32L4S9xx)
2272  case HAL_SD_READ_DMA_DBL_BUF0_CPLT_CB_ID :
2273  hsd->Read_DMADblBuf0CpltCallback = HAL_SDEx_Read_DMADoubleBuffer0CpltCallback;
2274  break;
2275  case HAL_SD_READ_DMA_DBL_BUF1_CPLT_CB_ID :
2276  hsd->Read_DMADblBuf1CpltCallback = HAL_SDEx_Read_DMADoubleBuffer1CpltCallback;
2277  break;
2278  case HAL_SD_WRITE_DMA_DBL_BUF0_CPLT_CB_ID :
2279  hsd->Write_DMADblBuf0CpltCallback = HAL_SDEx_Write_DMADoubleBuffer0CpltCallback;
2280  break;
2281  case HAL_SD_WRITE_DMA_DBL_BUF1_CPLT_CB_ID :
2282  hsd->Write_DMADblBuf1CpltCallback = HAL_SDEx_Write_DMADoubleBuffer1CpltCallback;
2283  break;
2284 #endif
2285  case HAL_SD_MSP_INIT_CB_ID :
2286  hsd->MspInitCallback = HAL_SD_MspInit;
2287  break;
2288  case HAL_SD_MSP_DEINIT_CB_ID :
2289  hsd->MspDeInitCallback = HAL_SD_MspDeInit;
2290  break;
2291  default :
2292  /* Update the error code */
2293  hsd->ErrorCode |= HAL_SD_ERROR_INVALID_CALLBACK;
2294  /* update return status */
2295  status = HAL_ERROR;
2296  break;
2297  }
2298  }
2299  else if (hsd->State == HAL_SD_STATE_RESET)
2300  {
2301  switch (CallbackID)
2302  {
2303  case HAL_SD_MSP_INIT_CB_ID :
2304  hsd->MspInitCallback = HAL_SD_MspInit;
2305  break;
2306  case HAL_SD_MSP_DEINIT_CB_ID :
2307  hsd->MspDeInitCallback = HAL_SD_MspDeInit;
2308  break;
2309  default :
2310  /* Update the error code */
2311  hsd->ErrorCode |= HAL_SD_ERROR_INVALID_CALLBACK;
2312  /* update return status */
2313  status = HAL_ERROR;
2314  break;
2315  }
2316  }
2317  else
2318  {
2319  /* Update the error code */
2320  hsd->ErrorCode |= HAL_SD_ERROR_INVALID_CALLBACK;
2321  /* update return status */
2322  status = HAL_ERROR;
2323  }
2324 
2325  /* Release Lock */
2326  __HAL_UNLOCK(hsd);
2327  return status;
2328 }
2329 
2330 #if defined(STM32L4R5xx) || defined(STM32L4R7xx) || defined(STM32L4R9xx) || defined(STM32L4S5xx) || defined(STM32L4S7xx) || defined(STM32L4S9xx)
2331 
2338 HAL_StatusTypeDef HAL_SD_RegisterTransceiverCallback(SD_HandleTypeDef *hsd, pSD_TransceiverCallbackTypeDef pCallback)
2339 {
2340  HAL_StatusTypeDef status = HAL_OK;
2341 
2342  if(pCallback == NULL)
2343  {
2344  /* Update the error code */
2345  hsd->ErrorCode |= HAL_SD_ERROR_INVALID_CALLBACK;
2346  return HAL_ERROR;
2347  }
2348 
2349  /* Process locked */
2350  __HAL_LOCK(hsd);
2351 
2352  if(hsd->State == HAL_SD_STATE_READY)
2353  {
2354  hsd->DriveTransceiver_1_8V_Callback = pCallback;
2355  }
2356  else
2357  {
2358  /* Update the error code */
2359  hsd->ErrorCode |= HAL_SD_ERROR_INVALID_CALLBACK;
2360  /* update return status */
2361  status = HAL_ERROR;
2362  }
2363 
2364  /* Release Lock */
2365  __HAL_UNLOCK(hsd);
2366  return status;
2367 }
2368 
2375 HAL_StatusTypeDef HAL_SD_UnRegisterTransceiverCallback(SD_HandleTypeDef *hsd)
2376 {
2377  HAL_StatusTypeDef status = HAL_OK;
2378 
2379  /* Process locked */
2380  __HAL_LOCK(hsd);
2381 
2382  if(hsd->State == HAL_SD_STATE_READY)
2383  {
2384  hsd->DriveTransceiver_1_8V_Callback = HAL_SDEx_DriveTransceiver_1_8V_Callback;
2385  }
2386  else
2387  {
2388  /* Update the error code */
2389  hsd->ErrorCode |= HAL_SD_ERROR_INVALID_CALLBACK;
2390  /* update return status */
2391  status = HAL_ERROR;
2392  }
2393 
2394  /* Release Lock */
2395  __HAL_UNLOCK(hsd);
2396  return status;
2397 }
2398 #endif
2399 #endif /* USE_HAL_SD_REGISTER_CALLBACKS */
2400 
2428 HAL_StatusTypeDef HAL_SD_GetCardCID(SD_HandleTypeDef *hsd, HAL_SD_CardCIDTypeDef *pCID)
2429 {
2430  pCID->ManufacturerID = (uint8_t)((hsd->CID[0] & 0xFF000000U) >> 24U);
2431 
2432  pCID->OEM_AppliID = (uint16_t)((hsd->CID[0] & 0x00FFFF00U) >> 8U);
2433 
2434  pCID->ProdName1 = (((hsd->CID[0] & 0x000000FFU) << 24U) | ((hsd->CID[1] & 0xFFFFFF00U) >> 8U));
2435 
2436  pCID->ProdName2 = (uint8_t)(hsd->CID[1] & 0x000000FFU);
2437 
2438  pCID->ProdRev = (uint8_t)((hsd->CID[2] & 0xFF000000U) >> 24U);
2439 
2440  pCID->ProdSN = (((hsd->CID[2] & 0x00FFFFFFU) << 8U) | ((hsd->CID[3] & 0xFF000000U) >> 24U));
2441 
2442  pCID->Reserved1 = (uint8_t)((hsd->CID[3] & 0x00F00000U) >> 20U);
2443 
2444  pCID->ManufactDate = (uint16_t)((hsd->CID[3] & 0x000FFF00U) >> 8U);
2445 
2446  pCID->CID_CRC = (uint8_t)((hsd->CID[3] & 0x000000FEU) >> 1U);
2447 
2448  pCID->Reserved2 = 1U;
2449 
2450  return HAL_OK;
2451 }
2452 
2461 HAL_StatusTypeDef HAL_SD_GetCardCSD(SD_HandleTypeDef *hsd, HAL_SD_CardCSDTypeDef *pCSD)
2462 {
2463  pCSD->CSDStruct = (uint8_t)((hsd->CSD[0] & 0xC0000000U) >> 30U);
2464 
2465  pCSD->SysSpecVersion = (uint8_t)((hsd->CSD[0] & 0x3C000000U) >> 26U);
2466 
2467  pCSD->Reserved1 = (uint8_t)((hsd->CSD[0] & 0x03000000U) >> 24U);
2468 
2469  pCSD->TAAC = (uint8_t)((hsd->CSD[0] & 0x00FF0000U) >> 16U);
2470 
2471  pCSD->NSAC = (uint8_t)((hsd->CSD[0] & 0x0000FF00U) >> 8U);
2472 
2473  pCSD->MaxBusClkFrec = (uint8_t)(hsd->CSD[0] & 0x000000FFU);
2474 
2475  pCSD->CardComdClasses = (uint16_t)((hsd->CSD[1] & 0xFFF00000U) >> 20U);
2476 
2477  pCSD->RdBlockLen = (uint8_t)((hsd->CSD[1] & 0x000F0000U) >> 16U);
2478 
2479  pCSD->PartBlockRead = (uint8_t)((hsd->CSD[1] & 0x00008000U) >> 15U);
2480 
2481  pCSD->WrBlockMisalign = (uint8_t)((hsd->CSD[1] & 0x00004000U) >> 14U);
2482 
2483  pCSD->RdBlockMisalign = (uint8_t)((hsd->CSD[1] & 0x00002000U) >> 13U);
2484 
2485  pCSD->DSRImpl = (uint8_t)((hsd->CSD[1] & 0x00001000U) >> 12U);
2486 
2487  pCSD->Reserved2 = 0U;
2489  if(hsd->SdCard.CardType == CARD_SDSC)
2490  {
2491  pCSD->DeviceSize = (((hsd->CSD[1] & 0x000003FFU) << 2U) | ((hsd->CSD[2] & 0xC0000000U) >> 30U));
2492 
2493  pCSD->MaxRdCurrentVDDMin = (uint8_t)((hsd->CSD[2] & 0x38000000U) >> 27U);
2494 
2495  pCSD->MaxRdCurrentVDDMax = (uint8_t)((hsd->CSD[2] & 0x07000000U) >> 24U);
2496 
2497  pCSD->MaxWrCurrentVDDMin = (uint8_t)((hsd->CSD[2] & 0x00E00000U) >> 21U);
2498 
2499  pCSD->MaxWrCurrentVDDMax = (uint8_t)((hsd->CSD[2] & 0x001C0000U) >> 18U);
2500 
2501  pCSD->DeviceSizeMul = (uint8_t)((hsd->CSD[2] & 0x00038000U) >> 15U);
2502 
2503  hsd->SdCard.BlockNbr = (pCSD->DeviceSize + 1U) ;
2504  hsd->SdCard.BlockNbr *= (1UL << ((pCSD->DeviceSizeMul & 0x07U) + 2U));
2505  hsd->SdCard.BlockSize = (1UL << (pCSD->RdBlockLen & 0x0FU));
2506 
2507  hsd->SdCard.LogBlockNbr = (hsd->SdCard.BlockNbr) * ((hsd->SdCard.BlockSize) / 512U);
2508  hsd->SdCard.LogBlockSize = 512U;
2509  }
2510  else if(hsd->SdCard.CardType == CARD_SDHC_SDXC)
2511  {
2512  /* Byte 7 */
2513  pCSD->DeviceSize = (((hsd->CSD[1] & 0x0000003FU) << 16U) | ((hsd->CSD[2] & 0xFFFF0000U) >> 16U));
2514 
2515  hsd->SdCard.BlockNbr = ((pCSD->DeviceSize + 1U) * 1024U);
2516  hsd->SdCard.LogBlockNbr = hsd->SdCard.BlockNbr;
2517  hsd->SdCard.BlockSize = 512U;
2518  hsd->SdCard.LogBlockSize = hsd->SdCard.BlockSize;
2519  }
2520  else
2521  {
2522  /* Clear all the static flags */
2523  __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
2524  hsd->ErrorCode |= HAL_SD_ERROR_UNSUPPORTED_FEATURE;
2525  hsd->State = HAL_SD_STATE_READY;
2526  return HAL_ERROR;
2527  }
2528 
2529  pCSD->EraseGrSize = (uint8_t)((hsd->CSD[2] & 0x00004000U) >> 14U);
2530 
2531  pCSD->EraseGrMul = (uint8_t)((hsd->CSD[2] & 0x00003F80U) >> 7U);
2532 
2533  pCSD->WrProtectGrSize = (uint8_t)(hsd->CSD[2] & 0x0000007FU);
2534 
2535  pCSD->WrProtectGrEnable = (uint8_t)((hsd->CSD[3] & 0x80000000U) >> 31U);
2536 
2537  pCSD->ManDeflECC = (uint8_t)((hsd->CSD[3] & 0x60000000U) >> 29U);
2538 
2539  pCSD->WrSpeedFact = (uint8_t)((hsd->CSD[3] & 0x1C000000U) >> 26U);
2540 
2541  pCSD->MaxWrBlockLen= (uint8_t)((hsd->CSD[3] & 0x03C00000U) >> 22U);
2542 
2543  pCSD->WriteBlockPaPartial = (uint8_t)((hsd->CSD[3] & 0x00200000U) >> 21U);
2544 
2545  pCSD->Reserved3 = 0;
2546 
2547  pCSD->ContentProtectAppli = (uint8_t)((hsd->CSD[3] & 0x00010000U) >> 16U);
2548 
2549  pCSD->FileFormatGroup = (uint8_t)((hsd->CSD[3] & 0x00008000U) >> 15U);
2550 
2551  pCSD->CopyFlag = (uint8_t)((hsd->CSD[3] & 0x00004000U) >> 14U);
2552 
2553  pCSD->PermWrProtect = (uint8_t)((hsd->CSD[3] & 0x00002000U) >> 13U);
2554 
2555  pCSD->TempWrProtect = (uint8_t)((hsd->CSD[3] & 0x00001000U) >> 12U);
2556 
2557  pCSD->FileFormat = (uint8_t)((hsd->CSD[3] & 0x00000C00U) >> 10U);
2558 
2559  pCSD->ECC= (uint8_t)((hsd->CSD[3] & 0x00000300U) >> 8U);
2560 
2561  pCSD->CSD_CRC = (uint8_t)((hsd->CSD[3] & 0x000000FEU) >> 1U);
2562 
2563  pCSD->Reserved4 = 1;
2564 
2565  return HAL_OK;
2566 }
2567 
2575 HAL_StatusTypeDef HAL_SD_GetCardStatus(SD_HandleTypeDef *hsd, HAL_SD_CardStatusTypeDef *pStatus)
2576 {
2577  uint32_t sd_status[16];
2578  uint32_t errorstate;
2579 
2580  errorstate = SD_SendSDStatus(hsd, sd_status);
2581  if(errorstate != HAL_SD_ERROR_NONE)
2582  {
2583  /* Clear all the static flags */
2584  __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
2585  hsd->ErrorCode |= errorstate;
2586  hsd->State = HAL_SD_STATE_READY;
2587  return HAL_ERROR;
2588  }
2589  else
2590  {
2591  pStatus->DataBusWidth = (uint8_t)((sd_status[0] & 0xC0U) >> 6U);
2592 
2593  pStatus->SecuredMode = (uint8_t)((sd_status[0] & 0x20U) >> 5U);
2594 
2595  pStatus->CardType = (uint16_t)(((sd_status[0] & 0x00FF0000U) >> 8U) | ((sd_status[0] & 0xFF000000U) >> 24U));
2596 
2597  pStatus->ProtectedAreaSize = (((sd_status[1] & 0xFFU) << 24U) | ((sd_status[1] & 0xFF00U) << 8U) |
2598  ((sd_status[1] & 0xFF0000U) >> 8U) | ((sd_status[1] & 0xFF000000U) >> 24U));
2599 
2600  pStatus->SpeedClass = (uint8_t)(sd_status[2] & 0xFFU);
2601 
2602  pStatus->PerformanceMove = (uint8_t)((sd_status[2] & 0xFF00U) >> 8U);
2603 
2604  pStatus->AllocationUnitSize = (uint8_t)((sd_status[2] & 0xF00000U) >> 20U);
2605 
2606  pStatus->EraseSize = (uint16_t)(((sd_status[2] & 0xFF000000U) >> 16U) | (sd_status[3] & 0xFFU));
2607 
2608  pStatus->EraseTimeout = (uint8_t)((sd_status[3] & 0xFC00U) >> 10U);
2609 
2610  pStatus->EraseOffset = (uint8_t)((sd_status[3] & 0x0300U) >> 8U);
2611 
2612 #if defined(STM32L4R5xx) || defined(STM32L4R7xx) || defined(STM32L4R9xx) || defined(STM32L4S5xx) || defined(STM32L4S7xx) || defined(STM32L4S9xx)
2613  pStatus->UhsSpeedGrade = (uint8_t)((sd_status[3] & 0x00F0U) >> 4U);
2614  pStatus->UhsAllocationUnitSize = (uint8_t)(sd_status[3] & 0x000FU) ;
2615  pStatus->VideoSpeedClass = (uint8_t)((sd_status[4] & 0xFF000000U) >> 24U);
2616 #endif
2617  }
2618 
2619  return HAL_OK;
2620 }
2621 
2629 HAL_StatusTypeDef HAL_SD_GetCardInfo(SD_HandleTypeDef *hsd, HAL_SD_CardInfoTypeDef *pCardInfo)
2630 {
2631  pCardInfo->CardType = (uint32_t)(hsd->SdCard.CardType);
2632  pCardInfo->CardVersion = (uint32_t)(hsd->SdCard.CardVersion);
2633  pCardInfo->Class = (uint32_t)(hsd->SdCard.Class);
2634  pCardInfo->RelCardAdd = (uint32_t)(hsd->SdCard.RelCardAdd);
2635  pCardInfo->BlockNbr = (uint32_t)(hsd->SdCard.BlockNbr);
2636  pCardInfo->BlockSize = (uint32_t)(hsd->SdCard.BlockSize);
2637  pCardInfo->LogBlockNbr = (uint32_t)(hsd->SdCard.LogBlockNbr);
2638  pCardInfo->LogBlockSize = (uint32_t)(hsd->SdCard.LogBlockSize);
2639 
2640  return HAL_OK;
2641 }
2642 
2654 HAL_StatusTypeDef HAL_SD_ConfigWideBusOperation(SD_HandleTypeDef *hsd, uint32_t WideMode)
2655 {
2656  SDMMC_InitTypeDef Init;
2657  uint32_t errorstate;
2658 
2659  /* Check the parameters */
2660  assert_param(IS_SDMMC_BUS_WIDE(WideMode));
2661 
2662  /* Change State */
2663  hsd->State = HAL_SD_STATE_BUSY;
2664 
2665  if(hsd->SdCard.CardType != CARD_SECURED)
2666  {
2667  if(WideMode == SDMMC_BUS_WIDE_8B)
2668  {
2669  hsd->ErrorCode |= HAL_SD_ERROR_UNSUPPORTED_FEATURE;
2670  }
2671  else if(WideMode == SDMMC_BUS_WIDE_4B)
2672  {
2673  errorstate = SD_WideBus_Enable(hsd);
2674 
2675  hsd->ErrorCode |= errorstate;
2676  }
2677  else if(WideMode == SDMMC_BUS_WIDE_1B)
2678  {
2679  errorstate = SD_WideBus_Disable(hsd);
2680 
2681  hsd->ErrorCode |= errorstate;
2682  }
2683  else
2684  {
2685  /* WideMode is not a valid argument*/
2686  hsd->ErrorCode |= HAL_SD_ERROR_PARAM;
2687  }
2688  }
2689  else
2690  {
2691  /* MMC Card does not support this feature */
2692  hsd->ErrorCode |= HAL_SD_ERROR_UNSUPPORTED_FEATURE;
2693  }
2694 
2695  if(hsd->ErrorCode != HAL_SD_ERROR_NONE)
2696  {
2697  /* Clear all the static flags */
2698  __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
2699  hsd->State = HAL_SD_STATE_READY;
2700  return HAL_ERROR;
2701  }
2702  else
2703  {
2704  /* Configure the SDMMC peripheral */
2705  Init.ClockEdge = hsd->Init.ClockEdge;
2706 #if !defined(STM32L4R5xx) && !defined(STM32L4R7xx) && !defined(STM32L4R9xx) && !defined(STM32L4S5xx) && !defined(STM32L4S7xx) && !defined(STM32L4S9xx)
2707  Init.ClockBypass = hsd->Init.ClockBypass;
2708 #endif /* !STM32L4R5xx && !STM32L4R7xx && !STM32L4R9xx && !STM32L4S5xx && !STM32L4S7xx && !STM32L4S9xx */
2709  Init.ClockPowerSave = hsd->Init.ClockPowerSave;
2710  Init.BusWide = WideMode;
2711  Init.HardwareFlowControl = hsd->Init.HardwareFlowControl;
2712 
2713 #if defined(STM32L4R5xx) || defined(STM32L4R7xx) || defined(STM32L4R9xx) || defined(STM32L4S5xx) || defined(STM32L4S7xx) || defined(STM32L4S9xx)
2714  /* Check if user Clock div < Normal speed 25Mhz, no change in Clockdiv */
2715  if(hsd->Init.ClockDiv >= SDMMC_NSpeed_CLK_DIV)
2716  {
2717  Init.ClockDiv = hsd->Init.ClockDiv;
2718  }
2719  else if (hsd->SdCard.CardSpeed == CARD_ULTRA_HIGH_SPEED)
2720  {
2721  /* UltraHigh speed SD card,user Clock div */
2722  Init.ClockDiv = hsd->Init.ClockDiv;
2723  }
2724  else if (hsd->SdCard.CardSpeed == CARD_HIGH_SPEED)
2725  {
2726  /* High speed SD card, Max Frequency = 50Mhz */
2727  Init.ClockDiv = SDMMC_HSpeed_CLK_DIV;
2728  }
2729  else
2730  {
2731  /* No High speed SD card, Max Frequency = 25Mhz */
2732  Init.ClockDiv = SDMMC_NSpeed_CLK_DIV;
2733  }
2734 #else
2735  Init.ClockDiv = hsd->Init.ClockDiv;
2736 #endif /* STM32L4R5xx || STM32L4R7xx || STM32L4R9xx || STM32L4S5xx || STM32L4S7xx || STM32L4S9xx */
2737 
2738  (void)SDMMC_Init(hsd->Instance, Init);
2739  }
2740 
2741  /* Change State */
2742  hsd->State = HAL_SD_STATE_READY;
2743 
2744  return HAL_OK;
2745 }
2746 
2747 #if defined(STM32L4R5xx) || defined(STM32L4R7xx) || defined(STM32L4R9xx) || defined(STM32L4S5xx) || defined(STM32L4S7xx) || defined(STM32L4S9xx)
2748 
2760 HAL_StatusTypeDef HAL_SD_ConfigSpeedBusOperation(SD_HandleTypeDef *hsd, uint32_t SpeedMode)
2761 {
2762  uint32_t tickstart;
2763  HAL_StatusTypeDef status = HAL_OK;
2764 
2765  /* Check the parameters */
2766  assert_param(IS_SDMMC_SPEED_MODE(SpeedMode));
2767  /* Change State */
2768  hsd->State = HAL_SD_STATE_BUSY;
2769 
2770  if(hsd->Init.Transceiver == SDMMC_TRANSCEIVER_ENABLE)
2771  {
2772  switch (SpeedMode)
2773  {
2774  case SDMMC_SPEED_MODE_AUTO:
2775  {
2776  if ((hsd->SdCard.CardSpeed == CARD_ULTRA_HIGH_SPEED) ||
2777  (hsd->SdCard.CardType == CARD_SDHC_SDXC))
2778  {
2779  hsd->Instance->CLKCR |= 0x00100000U;
2780  /* Enable Ultra High Speed */
2781  if (SD_UltraHighSpeed(hsd) != HAL_SD_ERROR_NONE)
2782  {
2783  if (SD_HighSpeed(hsd) != HAL_SD_ERROR_NONE)
2784  {
2785  hsd->ErrorCode |= HAL_SD_ERROR_UNSUPPORTED_FEATURE;
2786  status = HAL_ERROR;
2787  }
2788  }
2789  }
2790  else if (hsd->SdCard.CardSpeed == CARD_HIGH_SPEED)
2791  {
2792  /* Enable High Speed */
2793  if (SD_HighSpeed(hsd) != HAL_SD_ERROR_NONE)
2794  {
2795  hsd->ErrorCode |= HAL_SD_ERROR_UNSUPPORTED_FEATURE;
2796  status = HAL_ERROR;
2797  }
2798  }
2799  else
2800  {
2801  /*Nothing to do, Use defaultSpeed */
2802  }
2803  break;
2804  }
2805  case SDMMC_SPEED_MODE_ULTRA:
2806  {
2807  if ((hsd->SdCard.CardSpeed == CARD_ULTRA_HIGH_SPEED) ||
2808  (hsd->SdCard.CardType == CARD_SDHC_SDXC))
2809  {
2810  hsd->Instance->CLKCR |= 0x00100000U;
2811  /* Enable UltraHigh Speed */
2812  if (SD_UltraHighSpeed(hsd) != HAL_SD_ERROR_NONE)
2813  {
2814  hsd->ErrorCode |= HAL_SD_ERROR_UNSUPPORTED_FEATURE;
2815  status = HAL_ERROR;
2816  }
2817  }
2818  else
2819  {
2820  hsd->ErrorCode |= HAL_SD_ERROR_UNSUPPORTED_FEATURE;
2821  status = HAL_ERROR;
2822  }
2823  break;
2824  }
2825  case SDMMC_SPEED_MODE_DDR:
2826  {
2827  if ((hsd->SdCard.CardSpeed == CARD_ULTRA_HIGH_SPEED) ||
2828  (hsd->SdCard.CardType == CARD_SDHC_SDXC))
2829  {
2830  hsd->Instance->CLKCR |= 0x00100000U;
2831  /* Enable DDR Mode*/
2832  if (SD_DDR_Mode(hsd) != HAL_SD_ERROR_NONE)
2833  {
2834  hsd->ErrorCode |= HAL_SD_ERROR_UNSUPPORTED_FEATURE;
2835  status = HAL_ERROR;
2836  }
2837  }
2838  else
2839  {
2840  hsd->ErrorCode |= HAL_SD_ERROR_UNSUPPORTED_FEATURE;
2841  status = HAL_ERROR;
2842  }
2843  break;
2844  }
2845  case SDMMC_SPEED_MODE_HIGH:
2846  {
2847  if ((hsd->SdCard.CardSpeed == CARD_ULTRA_HIGH_SPEED) ||
2848  (hsd->SdCard.CardSpeed == CARD_HIGH_SPEED) ||
2849  (hsd->SdCard.CardType == CARD_SDHC_SDXC))
2850  {
2851  /* Enable High Speed */
2852  if (SD_HighSpeed(hsd) != HAL_SD_ERROR_NONE)
2853  {
2854  hsd->ErrorCode |= HAL_SD_ERROR_UNSUPPORTED_FEATURE;
2855  status = HAL_ERROR;
2856  }
2857  }
2858  else
2859  {
2860  hsd->ErrorCode |= HAL_SD_ERROR_UNSUPPORTED_FEATURE;
2861  status = HAL_ERROR;
2862  }
2863  break;
2864  }
2865  case SDMMC_SPEED_MODE_DEFAULT:
2866  break;
2867  default:
2868  hsd->ErrorCode |= HAL_SD_ERROR_PARAM;
2869  status = HAL_ERROR;
2870  break;
2871  }
2872  }
2873  else
2874  {
2875  switch (SpeedMode)
2876  {
2877  case SDMMC_SPEED_MODE_AUTO:
2878  {
2879  if ((hsd->SdCard.CardSpeed == CARD_ULTRA_HIGH_SPEED) ||
2880  (hsd->SdCard.CardSpeed == CARD_HIGH_SPEED) ||
2881  (hsd->SdCard.CardType == CARD_SDHC_SDXC))
2882  {
2883  /* Enable High Speed */
2884  if (SD_HighSpeed(hsd) != HAL_SD_ERROR_NONE)
2885  {
2886  hsd->ErrorCode |= HAL_SD_ERROR_UNSUPPORTED_FEATURE;
2887  status = HAL_ERROR;
2888  }
2889  }
2890  else
2891  {
2892  /*Nothing to do, Use defaultSpeed */
2893  }
2894  break;
2895  }
2896  case SDMMC_SPEED_MODE_HIGH:
2897  {
2898  if ((hsd->SdCard.CardSpeed == CARD_ULTRA_HIGH_SPEED) ||
2899  (hsd->SdCard.CardSpeed == CARD_HIGH_SPEED) ||
2900  (hsd->SdCard.CardType == CARD_SDHC_SDXC))
2901  {
2902  /* Enable High Speed */
2903  if (SD_HighSpeed(hsd) != HAL_SD_ERROR_NONE)
2904  {
2905  hsd->ErrorCode |= HAL_SD_ERROR_UNSUPPORTED_FEATURE;
2906  status = HAL_ERROR;
2907  }
2908  }
2909  else
2910  {
2911  hsd->ErrorCode |= HAL_SD_ERROR_UNSUPPORTED_FEATURE;
2912  status = HAL_ERROR;
2913  }
2914  break;
2915  }
2916  case SDMMC_SPEED_MODE_DEFAULT:
2917  break;
2918  case SDMMC_SPEED_MODE_ULTRA: /*not valid without transceiver*/
2919  default:
2920  hsd->ErrorCode |= HAL_SD_ERROR_PARAM;
2921  status = HAL_ERROR;
2922  break;
2923  }
2924  }
2925 
2926 
2927  /* Verify that SD card is ready to use after Speed mode switch*/
2928  tickstart = HAL_GetTick();
2929  while ((HAL_SD_GetCardState(hsd) != HAL_SD_CARD_TRANSFER))
2930  {
2931  if ((HAL_GetTick() - tickstart) >= SDMMC_DATATIMEOUT)
2932  {
2933  hsd->ErrorCode = HAL_SD_ERROR_TIMEOUT;
2934  hsd->State = HAL_SD_STATE_READY;
2935  return HAL_TIMEOUT;
2936  }
2937  }
2938 
2939  /* Change State */
2940  hsd->State = HAL_SD_STATE_READY;
2941  return status;
2942 }
2943 #endif /* STM32L4R5xx || STM32L4R7xx || STM32L4R9xx || STM32L4S5xx || STM32L4S7xx || STM32L4S9xx */
2944 
2950 HAL_SD_CardStateTypeDef HAL_SD_GetCardState(SD_HandleTypeDef *hsd)
2951 {
2952  uint32_t cardstate;
2953  uint32_t errorstate;
2954  uint32_t resp1 = 0;
2955 
2956  errorstate = SD_SendStatus(hsd, &resp1);
2957  if(errorstate != HAL_SD_ERROR_NONE)
2958  {
2959  hsd->ErrorCode |= errorstate;
2960  }
2961 
2962  cardstate = ((resp1 >> 9U) & 0x0FU);
2963 
2964  return (HAL_SD_CardStateTypeDef)cardstate;
2965 }
2966 
2973 HAL_StatusTypeDef HAL_SD_Abort(SD_HandleTypeDef *hsd)
2974 {
2975  HAL_SD_CardStateTypeDef CardState;
2976 #if !defined(STM32L4R5xx) && !defined(STM32L4R7xx) && !defined(STM32L4R9xx) && !defined(STM32L4S5xx) && !defined(STM32L4S7xx) && !defined(STM32L4S9xx)
2977  uint32_t context = hsd->Context;
2978 #endif
2979 
2980  /* DIsable All interrupts */
2981  __HAL_SD_DISABLE_IT(hsd, SDMMC_IT_DATAEND | SDMMC_IT_DCRCFAIL | SDMMC_IT_DTIMEOUT|\
2982  SDMMC_IT_TXUNDERR| SDMMC_IT_RXOVERR);
2983 
2984  /* Clear All flags */
2985  __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_DATA_FLAGS);
2986 
2987 #if defined(STM32L4R5xx) || defined(STM32L4R7xx) || defined(STM32L4R9xx) || defined(STM32L4S5xx) || defined(STM32L4S7xx) || defined(STM32L4S9xx)
2988  /* If IDMA Context, disable Internal DMA */
2989  hsd->Instance->IDMACTRL = SDMMC_DISABLE_IDMA;
2990 #else
2991  CLEAR_BIT(hsd->Instance->DCTRL, SDMMC_DCTRL_DTEN);
2992 
2993  if ((context & SD_CONTEXT_DMA) != 0U)
2994  {
2995  /* Disable the SD DMA request */
2996  hsd->Instance->DCTRL &= (uint32_t)~((uint32_t)SDMMC_DCTRL_DMAEN);
2997 
2998  /* Abort the SD DMA Tx channel */
2999  if (((context & SD_CONTEXT_WRITE_SINGLE_BLOCK) != 0U) || ((context & SD_CONTEXT_WRITE_MULTIPLE_BLOCK) != 0U))
3000  {
3001  if(HAL_DMA_Abort(hsd->hdmatx) != HAL_OK)
3002  {
3003  hsd->ErrorCode |= HAL_SD_ERROR_DMA;
3004  }
3005  }
3006  /* Abort the SD DMA Rx channel */
3007  else if (((context & SD_CONTEXT_READ_SINGLE_BLOCK) != 0U) || ((context & SD_CONTEXT_READ_MULTIPLE_BLOCK) != 0U))
3008  {
3009  if(HAL_DMA_Abort(hsd->hdmarx) != HAL_OK)
3010  {
3011  hsd->ErrorCode |= HAL_SD_ERROR_DMA;
3012  }
3013  }
3014  else
3015  {
3016  /* Nothing to do */
3017  }
3018  }
3019 #endif /* STM32L4R5xx || STM32L4R7xx || STM32L4R9xx || STM32L4S5xx || STM32L4S7xx || STM32L4S9xx */
3020 
3021  hsd->State = HAL_SD_STATE_READY;
3022 
3023  /* Initialize the SD operation */
3024  hsd->Context = SD_CONTEXT_NONE;
3025 
3026  CardState = HAL_SD_GetCardState(hsd);
3027  if((CardState == HAL_SD_CARD_RECEIVING) || (CardState == HAL_SD_CARD_SENDING))
3028  {
3029  hsd->ErrorCode = SDMMC_CmdStopTransfer(hsd->Instance);
3030  }
3031  if(hsd->ErrorCode != HAL_SD_ERROR_NONE)
3032  {
3033  return HAL_ERROR;
3034  }
3035  return HAL_OK;
3036 }
3037 
3044 HAL_StatusTypeDef HAL_SD_Abort_IT(SD_HandleTypeDef *hsd)
3045 {
3046  HAL_SD_CardStateTypeDef CardState;
3047 #if !defined(STM32L4R5xx) && !defined(STM32L4R7xx) && !defined(STM32L4R9xx) && !defined(STM32L4S5xx) && !defined(STM32L4S7xx) && !defined(STM32L4S9xx)
3048  uint32_t context = hsd->Context;
3049 #endif
3050 
3051  /* Disable All interrupts */
3052  __HAL_SD_DISABLE_IT(hsd, SDMMC_IT_DATAEND | SDMMC_IT_DCRCFAIL | SDMMC_IT_DTIMEOUT|\
3053  SDMMC_IT_TXUNDERR| SDMMC_IT_RXOVERR);
3054 
3055 #if defined(STM32L4R5xx) || defined(STM32L4R7xx) || defined(STM32L4R9xx) || defined(STM32L4S5xx) || defined(STM32L4S7xx) || defined(STM32L4S9xx)
3056  /* If IDMA Context, disable Internal DMA */
3057  hsd->Instance->IDMACTRL = SDMMC_DISABLE_IDMA;
3058 
3059  /* Clear All flags */
3060  __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_DATA_FLAGS);
3061 
3062  CardState = HAL_SD_GetCardState(hsd);
3063  hsd->State = HAL_SD_STATE_READY;
3064 
3065  if((CardState == HAL_SD_CARD_RECEIVING) || (CardState == HAL_SD_CARD_SENDING))
3066  {
3067  hsd->ErrorCode = SDMMC_CmdStopTransfer(hsd->Instance);
3068  }
3069 
3070  if(hsd->ErrorCode != HAL_SD_ERROR_NONE)
3071  {
3072  return HAL_ERROR;
3073  }
3074  else
3075  {
3076 #if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
3077  hsd->AbortCpltCallback(hsd);
3078 #else
3079  HAL_SD_AbortCallback(hsd);
3080 #endif /* USE_HAL_SD_REGISTER_CALLBACKS */
3081  }
3082 #else
3083  CLEAR_BIT(hsd->Instance->DCTRL, SDMMC_DCTRL_DTEN);
3084 
3085  if ((context & SD_CONTEXT_DMA) != 0U)
3086  {
3087  /* Disable the SD DMA request */
3088  hsd->Instance->DCTRL &= (uint32_t)~((uint32_t)SDMMC_DCTRL_DMAEN);
3089 
3090  /* Abort the SD DMA Tx channel */
3091  if (((context & SD_CONTEXT_WRITE_SINGLE_BLOCK) != 0U) || ((context & SD_CONTEXT_WRITE_MULTIPLE_BLOCK) != 0U))
3092  {
3093  hsd->hdmatx->XferAbortCallback = SD_DMATxAbort;
3094  if(HAL_DMA_Abort_IT(hsd->hdmatx) != HAL_OK)
3095  {
3096  hsd->hdmatx = NULL;
3097  }
3098  }
3099  /* Abort the SD DMA Rx channel */
3100  else if (((context & SD_CONTEXT_READ_SINGLE_BLOCK) != 0U) || ((context & SD_CONTEXT_READ_MULTIPLE_BLOCK) != 0U))
3101  {
3102  hsd->hdmarx->XferAbortCallback = SD_DMARxAbort;
3103  if(HAL_DMA_Abort_IT(hsd->hdmarx) != HAL_OK)
3104  {
3105  hsd->hdmarx = NULL;
3106  }
3107  }
3108  else
3109  {
3110  /* Nothing to do */
3111  }
3112  }
3113  /* No transfer ongoing on both DMA channels*/
3114  else
3115  {
3116  /* Clear All flags */
3117  __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_DATA_FLAGS);
3118 
3119  CardState = HAL_SD_GetCardState(hsd);
3120  hsd->State = HAL_SD_STATE_READY;
3121  hsd->Context = SD_CONTEXT_NONE;
3122  if((CardState == HAL_SD_CARD_RECEIVING) || (CardState == HAL_SD_CARD_SENDING))
3123  {
3124  hsd->ErrorCode = SDMMC_CmdStopTransfer(hsd->Instance);
3125  }
3126  if(hsd->ErrorCode != HAL_SD_ERROR_NONE)
3127  {
3128  return HAL_ERROR;
3129  }
3130  else
3131  {
3132 #if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
3133  hsd->AbortCpltCallback(hsd);
3134 #else
3135  HAL_SD_AbortCallback(hsd);
3136 #endif /* USE_HAL_SD_REGISTER_CALLBACKS */
3137  }
3138  }
3139 #endif /* STM32L4R5xx || STM32L4R7xx || STM32L4R9xx || STM32L4S5xx || STM32L4S7xx || STM32L4S9xx */
3140 
3141  return HAL_OK;
3142 }
3143 
3152 /* Private function ----------------------------------------------------------*/
3157 #if !defined(STM32L4R5xx) && !defined(STM32L4R7xx) && !defined(STM32L4R9xx) && !defined(STM32L4S5xx) && !defined(STM32L4S7xx) && !defined(STM32L4S9xx)
3158 
3163 static void SD_DMATransmitCplt(DMA_HandleTypeDef *hdma)
3164 {
3165  SD_HandleTypeDef* hsd = (SD_HandleTypeDef* )(hdma->Parent);
3166 
3167  /* Enable DATAEND Interrupt */
3168  __HAL_SD_ENABLE_IT(hsd, (SDMMC_IT_DATAEND));
3169 }
3170 
3176 static void SD_DMAReceiveCplt(DMA_HandleTypeDef *hdma)
3177 {
3178  SD_HandleTypeDef* hsd = (SD_HandleTypeDef* )(hdma->Parent);
3179  uint32_t errorstate;
3180 
3181  /* Send stop command in multiblock write */
3182  if(hsd->Context == (SD_CONTEXT_READ_MULTIPLE_BLOCK | SD_CONTEXT_DMA))
3183  {
3184  errorstate = SDMMC_CmdStopTransfer(hsd->Instance);
3185  if(errorstate != HAL_SD_ERROR_NONE)
3186  {
3187  hsd->ErrorCode |= errorstate;
3188 #if (USE_HAL_SD_REGISTER_CALLBACKS == 1)
3189  hsd->ErrorCallback(hsd);
3190 #else
3191  HAL_SD_ErrorCallback(hsd);
3192 #endif
3193  }
3194  }
3195 
3196  /* Disable the DMA transfer for transmit request by setting the DMAEN bit
3197  in the SD DCTRL register */
3198  hsd->Instance->DCTRL &= (uint32_t)~((uint32_t)SDMMC_DCTRL_DMAEN);
3199 
3200  /* Clear all the static flags */
3201  __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_DATA_FLAGS);
3202 
3203  hsd->State = HAL_SD_STATE_READY;
3204  hsd->Context = SD_CONTEXT_NONE;
3205 
3206 #if (USE_HAL_SD_REGISTER_CALLBACKS == 1)
3207  hsd->RxCpltCallback(hsd);
3208 #else
3209  HAL_SD_RxCpltCallback(hsd);
3210 #endif
3211 }
3212 
3218 static void SD_DMAError(DMA_HandleTypeDef *hdma)
3219 {
3220  SD_HandleTypeDef* hsd = (SD_HandleTypeDef* )(hdma->Parent);
3221  HAL_SD_CardStateTypeDef CardState;
3222  uint32_t RxErrorCode, TxErrorCode;
3223 
3224  RxErrorCode = hsd->hdmarx->ErrorCode;
3225  TxErrorCode = hsd->hdmatx->ErrorCode;
3226  if((RxErrorCode == HAL_DMA_ERROR_TE) || (TxErrorCode == HAL_DMA_ERROR_TE))
3227  {
3228  /* Clear All flags */
3229  __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
3230 
3231  /* Disable All interrupts */
3232  __HAL_SD_DISABLE_IT(hsd, SDMMC_IT_DATAEND | SDMMC_IT_DCRCFAIL | SDMMC_IT_DTIMEOUT|\
3233  SDMMC_IT_TXUNDERR| SDMMC_IT_RXOVERR);
3234 
3235  hsd->ErrorCode |= HAL_SD_ERROR_DMA;
3236  CardState = HAL_SD_GetCardState(hsd);
3237  if((CardState == HAL_SD_CARD_RECEIVING) || (CardState == HAL_SD_CARD_SENDING))
3238  {
3239  hsd->ErrorCode |= SDMMC_CmdStopTransfer(hsd->Instance);
3240  }
3241 
3242  hsd->State= HAL_SD_STATE_READY;
3243  hsd->Context = SD_CONTEXT_NONE;
3244  }
3245 
3246 #if (USE_HAL_SD_REGISTER_CALLBACKS == 1)
3247  hsd->ErrorCallback(hsd);
3248 #else
3249  HAL_SD_ErrorCallback(hsd);
3250 #endif
3251 }
3252 
3258 static void SD_DMATxAbort(DMA_HandleTypeDef *hdma)
3259 {
3260  SD_HandleTypeDef* hsd = (SD_HandleTypeDef* )(hdma->Parent);
3261  HAL_SD_CardStateTypeDef CardState;
3262 
3263  /* Clear All flags */
3264  __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_DATA_FLAGS);
3265 
3266  CardState = HAL_SD_GetCardState(hsd);
3267  hsd->State = HAL_SD_STATE_READY;
3268  hsd->Context = SD_CONTEXT_NONE;
3269  if((CardState == HAL_SD_CARD_RECEIVING) || (CardState == HAL_SD_CARD_SENDING))
3270  {
3271  hsd->ErrorCode |= SDMMC_CmdStopTransfer(hsd->Instance);
3272  }
3273 
3274  if(hsd->ErrorCode == HAL_SD_ERROR_NONE)
3275  {
3276 #if (USE_HAL_SD_REGISTER_CALLBACKS == 1)
3277  hsd->AbortCpltCallback(hsd);
3278 #else
3279  HAL_SD_AbortCallback(hsd);
3280 #endif
3281  }
3282  else
3283  {
3284 #if (USE_HAL_SD_REGISTER_CALLBACKS == 1)
3285  hsd->ErrorCallback(hsd);
3286 #else
3287  HAL_SD_ErrorCallback(hsd);
3288 #endif
3289  }
3290 }
3291 
3297 static void SD_DMARxAbort(DMA_HandleTypeDef *hdma)
3298 {
3299  SD_HandleTypeDef* hsd = (SD_HandleTypeDef* )(hdma->Parent);
3300  HAL_SD_CardStateTypeDef CardState;
3301 
3302  /* Clear All flags */
3303  __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_DATA_FLAGS);
3304 
3305  CardState = HAL_SD_GetCardState(hsd);
3306  hsd->State = HAL_SD_STATE_READY;
3307  hsd->Context = SD_CONTEXT_NONE;
3308  if((CardState == HAL_SD_CARD_RECEIVING) || (CardState == HAL_SD_CARD_SENDING))
3309  {
3310  hsd->ErrorCode |= SDMMC_CmdStopTransfer(hsd->Instance);
3311  }
3312 
3313  if(hsd->ErrorCode == HAL_SD_ERROR_NONE)
3314  {
3315 #if (USE_HAL_SD_REGISTER_CALLBACKS == 1)
3316  hsd->AbortCpltCallback(hsd);
3317 #else
3318  HAL_SD_AbortCallback(hsd);
3319 #endif
3320  }
3321  else
3322  {
3323 #if (USE_HAL_SD_REGISTER_CALLBACKS == 1)
3324  hsd->ErrorCallback(hsd);
3325 #else
3326  HAL_SD_ErrorCallback(hsd);
3327 #endif
3328  }
3329 }
3330 #endif /* !STM32L4R5xx && !STM32L4R7xx && !STM32L4R9xx && !STM32L4S5xx && !STM32L4S7xx && !STM32L4S9xx */
3331 
3337 static uint32_t SD_InitCard(SD_HandleTypeDef *hsd)
3338 {
3339  HAL_SD_CardCSDTypeDef CSD;
3340  uint32_t errorstate;
3341  uint16_t sd_rca = 1U;
3342 
3343  /* Check the power State */
3344  if(SDMMC_GetPowerState(hsd->Instance) == 0U)
3345  {
3346  /* Power off */
3347  return HAL_SD_ERROR_REQUEST_NOT_APPLICABLE;
3348  }
3349 
3350  if(hsd->SdCard.CardType != CARD_SECURED)
3351  {
3352  /* Send CMD2 ALL_SEND_CID */
3353  errorstate = SDMMC_CmdSendCID(hsd->Instance);
3354  if(errorstate != HAL_SD_ERROR_NONE)
3355  {
3356  return errorstate;
3357  }
3358  else
3359  {
3360  /* Get Card identification number data */
3361  hsd->CID[0U] = SDMMC_GetResponse(hsd->Instance, SDMMC_RESP1);
3362  hsd->CID[1U] = SDMMC_GetResponse(hsd->Instance, SDMMC_RESP2);
3363  hsd->CID[2U] = SDMMC_GetResponse(hsd->Instance, SDMMC_RESP3);
3364  hsd->CID[3U] = SDMMC_GetResponse(hsd->Instance, SDMMC_RESP4);
3365  }
3366  }
3367 
3368  if(hsd->SdCard.CardType != CARD_SECURED)
3369  {
3370  /* Send CMD3 SET_REL_ADDR with argument 0 */
3371  /* SD Card publishes its RCA. */
3372  errorstate = SDMMC_CmdSetRelAdd(hsd->Instance, &sd_rca);
3373  if(errorstate != HAL_SD_ERROR_NONE)
3374  {
3375  return errorstate;
3376  }
3377  }
3378  if(hsd->SdCard.CardType != CARD_SECURED)
3379  {
3380  /* Get the SD card RCA */
3381  hsd->SdCard.RelCardAdd = sd_rca;
3382 
3383  /* Send CMD9 SEND_CSD with argument as card's RCA */
3384  errorstate = SDMMC_CmdSendCSD(hsd->Instance, (uint32_t)(hsd->SdCard.RelCardAdd << 16U));
3385  if(errorstate != HAL_SD_ERROR_NONE)
3386  {
3387  return errorstate;
3388  }
3389  else
3390  {
3391  /* Get Card Specific Data */
3392  hsd->CSD[0U] = SDMMC_GetResponse(hsd->Instance, SDMMC_RESP1);
3393  hsd->CSD[1U] = SDMMC_GetResponse(hsd->Instance, SDMMC_RESP2);
3394  hsd->CSD[2U] = SDMMC_GetResponse(hsd->Instance, SDMMC_RESP3);
3395  hsd->CSD[3U] = SDMMC_GetResponse(hsd->Instance, SDMMC_RESP4);
3396  }
3397  }
3398 
3399  /* Get the Card Class */
3400  hsd->SdCard.Class = (SDMMC_GetResponse(hsd->Instance, SDMMC_RESP2) >> 20U);
3401 
3402  /* Get CSD parameters */
3403  if (HAL_SD_GetCardCSD(hsd, &CSD) != HAL_OK)
3404  {
3405  return HAL_SD_ERROR_UNSUPPORTED_FEATURE;
3406  }
3407 
3408  /* Select the Card */
3409  errorstate = SDMMC_CmdSelDesel(hsd->Instance, (uint32_t)(((uint32_t)hsd->SdCard.RelCardAdd) << 16U));
3410  if(errorstate != HAL_SD_ERROR_NONE)
3411  {
3412  return errorstate;
3413  }
3414 
3415 #if !defined(STM32L4R5xx) && !defined(STM32L4R7xx) && !defined(STM32L4R9xx) && !defined(STM32L4S5xx) && !defined(STM32L4S7xx) && !defined(STM32L4S9xx)
3416  /* Configure SDMMC peripheral interface */
3417  (void)SDMMC_Init(hsd->Instance, hsd->Init);
3418 #endif /* !STM32L4R5xx && !STM32L4R7xx && !STM32L4R9xx && !STM32L4S5xx && !STM32L4S7xx && !STM32L4S9xx */
3419 
3420  /* All cards are initialized */
3421  return HAL_SD_ERROR_NONE;
3422 }
3423 
3431 static uint32_t SD_PowerON(SD_HandleTypeDef *hsd)
3432 {
3433  __IO uint32_t count = 0U;
3434  uint32_t response = 0U, validvoltage = 0U;
3435  uint32_t errorstate;
3436 #if defined(STM32L4R5xx) || defined(STM32L4R7xx) || defined(STM32L4R9xx) || defined(STM32L4S5xx) || defined(STM32L4S7xx) || defined(STM32L4S9xx)
3437  uint32_t tickstart = HAL_GetTick();
3438 #endif /* STM32L4R5xx || STM32L4R7xx || STM32L4R9xx || STM32L4S5xx || STM32L4S7xx || STM32L4S9xx */
3439 
3440  /* CMD0: GO_IDLE_STATE */
3441  errorstate = SDMMC_CmdGoIdleState(hsd->Instance);
3442  if(errorstate != HAL_SD_ERROR_NONE)
3443  {
3444  return errorstate;
3445  }
3446 
3447  /* CMD8: SEND_IF_COND: Command available only on V2.0 cards */
3448  errorstate = SDMMC_CmdOperCond(hsd->Instance);
3449  if(errorstate != HAL_SD_ERROR_NONE)
3450  {
3451  hsd->SdCard.CardVersion = CARD_V1_X;
3452  /* CMD0: GO_IDLE_STATE */
3453  errorstate = SDMMC_CmdGoIdleState(hsd->Instance);
3454  if(errorstate != HAL_SD_ERROR_NONE)
3455  {
3456  return errorstate;
3457  }
3458 
3459  }
3460  else
3461  {
3462  hsd->SdCard.CardVersion = CARD_V2_X;
3463  }
3464 
3465  if( hsd->SdCard.CardVersion == CARD_V2_X)
3466  {
3467  /* SEND CMD55 APP_CMD with RCA as 0 */
3468  errorstate = SDMMC_CmdAppCommand(hsd->Instance, 0);
3469  if(errorstate != HAL_SD_ERROR_NONE)
3470  {
3471  return HAL_SD_ERROR_UNSUPPORTED_FEATURE;
3472  }
3473  }
3474  /* SD CARD */
3475  /* Send ACMD41 SD_APP_OP_COND with Argument 0x80100000 */
3476  while((count < SDMMC_MAX_VOLT_TRIAL) && (validvoltage == 0U))
3477  {
3478  /* SEND CMD55 APP_CMD with RCA as 0 */
3479  errorstate = SDMMC_CmdAppCommand(hsd->Instance, 0);
3480  if(errorstate != HAL_SD_ERROR_NONE)
3481  {
3482  return errorstate;
3483  }
3484 
3485  /* Send CMD41 */
3486  errorstate = SDMMC_CmdAppOperCommand(hsd->Instance, SDMMC_VOLTAGE_WINDOW_SD | SDMMC_HIGH_CAPACITY | SD_SWITCH_1_8V_CAPACITY);
3487  if(errorstate != HAL_SD_ERROR_NONE)
3488  {
3489  return HAL_SD_ERROR_UNSUPPORTED_FEATURE;
3490  }
3491 
3492  /* Get command response */
3493  response = SDMMC_GetResponse(hsd->Instance, SDMMC_RESP1);
3494 
3495  /* Get operating voltage*/
3496  validvoltage = (((response >> 31U) == 1U) ? 1U : 0U);
3497 
3498  count++;
3499  }
3500 
3501  if(count >= SDMMC_MAX_VOLT_TRIAL)
3502  {
3503  return HAL_SD_ERROR_INVALID_VOLTRANGE;
3504  }
3505 
3506  if((response & SDMMC_HIGH_CAPACITY) == SDMMC_HIGH_CAPACITY) /* (response &= SD_HIGH_CAPACITY) */
3507  {
3508  hsd->SdCard.CardType = CARD_SDHC_SDXC;
3509 #if defined(STM32L4R5xx) || defined(STM32L4R7xx) || defined(STM32L4R9xx) || defined(STM32L4S5xx) || defined(STM32L4S7xx) || defined(STM32L4S9xx)
3510  if(hsd->Init.Transceiver == SDMMC_TRANSCEIVER_ENABLE)
3511  {
3512  if((response & SD_SWITCH_1_8V_CAPACITY) == SD_SWITCH_1_8V_CAPACITY)
3513  {
3514  hsd->SdCard.CardSpeed = CARD_ULTRA_HIGH_SPEED;
3515 
3516  /* Start switching procedue */
3517  hsd->Instance->POWER |= SDMMC_POWER_VSWITCHEN;
3518 
3519  /* Send CMD11 to switch 1.8V mode */
3520  errorstate = SDMMC_CmdVoltageSwitch(hsd->Instance);
3521  if(errorstate != HAL_SD_ERROR_NONE)
3522  {
3523  return errorstate;
3524  }
3525 
3526  /* Check to CKSTOP */
3527  while(( hsd->Instance->STA & SDMMC_FLAG_CKSTOP) != SDMMC_FLAG_CKSTOP)
3528  {
3529  if((HAL_GetTick() - tickstart) >= SDMMC_DATATIMEOUT)
3530  {
3531  return HAL_SD_ERROR_TIMEOUT;
3532  }
3533  }
3534 
3535  /* Clear CKSTOP Flag */
3536  hsd->Instance->ICR = SDMMC_FLAG_CKSTOP;
3537 
3538  /* Check to BusyD0 */
3539  if(( hsd->Instance->STA & SDMMC_FLAG_BUSYD0) != SDMMC_FLAG_BUSYD0)
3540  {
3541  /* Error when activate Voltage Switch in SDMMC Peripheral */
3542  return SDMMC_ERROR_UNSUPPORTED_FEATURE;
3543  }
3544  else
3545  {
3546  /* Enable Transceiver Switch PIN */
3547 #if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
3548  hsd->DriveTransceiver_1_8V_Callback(SET);
3549 #else
3550  HAL_SDEx_DriveTransceiver_1_8V_Callback(SET);
3551 #endif
3552 
3553  /* Switch ready */
3554  hsd->Instance->POWER |= SDMMC_POWER_VSWITCH;
3555 
3556  /* Check VSWEND Flag */
3557  while(( hsd->Instance->STA & SDMMC_FLAG_VSWEND) != SDMMC_FLAG_VSWEND)
3558  {
3559  if((HAL_GetTick() - tickstart) >= SDMMC_DATATIMEOUT)
3560  {
3561  return HAL_SD_ERROR_TIMEOUT;
3562  }
3563  }
3564 
3565  /* Clear VSWEND Flag */
3566  hsd->Instance->ICR = SDMMC_FLAG_VSWEND;
3567 
3568  /* Check BusyD0 status */
3569  if(( hsd->Instance->STA & SDMMC_FLAG_BUSYD0) == SDMMC_FLAG_BUSYD0)
3570  {
3571  /* Error when enabling 1.8V mode */
3572  return HAL_SD_ERROR_INVALID_VOLTRANGE;
3573  }
3574  /* Switch to 1.8V OK */
3575 
3576  /* Disable VSWITCH FLAG from SDMMC Peripheral */
3577  hsd->Instance->POWER = 0x13U;
3578 
3579  /* Clean Status flags */
3580  hsd->Instance->ICR = 0xFFFFFFFFU;
3581  }
3582 
3583  hsd->SdCard.CardSpeed = CARD_ULTRA_HIGH_SPEED;
3584  }
3585  }
3586 #endif /* STM32L4R5xx || STM32L4R7xx || STM32L4R9xx || STM32L4S5xx || STM32L4S7xx || STM32L4S9xx */
3587  }
3588  else
3589  {
3590  hsd->SdCard.CardType = CARD_SDSC;
3591  }
3592 
3593 
3594  return HAL_SD_ERROR_NONE;
3595 }
3596 
3602 static void SD_PowerOFF(SD_HandleTypeDef *hsd)
3603 {
3604  /* Set Power State to OFF */
3605  (void)SDMMC_PowerState_OFF(hsd->Instance);
3606 }
3607 
3615 static uint32_t SD_SendSDStatus(SD_HandleTypeDef *hsd, uint32_t *pSDstatus)
3616 {
3617  SDMMC_DataInitTypeDef config;
3618  uint32_t errorstate;
3619  uint32_t tickstart = HAL_GetTick();
3620  uint32_t count;
3621  uint32_t *pData = pSDstatus;
3622 
3623  /* Check SD response */
3624  if((SDMMC_GetResponse(hsd->Instance, SDMMC_RESP1) & SDMMC_CARD_LOCKED) == SDMMC_CARD_LOCKED)
3625  {
3626  return HAL_SD_ERROR_LOCK_UNLOCK_FAILED;
3627  }
3628 
3629  /* Set block size for card if it is not equal to current block size for card */
3630  errorstate = SDMMC_CmdBlockLength(hsd->Instance, 64U);
3631  if(errorstate != HAL_SD_ERROR_NONE)
3632  {
3633  hsd->ErrorCode |= HAL_SD_ERROR_NONE;
3634  return errorstate;
3635  }
3636 
3637  /* Send CMD55 */
3638  errorstate = SDMMC_CmdAppCommand(hsd->Instance, (uint32_t)(hsd->SdCard.RelCardAdd << 16U));
3639  if(errorstate != HAL_SD_ERROR_NONE)
3640  {
3641  hsd->ErrorCode |= HAL_SD_ERROR_NONE;
3642  return errorstate;
3643  }
3644 
3645  /* Configure the SD DPSM (Data Path State Machine) */
3646  config.DataTimeOut = SDMMC_DATATIMEOUT;
3647  config.DataLength = 64U;
3648  config.DataBlockSize = SDMMC_DATABLOCK_SIZE_64B;
3649  config.TransferDir = SDMMC_TRANSFER_DIR_TO_SDMMC;
3650  config.TransferMode = SDMMC_TRANSFER_MODE_BLOCK;
3651  config.DPSM = SDMMC_DPSM_ENABLE;
3652  (void)SDMMC_ConfigData(hsd->Instance, &config);
3653 
3654  /* Send ACMD13 (SD_APP_STAUS) with argument as card's RCA */
3655  errorstate = SDMMC_CmdStatusRegister(hsd->Instance);
3656  if(errorstate != HAL_SD_ERROR_NONE)
3657  {
3658  hsd->ErrorCode |= HAL_SD_ERROR_NONE;
3659  return errorstate;
3660  }
3661 
3662  /* Get status data */
3663 #if defined(STM32L4R5xx) || defined(STM32L4R7xx) || defined(STM32L4R9xx) || defined(STM32L4S5xx) || defined(STM32L4S7xx) || defined(STM32L4S9xx)
3664  while(!__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXOVERR | SDMMC_FLAG_DCRCFAIL | SDMMC_FLAG_DTIMEOUT | SDMMC_FLAG_DATAEND))
3665 #else
3666  while(!__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXOVERR | SDMMC_FLAG_DCRCFAIL | SDMMC_FLAG_DTIMEOUT | SDMMC_FLAG_DBCKEND))
3667 #endif /* STM32L4R5xx || STM32L4R7xx || STM32L4R9xx || STM32L4S5xx || STM32L4S7xx || STM32L4S9xx */
3668  {
3669  if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXFIFOHF))
3670  {
3671  for(count = 0U; count < 8U; count++)
3672  {
3673  *pData = SDMMC_ReadFIFO(hsd->Instance);
3674  pData++;
3675  }
3676  }
3677 
3678  if((HAL_GetTick() - tickstart) >= SDMMC_DATATIMEOUT)
3679  {
3680  return HAL_SD_ERROR_TIMEOUT;
3681  }
3682  }
3683 
3684  if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DTIMEOUT))
3685  {
3686  return HAL_SD_ERROR_DATA_TIMEOUT;
3687  }
3688  else if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DCRCFAIL))
3689  {
3690  return HAL_SD_ERROR_DATA_CRC_FAIL;
3691  }
3692  else if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXOVERR))
3693  {
3694  return HAL_SD_ERROR_RX_OVERRUN;
3695  }
3696  else
3697  {
3698  /* Nothing to do */
3699  }
3700 
3701 #if defined(STM32L4R5xx) || defined(STM32L4R7xx) || defined(STM32L4R9xx) || defined(STM32L4S5xx) || defined(STM32L4S7xx) || defined(STM32L4S9xx)
3702  while ((__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DPSMACT)))
3703 #else
3704  while ((__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXDAVL)))
3705 #endif /* STM32L4R5xx || STM32L4R7xx || STM32L4R9xx || STM32L4S5xx || STM32L4S7xx || STM32L4S9xx */
3706  {
3707  *pData = SDMMC_ReadFIFO(hsd->Instance);
3708  pData++;
3709 
3710  if((HAL_GetTick() - tickstart) >= SDMMC_DATATIMEOUT)
3711  {
3712  return HAL_SD_ERROR_TIMEOUT;
3713  }
3714  }
3715 
3716  /* Clear all the static status flags*/
3717  __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_DATA_FLAGS);
3718 
3719  return HAL_SD_ERROR_NONE;
3720 }
3721 
3729 static uint32_t SD_SendStatus(SD_HandleTypeDef *hsd, uint32_t *pCardStatus)
3730 {
3731  uint32_t errorstate;
3732 
3733  if(pCardStatus == NULL)
3734  {
3735  return HAL_SD_ERROR_PARAM;
3736  }
3737 
3738  /* Send Status command */
3739  errorstate = SDMMC_CmdSendStatus(hsd->Instance, (uint32_t)(hsd->SdCard.RelCardAdd << 16U));
3740  if(errorstate != HAL_SD_ERROR_NONE)
3741  {
3742  return errorstate;
3743  }
3744 
3745  /* Get SD card status */
3746  *pCardStatus = SDMMC_GetResponse(hsd->Instance, SDMMC_RESP1);
3747 
3748  return HAL_SD_ERROR_NONE;
3749 }
3750 
3756 static uint32_t SD_WideBus_Enable(SD_HandleTypeDef *hsd)
3757 {
3758  uint32_t scr[2U] = {0U, 0U};
3759  uint32_t errorstate;
3760 
3761  if((SDMMC_GetResponse(hsd->Instance, SDMMC_RESP1) & SDMMC_CARD_LOCKED) == SDMMC_CARD_LOCKED)
3762  {
3763  return HAL_SD_ERROR_LOCK_UNLOCK_FAILED;
3764  }
3765 
3766  /* Get SCR Register */
3767  errorstate = SD_FindSCR(hsd, scr);
3768  if(errorstate != HAL_SD_ERROR_NONE)
3769  {
3770  return errorstate;
3771  }
3772 
3773  /* If requested card supports wide bus operation */
3774  if((scr[1U] & SDMMC_WIDE_BUS_SUPPORT) != SDMMC_ALLZERO)
3775  {
3776  /* Send CMD55 APP_CMD with argument as card's RCA.*/
3777  errorstate = SDMMC_CmdAppCommand(hsd->Instance, (uint32_t)(hsd->SdCard.RelCardAdd << 16U));
3778  if(errorstate != HAL_SD_ERROR_NONE)
3779  {
3780  return errorstate;
3781  }
3782 
3783  /* Send ACMD6 APP_CMD with argument as 2 for wide bus mode */
3784  errorstate = SDMMC_CmdBusWidth(hsd->Instance, 2U);
3785  if(errorstate != HAL_SD_ERROR_NONE)
3786  {
3787  return errorstate;
3788  }
3789 
3790  return HAL_SD_ERROR_NONE;
3791  }
3792  else
3793  {
3794  return HAL_SD_ERROR_REQUEST_NOT_APPLICABLE;
3795  }
3796 }
3797 
3803 static uint32_t SD_WideBus_Disable(SD_HandleTypeDef *hsd)
3804 {
3805  uint32_t scr[2U] = {0U, 0U};
3806  uint32_t errorstate;
3807 
3808  if((SDMMC_GetResponse(hsd->Instance, SDMMC_RESP1) & SDMMC_CARD_LOCKED) == SDMMC_CARD_LOCKED)
3809  {
3810  return HAL_SD_ERROR_LOCK_UNLOCK_FAILED;
3811  }
3812 
3813  /* Get SCR Register */
3814  errorstate = SD_FindSCR(hsd, scr);
3815  if(errorstate != HAL_SD_ERROR_NONE)
3816  {
3817  return errorstate;
3818  }
3819 
3820  /* If requested card supports 1 bit mode operation */
3821  if((scr[1U] & SDMMC_SINGLE_BUS_SUPPORT) != SDMMC_ALLZERO)
3822  {
3823  /* Send CMD55 APP_CMD with argument as card's RCA */
3824  errorstate = SDMMC_CmdAppCommand(hsd->Instance, (uint32_t)(hsd->SdCard.RelCardAdd << 16U));
3825  if(errorstate != HAL_SD_ERROR_NONE)
3826  {
3827  return errorstate;
3828  }
3829 
3830  /* Send ACMD6 APP_CMD with argument as 0 for single bus mode */
3831  errorstate = SDMMC_CmdBusWidth(hsd->Instance, 0U);
3832  if(errorstate != HAL_SD_ERROR_NONE)
3833  {
3834  return errorstate;
3835  }
3836 
3837  return HAL_SD_ERROR_NONE;
3838  }
3839  else
3840  {
3841  return HAL_SD_ERROR_REQUEST_NOT_APPLICABLE;
3842  }
3843 }
3844 
3845 
3852 static uint32_t SD_FindSCR(SD_HandleTypeDef *hsd, uint32_t *pSCR)
3853 {
3854  SDMMC_DataInitTypeDef config;
3855  uint32_t errorstate;
3856  uint32_t tickstart = HAL_GetTick();
3857  uint32_t index = 0U;
3858  uint32_t tempscr[2U] = {0U, 0U};
3859  uint32_t *scr = pSCR;
3860 
3861  /* Set Block Size To 8 Bytes */
3862  errorstate = SDMMC_CmdBlockLength(hsd->Instance, 8U);
3863  if(errorstate != HAL_SD_ERROR_NONE)
3864  {
3865  return errorstate;
3866  }
3867 
3868  /* Send CMD55 APP_CMD with argument as card's RCA */
3869  errorstate = SDMMC_CmdAppCommand(hsd->Instance, (uint32_t)((hsd->SdCard.RelCardAdd) << 16U));
3870  if(errorstate != HAL_SD_ERROR_NONE)
3871  {
3872  return errorstate;
3873  }
3874 
3875  config.DataTimeOut = SDMMC_DATATIMEOUT;
3876  config.DataLength = 8U;
3877  config.DataBlockSize = SDMMC_DATABLOCK_SIZE_8B;
3878  config.TransferDir = SDMMC_TRANSFER_DIR_TO_SDMMC;
3879  config.TransferMode = SDMMC_TRANSFER_MODE_BLOCK;
3880  config.DPSM = SDMMC_DPSM_ENABLE;
3881  (void)SDMMC_ConfigData(hsd->Instance, &config);
3882 
3883  /* Send ACMD51 SD_APP_SEND_SCR with argument as 0 */
3884  errorstate = SDMMC_CmdSendSCR(hsd->Instance);
3885  if(errorstate != HAL_SD_ERROR_NONE)
3886  {
3887  return errorstate;
3888  }
3889 
3890 #if defined(STM32L4R5xx) || defined(STM32L4R7xx) || defined(STM32L4R9xx) || defined(STM32L4S5xx) || defined(STM32L4S7xx) || defined(STM32L4S9xx)
3891  while(!__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXOVERR | SDMMC_FLAG_DCRCFAIL | SDMMC_FLAG_DTIMEOUT | SDMMC_FLAG_DBCKEND | SDMMC_FLAG_DATAEND))
3892  {
3893  if((!__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXFIFOE)) && (index == 0U))
3894  {
3895  tempscr[0] = SDMMC_ReadFIFO(hsd->Instance);
3896  tempscr[1] = SDMMC_ReadFIFO(hsd->Instance);
3897  index++;
3898  }
3899 
3900 
3901  if((HAL_GetTick() - tickstart) >= SDMMC_DATATIMEOUT)
3902  {
3903  return HAL_SD_ERROR_TIMEOUT;
3904  }
3905  }
3906 #else
3907  while(!__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXOVERR | SDMMC_FLAG_DCRCFAIL | SDMMC_FLAG_DTIMEOUT | SDMMC_FLAG_DBCKEND))
3908  {
3909  if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXDAVL))
3910  {
3911  *(tempscr + index) = SDMMC_ReadFIFO(hsd->Instance);
3912  index++;
3913  }
3914 
3915  if((HAL_GetTick() - tickstart) >= SDMMC_DATATIMEOUT)
3916  {
3917  return HAL_SD_ERROR_TIMEOUT;
3918  }
3919  }
3920 #endif /* STM32L4R5xx || STM32L4R7xx || STM32L4R9xx || STM32L4S5xx || STM32L4S7xx || STM32L4S9xx */
3921 
3922  if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DTIMEOUT))
3923  {
3924  __HAL_SD_CLEAR_FLAG(hsd, SDMMC_FLAG_DTIMEOUT);
3925 
3926  return HAL_SD_ERROR_DATA_TIMEOUT;
3927  }
3928  else if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DCRCFAIL))
3929  {
3930  __HAL_SD_CLEAR_FLAG(hsd, SDMMC_FLAG_DCRCFAIL);
3931 
3932  return HAL_SD_ERROR_DATA_CRC_FAIL;
3933  }
3934  else if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXOVERR))
3935  {
3936  __HAL_SD_CLEAR_FLAG(hsd, SDMMC_FLAG_RXOVERR);
3937 
3938  return HAL_SD_ERROR_RX_OVERRUN;
3939  }
3940  else
3941  {
3942  /* No error flag set */
3943  /* Clear all the static flags */
3944  __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_DATA_FLAGS);
3945 
3946  *scr = (((tempscr[1] & SDMMC_0TO7BITS) << 24) | ((tempscr[1] & SDMMC_8TO15BITS) << 8) |\
3947  ((tempscr[1] & SDMMC_16TO23BITS) >> 8) | ((tempscr[1] & SDMMC_24TO31BITS) >> 24));
3948  scr++;
3949  *scr = (((tempscr[0] & SDMMC_0TO7BITS) << 24) | ((tempscr[0] & SDMMC_8TO15BITS) << 8) |\
3950  ((tempscr[0] & SDMMC_16TO23BITS) >> 8) | ((tempscr[0] & SDMMC_24TO31BITS) >> 24));
3951 
3952  }
3953 
3954  return HAL_SD_ERROR_NONE;
3955 }
3956 
3963 static void SD_Read_IT(SD_HandleTypeDef *hsd)
3964 {
3965  uint32_t count, data, dataremaining;
3966  uint8_t* tmp;
3967 
3968  tmp = hsd->pRxBuffPtr;
3969  dataremaining = hsd->RxXferSize;
3970 
3971  if (dataremaining > 0U)
3972  {
3973  /* Read data from SDMMC Rx FIFO */
3974  for(count = 0U; count < 8U; count++)
3975  {
3976  data = SDMMC_ReadFIFO(hsd->Instance);
3977  *tmp = (uint8_t)(data & 0xFFU);
3978  tmp++;
3979  dataremaining--;
3980  *tmp = (uint8_t)((data >> 8U) & 0xFFU);
3981  tmp++;
3982  dataremaining--;
3983  *tmp = (uint8_t)((data >> 16U) & 0xFFU);
3984  tmp++;
3985  dataremaining--;
3986  *tmp = (uint8_t)((data >> 24U) & 0xFFU);
3987  tmp++;
3988  dataremaining--;
3989  }
3990 
3991  hsd->pRxBuffPtr = tmp;
3992  hsd->RxXferSize = dataremaining;
3993  }
3994 }
3995 
4002 static void SD_Write_IT(SD_HandleTypeDef *hsd)
4003 {
4004  uint32_t count, data, dataremaining;
4005  uint8_t* tmp;
4006 
4007  tmp = hsd->pTxBuffPtr;
4008  dataremaining = hsd->TxXferSize;
4009 
4010  if (dataremaining > 0U)
4011  {
4012  /* Write data to SDMMC Tx FIFO */
4013  for(count = 0U; count < 8U; count++)
4014  {
4015  data = (uint32_t)(*tmp);
4016  tmp++;
4017  dataremaining--;
4018  data |= ((uint32_t)(*tmp) << 8U);
4019  tmp++;
4020  dataremaining--;
4021  data |= ((uint32_t)(*tmp) << 16U);
4022  tmp++;
4023  dataremaining--;
4024  data |= ((uint32_t)(*tmp) << 24U);
4025  tmp++;
4026  dataremaining--;
4027  (void)SDMMC_WriteFIFO(hsd->Instance, &data);
4028  }
4029 
4030  hsd->pTxBuffPtr = tmp;
4031  hsd->TxXferSize = dataremaining;
4032  }
4033 }
4034 
4035 #if defined(STM32L4R5xx) || defined(STM32L4R7xx) || defined(STM32L4R9xx) || defined(STM32L4S5xx) || defined(STM32L4S7xx) || defined(STM32L4S9xx)
4036 
4044 uint32_t SD_HighSpeed(SD_HandleTypeDef *hsd)
4045 {
4046  uint32_t errorstate = HAL_SD_ERROR_NONE;
4047  SDMMC_DataInitTypeDef sdmmc_datainitstructure;
4048  uint32_t SD_hs[16] = {0};
4049  uint32_t count, loop = 0 ;
4050  uint32_t Timeout = HAL_GetTick();
4051 
4052  if(hsd->SdCard.CardSpeed == CARD_NORMAL_SPEED)
4053  {
4054  /* Standard Speed Card <= 12.5Mhz */
4055  return HAL_SD_ERROR_REQUEST_NOT_APPLICABLE;
4056  }
4057 
4058  if(hsd->SdCard.CardSpeed == CARD_HIGH_SPEED)
4059  {
4060  /* Initialize the Data control register */
4061  hsd->Instance->DCTRL = 0;
4062  errorstate = SDMMC_CmdBlockLength(hsd->Instance, 64);
4063 
4064  if (errorstate != HAL_SD_ERROR_NONE)
4065  {
4066  return errorstate;
4067  }
4068 
4069  /* Configure the SD DPSM (Data Path State Machine) */
4070  sdmmc_datainitstructure.DataTimeOut = SDMMC_DATATIMEOUT;
4071  sdmmc_datainitstructure.DataLength = 64;
4072  sdmmc_datainitstructure.DataBlockSize = SDMMC_DATABLOCK_SIZE_64B ;
4073  sdmmc_datainitstructure.TransferDir = SDMMC_TRANSFER_DIR_TO_SDMMC;
4074  sdmmc_datainitstructure.TransferMode = SDMMC_TRANSFER_MODE_BLOCK;
4075  sdmmc_datainitstructure.DPSM = SDMMC_DPSM_ENABLE;
4076 
4077  if ( SDMMC_ConfigData(hsd->Instance, &sdmmc_datainitstructure) != HAL_OK)
4078  {
4079  return (HAL_SD_ERROR_GENERAL_UNKNOWN_ERR);
4080  }
4081 
4082 
4083  errorstate = SDMMC_CmdSwitch(hsd->Instance,SDMMC_SDR25_SWITCH_PATTERN);
4084  if(errorstate != HAL_SD_ERROR_NONE)
4085  {
4086  return errorstate;
4087  }
4088 
4089  while(!__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXOVERR | SDMMC_FLAG_DCRCFAIL | SDMMC_FLAG_DTIMEOUT | SDMMC_FLAG_DBCKEND| SDMMC_FLAG_DATAEND ))
4090  {
4091  if (__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXFIFOHF))
4092  {
4093  for (count = 0U; count < 8U; count++)
4094  {
4095  SD_hs[(8U*loop)+count] = SDMMC_ReadFIFO(hsd->Instance);
4096  }
4097  loop ++;
4098  }
4099 
4100  if((HAL_GetTick()-Timeout) >= SDMMC_DATATIMEOUT)
4101  {
4102  hsd->ErrorCode = HAL_SD_ERROR_TIMEOUT;
4103  hsd->State= HAL_SD_STATE_READY;
4104  return HAL_SD_ERROR_TIMEOUT;
4105  }
4106  }
4107 
4108  if (__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DTIMEOUT))
4109  {
4110  __HAL_SD_CLEAR_FLAG(hsd, SDMMC_FLAG_DTIMEOUT);
4111 
4112  errorstate = 0;
4113 
4114  return errorstate;
4115  }
4116  else if (__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DCRCFAIL))
4117  {
4118  __HAL_SD_CLEAR_FLAG(hsd, SDMMC_FLAG_DCRCFAIL);
4119 
4120  errorstate = SDMMC_ERROR_DATA_CRC_FAIL;
4121 
4122  return errorstate;
4123  }
4124  else if (__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXOVERR))
4125  {
4126  __HAL_SD_CLEAR_FLAG(hsd, SDMMC_FLAG_RXOVERR);
4127 
4128  errorstate = SDMMC_ERROR_RX_OVERRUN;
4129 
4130  return errorstate;
4131  }
4132  else
4133  {
4134  /* No error flag set */
4135  }
4136 
4137  /* Clear all the static flags */
4138  __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_DATA_FLAGS);
4139 
4140  /* Test if the switch mode HS is ok */
4141  if ((((uint8_t*)SD_hs)[13] & 2U) != 2U)
4142  {
4143  errorstate = SDMMC_ERROR_UNSUPPORTED_FEATURE;
4144  }
4145 
4146  }
4147 
4148  return errorstate;
4149 }
4150 
4159 static uint32_t SD_UltraHighSpeed(SD_HandleTypeDef *hsd)
4160 {
4161  uint32_t errorstate = HAL_SD_ERROR_NONE;
4162  SDMMC_DataInitTypeDef sdmmc_datainitstructure;
4163  uint32_t SD_hs[16] = {0};
4164  uint32_t count, loop = 0 ;
4165  uint32_t Timeout = HAL_GetTick();
4166 
4167  if(hsd->SdCard.CardSpeed == CARD_NORMAL_SPEED)
4168  {
4169  /* Standard Speed Card <= 12.5Mhz */
4170  return HAL_SD_ERROR_REQUEST_NOT_APPLICABLE;
4171  }
4172 
4173  if((hsd->SdCard.CardSpeed == CARD_ULTRA_HIGH_SPEED) &&
4174  (hsd->Init.Transceiver == SDMMC_TRANSCEIVER_ENABLE))
4175  {
4176  /* Initialize the Data control register */
4177  hsd->Instance->DCTRL = 0;
4178  errorstate = SDMMC_CmdBlockLength(hsd->Instance, 64);
4179 
4180  if (errorstate != HAL_SD_ERROR_NONE)
4181  {
4182  return errorstate;
4183  }
4184 
4185  /* Configure the SD DPSM (Data Path State Machine) */
4186  sdmmc_datainitstructure.DataTimeOut = SDMMC_DATATIMEOUT;
4187  sdmmc_datainitstructure.DataLength = 64;
4188  sdmmc_datainitstructure.DataBlockSize = SDMMC_DATABLOCK_SIZE_64B ;
4189  sdmmc_datainitstructure.TransferDir = SDMMC_TRANSFER_DIR_TO_SDMMC;
4190  sdmmc_datainitstructure.TransferMode = SDMMC_TRANSFER_MODE_BLOCK;
4191  sdmmc_datainitstructure.DPSM = SDMMC_DPSM_ENABLE;
4192 
4193  if ( SDMMC_ConfigData(hsd->Instance, &sdmmc_datainitstructure) != HAL_OK)
4194  {
4195  return (HAL_SD_ERROR_GENERAL_UNKNOWN_ERR);
4196  }
4197 
4198  errorstate = SDMMC_CmdSwitch(hsd->Instance, SDMMC_SDR104_SWITCH_PATTERN);
4199  if(errorstate != HAL_SD_ERROR_NONE)
4200  {
4201  return errorstate;
4202  }
4203 
4204  while(!__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXOVERR | SDMMC_FLAG_DCRCFAIL | SDMMC_FLAG_DTIMEOUT | SDMMC_FLAG_DBCKEND| SDMMC_FLAG_DATAEND ))
4205  {
4206  if (__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXFIFOHF))
4207  {
4208  for (count = 0U; count < 8U; count++)
4209  {
4210  SD_hs[(8U*loop)+count] = SDMMC_ReadFIFO(hsd->Instance);
4211  }
4212  loop ++;
4213  }
4214 
4215  if((HAL_GetTick()-Timeout) >= SDMMC_DATATIMEOUT)
4216  {
4217  hsd->ErrorCode = HAL_SD_ERROR_TIMEOUT;
4218  hsd->State= HAL_SD_STATE_READY;
4219  return HAL_SD_ERROR_TIMEOUT;
4220  }
4221  }
4222 
4223  if (__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DTIMEOUT))
4224  {
4225  __HAL_SD_CLEAR_FLAG(hsd, SDMMC_FLAG_DTIMEOUT);
4226 
4227  errorstate = 0;
4228 
4229  return errorstate;
4230  }
4231  else if (__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DCRCFAIL))
4232  {
4233  __HAL_SD_CLEAR_FLAG(hsd, SDMMC_FLAG_DCRCFAIL);
4234 
4235  errorstate = SDMMC_ERROR_DATA_CRC_FAIL;
4236 
4237  return errorstate;
4238  }
4239  else if (__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXOVERR))
4240  {
4241  __HAL_SD_CLEAR_FLAG(hsd, SDMMC_FLAG_RXOVERR);
4242 
4243  errorstate = SDMMC_ERROR_RX_OVERRUN;
4244 
4245  return errorstate;
4246  }
4247  else
4248  {
4249  /* No error flag set */
4250  }
4251 
4252  /* Clear all the static flags */
4253  __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_DATA_FLAGS);
4254 
4255  /* Test if the switch mode HS is ok */
4256  if ((((uint8_t*)SD_hs)[13] & 2U) != 2U)
4257  {
4258  errorstate = SDMMC_ERROR_UNSUPPORTED_FEATURE;
4259  }
4260  else
4261  {
4262 #if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
4263  hsd->DriveTransceiver_1_8V_Callback(SET);
4264 #else
4265  HAL_SDEx_DriveTransceiver_1_8V_Callback(SET);
4266 #endif /* USE_HAL_SD_REGISTER_CALLBACKS */
4267 #if defined (DLYB_SDMMC1) || defined (DLYB_SDMMC2)
4268  /* Enable DelayBlock Peripheral */
4269  /* SDMMC_FB_CLK tuned feedback clock selected as receive clock, for SDR104 */
4270  MODIFY_REG(hsd->Instance->CLKCR, SDMMC_CLKCR_SELCLKRX,SDMMC_CLKCR_SELCLKRX_1);
4271  if (DelayBlock_Enable(SD_GET_DLYB_INSTANCE(hsd->Instance)) != HAL_OK)
4272  {
4273  return (HAL_SD_ERROR_GENERAL_UNKNOWN_ERR);
4274  }
4275 #endif /* (DLYB_SDMMC1) || (DLYB_SDMMC2) */
4276  }
4277  }
4278 
4279  return errorstate;
4280 }
4281 
4290 static uint32_t SD_DDR_Mode(SD_HandleTypeDef *hsd)
4291 {
4292  uint32_t errorstate = HAL_SD_ERROR_NONE;
4293  SDMMC_DataInitTypeDef sdmmc_datainitstructure;
4294  uint32_t SD_hs[16] = {0};
4295  uint32_t count, loop = 0 ;
4296  uint32_t Timeout = HAL_GetTick();
4297 
4298  if(hsd->SdCard.CardSpeed == CARD_NORMAL_SPEED)
4299  {
4300  /* Standard Speed Card <= 12.5Mhz */
4301  return HAL_SD_ERROR_REQUEST_NOT_APPLICABLE;
4302  }
4303 
4304  if((hsd->SdCard.CardSpeed == CARD_ULTRA_HIGH_SPEED) &&
4305  (hsd->Init.Transceiver == SDMMC_TRANSCEIVER_ENABLE))
4306  {
4307  /* Initialize the Data control register */
4308  hsd->Instance->DCTRL = 0;
4309  errorstate = SDMMC_CmdBlockLength(hsd->Instance, 64);
4310 
4311  if (errorstate != HAL_SD_ERROR_NONE)
4312  {
4313  return errorstate;
4314  }
4315 
4316  /* Configure the SD DPSM (Data Path State Machine) */
4317  sdmmc_datainitstructure.DataTimeOut = SDMMC_DATATIMEOUT;
4318  sdmmc_datainitstructure.DataLength = 64;
4319  sdmmc_datainitstructure.DataBlockSize = SDMMC_DATABLOCK_SIZE_64B ;
4320  sdmmc_datainitstructure.TransferDir = SDMMC_TRANSFER_DIR_TO_SDMMC;
4321  sdmmc_datainitstructure.TransferMode = SDMMC_TRANSFER_MODE_BLOCK;
4322  sdmmc_datainitstructure.DPSM = SDMMC_DPSM_ENABLE;
4323 
4324  if ( SDMMC_ConfigData(hsd->Instance, &sdmmc_datainitstructure) != HAL_OK)
4325  {
4326  return (HAL_SD_ERROR_GENERAL_UNKNOWN_ERR);
4327  }
4328 
4329  errorstate = SDMMC_CmdSwitch(hsd->Instance, SDMMC_DDR50_SWITCH_PATTERN);
4330  if(errorstate != HAL_SD_ERROR_NONE)
4331  {
4332  return errorstate;
4333  }
4334 
4335  while(!__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXOVERR | SDMMC_FLAG_DCRCFAIL | SDMMC_FLAG_DTIMEOUT | SDMMC_FLAG_DBCKEND| SDMMC_FLAG_DATAEND ))
4336  {
4337  if (__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXFIFOHF))
4338  {
4339  for (count = 0U; count < 8U; count++)
4340  {
4341  SD_hs[(8U*loop)+count] = SDMMC_ReadFIFO(hsd->Instance);
4342  }
4343  loop ++;
4344  }
4345 
4346  if((HAL_GetTick()-Timeout) >= SDMMC_DATATIMEOUT)
4347  {
4348  hsd->ErrorCode = HAL_SD_ERROR_TIMEOUT;
4349  hsd->State= HAL_SD_STATE_READY;
4350  return HAL_SD_ERROR_TIMEOUT;
4351  }
4352  }
4353 
4354  if (__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DTIMEOUT))
4355  {
4356  __HAL_SD_CLEAR_FLAG(hsd, SDMMC_FLAG_DTIMEOUT);
4357 
4358  errorstate = 0;
4359 
4360  return errorstate;
4361  }
4362  else if (__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DCRCFAIL))
4363  {
4364  __HAL_SD_CLEAR_FLAG(hsd, SDMMC_FLAG_DCRCFAIL);
4365 
4366  errorstate = SDMMC_ERROR_DATA_CRC_FAIL;
4367 
4368  return errorstate;
4369  }
4370  else if (__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXOVERR))
4371  {
4372  __HAL_SD_CLEAR_FLAG(hsd, SDMMC_FLAG_RXOVERR);
4373 
4374  errorstate = SDMMC_ERROR_RX_OVERRUN;
4375 
4376  return errorstate;
4377  }
4378  else
4379  {
4380  /* No error flag set */
4381  }
4382 
4383  /* Clear all the static flags */
4384  __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_DATA_FLAGS);
4385 
4386  /* Test if the switch mode is ok */
4387  if ((((uint8_t*)SD_hs)[13] & 2U) != 2U)
4388  {
4389  errorstate = SDMMC_ERROR_UNSUPPORTED_FEATURE;
4390  }
4391  else
4392  {
4393 #if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
4394  hsd->DriveTransceiver_1_8V_Callback(SET);
4395 #else
4396  HAL_SDEx_DriveTransceiver_1_8V_Callback(SET);
4397 #endif /* USE_HAL_SD_REGISTER_CALLBACKS */
4398 #if defined (DLYB_SDMMC1) || defined (DLYB_SDMMC2)
4399  /* Enable DelayBlock Peripheral */
4400  /* SDMMC_FB_CLK tuned feedback clock selected as receive clock, for SDR104 */
4401  MODIFY_REG(hsd->Instance->CLKCR, SDMMC_CLKCR_SELCLKRX,SDMMC_CLKCR_SELCLKRX_1);
4402  if (DelayBlock_Enable(SD_GET_DLYB_INSTANCE(hsd->Instance)) != HAL_OK)
4403  {
4404  return (HAL_SD_ERROR_GENERAL_UNKNOWN_ERR);
4405  }
4406 #endif /* (DLYB_SDMMC1) || (DLYB_SDMMC2) */
4407  }
4408  }
4409 
4410  return errorstate;
4411 }
4412 
4413 #endif /* STM32L4R5xx || STM32L4R7xx || STM32L4R9xx || STM32L4S5xx || STM32L4S7xx || STM32L4S9xx */
4414 
4418 #endif /* HAL_SD_MODULE_ENABLED */
4419 
4428 #endif /* SDMMC1 */
4429 
4430 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
SD_DMAError
static void SD_DMAError(DMA_HandleTypeDef *hdma)
DMA SD communication error callback.
Definition: stm32l4xx_hal_sd.c:3218
SDMMC_CmdBlockLength
uint32_t SDMMC_CmdBlockLength(SDMMC_TypeDef *SDMMCx, uint32_t BlockSize)
Send the Data Block Lenght command and check the response.
Definition: stm32l4xx_ll_sdmmc.c:553
SDMMC_CmdOperCond
uint32_t SDMMC_CmdOperCond(SDMMC_TypeDef *SDMMCx)
Send the Operating Condition command and check the response.
Definition: stm32l4xx_ll_sdmmc.c:875
HAL_SD_CardStatusTypeDef::AllocationUnitSize
__IO uint8_t AllocationUnitSize
Definition: stm32l4xx_hal_sd.h:261
HAL_SD_CardCIDTypeDef::Reserved1
__IO uint8_t Reserved1
Definition: stm32l4xx_hal_sd.h:240
HAL_SD_CardStatusTypeDef::ProtectedAreaSize
__IO uint32_t ProtectedAreaSize
Definition: stm32l4xx_hal_sd.h:258
HAL_SD_CardCSDTypeDef::Reserved1
__IO uint8_t Reserved1
Definition: stm32l4xx_hal_sd.h:189
HAL_SD_CardCSDTypeDef::CardComdClasses
__IO uint16_t CardComdClasses
Definition: stm32l4xx_hal_sd.h:193
HAL_SD_CardCSDTypeDef::PartBlockRead
__IO uint8_t PartBlockRead
Definition: stm32l4xx_hal_sd.h:195
HAL_SD_CallbackIDTypeDef
HAL_SD_CallbackIDTypeDef
Definition: stm32l4xx_hal_sd.h:279
HAL_SD_CardStatusTypeDef::SpeedClass
__IO uint8_t SpeedClass
Definition: stm32l4xx_hal_sd.h:259
HAL_UNLOCKED
Definition: stm32l4xx_hal_def.h:52
HAL_SD_CardStatusTypeDef::EraseSize
__IO uint16_t EraseSize
Definition: stm32l4xx_hal_sd.h:262
SD_DMAReceiveCplt
static void SD_DMAReceiveCplt(DMA_HandleTypeDef *hdma)
DMA SD receive process complete callback.
Definition: stm32l4xx_hal_sd.c:3176
pSD_TransceiverCallbackTypeDef
void(* pSD_TransceiverCallbackTypeDef)(FlagStatus status)
Definition: stm32l4xx_hal_sd.h:304
SDMMC_DataInitTypeDef::DataBlockSize
uint32_t DataBlockSize
Definition: stm32l4xx_ll_sdmmc.h:116
SD_DDR_Mode
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"...
Definition: stm32l4xx_hal_sd.c:4290
SDMMC_CmdSelDesel
uint32_t SDMMC_CmdSelDesel(SDMMC_TypeDef *SDMMCx, uint64_t Addr)
Send the Select Deselect command and check the response.
Definition: stm32l4xx_ll_sdmmc.c:828
HAL_SD_GetCardCSD
HAL_StatusTypeDef HAL_SD_GetCardCSD(SD_HandleTypeDef *hsd, HAL_SD_CardCSDTypeDef *pCSD)
Returns information the information of the card which are stored on the CSD register.
Definition: stm32l4xx_hal_sd.c:2461
SDMMC_CmdVoltageSwitch
uint32_t SDMMC_CmdVoltageSwitch(SDMMC_TypeDef *SDMMCx)
Send the command asking the accessed card to send its operating condition register (OCR) ...
Definition: stm32l4xx_ll_sdmmc.c:1183
HAL_SD_CardCSDTypeDef::TAAC
__IO uint8_t TAAC
Definition: stm32l4xx_hal_sd.h:190
HAL_SD_UnRegisterTransceiverCallback
HAL_StatusTypeDef HAL_SD_UnRegisterTransceiverCallback(SD_HandleTypeDef *hsd)
Unregister a User SD Transceiver Callback SD Callback is redirected to the weak (surcharged) predefin...
Definition: stm32l4xx_hal_sd.c:2375
HAL_SD_MspInit
void HAL_SD_MspInit(SD_HandleTypeDef *hsd)
Initializes the SD MSP.
Definition: stm32l4xx_hal_sd.c:611
HAL_SD_CardCSDTypeDef::MaxRdCurrentVDDMax
__IO uint8_t MaxRdCurrentVDDMax
Definition: stm32l4xx_hal_sd.h:202
__DMA_HandleTypeDef
DMA handle Structure definition.
Definition: stm32l4xx_hal_dma.h:113
HAL_SD_CardCIDTypeDef::ProdRev
__IO uint8_t ProdRev
Definition: stm32l4xx_hal_sd.h:238
HAL_SD_CardStatusTypeDef::EraseTimeout
__IO uint8_t EraseTimeout
Definition: stm32l4xx_hal_sd.h:263
__DMA_HandleTypeDef::Parent
void * Parent
Definition: stm32l4xx_hal_dma.h:123
SDMMC_CmdReadSingleBlock
uint32_t SDMMC_CmdReadSingleBlock(SDMMC_TypeDef *SDMMCx, uint32_t ReadAdd)
Send the Read Single Block command and check the response.
Definition: stm32l4xx_ll_sdmmc.c:577
HAL_SD_Erase
HAL_StatusTypeDef HAL_SD_Erase(SD_HandleTypeDef *hsd, uint32_t BlockStartAdd, uint32_t BlockEndAdd)
Erases the specified memory area of the given SD card.
Definition: stm32l4xx_hal_sd.c:1634
SD_WideBus_Disable
static uint32_t SD_WideBus_Disable(SD_HandleTypeDef *hsd)
Disables the SDMMC wide bus mode.
Definition: stm32l4xx_hal_sd.c:3803
HAL_SD_CardCIDTypeDef::ProdName2
__IO uint8_t ProdName2
Definition: stm32l4xx_hal_sd.h:237
HAL_SD_GetCardStatus
HAL_StatusTypeDef HAL_SD_GetCardStatus(SD_HandleTypeDef *hsd, HAL_SD_CardStatusTypeDef *pStatus)
Gets the SD status info.
Definition: stm32l4xx_hal_sd.c:2575
HAL_SD_CardStatusTypeDef::VideoSpeedClass
__IO uint8_t VideoSpeedClass
Definition: stm32l4xx_hal_sd.h:268
HAL_SD_CardInfoTypeDef::BlockSize
uint32_t BlockSize
Definition: stm32l4xx_hal_sd.h:104
SDMMC_CmdWriteMultiBlock
uint32_t SDMMC_CmdWriteMultiBlock(SDMMC_TypeDef *SDMMCx, uint32_t WriteAdd)
Send the Write Multi Block command and check the response.
Definition: stm32l4xx_ll_sdmmc.c:649
SD_WideBus_Enable
static uint32_t SD_WideBus_Enable(SD_HandleTypeDef *hsd)
Enables the SDMMC wide bus mode.
Definition: stm32l4xx_hal_sd.c:3756
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".
Definition: stm32l4xx_hal_sd.c:4044
HAL_SD_ErrorCallback
void HAL_SD_ErrorCallback(SD_HandleTypeDef *hsd)
SD error callbacks.
Definition: stm32l4xx_hal_sd.c:2096
stm32l4xx_hal.h
This file contains all the functions prototypes for the HAL module driver.
HAL_SD_CardCSDTypeDef::EraseGrMul
__IO uint8_t EraseGrMul
Definition: stm32l4xx_hal_sd.h:207
HAL_SD_CardStatusTypeDef
Definition: stm32l4xx_hal_sd.h:253
HAL_SD_ERROR_CB_ID
Definition: stm32l4xx_hal_sd.h:283
HAL_SD_DeInit
HAL_StatusTypeDef HAL_SD_DeInit(SD_HandleTypeDef *hsd)
De-Initializes the SD card.
Definition: stm32l4xx_hal_sd.c:554
HAL_SD_TX_CPLT_CB_ID
Definition: stm32l4xx_hal_sd.h:281
SD_UltraHighSpeed
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"...
Definition: stm32l4xx_hal_sd.c:4159
HAL_SD_CardCSDTypeDef::CopyFlag
__IO uint8_t CopyFlag
Definition: stm32l4xx_hal_sd.h:217
HAL_SD_CardCSDTypeDef::PermWrProtect
__IO uint8_t PermWrProtect
Definition: stm32l4xx_hal_sd.h:218
HAL_SD_CardCSDTypeDef::DSRImpl
__IO uint8_t DSRImpl
Definition: stm32l4xx_hal_sd.h:198
HAL_SD_CardCSDTypeDef::ContentProtectAppli
__IO uint8_t ContentProtectAppli
Definition: stm32l4xx_hal_sd.h:215
SDMMC_DataInitTypeDef
SDMMC Data Control structure.
Definition: stm32l4xx_ll_sdmmc.h:110
HAL_SD_CardCSDTypeDef::MaxWrCurrentVDDMax
__IO uint8_t MaxWrCurrentVDDMax
Definition: stm32l4xx_hal_sd.h:204
SDMMC_CmdErase
uint32_t SDMMC_CmdErase(SDMMC_TypeDef *SDMMCx)
Send the Erase command and check the response.
Definition: stm32l4xx_ll_sdmmc.c:769
SD_HandleTypeDef
struct __SD_HandleTypeDef else typedef struct endif SD_HandleTypeDef
SD handle Structure definition.
HAL_SD_CardCSDTypeDef::DeviceSizeMul
__IO uint8_t DeviceSizeMul
Definition: stm32l4xx_hal_sd.h:205
HAL_SD_CardCSDTypeDef::ECC
__IO uint8_t ECC
Definition: stm32l4xx_hal_sd.h:221
SDMMC_CmdSendStatus
uint32_t SDMMC_CmdSendStatus(SDMMC_TypeDef *SDMMCx, uint32_t Argument)
Send the Status command and check the response.
Definition: stm32l4xx_ll_sdmmc.c:1084
HAL_SD_CardCSDTypeDef::WriteBlockPaPartial
__IO uint8_t WriteBlockPaPartial
Definition: stm32l4xx_hal_sd.h:213
HAL_SD_ConfigWideBusOperation
HAL_StatusTypeDef HAL_SD_ConfigWideBusOperation(SD_HandleTypeDef *hsd, uint32_t WideMode)
Enables wide bus operation for the requested card if supported by card.
Definition: stm32l4xx_hal_sd.c:2654
SDMMC_CmdSwitch
uint32_t SDMMC_CmdSwitch(SDMMC_TypeDef *SDMMCx, uint32_t Argument)
Checks switchable function and switch card function. SDMMC_CMD_HS_SWITCH comand.
Definition: stm32l4xx_ll_sdmmc.c:1156
HAL_SD_WRITE_DMA_DBL_BUF1_CPLT_CB_ID
Definition: stm32l4xx_hal_sd.h:289
HAL_SD_CardCSDTypeDef::WrSpeedFact
__IO uint8_t WrSpeedFact
Definition: stm32l4xx_hal_sd.h:211
HAL_GetTick
uint32_t HAL_GetTick(void)
Provide a tick value in millisecond.
Definition: stm32l4xx_hal.c:337
HAL_SD_CardInfoTypeDef::LogBlockSize
uint32_t LogBlockSize
Definition: stm32l4xx_hal_sd.h:108
HAL_SD_ConfigSpeedBusOperation
HAL_StatusTypeDef HAL_SD_ConfigSpeedBusOperation(SD_HandleTypeDef *hsd, uint32_t SpeedMode)
Configure the speed bus mode.
Definition: stm32l4xx_hal_sd.c:2760
HAL_SD_InitCard
HAL_StatusTypeDef HAL_SD_InitCard(SD_HandleTypeDef *hsd)
Initializes the SD Card.
Definition: stm32l4xx_hal_sd.c:480
HAL_SD_ReadBlocks_DMA
HAL_StatusTypeDef HAL_SD_ReadBlocks_DMA(SD_HandleTypeDef *hsd, uint8_t *pData, uint32_t BlockAdd, uint32_t NumberOfBlocks)
Reads block(s) from a specified address in a card. The Data transfer is managed by DMA mode...
Definition: stm32l4xx_hal_sd.c:1335
HAL_SD_GetCardState
HAL_SD_CardStateTypeDef HAL_SD_GetCardState(SD_HandleTypeDef *hsd)
Gets the current sd card data state.
Definition: stm32l4xx_hal_sd.c:2950
HAL_SD_CardCSDTypeDef::MaxBusClkFrec
__IO uint8_t MaxBusClkFrec
Definition: stm32l4xx_hal_sd.h:192
HAL_DMA_Abort_IT
HAL_StatusTypeDef HAL_DMA_Abort_IT(DMA_HandleTypeDef *hdma)
Aborts the DMA Transfer in Interrupt mode.
Definition: stm32l4xx_hal_dma.c:608
HAL_SD_RxCpltCallback
void HAL_SD_RxCpltCallback(SD_HandleTypeDef *hsd)
Rx Transfer completed callbacks.
Definition: stm32l4xx_hal_sd.c:2081
__HAL_UNLOCK
__HAL_UNLOCK(hrtc)
HAL_SD_CardCSDTypeDef::FileFormat
__IO uint8_t FileFormat
Definition: stm32l4xx_hal_sd.h:220
SD_DMARxAbort
static void SD_DMARxAbort(DMA_HandleTypeDef *hdma)
DMA SD Rx Abort callback.
Definition: stm32l4xx_hal_sd.c:3297
SD_DMATxAbort
static void SD_DMATxAbort(DMA_HandleTypeDef *hdma)
DMA SD Tx Abort callback.
Definition: stm32l4xx_hal_sd.c:3258
HAL_SD_CardStatusTypeDef::DataBusWidth
__IO uint8_t DataBusWidth
Definition: stm32l4xx_hal_sd.h:255
SDMMC_DataInitTypeDef::DPSM
uint32_t DPSM
Definition: stm32l4xx_ll_sdmmc.h:126
HAL_SD_GetError
uint32_t HAL_SD_GetError(SD_HandleTypeDef *hsd)
Return the SD error code.
Definition: stm32l4xx_hal_sd.c:2056
HAL_SD_Init
HAL_StatusTypeDef HAL_SD_Init(SD_HandleTypeDef *hsd)
Initializes the SD according to the specified parameters in the SD_HandleTypeDef and create the assoc...
Definition: stm32l4xx_hal_sd.c:354
HAL_SD_CardStatusTypeDef::UhsAllocationUnitSize
__IO uint8_t UhsAllocationUnitSize
Definition: stm32l4xx_hal_sd.h:267
SDMMC_GetPowerState
uint32_t SDMMC_GetPowerState(SDMMC_TypeDef *SDMMCx)
Get SDMMC Power state.
Definition: stm32l4xx_ll_sdmmc.c:378
SDMMC_CmdSDEraseEndAdd
uint32_t SDMMC_CmdSDEraseEndAdd(SDMMC_TypeDef *SDMMCx, uint32_t EndAdd)
Send the End Address Erase command for SD and check the response.
Definition: stm32l4xx_ll_sdmmc.c:697
HAL_DMA_Start_IT
HAL_StatusTypeDef HAL_DMA_Start_IT(DMA_HandleTypeDef *hdma, uint32_t SrcAddress, uint32_t DstAddress, uint32_t DataLength)
Start the DMA Transfer with interrupt enabled.
Definition: stm32l4xx_hal_dma.c:473
HAL_SD_WriteBlocks_IT
HAL_StatusTypeDef HAL_SD_WriteBlocks_IT(SD_HandleTypeDef *hsd, uint8_t *pData, uint32_t BlockAdd, uint32_t NumberOfBlocks)
Writes block(s) to a specified address in a card. The Data transfer is managed in interrupt mode...
Definition: stm32l4xx_hal_sd.c:1216
SD_SendSDStatus
static uint32_t SD_SendSDStatus(SD_HandleTypeDef *hsd, uint32_t *pSDstatus)
Send Status info command.
Definition: stm32l4xx_hal_sd.c:3615
HAL_SD_CardCSDTypeDef::CSD_CRC
__IO uint8_t CSD_CRC
Definition: stm32l4xx_hal_sd.h:222
HAL_SDEx_Write_DMADoubleBuffer0CpltCallback
void HAL_SDEx_Write_DMADoubleBuffer0CpltCallback(SD_HandleTypeDef *hsd)
Write DMA Buffer 0 Transfer completed callbacks.
Definition: stm32l4xx_hal_sd_ex.c:393
CLEAR_BIT
CLEAR_BIT(hrtc->Instance->CR, RTC_CR_WUTE)
SDMMC_CmdSendCSD
uint32_t SDMMC_CmdSendCSD(SDMMC_TypeDef *SDMMCx, uint32_t Argument)
Send the Send CSD command and check the response.
Definition: stm32l4xx_ll_sdmmc.c:1034
SDMMC_CmdStatusRegister
uint32_t SDMMC_CmdStatusRegister(SDMMC_TypeDef *SDMMCx)
Send the Status register command and check the response.
Definition: stm32l4xx_ll_sdmmc.c:1107
HAL_SD_CardCSDTypeDef::ManDeflECC
__IO uint8_t ManDeflECC
Definition: stm32l4xx_hal_sd.h:210
__HAL_LOCK
__HAL_LOCK(hrtc)
HAL_SD_CardCSDTypeDef::Reserved4
__IO uint8_t Reserved4
Definition: stm32l4xx_hal_sd.h:223
HAL_SD_CardCSDTypeDef::SysSpecVersion
__IO uint8_t SysSpecVersion
Definition: stm32l4xx_hal_sd.h:188
HAL_SD_WRITE_DMA_DBL_BUF0_CPLT_CB_ID
Definition: stm32l4xx_hal_sd.h:288
__WWDG_HandleTypeDef::Init
WWDG_InitTypeDef Init
Definition: stm32l4xx_hal_wwdg.h:71
HAL_SD_READ_DMA_DBL_BUF0_CPLT_CB_ID
Definition: stm32l4xx_hal_sd.h:286
pSD_CallbackTypeDef
void(* pSD_CallbackTypeDef)(SD_HandleTypeDef *hsd)
Definition: stm32l4xx_hal_sd.h:302
HAL_SDEx_Read_DMADoubleBuffer0CpltCallback
void HAL_SDEx_Read_DMADoubleBuffer0CpltCallback(SD_HandleTypeDef *hsd)
Read DMA Buffer 0 Transfer completed callbacks.
Definition: stm32l4xx_hal_sd_ex.c:363
HAL_SD_CardInfoTypeDef::BlockNbr
uint32_t BlockNbr
Definition: stm32l4xx_hal_sd.h:102
HAL_SD_CardCSDTypeDef::WrProtectGrSize
__IO uint8_t WrProtectGrSize
Definition: stm32l4xx_hal_sd.h:208
HAL_SD_CardInfoTypeDef
SD Card Information Structure definition.
Definition: stm32l4xx_hal_sd.h:92
HAL_SD_CardStatusTypeDef::EraseOffset
__IO uint8_t EraseOffset
Definition: stm32l4xx_hal_sd.h:264
HAL_SD_CardCSDTypeDef::Reserved3
__IO uint8_t Reserved3
Definition: stm32l4xx_hal_sd.h:214
HAL_SDEx_Write_DMADoubleBuffer1CpltCallback
void HAL_SDEx_Write_DMADoubleBuffer1CpltCallback(SD_HandleTypeDef *hsd)
Write DMA Buffer 1 Transfer completed callbacks.
Definition: stm32l4xx_hal_sd_ex.c:408
HAL_SD_CardCSDTypeDef::MaxRdCurrentVDDMin
__IO uint8_t MaxRdCurrentVDDMin
Definition: stm32l4xx_hal_sd.h:201
HAL_SD_CardStatusTypeDef::SecuredMode
__IO uint8_t SecuredMode
Definition: stm32l4xx_hal_sd.h:256
HAL_SD_CardCSDTypeDef::RdBlockLen
__IO uint8_t RdBlockLen
Definition: stm32l4xx_hal_sd.h:194
HAL_SD_CardStatusTypeDef::CardType
__IO uint16_t CardType
Definition: stm32l4xx_hal_sd.h:257
HAL_SD_CardInfoTypeDef::CardVersion
uint32_t CardVersion
Definition: stm32l4xx_hal_sd.h:96
HAL_OK
return HAL_OK
Definition: stm32l4xx_hal_rtc_ex.c:885
HAL_SD_CardCIDTypeDef::ManufactDate
__IO uint16_t ManufactDate
Definition: stm32l4xx_hal_sd.h:241
HAL_SD_CardInfoTypeDef::Class
uint32_t Class
Definition: stm32l4xx_hal_sd.h:98
HAL_SD_ABORT_CB_ID
Definition: stm32l4xx_hal_sd.h:284
SDMMC_ReadFIFO
uint32_t SDMMC_ReadFIFO(SDMMC_TypeDef *SDMMCx)
Read data (word) from Rx FIFO in blocking mode (polling)
Definition: stm32l4xx_ll_sdmmc.c:277
SDMMC_CmdSetRelAdd
uint32_t SDMMC_CmdSetRelAdd(SDMMC_TypeDef *SDMMCx, uint16_t *pRCA)
Send the Send CSD command and check the response.
Definition: stm32l4xx_ll_sdmmc.c:1059
HAL_SD_CardCSDTypeDef::MaxWrCurrentVDDMin
__IO uint8_t MaxWrCurrentVDDMin
Definition: stm32l4xx_hal_sd.h:203
HAL_SD_ReadBlocks_IT
HAL_StatusTypeDef HAL_SD_ReadBlocks_IT(SD_HandleTypeDef *hsd, uint8_t *pData, uint32_t BlockAdd, uint32_t NumberOfBlocks)
Reads block(s) from a specified address in a card. The Data transfer is managed in interrupt mode...
Definition: stm32l4xx_hal_sd.c:1106
HAL_SD_CardCSDTypeDef::EraseGrSize
__IO uint8_t EraseGrSize
Definition: stm32l4xx_hal_sd.h:206
HAL_SD_CardCIDTypeDef
Definition: stm32l4xx_hal_sd.h:232
SD_PowerON
static uint32_t SD_PowerON(SD_HandleTypeDef *hsd)
Enquires cards about their operating voltage and configures clock controls and stores SD information ...
Definition: stm32l4xx_hal_sd.c:3431
HAL_SD_CardCSDTypeDef::Reserved2
__IO uint8_t Reserved2
Definition: stm32l4xx_hal_sd.h:199
HAL_SD_WriteBlocks
HAL_StatusTypeDef HAL_SD_WriteBlocks(SD_HandleTypeDef *hsd, uint8_t *pData, uint32_t BlockAdd, uint32_t NumberOfBlocks, uint32_t Timeout)
Allows to write block(s) to a specified address in a card. The Data transfer is managed by polling mo...
Definition: stm32l4xx_hal_sd.c:901
HAL_SD_CardStatusTypeDef::UhsSpeedGrade
__IO uint8_t UhsSpeedGrade
Definition: stm32l4xx_hal_sd.h:266
SDMMC_CmdSendCID
uint32_t SDMMC_CmdSendCID(SDMMC_TypeDef *SDMMCx)
Send the Send CID command and check the response.
Definition: stm32l4xx_ll_sdmmc.c:1009
SDMMC_DataInitTypeDef::DataLength
uint32_t DataLength
Definition: stm32l4xx_ll_sdmmc.h:114
SD_DMATransmitCplt
static void SD_DMATransmitCplt(DMA_HandleTypeDef *hdma)
DMA SD transmit process complete callback.
Definition: stm32l4xx_hal_sd.c:3163
SD_PowerOFF
static void SD_PowerOFF(SD_HandleTypeDef *hsd)
Turns the SDMMC output signals off.
Definition: stm32l4xx_hal_sd.c:3602
HAL_SD_CardCIDTypeDef::Reserved2
__IO uint8_t Reserved2
Definition: stm32l4xx_hal_sd.h:243
HAL_SD_MSP_DEINIT_CB_ID
Definition: stm32l4xx_hal_sd.h:293
HAL_SD_GetCardCID
HAL_StatusTypeDef HAL_SD_GetCardCID(SD_HandleTypeDef *hsd, HAL_SD_CardCIDTypeDef *pCID)
Returns information the information of the card which are stored on the CID register.
Definition: stm32l4xx_hal_sd.c:2428
HAL_DMA_Abort
HAL_StatusTypeDef HAL_DMA_Abort(DMA_HandleTypeDef *hdma)
Abort the DMA Transfer.
Definition: stm32l4xx_hal_dma.c:546
HAL_SD_CardCSDTypeDef
Definition: stm32l4xx_hal_sd.h:185
SDMMC_GetResponse
uint32_t SDMMC_GetResponse(SDMMC_TypeDef *SDMMCx, uint32_t Response)
Return the response received from the card for the last command.
Definition: stm32l4xx_ll_sdmmc.c:438
HAL_SD_UnRegisterCallback
HAL_StatusTypeDef HAL_SD_UnRegisterCallback(SD_HandleTypeDef *hsd, HAL_SD_CallbackIDTypeDef CallbackID)
Unregister a User SD Callback SD Callback is redirected to the weak (surcharged) predefined callback...
Definition: stm32l4xx_hal_sd.c:2248
HAL_SD_RegisterCallback
HAL_StatusTypeDef HAL_SD_RegisterCallback(SD_HandleTypeDef *hsd, HAL_SD_CallbackIDTypeDef CallbackID, pSD_CallbackTypeDef pCallback)
Register a User SD Callback To be used instead of the weak (surcharged) predefined callback...
Definition: stm32l4xx_hal_sd.c:2141
HAL_SD_CardCSDTypeDef::FileFormatGroup
__IO uint8_t FileFormatGroup
Definition: stm32l4xx_hal_sd.h:216
SD_Read_IT
static void SD_Read_IT(SD_HandleTypeDef *hsd)
Wrap up reading in non-blocking mode.
Definition: stm32l4xx_hal_sd.c:3963
HAL_SD_Abort
HAL_StatusTypeDef HAL_SD_Abort(SD_HandleTypeDef *hsd)
Abort the current transfer and disable the SD.
Definition: stm32l4xx_hal_sd.c:2973
HAL_SD_CardInfoTypeDef::RelCardAdd
uint32_t RelCardAdd
Definition: stm32l4xx_hal_sd.h:100
HAL_SD_CardStateTypeDef
uint32_t HAL_SD_CardStateTypeDef
Definition: stm32l4xx_hal_sd.h:68
HAL_SD_RX_CPLT_CB_ID
Definition: stm32l4xx_hal_sd.h:282
SDMMC_CmdWriteSingleBlock
uint32_t SDMMC_CmdWriteSingleBlock(SDMMC_TypeDef *SDMMCx, uint32_t WriteAdd)
Send the Write Single Block command and check the response.
Definition: stm32l4xx_ll_sdmmc.c:625
SDMMC_CmdStopTransfer
uint32_t SDMMC_CmdStopTransfer(SDMMC_TypeDef *SDMMCx)
Send the Stop Transfer command and check the response.
Definition: stm32l4xx_ll_sdmmc.c:793
HAL_SD_CardCSDTypeDef::RdBlockMisalign
__IO uint8_t RdBlockMisalign
Definition: stm32l4xx_hal_sd.h:197
HAL_SD_AbortCallback
void HAL_SD_AbortCallback(SD_HandleTypeDef *hsd)
SD Abort callbacks.
Definition: stm32l4xx_hal_sd.c:2111
SDMMC_CmdBusWidth
uint32_t SDMMC_CmdBusWidth(SDMMC_TypeDef *SDMMCx, uint32_t BusWidth)
Send the Bus Width command and check the response.
Definition: stm32l4xx_ll_sdmmc.c:962
SDMMC_CmdSendSCR
uint32_t SDMMC_CmdSendSCR(SDMMC_TypeDef *SDMMCx)
Send the Send SCR command and check the response.
Definition: stm32l4xx_ll_sdmmc.c:985
SDMMC_DataInitTypeDef::DataTimeOut
uint32_t DataTimeOut
Definition: stm32l4xx_ll_sdmmc.h:112
HAL_SD_CardCIDTypeDef::ManufacturerID
__IO uint8_t ManufacturerID
Definition: stm32l4xx_hal_sd.h:234
HAL_SD_CardCSDTypeDef::MaxWrBlockLen
__IO uint8_t MaxWrBlockLen
Definition: stm32l4xx_hal_sd.h:212
HAL_SD_CardCSDTypeDef::NSAC
__IO uint8_t NSAC
Definition: stm32l4xx_hal_sd.h:191
SDMMC_CmdAppOperCommand
uint32_t SDMMC_CmdAppOperCommand(SDMMC_TypeDef *SDMMCx, uint32_t Argument)
Send the command asking the accessed card to send its operating condition register (OCR) ...
Definition: stm32l4xx_ll_sdmmc.c:934
HAL_SD_READ_DMA_DBL_BUF1_CPLT_CB_ID
Definition: stm32l4xx_hal_sd.h:287
SDMMC_CmdGoIdleState
uint32_t SDMMC_CmdGoIdleState(SDMMC_TypeDef *SDMMCx)
Send the Go Idle State command and check the response.
Definition: stm32l4xx_ll_sdmmc.c:852
HAL_SD_TxCpltCallback
void HAL_SD_TxCpltCallback(SD_HandleTypeDef *hsd)
Tx Transfer completed callbacks.
Definition: stm32l4xx_hal_sd.c:2066
HAL_SD_CardCSDTypeDef::DeviceSize
__IO uint32_t DeviceSize
Definition: stm32l4xx_hal_sd.h:200
HAL_SD_CardCSDTypeDef::TempWrProtect
__IO uint8_t TempWrProtect
Definition: stm32l4xx_hal_sd.h:219
HAL_SD_CardCSDTypeDef::CSDStruct
__IO uint8_t CSDStruct
Definition: stm32l4xx_hal_sd.h:187
HAL_SD_CardInfoTypeDef::LogBlockNbr
uint32_t LogBlockNbr
Definition: stm32l4xx_hal_sd.h:106
SDMMC_CmdAppCommand
uint32_t SDMMC_CmdAppCommand(SDMMC_TypeDef *SDMMCx, uint32_t Argument)
Send the Application command to verify that that the next command is an application specific com-mand...
Definition: stm32l4xx_ll_sdmmc.c:906
SDMMC_Init
HAL_StatusTypeDef SDMMC_Init(SDMMC_TypeDef *SDMMCx, SDMMC_InitTypeDef Init)
Initializes the SDMMC according to the specified parameters in the SDMMC_InitTypeDef and create the a...
Definition: stm32l4xx_ll_sdmmc.c:220
HAL_SD_CardCIDTypeDef::ProdName1
__IO uint32_t ProdName1
Definition: stm32l4xx_hal_sd.h:236
SD_SendStatus
static uint32_t SD_SendStatus(SD_HandleTypeDef *hsd, uint32_t *pCardStatus)
Returns the current card&#39;s status.
Definition: stm32l4xx_hal_sd.c:3729
MODIFY_REG
MODIFY_REG(hrtc->Instance->CR, RTC_CR_WUCKSEL,(uint32_t) WakeUpClock)
SDMMC_CmdReadMultiBlock
uint32_t SDMMC_CmdReadMultiBlock(SDMMC_TypeDef *SDMMCx, uint32_t ReadAdd)
Send the Read Multi Block command and check the response.
Definition: stm32l4xx_ll_sdmmc.c:601
HAL_SD_MSP_INIT_CB_ID
Definition: stm32l4xx_hal_sd.h:292
SDMMC_DataInitTypeDef::TransferDir
uint32_t TransferDir
Definition: stm32l4xx_ll_sdmmc.h:119
HAL_SD_WriteBlocks_DMA
HAL_StatusTypeDef HAL_SD_WriteBlocks_DMA(SD_HandleTypeDef *hsd, uint8_t *pData, uint32_t BlockAdd, uint32_t NumberOfBlocks)
Writes block(s) to a specified address in a card. The Data transfer is managed by DMA mode...
Definition: stm32l4xx_hal_sd.c:1482
HAL_SD_CardCSDTypeDef::WrBlockMisalign
__IO uint8_t WrBlockMisalign
Definition: stm32l4xx_hal_sd.h:196
HAL_SD_CardInfoTypeDef::CardType
uint32_t CardType
Definition: stm32l4xx_hal_sd.h:94
HAL_SD_CardCIDTypeDef::ProdSN
__IO uint32_t ProdSN
Definition: stm32l4xx_hal_sd.h:239
SDMMC_PowerState_ON
HAL_StatusTypeDef SDMMC_PowerState_ON(SDMMC_TypeDef *SDMMCx)
Set SDMMC Power state to ON.
Definition: stm32l4xx_ll_sdmmc.c:321
HAL_SD_ReadBlocks
HAL_StatusTypeDef HAL_SD_ReadBlocks(SD_HandleTypeDef *hsd, uint8_t *pData, uint32_t BlockAdd, uint32_t NumberOfBlocks, uint32_t Timeout)
Reads block(s) from a specified address in a card. The Data transfer is managed by polling mode...
Definition: stm32l4xx_hal_sd.c:667
HAL_SD_CardCIDTypeDef::OEM_AppliID
__IO uint16_t OEM_AppliID
Definition: stm32l4xx_hal_sd.h:235
HAL_SD_RegisterTransceiverCallback
HAL_StatusTypeDef HAL_SD_RegisterTransceiverCallback(SD_HandleTypeDef *hsd, pSD_TransceiverCallbackTypeDef pCallback)
Register a User SD Transceiver Callback To be used instead of the weak (surcharged) predefined callba...
Definition: stm32l4xx_hal_sd.c:2338
HAL_SDEx_Read_DMADoubleBuffer1CpltCallback
void HAL_SDEx_Read_DMADoubleBuffer1CpltCallback(SD_HandleTypeDef *hsd)
Read DMA Buffer 1 Transfer completed callbacks.
Definition: stm32l4xx_hal_sd_ex.c:378
SDMMC_DataInitTypeDef::TransferMode
uint32_t TransferMode
Definition: stm32l4xx_ll_sdmmc.h:123
HAL_SD_MspDeInit
void HAL_SD_MspDeInit(SD_HandleTypeDef *hsd)
De-Initialize SD MSP.
Definition: stm32l4xx_hal_sd.c:626
SD_Write_IT
static void SD_Write_IT(SD_HandleTypeDef *hsd)
Wrap up writing in non-blocking mode.
Definition: stm32l4xx_hal_sd.c:4002
SDMMC_WriteFIFO
HAL_StatusTypeDef SDMMC_WriteFIFO(SDMMC_TypeDef *SDMMCx, uint32_t *pWriteData)
Write data (word) to Tx FIFO in blocking mode (polling)
Definition: stm32l4xx_ll_sdmmc.c:289
SD_InitCard
static uint32_t SD_InitCard(SD_HandleTypeDef *hsd)
Initializes the sd card.
Definition: stm32l4xx_hal_sd.c:3337
HAL_SD_GetCardInfo
HAL_StatusTypeDef HAL_SD_GetCardInfo(SD_HandleTypeDef *hsd, HAL_SD_CardInfoTypeDef *pCardInfo)
Gets the SD card info.
Definition: stm32l4xx_hal_sd.c:2629
HAL_SD_IRQHandler
void HAL_SD_IRQHandler(SD_HandleTypeDef *hsd)
This function handles SD card interrupt request.
Definition: stm32l4xx_hal_sd.c:1736
HAL_SD_GetState
HAL_SD_StateTypeDef HAL_SD_GetState(SD_HandleTypeDef *hsd)
return the SD state
Definition: stm32l4xx_hal_sd.c:2045
SD_FindSCR
static uint32_t SD_FindSCR(SD_HandleTypeDef *hsd, uint32_t *pSCR)
Finds the SD card SCR register value.
Definition: stm32l4xx_hal_sd.c:3852
SDMMC_CmdSDEraseStartAdd
uint32_t SDMMC_CmdSDEraseStartAdd(SDMMC_TypeDef *SDMMCx, uint32_t StartAdd)
Send the Start Address Erase command for SD and check the response.
Definition: stm32l4xx_ll_sdmmc.c:673
HAL_SDEx_DriveTransceiver_1_8V_Callback
void HAL_SDEx_DriveTransceiver_1_8V_Callback(FlagStatus status)
Enable/Disable the SD Transceiver 1.8V Mode Callback.
Definition: stm32l4xx_hal_sd_ex.c:95
assert_param
assert_param(IS_RTC_WAKEUP_CLOCK(WakeUpClock))
HAL_SD_Abort_IT
HAL_StatusTypeDef HAL_SD_Abort_IT(SD_HandleTypeDef *hsd)
Abort the current transfer and disable the SD (IT mode).
Definition: stm32l4xx_hal_sd.c:3044
SDMMC_PowerState_OFF
HAL_StatusTypeDef SDMMC_PowerState_OFF(SDMMC_TypeDef *SDMMCx)
Set SDMMC Power state to OFF.
Definition: stm32l4xx_ll_sdmmc.c:357
HAL_SD_CardCSDTypeDef::WrProtectGrEnable
__IO uint8_t WrProtectGrEnable
Definition: stm32l4xx_hal_sd.h:209
SDMMC_ConfigData
HAL_StatusTypeDef SDMMC_ConfigData(SDMMC_TypeDef *SDMMCx, SDMMC_DataInitTypeDef *Data)
Configure the SDMMC data path according to the specified parameters in the SDMMC_DataInitTypeDef.
Definition: stm32l4xx_ll_sdmmc.c:459
HAL_SD_CardStatusTypeDef::PerformanceMove
__IO uint8_t PerformanceMove
Definition: stm32l4xx_hal_sd.h:260
HAL_SD_CardCIDTypeDef::CID_CRC
__IO uint8_t CID_CRC
Definition: stm32l4xx_hal_sd.h:242