STM32F4xx HAL Driver master
STM32CubeF4 HAL / LL Drivers API Reference
Loading...
Searching...
No Matches
stm32f4xx_hal_sd.c
Go to the documentation of this file.
1
257
258/* Includes ------------------------------------------------------------------*/
259#include "stm32f4xx_hal.h"
260
261#if defined(SDIO)
262
266
270
271#ifdef HAL_SD_MODULE_ENABLED
272
273/* Private typedef -----------------------------------------------------------*/
274/* Private define ------------------------------------------------------------*/
278
282
283/* Private macro -------------------------------------------------------------*/
284/* Private variables ---------------------------------------------------------*/
285/* Private function prototypes -----------------------------------------------*/
286/* Private functions ---------------------------------------------------------*/
290static uint32_t SD_InitCard(SD_HandleTypeDef *hsd);
291static uint32_t SD_PowerON(SD_HandleTypeDef *hsd);
292static uint32_t SD_SendSDStatus(SD_HandleTypeDef *hsd, uint32_t *pSDstatus);
293static uint32_t SD_SendStatus(SD_HandleTypeDef *hsd, uint32_t *pCardStatus);
294static uint32_t SD_WideBus_Enable(SD_HandleTypeDef *hsd);
295static uint32_t SD_WideBus_Disable(SD_HandleTypeDef *hsd);
296static uint32_t SD_FindSCR(SD_HandleTypeDef *hsd, uint32_t *pSCR);
297static void SD_PowerOFF(SD_HandleTypeDef *hsd);
298static void SD_Write_IT(SD_HandleTypeDef *hsd);
299static void SD_Read_IT(SD_HandleTypeDef *hsd);
300static void SD_DMATransmitCplt(DMA_HandleTypeDef *hdma);
301static void SD_DMAReceiveCplt(DMA_HandleTypeDef *hdma);
302static void SD_DMAError(DMA_HandleTypeDef *hdma);
303static void SD_DMATxAbort(DMA_HandleTypeDef *hdma);
304static void SD_DMARxAbort(DMA_HandleTypeDef *hdma);
308
309/* Exported functions --------------------------------------------------------*/
313
328
335HAL_StatusTypeDef HAL_SD_Init(SD_HandleTypeDef *hsd)
336{
337 /* Check the SD handle allocation */
338 if(hsd == NULL)
339 {
340 return HAL_ERROR;
341 }
342
343 /* Check the parameters */
344 assert_param(IS_SDIO_ALL_INSTANCE(hsd->Instance));
345 assert_param(IS_SDIO_CLOCK_EDGE(hsd->Init.ClockEdge));
346 assert_param(IS_SDIO_CLOCK_BYPASS(hsd->Init.ClockBypass));
347 assert_param(IS_SDIO_CLOCK_POWER_SAVE(hsd->Init.ClockPowerSave));
348 assert_param(IS_SDIO_BUS_WIDE(hsd->Init.BusWide));
349 assert_param(IS_SDIO_HARDWARE_FLOW_CONTROL(hsd->Init.HardwareFlowControl));
350 assert_param(IS_SDIO_CLKDIV(hsd->Init.ClockDiv));
351
352 if(hsd->State == HAL_SD_STATE_RESET)
353 {
354 /* Allocate lock resource and initialize it */
355 hsd->Lock = HAL_UNLOCKED;
356#if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
357 /* Reset Callback pointers in HAL_SD_STATE_RESET only */
358 hsd->TxCpltCallback = HAL_SD_TxCpltCallback;
359 hsd->RxCpltCallback = HAL_SD_RxCpltCallback;
360 hsd->ErrorCallback = HAL_SD_ErrorCallback;
361 hsd->AbortCpltCallback = HAL_SD_AbortCallback;
362
363 if(hsd->MspInitCallback == NULL)
364 {
365 hsd->MspInitCallback = HAL_SD_MspInit;
366 }
367
368 /* Init the low level hardware */
369 hsd->MspInitCallback(hsd);
370#else
371 /* Init the low level hardware : GPIO, CLOCK, CORTEX...etc */
372 HAL_SD_MspInit(hsd);
373#endif /* USE_HAL_SD_REGISTER_CALLBACKS */
374 }
375
376 hsd->State = HAL_SD_STATE_BUSY;
377
378 /* Initialize the Card parameters */
379 if (HAL_SD_InitCard(hsd) != HAL_OK)
380 {
381 return HAL_ERROR;
382 }
383
384 /* Configure the bus wide with the specified value in the SD_HandleTypeDef */
385 if(HAL_SD_ConfigWideBusOperation(hsd, hsd->Init.BusWide) != HAL_OK)
386 {
387 return HAL_ERROR;
388 }
389
390 /* Initialize the error code */
391 hsd->ErrorCode = HAL_SD_ERROR_NONE;
392
393 /* Initialize the SD operation */
394 hsd->Context = SD_CONTEXT_NONE;
395
396 /* Initialize the SD state */
397 hsd->State = HAL_SD_STATE_READY;
398
399 return HAL_OK;
400}
401
409HAL_StatusTypeDef HAL_SD_InitCard(SD_HandleTypeDef *hsd)
410{
411 uint32_t errorstate;
412 SD_InitTypeDef Init;
413
414 /* Default SDIO peripheral configuration for SD card initialization */
415 Init.ClockEdge = SDIO_CLOCK_EDGE_RISING;
416 Init.ClockBypass = SDIO_CLOCK_BYPASS_DISABLE;
417 Init.ClockPowerSave = SDIO_CLOCK_POWER_SAVE_DISABLE;
418 Init.BusWide = SDIO_BUS_WIDE_1B;
419 Init.HardwareFlowControl = SDIO_HARDWARE_FLOW_CONTROL_DISABLE;
420 Init.ClockDiv = SDIO_INIT_CLK_DIV;
421
422 /* Initialize SDIO peripheral interface with default configuration */
423 SDIO_Init(hsd->Instance, Init);
424
425 /* Disable SDIO Clock */
426 __HAL_SD_DISABLE(hsd);
427
428 /* Set Power State to ON */
429 (void)SDIO_PowerState_ON(hsd->Instance);
430
431 /* Enable SDIO Clock */
432 __HAL_SD_ENABLE(hsd);
433
434 /* Required power up waiting time before starting the SD initialization sequence */
435 HAL_Delay(2);
436
437 /* Identify card operating voltage */
438 errorstate = SD_PowerON(hsd);
439 if(errorstate != HAL_SD_ERROR_NONE)
440 {
441 hsd->State = HAL_SD_STATE_READY;
442 hsd->ErrorCode |= errorstate;
443 return HAL_ERROR;
444 }
445
446 /* Card initialization */
447 errorstate = SD_InitCard(hsd);
448 if(errorstate != HAL_SD_ERROR_NONE)
449 {
450 hsd->State = HAL_SD_STATE_READY;
451 hsd->ErrorCode |= errorstate;
452 return HAL_ERROR;
453 }
454
455 /* Set Block Size for Card */
456 errorstate = SDMMC_CmdBlockLength(hsd->Instance, BLOCKSIZE);
457 if(errorstate != HAL_SD_ERROR_NONE)
458 {
459 /* Clear all the static flags */
460 __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
461 hsd->ErrorCode |= errorstate;
462 hsd->State = HAL_SD_STATE_READY;
463 return HAL_ERROR;
464 }
465
466 return HAL_OK;
467}
468
474HAL_StatusTypeDef HAL_SD_DeInit(SD_HandleTypeDef *hsd)
475{
476 /* Check the SD handle allocation */
477 if(hsd == NULL)
478 {
479 return HAL_ERROR;
480 }
481
482 /* Check the parameters */
483 assert_param(IS_SDIO_ALL_INSTANCE(hsd->Instance));
484
485 hsd->State = HAL_SD_STATE_BUSY;
486
487 /* Set SD power state to off */
488 SD_PowerOFF(hsd);
489
490#if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
491 if(hsd->MspDeInitCallback == NULL)
492 {
493 hsd->MspDeInitCallback = HAL_SD_MspDeInit;
494 }
495
496 /* DeInit the low level hardware */
497 hsd->MspDeInitCallback(hsd);
498#else
499 /* De-Initialize the MSP layer */
500 HAL_SD_MspDeInit(hsd);
501#endif /* USE_HAL_SD_REGISTER_CALLBACKS */
502
503 hsd->ErrorCode = HAL_SD_ERROR_NONE;
504 hsd->State = HAL_SD_STATE_RESET;
505
506 return HAL_OK;
507}
508
509
515__weak void HAL_SD_MspInit(SD_HandleTypeDef *hsd)
516{
517 /* Prevent unused argument(s) compilation warning */
518 UNUSED(hsd);
519
520 /* NOTE : This function should not be modified, when the callback is needed,
521 the HAL_SD_MspInit could be implemented in the user file
522 */
523}
524
530__weak void HAL_SD_MspDeInit(SD_HandleTypeDef *hsd)
531{
532 /* Prevent unused argument(s) compilation warning */
533 UNUSED(hsd);
534
535 /* NOTE : This function should not be modified, when the callback is needed,
536 the HAL_SD_MspDeInit could be implemented in the user file
537 */
538}
539
543
558
571HAL_StatusTypeDef HAL_SD_ReadBlocks(SD_HandleTypeDef *hsd, uint8_t *pData, uint32_t BlockAdd, uint32_t NumberOfBlocks, uint32_t Timeout)
572{
573 SDIO_DataInitTypeDef config;
574 uint32_t errorstate;
575 uint32_t tickstart = HAL_GetTick();
576 uint32_t count, data, dataremaining;
577 uint32_t add = BlockAdd;
578 uint8_t *tempbuff = pData;
579
580 if(NULL == pData)
581 {
582 hsd->ErrorCode |= HAL_SD_ERROR_PARAM;
583 return HAL_ERROR;
584 }
585
586 if(hsd->State == HAL_SD_STATE_READY)
587 {
588 hsd->ErrorCode = HAL_SD_ERROR_NONE;
589
590 if((add + NumberOfBlocks) > (hsd->SdCard.LogBlockNbr))
591 {
592 hsd->ErrorCode |= HAL_SD_ERROR_ADDR_OUT_OF_RANGE;
593 return HAL_ERROR;
594 }
595
596 hsd->State = HAL_SD_STATE_BUSY;
597
598 /* Initialize data control register */
599 hsd->Instance->DCTRL = 0U;
600
601 if(hsd->SdCard.CardType != CARD_SDHC_SDXC)
602 {
603 add *= 512U;
604 }
605
606 /* Configure the SD DPSM (Data Path State Machine) */
607 config.DataTimeOut = SDMMC_DATATIMEOUT;
608 config.DataLength = NumberOfBlocks * BLOCKSIZE;
609 config.DataBlockSize = SDIO_DATABLOCK_SIZE_512B;
610 config.TransferDir = SDIO_TRANSFER_DIR_TO_SDIO;
611 config.TransferMode = SDIO_TRANSFER_MODE_BLOCK;
612 config.DPSM = SDIO_DPSM_ENABLE;
613 (void)SDIO_ConfigData(hsd->Instance, &config);
614
615 /* Read block(s) in polling mode */
616 if(NumberOfBlocks > 1U)
617 {
618 hsd->Context = SD_CONTEXT_READ_MULTIPLE_BLOCK;
619
620 /* Read Multi Block command */
621 errorstate = SDMMC_CmdReadMultiBlock(hsd->Instance, add);
622 }
623 else
624 {
625 hsd->Context = SD_CONTEXT_READ_SINGLE_BLOCK;
626
627 /* Read Single Block command */
628 errorstate = SDMMC_CmdReadSingleBlock(hsd->Instance, add);
629 }
630 if(errorstate != HAL_SD_ERROR_NONE)
631 {
632 /* Clear all the static flags */
633 __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
634 hsd->ErrorCode |= errorstate;
635 hsd->State = HAL_SD_STATE_READY;
636 hsd->Context = SD_CONTEXT_NONE;
637 return HAL_ERROR;
638 }
639
640 /* Poll on SDIO flags */
641 dataremaining = config.DataLength;
642#if defined(SDIO_STA_STBITERR)
643 while(!__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_RXOVERR | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_DATAEND | SDIO_FLAG_STBITERR))
644#else /* SDIO_STA_STBITERR not defined */
645 while(!__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_RXOVERR | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_DATAEND))
646#endif /* SDIO_STA_STBITERR */
647 {
648 if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_RXFIFOHF) && (dataremaining > 0U))
649 {
650 /* Read data from SDIO Rx FIFO */
651 for(count = 0U; count < 8U; count++)
652 {
653 data = SDIO_ReadFIFO(hsd->Instance);
654 *tempbuff = (uint8_t)(data & 0xFFU);
655 tempbuff++;
656 dataremaining--;
657 *tempbuff = (uint8_t)((data >> 8U) & 0xFFU);
658 tempbuff++;
659 dataremaining--;
660 *tempbuff = (uint8_t)((data >> 16U) & 0xFFU);
661 tempbuff++;
662 dataremaining--;
663 *tempbuff = (uint8_t)((data >> 24U) & 0xFFU);
664 tempbuff++;
665 dataremaining--;
666 }
667 }
668
669 if(((HAL_GetTick()-tickstart) >= Timeout) || (Timeout == 0U))
670 {
671 /* Clear all the static flags */
672 __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
673 hsd->ErrorCode |= HAL_SD_ERROR_TIMEOUT;
674 hsd->State= HAL_SD_STATE_READY;
675 hsd->Context = SD_CONTEXT_NONE;
676 return HAL_TIMEOUT;
677 }
678 }
679
680 /* Send stop transmission command in case of multiblock read */
681 if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_DATAEND) && (NumberOfBlocks > 1U))
682 {
683 if(hsd->SdCard.CardType != CARD_SECURED)
684 {
685 /* Send stop transmission command */
686 errorstate = SDMMC_CmdStopTransfer(hsd->Instance);
687 if(errorstate != HAL_SD_ERROR_NONE)
688 {
689 /* Clear all the static flags */
690 __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
691 hsd->ErrorCode |= errorstate;
692 hsd->State = HAL_SD_STATE_READY;
693 hsd->Context = SD_CONTEXT_NONE;
694 return HAL_ERROR;
695 }
696 }
697 }
698
699 /* Get error state */
700#if defined(SDIO_STA_STBITERR)
701 if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_DTIMEOUT) || (__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_STBITERR)))
702#else /* SDIO_STA_STBITERR not defined */
703 if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_DTIMEOUT))
704#endif /* SDIO_STA_STBITERR */
705 {
706 /* Clear all the static flags */
707 __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
708 hsd->ErrorCode |= HAL_SD_ERROR_DATA_TIMEOUT;
709 hsd->State = HAL_SD_STATE_READY;
710 hsd->Context = SD_CONTEXT_NONE;
711 return HAL_ERROR;
712 }
713 else if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_DCRCFAIL))
714 {
715 /* Clear all the static flags */
716 __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
717 hsd->ErrorCode |= HAL_SD_ERROR_DATA_CRC_FAIL;
718 hsd->State = HAL_SD_STATE_READY;
719 hsd->Context = SD_CONTEXT_NONE;
720 return HAL_ERROR;
721 }
722 else if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_RXOVERR))
723 {
724 /* Clear all the static flags */
725 __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
726 hsd->ErrorCode |= HAL_SD_ERROR_RX_OVERRUN;
727 hsd->State = HAL_SD_STATE_READY;
728 hsd->Context = SD_CONTEXT_NONE;
729 return HAL_ERROR;
730 }
731 else
732 {
733 /* Nothing to do */
734 }
735
736 /* Empty FIFO if there is still any data */
737 while ((__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_RXDAVL)) && (dataremaining > 0U))
738 {
739 data = SDIO_ReadFIFO(hsd->Instance);
740 *tempbuff = (uint8_t)(data & 0xFFU);
741 tempbuff++;
742 dataremaining--;
743 *tempbuff = (uint8_t)((data >> 8U) & 0xFFU);
744 tempbuff++;
745 dataremaining--;
746 *tempbuff = (uint8_t)((data >> 16U) & 0xFFU);
747 tempbuff++;
748 dataremaining--;
749 *tempbuff = (uint8_t)((data >> 24U) & 0xFFU);
750 tempbuff++;
751 dataremaining--;
752
753 if(((HAL_GetTick()-tickstart) >= Timeout) || (Timeout == 0U))
754 {
755 /* Clear all the static flags */
756 __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
757 hsd->ErrorCode |= HAL_SD_ERROR_TIMEOUT;
758 hsd->State= HAL_SD_STATE_READY;
759 hsd->Context = SD_CONTEXT_NONE;
760 return HAL_ERROR;
761 }
762 }
763
764 /* Clear all the static flags */
765 __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_DATA_FLAGS);
766
767 hsd->State = HAL_SD_STATE_READY;
768
769 return HAL_OK;
770 }
771 else
772 {
773 hsd->ErrorCode |= HAL_SD_ERROR_BUSY;
774 return HAL_ERROR;
775 }
776}
777
790HAL_StatusTypeDef HAL_SD_WriteBlocks(SD_HandleTypeDef *hsd, uint8_t *pData, uint32_t BlockAdd, uint32_t NumberOfBlocks, uint32_t Timeout)
791{
792 SDIO_DataInitTypeDef config;
793 uint32_t errorstate;
794 uint32_t tickstart = HAL_GetTick();
795 uint32_t count, data, dataremaining;
796 uint32_t add = BlockAdd;
797 uint8_t *tempbuff = pData;
798
799 if(NULL == pData)
800 {
801 hsd->ErrorCode |= HAL_SD_ERROR_PARAM;
802 return HAL_ERROR;
803 }
804
805 if(hsd->State == HAL_SD_STATE_READY)
806 {
807 hsd->ErrorCode = HAL_SD_ERROR_NONE;
808
809 if((add + NumberOfBlocks) > (hsd->SdCard.LogBlockNbr))
810 {
811 hsd->ErrorCode |= HAL_SD_ERROR_ADDR_OUT_OF_RANGE;
812 return HAL_ERROR;
813 }
814
815 hsd->State = HAL_SD_STATE_BUSY;
816
817 /* Initialize data control register */
818 hsd->Instance->DCTRL = 0U;
819
820 if(hsd->SdCard.CardType != CARD_SDHC_SDXC)
821 {
822 add *= 512U;
823 }
824
825 /* Configure the SD DPSM (Data Path State Machine) */
826 config.DataTimeOut = SDMMC_DATATIMEOUT;
827 config.DataLength = NumberOfBlocks * BLOCKSIZE;
828 config.DataBlockSize = SDIO_DATABLOCK_SIZE_512B;
829 config.TransferDir = SDIO_TRANSFER_DIR_TO_CARD;
830 config.TransferMode = SDIO_TRANSFER_MODE_BLOCK;
831 config.DPSM = SDIO_DPSM_ENABLE;
832 (void)SDIO_ConfigData(hsd->Instance, &config);
833
834 /* Write Blocks in Polling mode */
835 if(NumberOfBlocks > 1U)
836 {
837 hsd->Context = SD_CONTEXT_WRITE_MULTIPLE_BLOCK;
838
839 /* Write Multi Block command */
840 errorstate = SDMMC_CmdWriteMultiBlock(hsd->Instance, add);
841 }
842 else
843 {
844 hsd->Context = SD_CONTEXT_WRITE_SINGLE_BLOCK;
845
846 /* Write Single Block command */
847 errorstate = SDMMC_CmdWriteSingleBlock(hsd->Instance, add);
848 }
849 if(errorstate != HAL_SD_ERROR_NONE)
850 {
851 /* Clear all the static flags */
852 __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
853 hsd->ErrorCode |= errorstate;
854 hsd->State = HAL_SD_STATE_READY;
855 hsd->Context = SD_CONTEXT_NONE;
856 return HAL_ERROR;
857 }
858
859 /* Write block(s) in polling mode */
860 dataremaining = config.DataLength;
861#if defined(SDIO_STA_STBITERR)
862 while(!__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_TXUNDERR | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_DATAEND | SDIO_FLAG_STBITERR))
863#else /* SDIO_STA_STBITERR not defined */
864 while(!__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_TXUNDERR | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_DATAEND))
865#endif /* SDIO_STA_STBITERR */
866 {
867 if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_TXFIFOHE) && (dataremaining > 0U))
868 {
869 /* Write data to SDIO Tx FIFO */
870 for(count = 0U; count < 8U; count++)
871 {
872 data = (uint32_t)(*tempbuff);
873 tempbuff++;
874 dataremaining--;
875 data |= ((uint32_t)(*tempbuff) << 8U);
876 tempbuff++;
877 dataremaining--;
878 data |= ((uint32_t)(*tempbuff) << 16U);
879 tempbuff++;
880 dataremaining--;
881 data |= ((uint32_t)(*tempbuff) << 24U);
882 tempbuff++;
883 dataremaining--;
884 (void)SDIO_WriteFIFO(hsd->Instance, &data);
885 }
886 }
887
888 if(((HAL_GetTick()-tickstart) >= Timeout) || (Timeout == 0U))
889 {
890 /* Clear all the static flags */
891 __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
892 hsd->ErrorCode |= errorstate;
893 hsd->State = HAL_SD_STATE_READY;
894 hsd->Context = SD_CONTEXT_NONE;
895 return HAL_TIMEOUT;
896 }
897 }
898
899 /* Send stop transmission command in case of multiblock write */
900 if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_DATAEND) && (NumberOfBlocks > 1U))
901 {
902 if(hsd->SdCard.CardType != CARD_SECURED)
903 {
904 /* Send stop transmission command */
905 errorstate = SDMMC_CmdStopTransfer(hsd->Instance);
906 if(errorstate != HAL_SD_ERROR_NONE)
907 {
908 /* Clear all the static flags */
909 __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
910 hsd->ErrorCode |= errorstate;
911 hsd->State = HAL_SD_STATE_READY;
912 hsd->Context = SD_CONTEXT_NONE;
913 return HAL_ERROR;
914 }
915 }
916 }
917
918 /* Get error state */
919#if defined(SDIO_STA_STBITERR)
920 if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_DTIMEOUT) || (__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_STBITERR)))
921#else /* SDIO_STA_STBITERR not defined */
922 if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_DTIMEOUT))
923#endif /* SDIO_STA_STBITERR */
924 {
925 /* Clear all the static flags */
926 __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
927 hsd->ErrorCode |= HAL_SD_ERROR_DATA_TIMEOUT;
928 hsd->State = HAL_SD_STATE_READY;
929 hsd->Context = SD_CONTEXT_NONE;
930 return HAL_ERROR;
931 }
932 else if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_DCRCFAIL))
933 {
934 /* Clear all the static flags */
935 __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
936 hsd->ErrorCode |= HAL_SD_ERROR_DATA_CRC_FAIL;
937 hsd->State = HAL_SD_STATE_READY;
938 hsd->Context = SD_CONTEXT_NONE;
939 return HAL_ERROR;
940 }
941 else if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_TXUNDERR))
942 {
943 /* Clear all the static flags */
944 __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
945 hsd->ErrorCode |= HAL_SD_ERROR_TX_UNDERRUN;
946 hsd->State = HAL_SD_STATE_READY;
947 hsd->Context = SD_CONTEXT_NONE;
948 return HAL_ERROR;
949 }
950 else
951 {
952 /* Nothing to do */
953 }
954
955 /* Clear all the static flags */
956 __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_DATA_FLAGS);
957
958 hsd->State = HAL_SD_STATE_READY;
959
960 return HAL_OK;
961 }
962 else
963 {
964 hsd->ErrorCode |= HAL_SD_ERROR_BUSY;
965 return HAL_ERROR;
966 }
967}
968
982HAL_StatusTypeDef HAL_SD_ReadBlocks_IT(SD_HandleTypeDef *hsd, uint8_t *pData, uint32_t BlockAdd, uint32_t NumberOfBlocks)
983{
984 SDIO_DataInitTypeDef config;
985 uint32_t errorstate;
986 uint32_t add = BlockAdd;
987
988 if(NULL == pData)
989 {
990 hsd->ErrorCode |= HAL_SD_ERROR_PARAM;
991 return HAL_ERROR;
992 }
993
994 if(hsd->State == HAL_SD_STATE_READY)
995 {
996 hsd->ErrorCode = HAL_SD_ERROR_NONE;
997
998 if((add + NumberOfBlocks) > (hsd->SdCard.LogBlockNbr))
999 {
1000 hsd->ErrorCode |= HAL_SD_ERROR_ADDR_OUT_OF_RANGE;
1001 return HAL_ERROR;
1002 }
1003
1004 hsd->State = HAL_SD_STATE_BUSY;
1005
1006 /* Initialize data control register */
1007 hsd->Instance->DCTRL = 0U;
1008
1009 hsd->pRxBuffPtr = pData;
1010 hsd->RxXferSize = BLOCKSIZE * NumberOfBlocks;
1011
1012#if defined(SDIO_STA_STBITERR)
1013 __HAL_SD_ENABLE_IT(hsd, (SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_RXOVERR | SDIO_IT_DATAEND | SDIO_FLAG_RXFIFOHF | SDIO_IT_STBITERR));
1014#else /* SDIO_STA_STBITERR not defined */
1015 __HAL_SD_ENABLE_IT(hsd, (SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_RXOVERR | SDIO_IT_DATAEND | SDIO_FLAG_RXFIFOHF));
1016#endif /* SDIO_STA_STBITERR */
1017
1018 if(hsd->SdCard.CardType != CARD_SDHC_SDXC)
1019 {
1020 add *= 512U;
1021 }
1022
1023 /* Configure the SD DPSM (Data Path State Machine) */
1024 config.DataTimeOut = SDMMC_DATATIMEOUT;
1025 config.DataLength = BLOCKSIZE * NumberOfBlocks;
1026 config.DataBlockSize = SDIO_DATABLOCK_SIZE_512B;
1027 config.TransferDir = SDIO_TRANSFER_DIR_TO_SDIO;
1028 config.TransferMode = SDIO_TRANSFER_MODE_BLOCK;
1029 config.DPSM = SDIO_DPSM_ENABLE;
1030 (void)SDIO_ConfigData(hsd->Instance, &config);
1031
1032 /* Read Blocks in IT mode */
1033 if(NumberOfBlocks > 1U)
1034 {
1035 hsd->Context = (SD_CONTEXT_READ_MULTIPLE_BLOCK | SD_CONTEXT_IT);
1036
1037 /* Read Multi Block command */
1038 errorstate = SDMMC_CmdReadMultiBlock(hsd->Instance, add);
1039 }
1040 else
1041 {
1042 hsd->Context = (SD_CONTEXT_READ_SINGLE_BLOCK | SD_CONTEXT_IT);
1043
1044 /* Read Single Block command */
1045 errorstate = SDMMC_CmdReadSingleBlock(hsd->Instance, add);
1046 }
1047 if(errorstate != HAL_SD_ERROR_NONE)
1048 {
1049 /* Clear all the static flags */
1050 __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
1051 hsd->ErrorCode |= errorstate;
1052 hsd->State = HAL_SD_STATE_READY;
1053 hsd->Context = SD_CONTEXT_NONE;
1054 return HAL_ERROR;
1055 }
1056
1057 return HAL_OK;
1058 }
1059 else
1060 {
1061 return HAL_BUSY;
1062 }
1063}
1064
1078HAL_StatusTypeDef HAL_SD_WriteBlocks_IT(SD_HandleTypeDef *hsd, uint8_t *pData, uint32_t BlockAdd, uint32_t NumberOfBlocks)
1079{
1080 SDIO_DataInitTypeDef config;
1081 uint32_t errorstate;
1082 uint32_t add = BlockAdd;
1083
1084 if(NULL == pData)
1085 {
1086 hsd->ErrorCode |= HAL_SD_ERROR_PARAM;
1087 return HAL_ERROR;
1088 }
1089
1090 if(hsd->State == HAL_SD_STATE_READY)
1091 {
1092 hsd->ErrorCode = HAL_SD_ERROR_NONE;
1093
1094 if((add + NumberOfBlocks) > (hsd->SdCard.LogBlockNbr))
1095 {
1096 hsd->ErrorCode |= HAL_SD_ERROR_ADDR_OUT_OF_RANGE;
1097 return HAL_ERROR;
1098 }
1099
1100 hsd->State = HAL_SD_STATE_BUSY;
1101
1102 /* Initialize data control register */
1103 hsd->Instance->DCTRL = 0U;
1104
1105 hsd->pTxBuffPtr = pData;
1106 hsd->TxXferSize = BLOCKSIZE * NumberOfBlocks;
1107
1108 /* Enable transfer interrupts */
1109#if defined(SDIO_STA_STBITERR)
1110 __HAL_SD_ENABLE_IT(hsd, (SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_TXUNDERR | SDIO_IT_DATAEND | SDIO_FLAG_TXFIFOHE | SDIO_IT_STBITERR));
1111#else /* SDIO_STA_STBITERR not defined */
1112 __HAL_SD_ENABLE_IT(hsd, (SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_TXUNDERR | SDIO_IT_DATAEND | SDIO_FLAG_TXFIFOHE));
1113#endif /* SDIO_STA_STBITERR */
1114
1115 if(hsd->SdCard.CardType != CARD_SDHC_SDXC)
1116 {
1117 add *= 512U;
1118 }
1119
1120 /* Write Blocks in Polling mode */
1121 if(NumberOfBlocks > 1U)
1122 {
1123 hsd->Context = (SD_CONTEXT_WRITE_MULTIPLE_BLOCK| SD_CONTEXT_IT);
1124
1125 /* Write Multi Block command */
1126 errorstate = SDMMC_CmdWriteMultiBlock(hsd->Instance, add);
1127 }
1128 else
1129 {
1130 hsd->Context = (SD_CONTEXT_WRITE_SINGLE_BLOCK | SD_CONTEXT_IT);
1131
1132 /* Write Single Block command */
1133 errorstate = SDMMC_CmdWriteSingleBlock(hsd->Instance, add);
1134 }
1135 if(errorstate != HAL_SD_ERROR_NONE)
1136 {
1137 /* Clear all the static flags */
1138 __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
1139 hsd->ErrorCode |= errorstate;
1140 hsd->State = HAL_SD_STATE_READY;
1141 hsd->Context = SD_CONTEXT_NONE;
1142 return HAL_ERROR;
1143 }
1144
1145 /* Configure the SD DPSM (Data Path State Machine) */
1146 config.DataTimeOut = SDMMC_DATATIMEOUT;
1147 config.DataLength = BLOCKSIZE * NumberOfBlocks;
1148 config.DataBlockSize = SDIO_DATABLOCK_SIZE_512B;
1149 config.TransferDir = SDIO_TRANSFER_DIR_TO_CARD;
1150 config.TransferMode = SDIO_TRANSFER_MODE_BLOCK;
1151 config.DPSM = SDIO_DPSM_ENABLE;
1152 (void)SDIO_ConfigData(hsd->Instance, &config);
1153
1154 return HAL_OK;
1155 }
1156 else
1157 {
1158 return HAL_BUSY;
1159 }
1160}
1161
1175HAL_StatusTypeDef HAL_SD_ReadBlocks_DMA(SD_HandleTypeDef *hsd, uint8_t *pData, uint32_t BlockAdd, uint32_t NumberOfBlocks)
1176{
1177 SDIO_DataInitTypeDef config;
1178 uint32_t errorstate;
1179 uint32_t add = BlockAdd;
1180
1181 if(NULL == pData)
1182 {
1183 hsd->ErrorCode |= HAL_SD_ERROR_PARAM;
1184 return HAL_ERROR;
1185 }
1186
1187 if(hsd->State == HAL_SD_STATE_READY)
1188 {
1189 hsd->ErrorCode = HAL_SD_ERROR_NONE;
1190
1191 if((add + NumberOfBlocks) > (hsd->SdCard.LogBlockNbr))
1192 {
1193 hsd->ErrorCode |= HAL_SD_ERROR_ADDR_OUT_OF_RANGE;
1194 return HAL_ERROR;
1195 }
1196
1197 hsd->State = HAL_SD_STATE_BUSY;
1198
1199 /* Initialize data control register */
1200 hsd->Instance->DCTRL = 0U;
1201
1202#if defined(SDIO_STA_STBITERR)
1203 __HAL_SD_ENABLE_IT(hsd, (SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_RXOVERR | SDIO_IT_DATAEND | SDIO_IT_STBITERR));
1204#else /* SDIO_STA_STBITERR not defined */
1205 __HAL_SD_ENABLE_IT(hsd, (SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_RXOVERR | SDIO_IT_DATAEND));
1206#endif /* SDIO_STA_STBITERR */
1207
1208 /* Set the DMA transfer complete callback */
1209 hsd->hdmarx->XferCpltCallback = SD_DMAReceiveCplt;
1210
1211 /* Set the DMA error callback */
1212 hsd->hdmarx->XferErrorCallback = SD_DMAError;
1213
1214 /* Set the DMA Abort callback */
1215 hsd->hdmarx->XferAbortCallback = NULL;
1216
1217 /* Force DMA Direction */
1218 hsd->hdmarx->Init.Direction = DMA_PERIPH_TO_MEMORY;
1219 MODIFY_REG(hsd->hdmarx->Instance->CR, DMA_SxCR_DIR, hsd->hdmarx->Init.Direction);
1220
1221 /* Enable the DMA Channel */
1222 if(HAL_DMA_Start_IT(hsd->hdmarx, (uint32_t)&hsd->Instance->FIFO, (uint32_t)pData, (uint32_t)(BLOCKSIZE * NumberOfBlocks)/4U) != HAL_OK)
1223 {
1224 __HAL_SD_DISABLE_IT(hsd, (SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_RXOVERR | SDIO_IT_DATAEND));
1225 __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
1226 hsd->ErrorCode |= HAL_SD_ERROR_DMA;
1227 hsd->State = HAL_SD_STATE_READY;
1228 return HAL_ERROR;
1229 }
1230 else
1231 {
1232 /* Enable SD DMA transfer */
1233 __HAL_SD_DMA_ENABLE(hsd);
1234
1235 if(hsd->SdCard.CardType != CARD_SDHC_SDXC)
1236 {
1237 add *= 512U;
1238 }
1239
1240 /* Configure the SD DPSM (Data Path State Machine) */
1241 config.DataTimeOut = SDMMC_DATATIMEOUT;
1242 config.DataLength = BLOCKSIZE * NumberOfBlocks;
1243 config.DataBlockSize = SDIO_DATABLOCK_SIZE_512B;
1244 config.TransferDir = SDIO_TRANSFER_DIR_TO_SDIO;
1245 config.TransferMode = SDIO_TRANSFER_MODE_BLOCK;
1246 config.DPSM = SDIO_DPSM_ENABLE;
1247 (void)SDIO_ConfigData(hsd->Instance, &config);
1248
1249 /* Read Blocks in DMA mode */
1250 if(NumberOfBlocks > 1U)
1251 {
1252 hsd->Context = (SD_CONTEXT_READ_MULTIPLE_BLOCK | SD_CONTEXT_DMA);
1253
1254 /* Read Multi Block command */
1255 errorstate = SDMMC_CmdReadMultiBlock(hsd->Instance, add);
1256 }
1257 else
1258 {
1259 hsd->Context = (SD_CONTEXT_READ_SINGLE_BLOCK | SD_CONTEXT_DMA);
1260
1261 /* Read Single Block command */
1262 errorstate = SDMMC_CmdReadSingleBlock(hsd->Instance, add);
1263 }
1264 if(errorstate != HAL_SD_ERROR_NONE)
1265 {
1266 /* Clear all the static flags */
1267 __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
1268 hsd->ErrorCode |= errorstate;
1269 hsd->State = HAL_SD_STATE_READY;
1270 hsd->Context = SD_CONTEXT_NONE;
1271 return HAL_ERROR;
1272 }
1273
1274 return HAL_OK;
1275 }
1276 }
1277 else
1278 {
1279 return HAL_BUSY;
1280 }
1281}
1282
1296HAL_StatusTypeDef HAL_SD_WriteBlocks_DMA(SD_HandleTypeDef *hsd, uint8_t *pData, uint32_t BlockAdd, uint32_t NumberOfBlocks)
1297{
1298 SDIO_DataInitTypeDef config;
1299 uint32_t errorstate;
1300 uint32_t add = BlockAdd;
1301
1302 if(NULL == pData)
1303 {
1304 hsd->ErrorCode |= HAL_SD_ERROR_PARAM;
1305 return HAL_ERROR;
1306 }
1307
1308 if(hsd->State == HAL_SD_STATE_READY)
1309 {
1310 hsd->ErrorCode = HAL_SD_ERROR_NONE;
1311
1312 if((add + NumberOfBlocks) > (hsd->SdCard.LogBlockNbr))
1313 {
1314 hsd->ErrorCode |= HAL_SD_ERROR_ADDR_OUT_OF_RANGE;
1315 return HAL_ERROR;
1316 }
1317
1318 hsd->State = HAL_SD_STATE_BUSY;
1319
1320 /* Initialize data control register */
1321 hsd->Instance->DCTRL = 0U;
1322
1323 /* Enable SD Error interrupts */
1324#if defined(SDIO_STA_STBITERR)
1325 __HAL_SD_ENABLE_IT(hsd, (SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_TXUNDERR | SDIO_IT_STBITERR));
1326#else /* SDIO_STA_STBITERR not defined */
1327 __HAL_SD_ENABLE_IT(hsd, (SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_TXUNDERR));
1328#endif /* SDIO_STA_STBITERR */
1329
1330 /* Set the DMA transfer complete callback */
1331 hsd->hdmatx->XferCpltCallback = SD_DMATransmitCplt;
1332
1333 /* Set the DMA error callback */
1334 hsd->hdmatx->XferErrorCallback = SD_DMAError;
1335
1336 /* Set the DMA Abort callback */
1337 hsd->hdmatx->XferAbortCallback = NULL;
1338
1339 if(hsd->SdCard.CardType != CARD_SDHC_SDXC)
1340 {
1341 add *= 512U;
1342 }
1343
1344 /* Write Blocks in Polling mode */
1345 if(NumberOfBlocks > 1U)
1346 {
1347 hsd->Context = (SD_CONTEXT_WRITE_MULTIPLE_BLOCK | SD_CONTEXT_DMA);
1348
1349 /* Write Multi Block command */
1350 errorstate = SDMMC_CmdWriteMultiBlock(hsd->Instance, add);
1351 }
1352 else
1353 {
1354 hsd->Context = (SD_CONTEXT_WRITE_SINGLE_BLOCK | SD_CONTEXT_DMA);
1355
1356 /* Write Single Block command */
1357 errorstate = SDMMC_CmdWriteSingleBlock(hsd->Instance, add);
1358 }
1359 if(errorstate != HAL_SD_ERROR_NONE)
1360 {
1361 /* Clear all the static flags */
1362 __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
1363 hsd->ErrorCode |= errorstate;
1364 hsd->State = HAL_SD_STATE_READY;
1365 hsd->Context = SD_CONTEXT_NONE;
1366 return HAL_ERROR;
1367 }
1368
1369 /* Enable SDIO DMA transfer */
1370 __HAL_SD_DMA_ENABLE(hsd);
1371
1372 /* Force DMA Direction */
1373 hsd->hdmatx->Init.Direction = DMA_MEMORY_TO_PERIPH;
1374 MODIFY_REG(hsd->hdmatx->Instance->CR, DMA_SxCR_DIR, hsd->hdmatx->Init.Direction);
1375
1376 /* Enable the DMA Channel */
1377 if(HAL_DMA_Start_IT(hsd->hdmatx, (uint32_t)pData, (uint32_t)&hsd->Instance->FIFO, (uint32_t)(BLOCKSIZE * NumberOfBlocks)/4U) != HAL_OK)
1378 {
1379#if defined(SDIO_STA_STBITERR)
1380 __HAL_SD_DISABLE_IT(hsd, (SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_TXUNDERR | SDIO_IT_STBITERR));
1381#else /* SDIO_STA_STBITERR not defined */
1382 __HAL_SD_DISABLE_IT(hsd, (SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_TXUNDERR));
1383#endif /* SDIO_STA_STBITERR */
1384 __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
1385 hsd->ErrorCode |= HAL_SD_ERROR_DMA;
1386 hsd->State = HAL_SD_STATE_READY;
1387 hsd->Context = SD_CONTEXT_NONE;
1388 return HAL_ERROR;
1389 }
1390 else
1391 {
1392 /* Configure the SD DPSM (Data Path State Machine) */
1393 config.DataTimeOut = SDMMC_DATATIMEOUT;
1394 config.DataLength = BLOCKSIZE * NumberOfBlocks;
1395 config.DataBlockSize = SDIO_DATABLOCK_SIZE_512B;
1396 config.TransferDir = SDIO_TRANSFER_DIR_TO_CARD;
1397 config.TransferMode = SDIO_TRANSFER_MODE_BLOCK;
1398 config.DPSM = SDIO_DPSM_ENABLE;
1399 (void)SDIO_ConfigData(hsd->Instance, &config);
1400
1401 return HAL_OK;
1402 }
1403 }
1404 else
1405 {
1406 return HAL_BUSY;
1407 }
1408}
1409
1419HAL_StatusTypeDef HAL_SD_Erase(SD_HandleTypeDef *hsd, uint32_t BlockStartAdd, uint32_t BlockEndAdd)
1420{
1421 uint32_t errorstate;
1422 uint32_t start_add = BlockStartAdd;
1423 uint32_t end_add = BlockEndAdd;
1424
1425 if(hsd->State == HAL_SD_STATE_READY)
1426 {
1427 hsd->ErrorCode = HAL_SD_ERROR_NONE;
1428
1429 if(end_add < start_add)
1430 {
1431 hsd->ErrorCode |= HAL_SD_ERROR_PARAM;
1432 return HAL_ERROR;
1433 }
1434
1435 if(end_add > (hsd->SdCard.LogBlockNbr))
1436 {
1437 hsd->ErrorCode |= HAL_SD_ERROR_ADDR_OUT_OF_RANGE;
1438 return HAL_ERROR;
1439 }
1440
1441 hsd->State = HAL_SD_STATE_BUSY;
1442
1443 /* Check if the card command class supports erase command */
1444 if(((hsd->SdCard.Class) & SDIO_CCCC_ERASE) == 0U)
1445 {
1446 /* Clear all the static flags */
1447 __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
1448 hsd->ErrorCode |= HAL_SD_ERROR_REQUEST_NOT_APPLICABLE;
1449 hsd->State = HAL_SD_STATE_READY;
1450 return HAL_ERROR;
1451 }
1452
1453 if((SDIO_GetResponse(hsd->Instance, SDIO_RESP1) & SDMMC_CARD_LOCKED) == SDMMC_CARD_LOCKED)
1454 {
1455 /* Clear all the static flags */
1456 __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
1457 hsd->ErrorCode |= HAL_SD_ERROR_LOCK_UNLOCK_FAILED;
1458 hsd->State = HAL_SD_STATE_READY;
1459 return HAL_ERROR;
1460 }
1461
1462 /* Get start and end block for high capacity cards */
1463 if(hsd->SdCard.CardType != CARD_SDHC_SDXC)
1464 {
1465 start_add *= 512U;
1466 end_add *= 512U;
1467 }
1468
1469 /* According to sd-card spec 1.0 ERASE_GROUP_START (CMD32) and erase_group_end(CMD33) */
1470 if(hsd->SdCard.CardType != CARD_SECURED)
1471 {
1472 /* Send CMD32 SD_ERASE_GRP_START with argument as addr */
1473 errorstate = SDMMC_CmdSDEraseStartAdd(hsd->Instance, start_add);
1474 if(errorstate != HAL_SD_ERROR_NONE)
1475 {
1476 /* Clear all the static flags */
1477 __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
1478 hsd->ErrorCode |= errorstate;
1479 hsd->State = HAL_SD_STATE_READY;
1480 return HAL_ERROR;
1481 }
1482
1483 /* Send CMD33 SD_ERASE_GRP_END with argument as addr */
1484 errorstate = SDMMC_CmdSDEraseEndAdd(hsd->Instance, end_add);
1485 if(errorstate != HAL_SD_ERROR_NONE)
1486 {
1487 /* Clear all the static flags */
1488 __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
1489 hsd->ErrorCode |= errorstate;
1490 hsd->State = HAL_SD_STATE_READY;
1491 return HAL_ERROR;
1492 }
1493 }
1494
1495 /* Send CMD38 ERASE */
1496 errorstate = SDMMC_CmdErase(hsd->Instance);
1497 if(errorstate != HAL_SD_ERROR_NONE)
1498 {
1499 /* Clear all the static flags */
1500 __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
1501 hsd->ErrorCode |= errorstate;
1502 hsd->State = HAL_SD_STATE_READY;
1503 return HAL_ERROR;
1504 }
1505
1506 hsd->State = HAL_SD_STATE_READY;
1507
1508 return HAL_OK;
1509 }
1510 else
1511 {
1512 return HAL_BUSY;
1513 }
1514}
1515
1521void HAL_SD_IRQHandler(SD_HandleTypeDef *hsd)
1522{
1523 uint32_t errorstate;
1524 uint32_t context = hsd->Context;
1525
1526 /* Check for SDIO interrupt flags */
1527 if((__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_RXFIFOHF) != RESET) && ((context & SD_CONTEXT_IT) != 0U))
1528 {
1529 SD_Read_IT(hsd);
1530 }
1531
1532 else if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_DATAEND) != RESET)
1533 {
1534 __HAL_SD_CLEAR_FLAG(hsd, SDIO_FLAG_DATAEND);
1535
1536#if defined(SDIO_STA_STBITERR)
1537 __HAL_SD_DISABLE_IT(hsd, SDIO_IT_DATAEND | SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT|\
1538 SDIO_IT_TXUNDERR | SDIO_IT_RXOVERR | SDIO_IT_TXFIFOHE |\
1539 SDIO_IT_RXFIFOHF | SDIO_IT_STBITERR);
1540#else /* SDIO_STA_STBITERR not defined */
1541 __HAL_SD_DISABLE_IT(hsd, SDIO_IT_DATAEND | SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT|\
1542 SDIO_IT_TXUNDERR | SDIO_IT_RXOVERR | SDIO_IT_TXFIFOHE |\
1543 SDIO_IT_RXFIFOHF);
1544#endif /* SDIO_STA_STBITERR */
1545
1546 hsd->Instance->DCTRL &= ~(SDIO_DCTRL_DTEN);
1547
1548 if((context & SD_CONTEXT_IT) != 0U)
1549 {
1550 if(((context & SD_CONTEXT_READ_MULTIPLE_BLOCK) != 0U) || ((context & SD_CONTEXT_WRITE_MULTIPLE_BLOCK) != 0U))
1551 {
1552 errorstate = SDMMC_CmdStopTransfer(hsd->Instance);
1553 if(errorstate != HAL_SD_ERROR_NONE)
1554 {
1555 hsd->ErrorCode |= errorstate;
1556#if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
1557 hsd->ErrorCallback(hsd);
1558#else
1559 HAL_SD_ErrorCallback(hsd);
1560#endif /* USE_HAL_SD_REGISTER_CALLBACKS */
1561 }
1562 }
1563
1564 /* Clear all the static flags */
1565 __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_DATA_FLAGS);
1566
1567 hsd->State = HAL_SD_STATE_READY;
1568 hsd->Context = SD_CONTEXT_NONE;
1569 if(((context & SD_CONTEXT_READ_SINGLE_BLOCK) != 0U) || ((context & SD_CONTEXT_READ_MULTIPLE_BLOCK) != 0U))
1570 {
1571#if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
1572 hsd->RxCpltCallback(hsd);
1573#else
1574 HAL_SD_RxCpltCallback(hsd);
1575#endif /* USE_HAL_SD_REGISTER_CALLBACKS */
1576 }
1577 else
1578 {
1579#if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
1580 hsd->TxCpltCallback(hsd);
1581#else
1582 HAL_SD_TxCpltCallback(hsd);
1583#endif /* USE_HAL_SD_REGISTER_CALLBACKS */
1584 }
1585 }
1586 else if((context & SD_CONTEXT_DMA) != 0U)
1587 {
1588 if((context & SD_CONTEXT_WRITE_MULTIPLE_BLOCK) != 0U)
1589 {
1590 errorstate = SDMMC_CmdStopTransfer(hsd->Instance);
1591 if(errorstate != HAL_SD_ERROR_NONE)
1592 {
1593 hsd->ErrorCode |= errorstate;
1594#if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
1595 hsd->ErrorCallback(hsd);
1596#else
1597 HAL_SD_ErrorCallback(hsd);
1598#endif /* USE_HAL_SD_REGISTER_CALLBACKS */
1599 }
1600 }
1601 if(((context & SD_CONTEXT_READ_SINGLE_BLOCK) == 0U) && ((context & SD_CONTEXT_READ_MULTIPLE_BLOCK) == 0U))
1602 {
1603 /* Disable the DMA transfer for transmit request by setting the DMAEN bit
1604 in the SD DCTRL register */
1605 hsd->Instance->DCTRL &= (uint32_t)~((uint32_t)SDIO_DCTRL_DMAEN);
1606
1607 hsd->State = HAL_SD_STATE_READY;
1608
1609#if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
1610 hsd->TxCpltCallback(hsd);
1611#else
1612 HAL_SD_TxCpltCallback(hsd);
1613#endif /* USE_HAL_SD_REGISTER_CALLBACKS */
1614 }
1615 }
1616 else
1617 {
1618 /* Nothing to do */
1619 }
1620 }
1621
1622 else if((__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_TXFIFOHE) != RESET) && ((context & SD_CONTEXT_IT) != 0U))
1623 {
1624 SD_Write_IT(hsd);
1625 }
1626
1627#if defined(SDIO_STA_STBITERR)
1628 else if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_RXOVERR | SDIO_FLAG_TXUNDERR | SDIO_FLAG_STBITERR) != RESET)
1629#else /* SDIO_STA_STBITERR not defined */
1630 else if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_RXOVERR | SDIO_FLAG_TXUNDERR) != RESET)
1631#endif /* SDIO_STA_STBITERR */
1632 {
1633 /* Set Error code */
1634 if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_DCRCFAIL) != RESET)
1635 {
1636 hsd->ErrorCode |= HAL_SD_ERROR_DATA_CRC_FAIL;
1637 }
1638 if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_DTIMEOUT) != RESET)
1639 {
1640 hsd->ErrorCode |= HAL_SD_ERROR_DATA_TIMEOUT;
1641 }
1642 if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_RXOVERR) != RESET)
1643 {
1644 hsd->ErrorCode |= HAL_SD_ERROR_RX_OVERRUN;
1645 }
1646 if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_TXUNDERR) != RESET)
1647 {
1648 hsd->ErrorCode |= HAL_SD_ERROR_TX_UNDERRUN;
1649 }
1650#if defined(SDIO_STA_STBITERR)
1651 if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_STBITERR) != RESET)
1652 {
1653 hsd->ErrorCode |= HAL_SD_ERROR_DATA_TIMEOUT;
1654 }
1655#endif /* SDIO_STA_STBITERR */
1656
1657#if defined(SDIO_STA_STBITERR)
1658 /* Clear All flags */
1659 __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_DATA_FLAGS | SDIO_FLAG_STBITERR);
1660
1661 /* Disable all interrupts */
1662 __HAL_SD_DISABLE_IT(hsd, SDIO_IT_DATAEND | SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT|\
1663 SDIO_IT_TXUNDERR| SDIO_IT_RXOVERR | SDIO_IT_STBITERR);
1664#else /* SDIO_STA_STBITERR not defined */
1665 /* Clear All flags */
1666 __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_DATA_FLAGS);
1667
1668 /* Disable all interrupts */
1669 __HAL_SD_DISABLE_IT(hsd, SDIO_IT_DATAEND | SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT|\
1670 SDIO_IT_TXUNDERR| SDIO_IT_RXOVERR);
1671#endif /* SDIO_STA_STBITERR */
1672
1673 hsd->ErrorCode |= SDMMC_CmdStopTransfer(hsd->Instance);
1674
1675 if((context & SD_CONTEXT_IT) != 0U)
1676 {
1677 /* Set the SD state to ready to be able to start again the process */
1678 hsd->State = HAL_SD_STATE_READY;
1679 hsd->Context = SD_CONTEXT_NONE;
1680#if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
1681 hsd->ErrorCallback(hsd);
1682#else
1683 HAL_SD_ErrorCallback(hsd);
1684#endif /* USE_HAL_SD_REGISTER_CALLBACKS */
1685 }
1686 else if((context & SD_CONTEXT_DMA) != 0U)
1687 {
1688 /* Abort the SD DMA channel */
1689 if(((context & SD_CONTEXT_WRITE_SINGLE_BLOCK) != 0U) || ((context & SD_CONTEXT_WRITE_MULTIPLE_BLOCK) != 0U))
1690 {
1691 /* Set the DMA Tx abort callback */
1692 hsd->hdmatx->XferAbortCallback = SD_DMATxAbort;
1693 /* Abort DMA in IT mode */
1694 if(HAL_DMA_Abort_IT(hsd->hdmatx) != HAL_OK)
1695 {
1696 SD_DMATxAbort(hsd->hdmatx);
1697 }
1698 }
1699 else if(((context & SD_CONTEXT_READ_SINGLE_BLOCK) != 0U) || ((context & SD_CONTEXT_READ_MULTIPLE_BLOCK) != 0U))
1700 {
1701 /* Set the DMA Rx abort callback */
1702 hsd->hdmarx->XferAbortCallback = SD_DMARxAbort;
1703 /* Abort DMA in IT mode */
1704 if(HAL_DMA_Abort_IT(hsd->hdmarx) != HAL_OK)
1705 {
1706 SD_DMARxAbort(hsd->hdmarx);
1707 }
1708 }
1709 else
1710 {
1711 hsd->ErrorCode = HAL_SD_ERROR_NONE;
1712 hsd->State = HAL_SD_STATE_READY;
1713 hsd->Context = SD_CONTEXT_NONE;
1714#if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
1715 hsd->AbortCpltCallback(hsd);
1716#else
1717 HAL_SD_AbortCallback(hsd);
1718#endif /* USE_HAL_SD_REGISTER_CALLBACKS */
1719 }
1720 }
1721 else
1722 {
1723 /* Nothing to do */
1724 }
1725 }
1726 else
1727 {
1728 /* Nothing to do */
1729 }
1730}
1731
1737HAL_SD_StateTypeDef HAL_SD_GetState(SD_HandleTypeDef *hsd)
1738{
1739 return hsd->State;
1740}
1741
1748uint32_t HAL_SD_GetError(SD_HandleTypeDef *hsd)
1749{
1750 return hsd->ErrorCode;
1751}
1752
1758__weak void HAL_SD_TxCpltCallback(SD_HandleTypeDef *hsd)
1759{
1760 /* Prevent unused argument(s) compilation warning */
1761 UNUSED(hsd);
1762
1763 /* NOTE : This function should not be modified, when the callback is needed,
1764 the HAL_SD_TxCpltCallback can be implemented in the user file
1765 */
1766}
1767
1773__weak void HAL_SD_RxCpltCallback(SD_HandleTypeDef *hsd)
1774{
1775 /* Prevent unused argument(s) compilation warning */
1776 UNUSED(hsd);
1777
1778 /* NOTE : This function should not be modified, when the callback is needed,
1779 the HAL_SD_RxCpltCallback can be implemented in the user file
1780 */
1781}
1782
1788__weak void HAL_SD_ErrorCallback(SD_HandleTypeDef *hsd)
1789{
1790 /* Prevent unused argument(s) compilation warning */
1791 UNUSED(hsd);
1792
1793 /* NOTE : This function should not be modified, when the callback is needed,
1794 the HAL_SD_ErrorCallback can be implemented in the user file
1795 */
1796}
1797
1803__weak void HAL_SD_AbortCallback(SD_HandleTypeDef *hsd)
1804{
1805 /* Prevent unused argument(s) compilation warning */
1806 UNUSED(hsd);
1807
1808 /* NOTE : This function should not be modified, when the callback is needed,
1809 the HAL_SD_AbortCallback can be implemented in the user file
1810 */
1811}
1812
1813#if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
1829HAL_StatusTypeDef HAL_SD_RegisterCallback(SD_HandleTypeDef *hsd, HAL_SD_CallbackIDTypeDef CallbackID, pSD_CallbackTypeDef pCallback)
1830{
1831 HAL_StatusTypeDef status = HAL_OK;
1832
1833 if(pCallback == NULL)
1834 {
1835 /* Update the error code */
1836 hsd->ErrorCode |= HAL_SD_ERROR_INVALID_CALLBACK;
1837 return HAL_ERROR;
1838 }
1839
1840 /* Process locked */
1841 __HAL_LOCK(hsd);
1842
1843 if(hsd->State == HAL_SD_STATE_READY)
1844 {
1845 switch (CallbackID)
1846 {
1847 case HAL_SD_TX_CPLT_CB_ID :
1848 hsd->TxCpltCallback = pCallback;
1849 break;
1850 case HAL_SD_RX_CPLT_CB_ID :
1851 hsd->RxCpltCallback = pCallback;
1852 break;
1853 case HAL_SD_ERROR_CB_ID :
1854 hsd->ErrorCallback = pCallback;
1855 break;
1856 case HAL_SD_ABORT_CB_ID :
1857 hsd->AbortCpltCallback = pCallback;
1858 break;
1859 case HAL_SD_MSP_INIT_CB_ID :
1860 hsd->MspInitCallback = pCallback;
1861 break;
1862 case HAL_SD_MSP_DEINIT_CB_ID :
1863 hsd->MspDeInitCallback = pCallback;
1864 break;
1865 default :
1866 /* Update the error code */
1867 hsd->ErrorCode |= HAL_SD_ERROR_INVALID_CALLBACK;
1868 /* update return status */
1869 status = HAL_ERROR;
1870 break;
1871 }
1872 }
1873 else if (hsd->State == HAL_SD_STATE_RESET)
1874 {
1875 switch (CallbackID)
1876 {
1877 case HAL_SD_MSP_INIT_CB_ID :
1878 hsd->MspInitCallback = pCallback;
1879 break;
1880 case HAL_SD_MSP_DEINIT_CB_ID :
1881 hsd->MspDeInitCallback = pCallback;
1882 break;
1883 default :
1884 /* Update the error code */
1885 hsd->ErrorCode |= HAL_SD_ERROR_INVALID_CALLBACK;
1886 /* update return status */
1887 status = HAL_ERROR;
1888 break;
1889 }
1890 }
1891 else
1892 {
1893 /* Update the error code */
1894 hsd->ErrorCode |= HAL_SD_ERROR_INVALID_CALLBACK;
1895 /* update return status */
1896 status = HAL_ERROR;
1897 }
1898
1899 /* Release Lock */
1900 __HAL_UNLOCK(hsd);
1901 return status;
1902}
1903
1918HAL_StatusTypeDef HAL_SD_UnRegisterCallback(SD_HandleTypeDef *hsd, HAL_SD_CallbackIDTypeDef CallbackID)
1919{
1920 HAL_StatusTypeDef status = HAL_OK;
1921
1922 /* Process locked */
1923 __HAL_LOCK(hsd);
1924
1925 if(hsd->State == HAL_SD_STATE_READY)
1926 {
1927 switch (CallbackID)
1928 {
1929 case HAL_SD_TX_CPLT_CB_ID :
1930 hsd->TxCpltCallback = HAL_SD_TxCpltCallback;
1931 break;
1932 case HAL_SD_RX_CPLT_CB_ID :
1933 hsd->RxCpltCallback = HAL_SD_RxCpltCallback;
1934 break;
1935 case HAL_SD_ERROR_CB_ID :
1936 hsd->ErrorCallback = HAL_SD_ErrorCallback;
1937 break;
1938 case HAL_SD_ABORT_CB_ID :
1939 hsd->AbortCpltCallback = HAL_SD_AbortCallback;
1940 break;
1941 case HAL_SD_MSP_INIT_CB_ID :
1942 hsd->MspInitCallback = HAL_SD_MspInit;
1943 break;
1944 case HAL_SD_MSP_DEINIT_CB_ID :
1945 hsd->MspDeInitCallback = HAL_SD_MspDeInit;
1946 break;
1947 default :
1948 /* Update the error code */
1949 hsd->ErrorCode |= HAL_SD_ERROR_INVALID_CALLBACK;
1950 /* update return status */
1951 status = HAL_ERROR;
1952 break;
1953 }
1954 }
1955 else if (hsd->State == HAL_SD_STATE_RESET)
1956 {
1957 switch (CallbackID)
1958 {
1959 case HAL_SD_MSP_INIT_CB_ID :
1960 hsd->MspInitCallback = HAL_SD_MspInit;
1961 break;
1962 case HAL_SD_MSP_DEINIT_CB_ID :
1963 hsd->MspDeInitCallback = HAL_SD_MspDeInit;
1964 break;
1965 default :
1966 /* Update the error code */
1967 hsd->ErrorCode |= HAL_SD_ERROR_INVALID_CALLBACK;
1968 /* update return status */
1969 status = HAL_ERROR;
1970 break;
1971 }
1972 }
1973 else
1974 {
1975 /* Update the error code */
1976 hsd->ErrorCode |= HAL_SD_ERROR_INVALID_CALLBACK;
1977 /* update return status */
1978 status = HAL_ERROR;
1979 }
1980
1981 /* Release Lock */
1982 __HAL_UNLOCK(hsd);
1983 return status;
1984}
1985#endif /* USE_HAL_SD_REGISTER_CALLBACKS */
1986
1990
2005
2014HAL_StatusTypeDef HAL_SD_GetCardCID(SD_HandleTypeDef *hsd, HAL_SD_CardCIDTypeDef *pCID)
2015{
2016 pCID->ManufacturerID = (uint8_t)((hsd->CID[0] & 0xFF000000U) >> 24U);
2017
2018 pCID->OEM_AppliID = (uint16_t)((hsd->CID[0] & 0x00FFFF00U) >> 8U);
2019
2020 pCID->ProdName1 = (((hsd->CID[0] & 0x000000FFU) << 24U) | ((hsd->CID[1] & 0xFFFFFF00U) >> 8U));
2021
2022 pCID->ProdName2 = (uint8_t)(hsd->CID[1] & 0x000000FFU);
2023
2024 pCID->ProdRev = (uint8_t)((hsd->CID[2] & 0xFF000000U) >> 24U);
2025
2026 pCID->ProdSN = (((hsd->CID[2] & 0x00FFFFFFU) << 8U) | ((hsd->CID[3] & 0xFF000000U) >> 24U));
2027
2028 pCID->Reserved1 = (uint8_t)((hsd->CID[3] & 0x00F00000U) >> 20U);
2029
2030 pCID->ManufactDate = (uint16_t)((hsd->CID[3] & 0x000FFF00U) >> 8U);
2031
2032 pCID->CID_CRC = (uint8_t)((hsd->CID[3] & 0x000000FEU) >> 1U);
2033
2034 pCID->Reserved2 = 1U;
2035
2036 return HAL_OK;
2037}
2038
2047HAL_StatusTypeDef HAL_SD_GetCardCSD(SD_HandleTypeDef *hsd, HAL_SD_CardCSDTypeDef *pCSD)
2048{
2049 pCSD->CSDStruct = (uint8_t)((hsd->CSD[0] & 0xC0000000U) >> 30U);
2050
2051 pCSD->SysSpecVersion = (uint8_t)((hsd->CSD[0] & 0x3C000000U) >> 26U);
2052
2053 pCSD->Reserved1 = (uint8_t)((hsd->CSD[0] & 0x03000000U) >> 24U);
2054
2055 pCSD->TAAC = (uint8_t)((hsd->CSD[0] & 0x00FF0000U) >> 16U);
2056
2057 pCSD->NSAC = (uint8_t)((hsd->CSD[0] & 0x0000FF00U) >> 8U);
2058
2059 pCSD->MaxBusClkFrec = (uint8_t)(hsd->CSD[0] & 0x000000FFU);
2060
2061 pCSD->CardComdClasses = (uint16_t)((hsd->CSD[1] & 0xFFF00000U) >> 20U);
2062
2063 pCSD->RdBlockLen = (uint8_t)((hsd->CSD[1] & 0x000F0000U) >> 16U);
2064
2065 pCSD->PartBlockRead = (uint8_t)((hsd->CSD[1] & 0x00008000U) >> 15U);
2066
2067 pCSD->WrBlockMisalign = (uint8_t)((hsd->CSD[1] & 0x00004000U) >> 14U);
2068
2069 pCSD->RdBlockMisalign = (uint8_t)((hsd->CSD[1] & 0x00002000U) >> 13U);
2070
2071 pCSD->DSRImpl = (uint8_t)((hsd->CSD[1] & 0x00001000U) >> 12U);
2072
2073 pCSD->Reserved2 = 0U;
2074
2075 if(hsd->SdCard.CardType == CARD_SDSC)
2076 {
2077 pCSD->DeviceSize = (((hsd->CSD[1] & 0x000003FFU) << 2U) | ((hsd->CSD[2] & 0xC0000000U) >> 30U));
2078
2079 pCSD->MaxRdCurrentVDDMin = (uint8_t)((hsd->CSD[2] & 0x38000000U) >> 27U);
2080
2081 pCSD->MaxRdCurrentVDDMax = (uint8_t)((hsd->CSD[2] & 0x07000000U) >> 24U);
2082
2083 pCSD->MaxWrCurrentVDDMin = (uint8_t)((hsd->CSD[2] & 0x00E00000U) >> 21U);
2084
2085 pCSD->MaxWrCurrentVDDMax = (uint8_t)((hsd->CSD[2] & 0x001C0000U) >> 18U);
2086
2087 pCSD->DeviceSizeMul = (uint8_t)((hsd->CSD[2] & 0x00038000U) >> 15U);
2088
2089 hsd->SdCard.BlockNbr = (pCSD->DeviceSize + 1U) ;
2090 hsd->SdCard.BlockNbr *= (1UL << ((pCSD->DeviceSizeMul & 0x07U) + 2U));
2091 hsd->SdCard.BlockSize = (1UL << (pCSD->RdBlockLen & 0x0FU));
2092
2093 hsd->SdCard.LogBlockNbr = (hsd->SdCard.BlockNbr) * ((hsd->SdCard.BlockSize) / 512U);
2094 hsd->SdCard.LogBlockSize = 512U;
2095 }
2096 else if(hsd->SdCard.CardType == CARD_SDHC_SDXC)
2097 {
2098 /* Byte 7 */
2099 pCSD->DeviceSize = (((hsd->CSD[1] & 0x0000003FU) << 16U) | ((hsd->CSD[2] & 0xFFFF0000U) >> 16U));
2100
2101 hsd->SdCard.BlockNbr = ((pCSD->DeviceSize + 1U) * 1024U);
2102 hsd->SdCard.LogBlockNbr = hsd->SdCard.BlockNbr;
2103 hsd->SdCard.BlockSize = 512U;
2104 hsd->SdCard.LogBlockSize = hsd->SdCard.BlockSize;
2105 }
2106 else
2107 {
2108 /* Clear all the static flags */
2109 __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
2110 hsd->ErrorCode |= HAL_SD_ERROR_UNSUPPORTED_FEATURE;
2111 hsd->State = HAL_SD_STATE_READY;
2112 return HAL_ERROR;
2113 }
2114
2115 pCSD->EraseGrSize = (uint8_t)((hsd->CSD[2] & 0x00004000U) >> 14U);
2116
2117 pCSD->EraseGrMul = (uint8_t)((hsd->CSD[2] & 0x00003F80U) >> 7U);
2118
2119 pCSD->WrProtectGrSize = (uint8_t)(hsd->CSD[2] & 0x0000007FU);
2120
2121 pCSD->WrProtectGrEnable = (uint8_t)((hsd->CSD[3] & 0x80000000U) >> 31U);
2122
2123 pCSD->ManDeflECC = (uint8_t)((hsd->CSD[3] & 0x60000000U) >> 29U);
2124
2125 pCSD->WrSpeedFact = (uint8_t)((hsd->CSD[3] & 0x1C000000U) >> 26U);
2126
2127 pCSD->MaxWrBlockLen= (uint8_t)((hsd->CSD[3] & 0x03C00000U) >> 22U);
2128
2129 pCSD->WriteBlockPaPartial = (uint8_t)((hsd->CSD[3] & 0x00200000U) >> 21U);
2130
2131 pCSD->Reserved3 = 0;
2132
2133 pCSD->ContentProtectAppli = (uint8_t)((hsd->CSD[3] & 0x00010000U) >> 16U);
2134
2135 pCSD->FileFormatGroup = (uint8_t)((hsd->CSD[3] & 0x00008000U) >> 15U);
2136
2137 pCSD->CopyFlag = (uint8_t)((hsd->CSD[3] & 0x00004000U) >> 14U);
2138
2139 pCSD->PermWrProtect = (uint8_t)((hsd->CSD[3] & 0x00002000U) >> 13U);
2140
2141 pCSD->TempWrProtect = (uint8_t)((hsd->CSD[3] & 0x00001000U) >> 12U);
2142
2143 pCSD->FileFormat = (uint8_t)((hsd->CSD[3] & 0x00000C00U) >> 10U);
2144
2145 pCSD->ECC= (uint8_t)((hsd->CSD[3] & 0x00000300U) >> 8U);
2146
2147 pCSD->CSD_CRC = (uint8_t)((hsd->CSD[3] & 0x000000FEU) >> 1U);
2148
2149 pCSD->Reserved4 = 1;
2150
2151 return HAL_OK;
2152}
2153
2161HAL_StatusTypeDef HAL_SD_GetCardStatus(SD_HandleTypeDef *hsd, HAL_SD_CardStatusTypeDef *pStatus)
2162{
2163 uint32_t sd_status[16];
2164 uint32_t errorstate;
2165 HAL_StatusTypeDef status = HAL_OK;
2166
2167 errorstate = SD_SendSDStatus(hsd, sd_status);
2168 if(errorstate != HAL_SD_ERROR_NONE)
2169 {
2170 /* Clear all the static flags */
2171 __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
2172 hsd->ErrorCode |= errorstate;
2173 hsd->State = HAL_SD_STATE_READY;
2174 status = HAL_ERROR;
2175 }
2176 else
2177 {
2178 pStatus->DataBusWidth = (uint8_t)((sd_status[0] & 0xC0U) >> 6U);
2179
2180 pStatus->SecuredMode = (uint8_t)((sd_status[0] & 0x20U) >> 5U);
2181
2182 pStatus->CardType = (uint16_t)(((sd_status[0] & 0x00FF0000U) >> 8U) | ((sd_status[0] & 0xFF000000U) >> 24U));
2183
2184 pStatus->ProtectedAreaSize = (((sd_status[1] & 0xFFU) << 24U) | ((sd_status[1] & 0xFF00U) << 8U) |
2185 ((sd_status[1] & 0xFF0000U) >> 8U) | ((sd_status[1] & 0xFF000000U) >> 24U));
2186
2187 pStatus->SpeedClass = (uint8_t)(sd_status[2] & 0xFFU);
2188
2189 pStatus->PerformanceMove = (uint8_t)((sd_status[2] & 0xFF00U) >> 8U);
2190
2191 pStatus->AllocationUnitSize = (uint8_t)((sd_status[2] & 0xF00000U) >> 20U);
2192
2193 pStatus->EraseSize = (uint16_t)(((sd_status[2] & 0xFF000000U) >> 16U) | (sd_status[3] & 0xFFU));
2194
2195 pStatus->EraseTimeout = (uint8_t)((sd_status[3] & 0xFC00U) >> 10U);
2196
2197 pStatus->EraseOffset = (uint8_t)((sd_status[3] & 0x0300U) >> 8U);
2198 }
2199
2200 /* Set Block Size for Card */
2201 errorstate = SDMMC_CmdBlockLength(hsd->Instance, BLOCKSIZE);
2202 if(errorstate != HAL_SD_ERROR_NONE)
2203 {
2204 /* Clear all the static flags */
2205 __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
2206 hsd->ErrorCode = errorstate;
2207 hsd->State = HAL_SD_STATE_READY;
2208 status = HAL_ERROR;
2209 }
2210
2211 return status;
2212}
2213
2221HAL_StatusTypeDef HAL_SD_GetCardInfo(SD_HandleTypeDef *hsd, HAL_SD_CardInfoTypeDef *pCardInfo)
2222{
2223 pCardInfo->CardType = (uint32_t)(hsd->SdCard.CardType);
2224 pCardInfo->CardVersion = (uint32_t)(hsd->SdCard.CardVersion);
2225 pCardInfo->Class = (uint32_t)(hsd->SdCard.Class);
2226 pCardInfo->RelCardAdd = (uint32_t)(hsd->SdCard.RelCardAdd);
2227 pCardInfo->BlockNbr = (uint32_t)(hsd->SdCard.BlockNbr);
2228 pCardInfo->BlockSize = (uint32_t)(hsd->SdCard.BlockSize);
2229 pCardInfo->LogBlockNbr = (uint32_t)(hsd->SdCard.LogBlockNbr);
2230 pCardInfo->LogBlockSize = (uint32_t)(hsd->SdCard.LogBlockSize);
2231
2232 return HAL_OK;
2233}
2234
2246HAL_StatusTypeDef HAL_SD_ConfigWideBusOperation(SD_HandleTypeDef *hsd, uint32_t WideMode)
2247{
2248 SDIO_InitTypeDef Init;
2249 uint32_t errorstate;
2250 HAL_StatusTypeDef status = HAL_OK;
2251
2252 /* Check the parameters */
2253 assert_param(IS_SDIO_BUS_WIDE(WideMode));
2254
2255 /* Change State */
2256 hsd->State = HAL_SD_STATE_BUSY;
2257
2258 if(hsd->SdCard.CardType != CARD_SECURED)
2259 {
2260 if(WideMode == SDIO_BUS_WIDE_8B)
2261 {
2262 hsd->ErrorCode |= HAL_SD_ERROR_UNSUPPORTED_FEATURE;
2263 }
2264 else if(WideMode == SDIO_BUS_WIDE_4B)
2265 {
2266 errorstate = SD_WideBus_Enable(hsd);
2267
2268 hsd->ErrorCode |= errorstate;
2269 }
2270 else if(WideMode == SDIO_BUS_WIDE_1B)
2271 {
2272 errorstate = SD_WideBus_Disable(hsd);
2273
2274 hsd->ErrorCode |= errorstate;
2275 }
2276 else
2277 {
2278 /* WideMode is not a valid argument*/
2279 hsd->ErrorCode |= HAL_SD_ERROR_PARAM;
2280 }
2281 }
2282 else
2283 {
2284 /* MMC Card does not support this feature */
2285 hsd->ErrorCode |= HAL_SD_ERROR_UNSUPPORTED_FEATURE;
2286 }
2287
2288 if(hsd->ErrorCode != HAL_SD_ERROR_NONE)
2289 {
2290 /* Clear all the static flags */
2291 __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
2292 hsd->State = HAL_SD_STATE_READY;
2293 status = HAL_ERROR;
2294 }
2295 else
2296 {
2297 /* Configure the SDIO peripheral */
2298 Init.ClockEdge = hsd->Init.ClockEdge;
2299 Init.ClockBypass = hsd->Init.ClockBypass;
2300 Init.ClockPowerSave = hsd->Init.ClockPowerSave;
2301 Init.BusWide = WideMode;
2302 Init.HardwareFlowControl = hsd->Init.HardwareFlowControl;
2303 Init.ClockDiv = hsd->Init.ClockDiv;
2304 (void)SDIO_Init(hsd->Instance, Init);
2305 }
2306
2307 /* Set Block Size for Card */
2308 errorstate = SDMMC_CmdBlockLength(hsd->Instance, BLOCKSIZE);
2309 if(errorstate != HAL_SD_ERROR_NONE)
2310 {
2311 /* Clear all the static flags */
2312 __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
2313 hsd->ErrorCode |= errorstate;
2314 status = HAL_ERROR;
2315 }
2316
2317 /* Change State */
2318 hsd->State = HAL_SD_STATE_READY;
2319
2320 return status;
2321}
2322
2328HAL_SD_CardStateTypeDef HAL_SD_GetCardState(SD_HandleTypeDef *hsd)
2329{
2330 uint32_t cardstate;
2331 uint32_t errorstate;
2332 uint32_t resp1 = 0;
2333
2334 errorstate = SD_SendStatus(hsd, &resp1);
2335 if(errorstate != HAL_SD_ERROR_NONE)
2336 {
2337 hsd->ErrorCode |= errorstate;
2338 }
2339
2340 cardstate = ((resp1 >> 9U) & 0x0FU);
2341
2342 return (HAL_SD_CardStateTypeDef)cardstate;
2343}
2344
2351HAL_StatusTypeDef HAL_SD_Abort(SD_HandleTypeDef *hsd)
2352{
2353 HAL_SD_CardStateTypeDef CardState;
2354 uint32_t context = hsd->Context;
2355
2356 /* DIsable All interrupts */
2357 __HAL_SD_DISABLE_IT(hsd, SDIO_IT_DATAEND | SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT|\
2358 SDIO_IT_TXUNDERR| SDIO_IT_RXOVERR);
2359
2360 /* Clear All flags */
2361 __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_DATA_FLAGS);
2362
2363 CLEAR_BIT(hsd->Instance->DCTRL, SDIO_DCTRL_DTEN);
2364
2365 if ((context & SD_CONTEXT_DMA) != 0U)
2366 {
2367 /* Disable the SD DMA request */
2368 hsd->Instance->DCTRL &= (uint32_t)~((uint32_t)SDIO_DCTRL_DMAEN);
2369
2370 /* Abort the SD DMA Tx channel */
2371 if (((context & SD_CONTEXT_WRITE_SINGLE_BLOCK) != 0U) || ((context & SD_CONTEXT_WRITE_MULTIPLE_BLOCK) != 0U))
2372 {
2373 if(HAL_DMA_Abort(hsd->hdmatx) != HAL_OK)
2374 {
2375 hsd->ErrorCode |= HAL_SD_ERROR_DMA;
2376 }
2377 }
2378 /* Abort the SD DMA Rx channel */
2379 else if (((context & SD_CONTEXT_READ_SINGLE_BLOCK) != 0U) || ((context & SD_CONTEXT_READ_MULTIPLE_BLOCK) != 0U))
2380 {
2381 if(HAL_DMA_Abort(hsd->hdmarx) != HAL_OK)
2382 {
2383 hsd->ErrorCode |= HAL_SD_ERROR_DMA;
2384 }
2385 }
2386 else
2387 {
2388 /* Nothing to do */
2389 }
2390 }
2391
2392 hsd->State = HAL_SD_STATE_READY;
2393
2394 /* Initialize the SD operation */
2395 hsd->Context = SD_CONTEXT_NONE;
2396
2397 CardState = HAL_SD_GetCardState(hsd);
2398 if((CardState == HAL_SD_CARD_RECEIVING) || (CardState == HAL_SD_CARD_SENDING))
2399 {
2400 hsd->ErrorCode = SDMMC_CmdStopTransfer(hsd->Instance);
2401 }
2402 if(hsd->ErrorCode != HAL_SD_ERROR_NONE)
2403 {
2404 return HAL_ERROR;
2405 }
2406 return HAL_OK;
2407}
2408
2415HAL_StatusTypeDef HAL_SD_Abort_IT(SD_HandleTypeDef *hsd)
2416{
2417 HAL_SD_CardStateTypeDef CardState;
2418 uint32_t context = hsd->Context;
2419
2420 /* Disable All interrupts */
2421 __HAL_SD_DISABLE_IT(hsd, SDIO_IT_DATAEND | SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT|\
2422 SDIO_IT_TXUNDERR| SDIO_IT_RXOVERR);
2423
2424 CLEAR_BIT(hsd->Instance->DCTRL, SDIO_DCTRL_DTEN);
2425
2426 if ((context & SD_CONTEXT_DMA) != 0U)
2427 {
2428 /* Disable the SD DMA request */
2429 hsd->Instance->DCTRL &= (uint32_t)~((uint32_t)SDIO_DCTRL_DMAEN);
2430
2431 /* Abort the SD DMA Tx channel */
2432 if (((context & SD_CONTEXT_WRITE_SINGLE_BLOCK) != 0U) || ((context & SD_CONTEXT_WRITE_MULTIPLE_BLOCK) != 0U))
2433 {
2434 hsd->hdmatx->XferAbortCallback = SD_DMATxAbort;
2435 if(HAL_DMA_Abort_IT(hsd->hdmatx) != HAL_OK)
2436 {
2437 hsd->hdmatx = NULL;
2438 }
2439 }
2440 /* Abort the SD DMA Rx channel */
2441 else if (((context & SD_CONTEXT_READ_SINGLE_BLOCK) != 0U) || ((context & SD_CONTEXT_READ_MULTIPLE_BLOCK) != 0U))
2442 {
2443 hsd->hdmarx->XferAbortCallback = SD_DMARxAbort;
2444 if(HAL_DMA_Abort_IT(hsd->hdmarx) != HAL_OK)
2445 {
2446 hsd->hdmarx = NULL;
2447 }
2448 }
2449 else
2450 {
2451 /* Nothing to do */
2452 }
2453 }
2454 /* No transfer ongoing on both DMA channels*/
2455 else
2456 {
2457 /* Clear All flags */
2458 __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_DATA_FLAGS);
2459
2460 CardState = HAL_SD_GetCardState(hsd);
2461 hsd->State = HAL_SD_STATE_READY;
2462 hsd->Context = SD_CONTEXT_NONE;
2463 if((CardState == HAL_SD_CARD_RECEIVING) || (CardState == HAL_SD_CARD_SENDING))
2464 {
2465 hsd->ErrorCode = SDMMC_CmdStopTransfer(hsd->Instance);
2466 }
2467 if(hsd->ErrorCode != HAL_SD_ERROR_NONE)
2468 {
2469 return HAL_ERROR;
2470 }
2471 else
2472 {
2473#if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
2474 hsd->AbortCpltCallback(hsd);
2475#else
2476 HAL_SD_AbortCallback(hsd);
2477#endif /* USE_HAL_SD_REGISTER_CALLBACKS */
2478 }
2479 }
2480
2481 return HAL_OK;
2482}
2483
2487
2491
2492/* Private function ----------------------------------------------------------*/
2496
2502static void SD_DMATransmitCplt(DMA_HandleTypeDef *hdma)
2503{
2504 SD_HandleTypeDef* hsd = (SD_HandleTypeDef* )(hdma->Parent);
2505
2506 /* Enable DATAEND Interrupt */
2507 __HAL_SD_ENABLE_IT(hsd, (SDIO_IT_DATAEND));
2508}
2509
2515static void SD_DMAReceiveCplt(DMA_HandleTypeDef *hdma)
2516{
2517 SD_HandleTypeDef* hsd = (SD_HandleTypeDef* )(hdma->Parent);
2518 uint32_t errorstate;
2519
2520 /* Send stop command in multiblock write */
2521 if(hsd->Context == (SD_CONTEXT_READ_MULTIPLE_BLOCK | SD_CONTEXT_DMA))
2522 {
2523 errorstate = SDMMC_CmdStopTransfer(hsd->Instance);
2524 if(errorstate != HAL_SD_ERROR_NONE)
2525 {
2526 hsd->ErrorCode |= errorstate;
2527#if (USE_HAL_SD_REGISTER_CALLBACKS == 1)
2528 hsd->ErrorCallback(hsd);
2529#else
2530 HAL_SD_ErrorCallback(hsd);
2531#endif
2532 }
2533 }
2534
2535 /* Disable the DMA transfer for transmit request by setting the DMAEN bit
2536 in the SD DCTRL register */
2537 hsd->Instance->DCTRL &= (uint32_t)~((uint32_t)SDIO_DCTRL_DMAEN);
2538
2539 /* Clear all the static flags */
2540 __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_DATA_FLAGS);
2541
2542 hsd->State = HAL_SD_STATE_READY;
2543 hsd->Context = SD_CONTEXT_NONE;
2544
2545#if (USE_HAL_SD_REGISTER_CALLBACKS == 1)
2546 hsd->RxCpltCallback(hsd);
2547#else
2548 HAL_SD_RxCpltCallback(hsd);
2549#endif
2550}
2551
2557static void SD_DMAError(DMA_HandleTypeDef *hdma)
2558{
2559 SD_HandleTypeDef* hsd = (SD_HandleTypeDef* )(hdma->Parent);
2560 HAL_SD_CardStateTypeDef CardState;
2561 uint32_t RxErrorCode, TxErrorCode;
2562
2563 /* if DMA error is FIFO error ignore it */
2564 if(HAL_DMA_GetError(hdma) != HAL_DMA_ERROR_FE)
2565 {
2566 RxErrorCode = hsd->hdmarx->ErrorCode;
2567 TxErrorCode = hsd->hdmatx->ErrorCode;
2568 if((RxErrorCode == HAL_DMA_ERROR_TE) || (TxErrorCode == HAL_DMA_ERROR_TE))
2569 {
2570 /* Clear All flags */
2571 __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_FLAGS);
2572
2573 /* Disable All interrupts */
2574 __HAL_SD_DISABLE_IT(hsd, SDIO_IT_DATAEND | SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT|\
2575 SDIO_IT_TXUNDERR| SDIO_IT_RXOVERR);
2576
2577 hsd->ErrorCode |= HAL_SD_ERROR_DMA;
2578 CardState = HAL_SD_GetCardState(hsd);
2579 if((CardState == HAL_SD_CARD_RECEIVING) || (CardState == HAL_SD_CARD_SENDING))
2580 {
2581 hsd->ErrorCode |= SDMMC_CmdStopTransfer(hsd->Instance);
2582 }
2583
2584 hsd->State= HAL_SD_STATE_READY;
2585 hsd->Context = SD_CONTEXT_NONE;
2586 }
2587
2588#if (USE_HAL_SD_REGISTER_CALLBACKS == 1)
2589 hsd->ErrorCallback(hsd);
2590#else
2591 HAL_SD_ErrorCallback(hsd);
2592#endif
2593 }
2594}
2595
2601static void SD_DMATxAbort(DMA_HandleTypeDef *hdma)
2602{
2603 SD_HandleTypeDef* hsd = (SD_HandleTypeDef* )(hdma->Parent);
2604 HAL_SD_CardStateTypeDef CardState;
2605
2606 /* Clear All flags */
2607 __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_DATA_FLAGS);
2608
2609 CardState = HAL_SD_GetCardState(hsd);
2610 hsd->State = HAL_SD_STATE_READY;
2611 hsd->Context = SD_CONTEXT_NONE;
2612 if((CardState == HAL_SD_CARD_RECEIVING) || (CardState == HAL_SD_CARD_SENDING))
2613 {
2614 hsd->ErrorCode |= SDMMC_CmdStopTransfer(hsd->Instance);
2615 }
2616
2617 if(hsd->ErrorCode == HAL_SD_ERROR_NONE)
2618 {
2619#if (USE_HAL_SD_REGISTER_CALLBACKS == 1)
2620 hsd->AbortCpltCallback(hsd);
2621#else
2622 HAL_SD_AbortCallback(hsd);
2623#endif
2624 }
2625 else
2626 {
2627#if (USE_HAL_SD_REGISTER_CALLBACKS == 1)
2628 hsd->ErrorCallback(hsd);
2629#else
2630 HAL_SD_ErrorCallback(hsd);
2631#endif
2632 }
2633}
2634
2640static void SD_DMARxAbort(DMA_HandleTypeDef *hdma)
2641{
2642 SD_HandleTypeDef* hsd = (SD_HandleTypeDef* )(hdma->Parent);
2643 HAL_SD_CardStateTypeDef CardState;
2644
2645 /* Clear All flags */
2646 __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_DATA_FLAGS);
2647
2648 CardState = HAL_SD_GetCardState(hsd);
2649 hsd->State = HAL_SD_STATE_READY;
2650 hsd->Context = SD_CONTEXT_NONE;
2651 if((CardState == HAL_SD_CARD_RECEIVING) || (CardState == HAL_SD_CARD_SENDING))
2652 {
2653 hsd->ErrorCode |= SDMMC_CmdStopTransfer(hsd->Instance);
2654 }
2655
2656 if(hsd->ErrorCode == HAL_SD_ERROR_NONE)
2657 {
2658#if (USE_HAL_SD_REGISTER_CALLBACKS == 1)
2659 hsd->AbortCpltCallback(hsd);
2660#else
2661 HAL_SD_AbortCallback(hsd);
2662#endif
2663 }
2664 else
2665 {
2666#if (USE_HAL_SD_REGISTER_CALLBACKS == 1)
2667 hsd->ErrorCallback(hsd);
2668#else
2669 HAL_SD_ErrorCallback(hsd);
2670#endif
2671 }
2672}
2673
2679static uint32_t SD_InitCard(SD_HandleTypeDef *hsd)
2680{
2681 HAL_SD_CardCSDTypeDef CSD;
2682 uint32_t errorstate;
2683 uint16_t sd_rca = 1U;
2684
2685 /* Check the power State */
2686 if(SDIO_GetPowerState(hsd->Instance) == 0U)
2687 {
2688 /* Power off */
2689 return HAL_SD_ERROR_REQUEST_NOT_APPLICABLE;
2690 }
2691
2692 if(hsd->SdCard.CardType != CARD_SECURED)
2693 {
2694 /* Send CMD2 ALL_SEND_CID */
2695 errorstate = SDMMC_CmdSendCID(hsd->Instance);
2696 if(errorstate != HAL_SD_ERROR_NONE)
2697 {
2698 return errorstate;
2699 }
2700 else
2701 {
2702 /* Get Card identification number data */
2703 hsd->CID[0U] = SDIO_GetResponse(hsd->Instance, SDIO_RESP1);
2704 hsd->CID[1U] = SDIO_GetResponse(hsd->Instance, SDIO_RESP2);
2705 hsd->CID[2U] = SDIO_GetResponse(hsd->Instance, SDIO_RESP3);
2706 hsd->CID[3U] = SDIO_GetResponse(hsd->Instance, SDIO_RESP4);
2707 }
2708 }
2709
2710 if(hsd->SdCard.CardType != CARD_SECURED)
2711 {
2712 /* Send CMD3 SET_REL_ADDR with argument 0 */
2713 /* SD Card publishes its RCA. */
2714 errorstate = SDMMC_CmdSetRelAdd(hsd->Instance, &sd_rca);
2715 if(errorstate != HAL_SD_ERROR_NONE)
2716 {
2717 return errorstate;
2718 }
2719 }
2720 if(hsd->SdCard.CardType != CARD_SECURED)
2721 {
2722 /* Get the SD card RCA */
2723 hsd->SdCard.RelCardAdd = sd_rca;
2724
2725 /* Send CMD9 SEND_CSD with argument as card's RCA */
2726 errorstate = SDMMC_CmdSendCSD(hsd->Instance, (uint32_t)(hsd->SdCard.RelCardAdd << 16U));
2727 if(errorstate != HAL_SD_ERROR_NONE)
2728 {
2729 return errorstate;
2730 }
2731 else
2732 {
2733 /* Get Card Specific Data */
2734 hsd->CSD[0U] = SDIO_GetResponse(hsd->Instance, SDIO_RESP1);
2735 hsd->CSD[1U] = SDIO_GetResponse(hsd->Instance, SDIO_RESP2);
2736 hsd->CSD[2U] = SDIO_GetResponse(hsd->Instance, SDIO_RESP3);
2737 hsd->CSD[3U] = SDIO_GetResponse(hsd->Instance, SDIO_RESP4);
2738 }
2739 }
2740
2741 /* Get the Card Class */
2742 hsd->SdCard.Class = (SDIO_GetResponse(hsd->Instance, SDIO_RESP2) >> 20U);
2743
2744 /* Get CSD parameters */
2745 if (HAL_SD_GetCardCSD(hsd, &CSD) != HAL_OK)
2746 {
2747 return HAL_SD_ERROR_UNSUPPORTED_FEATURE;
2748 }
2749
2750 /* Select the Card */
2751 errorstate = SDMMC_CmdSelDesel(hsd->Instance, (uint32_t)(((uint32_t)hsd->SdCard.RelCardAdd) << 16U));
2752 if(errorstate != HAL_SD_ERROR_NONE)
2753 {
2754 return errorstate;
2755 }
2756
2757 /* All cards are initialized */
2758 return HAL_SD_ERROR_NONE;
2759}
2760
2768static uint32_t SD_PowerON(SD_HandleTypeDef *hsd)
2769{
2770 __IO uint32_t count = 0U;
2771 uint32_t response = 0U, validvoltage = 0U;
2772 uint32_t errorstate;
2773
2774 /* CMD0: GO_IDLE_STATE */
2775 errorstate = SDMMC_CmdGoIdleState(hsd->Instance);
2776 if(errorstate != HAL_SD_ERROR_NONE)
2777 {
2778 return errorstate;
2779 }
2780
2781 /* CMD8: SEND_IF_COND: Command available only on V2.0 cards */
2782 errorstate = SDMMC_CmdOperCond(hsd->Instance);
2783 if(errorstate != HAL_SD_ERROR_NONE)
2784 {
2785 hsd->SdCard.CardVersion = CARD_V1_X;
2786 /* CMD0: GO_IDLE_STATE */
2787 errorstate = SDMMC_CmdGoIdleState(hsd->Instance);
2788 if(errorstate != HAL_SD_ERROR_NONE)
2789 {
2790 return errorstate;
2791 }
2792
2793 }
2794 else
2795 {
2796 hsd->SdCard.CardVersion = CARD_V2_X;
2797 }
2798
2799 if( hsd->SdCard.CardVersion == CARD_V2_X)
2800 {
2801 /* SEND CMD55 APP_CMD with RCA as 0 */
2802 errorstate = SDMMC_CmdAppCommand(hsd->Instance, 0);
2803 if(errorstate != HAL_SD_ERROR_NONE)
2804 {
2805 return HAL_SD_ERROR_UNSUPPORTED_FEATURE;
2806 }
2807 }
2808 /* SD CARD */
2809 /* Send ACMD41 SD_APP_OP_COND with Argument 0x80100000 */
2810 while((count < SDMMC_MAX_VOLT_TRIAL) && (validvoltage == 0U))
2811 {
2812 /* SEND CMD55 APP_CMD with RCA as 0 */
2813 errorstate = SDMMC_CmdAppCommand(hsd->Instance, 0);
2814 if(errorstate != HAL_SD_ERROR_NONE)
2815 {
2816 return errorstate;
2817 }
2818
2819 /* Send CMD41 */
2820 errorstate = SDMMC_CmdAppOperCommand(hsd->Instance, SDMMC_VOLTAGE_WINDOW_SD | SDMMC_HIGH_CAPACITY | SD_SWITCH_1_8V_CAPACITY);
2821 if(errorstate != HAL_SD_ERROR_NONE)
2822 {
2823 return HAL_SD_ERROR_UNSUPPORTED_FEATURE;
2824 }
2825
2826 /* Get command response */
2827 response = SDIO_GetResponse(hsd->Instance, SDIO_RESP1);
2828
2829 /* Get operating voltage*/
2830 validvoltage = (((response >> 31U) == 1U) ? 1U : 0U);
2831
2832 count++;
2833 }
2834
2835 if(count >= SDMMC_MAX_VOLT_TRIAL)
2836 {
2837 return HAL_SD_ERROR_INVALID_VOLTRANGE;
2838 }
2839
2840 if((response & SDMMC_HIGH_CAPACITY) == SDMMC_HIGH_CAPACITY) /* (response &= SD_HIGH_CAPACITY) */
2841 {
2842 hsd->SdCard.CardType = CARD_SDHC_SDXC;
2843 }
2844 else
2845 {
2846 hsd->SdCard.CardType = CARD_SDSC;
2847 }
2848
2849
2850 return HAL_SD_ERROR_NONE;
2851}
2852
2858static void SD_PowerOFF(SD_HandleTypeDef *hsd)
2859{
2860 /* Set Power State to OFF */
2861 (void)SDIO_PowerState_OFF(hsd->Instance);
2862}
2863
2871static uint32_t SD_SendSDStatus(SD_HandleTypeDef *hsd, uint32_t *pSDstatus)
2872{
2873 SDIO_DataInitTypeDef config;
2874 uint32_t errorstate;
2875 uint32_t tickstart = HAL_GetTick();
2876 uint32_t count;
2877 uint32_t *pData = pSDstatus;
2878
2879 /* Check SD response */
2880 if((SDIO_GetResponse(hsd->Instance, SDIO_RESP1) & SDMMC_CARD_LOCKED) == SDMMC_CARD_LOCKED)
2881 {
2882 return HAL_SD_ERROR_LOCK_UNLOCK_FAILED;
2883 }
2884
2885 /* Set block size for card if it is not equal to current block size for card */
2886 errorstate = SDMMC_CmdBlockLength(hsd->Instance, 64U);
2887 if(errorstate != HAL_SD_ERROR_NONE)
2888 {
2889 hsd->ErrorCode |= HAL_SD_ERROR_NONE;
2890 return errorstate;
2891 }
2892
2893 /* Send CMD55 */
2894 errorstate = SDMMC_CmdAppCommand(hsd->Instance, (uint32_t)(hsd->SdCard.RelCardAdd << 16U));
2895 if(errorstate != HAL_SD_ERROR_NONE)
2896 {
2897 hsd->ErrorCode |= HAL_SD_ERROR_NONE;
2898 return errorstate;
2899 }
2900
2901 /* Configure the SD DPSM (Data Path State Machine) */
2902 config.DataTimeOut = SDMMC_DATATIMEOUT;
2903 config.DataLength = 64U;
2904 config.DataBlockSize = SDIO_DATABLOCK_SIZE_64B;
2905 config.TransferDir = SDIO_TRANSFER_DIR_TO_SDIO;
2906 config.TransferMode = SDIO_TRANSFER_MODE_BLOCK;
2907 config.DPSM = SDIO_DPSM_ENABLE;
2908 (void)SDIO_ConfigData(hsd->Instance, &config);
2909
2910 /* Send ACMD13 (SD_APP_STAUS) with argument as card's RCA */
2911 errorstate = SDMMC_CmdStatusRegister(hsd->Instance);
2912 if(errorstate != HAL_SD_ERROR_NONE)
2913 {
2914 hsd->ErrorCode |= HAL_SD_ERROR_NONE;
2915 return errorstate;
2916 }
2917
2918 /* Get status data */
2919 while(!__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_RXOVERR | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_DBCKEND))
2920 {
2921 if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_RXFIFOHF))
2922 {
2923 for(count = 0U; count < 8U; count++)
2924 {
2925 *pData = SDIO_ReadFIFO(hsd->Instance);
2926 pData++;
2927 }
2928 }
2929
2930 if((HAL_GetTick() - tickstart) >= SDMMC_SWDATATIMEOUT)
2931 {
2932 return HAL_SD_ERROR_TIMEOUT;
2933 }
2934 }
2935
2936#if defined(SDIO_STA_STBITERR)
2937 if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_DTIMEOUT) || (__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_STBITERR)))
2938#else /* SDIO_STA_STBITERR not defined */
2939 if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_DTIMEOUT))
2940#endif /* SDIO_STA_STBITERR */
2941 {
2942 return HAL_SD_ERROR_DATA_TIMEOUT;
2943 }
2944 else if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_DCRCFAIL))
2945 {
2946 return HAL_SD_ERROR_DATA_CRC_FAIL;
2947 }
2948 else if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_RXOVERR))
2949 {
2950 return HAL_SD_ERROR_RX_OVERRUN;
2951 }
2952 else
2953 {
2954 /* Nothing to do */
2955 }
2956
2957 while ((__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_RXDAVL)))
2958 {
2959 *pData = SDIO_ReadFIFO(hsd->Instance);
2960 pData++;
2961
2962 if((HAL_GetTick() - tickstart) >= SDMMC_SWDATATIMEOUT)
2963 {
2964 return HAL_SD_ERROR_TIMEOUT;
2965 }
2966 }
2967
2968 /* Clear all the static status flags*/
2969 __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_DATA_FLAGS);
2970
2971 return HAL_SD_ERROR_NONE;
2972}
2973
2981static uint32_t SD_SendStatus(SD_HandleTypeDef *hsd, uint32_t *pCardStatus)
2982{
2983 uint32_t errorstate;
2984
2985 if(pCardStatus == NULL)
2986 {
2987 return HAL_SD_ERROR_PARAM;
2988 }
2989
2990 /* Send Status command */
2991 errorstate = SDMMC_CmdSendStatus(hsd->Instance, (uint32_t)(hsd->SdCard.RelCardAdd << 16U));
2992 if(errorstate != HAL_SD_ERROR_NONE)
2993 {
2994 return errorstate;
2995 }
2996
2997 /* Get SD card status */
2998 *pCardStatus = SDIO_GetResponse(hsd->Instance, SDIO_RESP1);
2999
3000 return HAL_SD_ERROR_NONE;
3001}
3002
3008static uint32_t SD_WideBus_Enable(SD_HandleTypeDef *hsd)
3009{
3010 uint32_t scr[2U] = {0U, 0U};
3011 uint32_t errorstate;
3012
3013 if((SDIO_GetResponse(hsd->Instance, SDIO_RESP1) & SDMMC_CARD_LOCKED) == SDMMC_CARD_LOCKED)
3014 {
3015 return HAL_SD_ERROR_LOCK_UNLOCK_FAILED;
3016 }
3017
3018 /* Get SCR Register */
3019 errorstate = SD_FindSCR(hsd, scr);
3020 if(errorstate != HAL_SD_ERROR_NONE)
3021 {
3022 return errorstate;
3023 }
3024
3025 /* If requested card supports wide bus operation */
3026 if((scr[1U] & SDMMC_WIDE_BUS_SUPPORT) != SDMMC_ALLZERO)
3027 {
3028 /* Send CMD55 APP_CMD with argument as card's RCA.*/
3029 errorstate = SDMMC_CmdAppCommand(hsd->Instance, (uint32_t)(hsd->SdCard.RelCardAdd << 16U));
3030 if(errorstate != HAL_SD_ERROR_NONE)
3031 {
3032 return errorstate;
3033 }
3034
3035 /* Send ACMD6 APP_CMD with argument as 2 for wide bus mode */
3036 errorstate = SDMMC_CmdBusWidth(hsd->Instance, 2U);
3037 if(errorstate != HAL_SD_ERROR_NONE)
3038 {
3039 return errorstate;
3040 }
3041
3042 return HAL_SD_ERROR_NONE;
3043 }
3044 else
3045 {
3046 return HAL_SD_ERROR_REQUEST_NOT_APPLICABLE;
3047 }
3048}
3049
3055static uint32_t SD_WideBus_Disable(SD_HandleTypeDef *hsd)
3056{
3057 uint32_t scr[2U] = {0U, 0U};
3058 uint32_t errorstate;
3059
3060 if((SDIO_GetResponse(hsd->Instance, SDIO_RESP1) & SDMMC_CARD_LOCKED) == SDMMC_CARD_LOCKED)
3061 {
3062 return HAL_SD_ERROR_LOCK_UNLOCK_FAILED;
3063 }
3064
3065 /* Get SCR Register */
3066 errorstate = SD_FindSCR(hsd, scr);
3067 if(errorstate != HAL_SD_ERROR_NONE)
3068 {
3069 return errorstate;
3070 }
3071
3072 /* If requested card supports 1 bit mode operation */
3073 if((scr[1U] & SDMMC_SINGLE_BUS_SUPPORT) != SDMMC_ALLZERO)
3074 {
3075 /* Send CMD55 APP_CMD with argument as card's RCA */
3076 errorstate = SDMMC_CmdAppCommand(hsd->Instance, (uint32_t)(hsd->SdCard.RelCardAdd << 16U));
3077 if(errorstate != HAL_SD_ERROR_NONE)
3078 {
3079 return errorstate;
3080 }
3081
3082 /* Send ACMD6 APP_CMD with argument as 0 for single bus mode */
3083 errorstate = SDMMC_CmdBusWidth(hsd->Instance, 0U);
3084 if(errorstate != HAL_SD_ERROR_NONE)
3085 {
3086 return errorstate;
3087 }
3088
3089 return HAL_SD_ERROR_NONE;
3090 }
3091 else
3092 {
3093 return HAL_SD_ERROR_REQUEST_NOT_APPLICABLE;
3094 }
3095}
3096
3097
3104static uint32_t SD_FindSCR(SD_HandleTypeDef *hsd, uint32_t *pSCR)
3105{
3106 SDIO_DataInitTypeDef config;
3107 uint32_t errorstate;
3108 uint32_t tickstart = HAL_GetTick();
3109 uint32_t index = 0U;
3110 uint32_t tempscr[2U] = {0U, 0U};
3111 uint32_t *scr = pSCR;
3112
3113 /* Set Block Size To 8 Bytes */
3114 errorstate = SDMMC_CmdBlockLength(hsd->Instance, 8U);
3115 if(errorstate != HAL_SD_ERROR_NONE)
3116 {
3117 return errorstate;
3118 }
3119
3120 /* Send CMD55 APP_CMD with argument as card's RCA */
3121 errorstate = SDMMC_CmdAppCommand(hsd->Instance, (uint32_t)((hsd->SdCard.RelCardAdd) << 16U));
3122 if(errorstate != HAL_SD_ERROR_NONE)
3123 {
3124 return errorstate;
3125 }
3126
3127 config.DataTimeOut = SDMMC_DATATIMEOUT;
3128 config.DataLength = 8U;
3129 config.DataBlockSize = SDIO_DATABLOCK_SIZE_8B;
3130 config.TransferDir = SDIO_TRANSFER_DIR_TO_SDIO;
3131 config.TransferMode = SDIO_TRANSFER_MODE_BLOCK;
3132 config.DPSM = SDIO_DPSM_ENABLE;
3133 (void)SDIO_ConfigData(hsd->Instance, &config);
3134
3135 /* Send ACMD51 SD_APP_SEND_SCR with argument as 0 */
3136 errorstate = SDMMC_CmdSendSCR(hsd->Instance);
3137 if(errorstate != HAL_SD_ERROR_NONE)
3138 {
3139 return errorstate;
3140 }
3141
3142 while(!__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_RXOVERR | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT))
3143 {
3144 if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_RXDAVL))
3145 {
3146 *(tempscr + index) = SDIO_ReadFIFO(hsd->Instance);
3147 index++;
3148 }
3149 else if(!__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_RXACT))
3150 {
3151 break;
3152 }
3153
3154 if((HAL_GetTick() - tickstart) >= SDMMC_SWDATATIMEOUT)
3155 {
3156 return HAL_SD_ERROR_TIMEOUT;
3157 }
3158 }
3159
3160#if defined(SDIO_STA_STBITERR)
3161 if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_DTIMEOUT) || (__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_STBITERR)))
3162#else /* SDIO_STA_STBITERR not defined */
3163 if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_DTIMEOUT))
3164#endif /* SDIO_STA_STBITERR */
3165 {
3166 __HAL_SD_CLEAR_FLAG(hsd, SDIO_FLAG_DTIMEOUT);
3167
3168 return HAL_SD_ERROR_DATA_TIMEOUT;
3169 }
3170 else if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_DCRCFAIL))
3171 {
3172 __HAL_SD_CLEAR_FLAG(hsd, SDIO_FLAG_DCRCFAIL);
3173
3174 return HAL_SD_ERROR_DATA_CRC_FAIL;
3175 }
3176 else if(__HAL_SD_GET_FLAG(hsd, SDIO_FLAG_RXOVERR))
3177 {
3178 __HAL_SD_CLEAR_FLAG(hsd, SDIO_FLAG_RXOVERR);
3179
3180 return HAL_SD_ERROR_RX_OVERRUN;
3181 }
3182 else
3183 {
3184 /* No error flag set */
3185 /* Clear all the static flags */
3186 __HAL_SD_CLEAR_FLAG(hsd, SDIO_STATIC_DATA_FLAGS);
3187
3188 *scr = (((tempscr[1] & SDMMC_0TO7BITS) << 24) | ((tempscr[1] & SDMMC_8TO15BITS) << 8) |\
3189 ((tempscr[1] & SDMMC_16TO23BITS) >> 8) | ((tempscr[1] & SDMMC_24TO31BITS) >> 24));
3190 scr++;
3191 *scr = (((tempscr[0] & SDMMC_0TO7BITS) << 24) | ((tempscr[0] & SDMMC_8TO15BITS) << 8) |\
3192 ((tempscr[0] & SDMMC_16TO23BITS) >> 8) | ((tempscr[0] & SDMMC_24TO31BITS) >> 24));
3193
3194 }
3195
3196 return HAL_SD_ERROR_NONE;
3197}
3198
3205static void SD_Read_IT(SD_HandleTypeDef *hsd)
3206{
3207 uint32_t count, data, dataremaining;
3208 uint8_t* tmp;
3209
3210 tmp = hsd->pRxBuffPtr;
3211 dataremaining = hsd->RxXferSize;
3212
3213 if (dataremaining > 0U)
3214 {
3215 /* Read data from SDIO Rx FIFO */
3216 for(count = 0U; count < 8U; count++)
3217 {
3218 data = SDIO_ReadFIFO(hsd->Instance);
3219 *tmp = (uint8_t)(data & 0xFFU);
3220 tmp++;
3221 dataremaining--;
3222 *tmp = (uint8_t)((data >> 8U) & 0xFFU);
3223 tmp++;
3224 dataremaining--;
3225 *tmp = (uint8_t)((data >> 16U) & 0xFFU);
3226 tmp++;
3227 dataremaining--;
3228 *tmp = (uint8_t)((data >> 24U) & 0xFFU);
3229 tmp++;
3230 dataremaining--;
3231 }
3232
3233 hsd->pRxBuffPtr = tmp;
3234 hsd->RxXferSize = dataremaining;
3235 }
3236}
3237
3244static void SD_Write_IT(SD_HandleTypeDef *hsd)
3245{
3246 uint32_t count, data, dataremaining;
3247 uint8_t* tmp;
3248
3249 tmp = hsd->pTxBuffPtr;
3250 dataremaining = hsd->TxXferSize;
3251
3252 if (dataremaining > 0U)
3253 {
3254 /* Write data to SDIO Tx FIFO */
3255 for(count = 0U; count < 8U; count++)
3256 {
3257 data = (uint32_t)(*tmp);
3258 tmp++;
3259 dataremaining--;
3260 data |= ((uint32_t)(*tmp) << 8U);
3261 tmp++;
3262 dataremaining--;
3263 data |= ((uint32_t)(*tmp) << 16U);
3264 tmp++;
3265 dataremaining--;
3266 data |= ((uint32_t)(*tmp) << 24U);
3267 tmp++;
3268 dataremaining--;
3269 (void)SDIO_WriteFIFO(hsd->Instance, &data);
3270 }
3271
3272 hsd->pTxBuffPtr = tmp;
3273 hsd->TxXferSize = dataremaining;
3274 }
3275}
3276
3280
3281#endif /* HAL_SD_MODULE_ENABLED */
3282
3286
3290
3291#endif /* SDIO */
DMA_MEMORY_TO_PERIPH
#define DMA_MEMORY_TO_PERIPH
Definition stm32f4xx_hal_dma.h:228
DMA_PERIPH_TO_MEMORY
#define DMA_PERIPH_TO_MEMORY
Definition stm32f4xx_hal_dma.h:227
HAL_DMA_ERROR_FE
#define HAL_DMA_ERROR_FE
Definition stm32f4xx_hal_dma.h:187
HAL_DMA_ERROR_TE
#define HAL_DMA_ERROR_TE
Definition stm32f4xx_hal_dma.h:186
HAL_DMA_Abort
HAL_StatusTypeDef HAL_DMA_Abort(DMA_HandleTypeDef *hdma)
HAL_DMA_Abort_IT
HAL_StatusTypeDef HAL_DMA_Abort_IT(DMA_HandleTypeDef *hdma)
HAL_DMA_Start_IT
HAL_StatusTypeDef HAL_DMA_Start_IT(DMA_HandleTypeDef *hdma, uint32_t SrcAddress, uint32_t DstAddress, uint32_t DataLength)
HAL_DMA_GetError
uint32_t HAL_DMA_GetError(DMA_HandleTypeDef *hdma)
DMA_HandleTypeDef
struct __DMA_HandleTypeDef DMA_HandleTypeDef
DMA handle Structure definition.
HAL_Delay
void HAL_Delay(uint32_t Delay)
This function provides minimum delay (in milliseconds) based on variable incremented.
Definition stm32f4xx_hal.c:390
HAL_GetTick
uint32_t HAL_GetTick(void)
Provides a tick value in millisecond.
Definition stm32f4xx_hal.c:323
assert_param
#define assert_param(expr)
Definition stm32_assert_template.h:46
stm32f4xx_hal.h
This file contains all the functions prototypes for the HAL module driver.
HAL_StatusTypeDef
HAL_StatusTypeDef
HAL Status structures definition.
Definition stm32f4xx_hal_def.h:39
HAL_TIMEOUT
@ HAL_TIMEOUT
Definition stm32f4xx_hal_def.h:43
HAL_ERROR
@ HAL_ERROR
Definition stm32f4xx_hal_def.h:41
HAL_OK
@ HAL_OK
Definition stm32f4xx_hal_def.h:40
HAL_BUSY
@ HAL_BUSY
Definition stm32f4xx_hal_def.h:42
__HAL_UNLOCK
#define __HAL_UNLOCK(__HANDLE__)
Definition stm32f4xx_hal_def.h:105
HAL_UNLOCKED
@ HAL_UNLOCKED
Definition stm32f4xx_hal_def.h:51
__HAL_LOCK
#define __HAL_LOCK(__HANDLE__)
Definition stm32f4xx_hal_def.h:93
__DMA_HandleTypeDef::Parent
void * Parent
Definition stm32f4xx_hal_dma.h:148