STM32F4xx HAL Driver master
STM32CubeF4 HAL / LL Drivers API Reference
Loading...
Searching...
No Matches
stm32f4xx_hal_mmc.c
Go to the documentation of this file.
1
253
254/* Includes ------------------------------------------------------------------*/
255#include "stm32f4xx_hal.h"
256
260
265
266#ifdef HAL_MMC_MODULE_ENABLED
267
268#if defined(SDIO)
269
270/* Private typedef -----------------------------------------------------------*/
271/* Private define ------------------------------------------------------------*/
275#if defined (VDD_VALUE) && (VDD_VALUE <= 1950U)
276#define MMC_VOLTAGE_RANGE EMMC_LOW_VOLTAGE_RANGE
277
278#define MMC_EXT_CSD_PWR_CL_26_INDEX 201
279#define MMC_EXT_CSD_PWR_CL_52_INDEX 200
280#define MMC_EXT_CSD_PWR_CL_DDR_52_INDEX 238
281
282#define MMC_EXT_CSD_PWR_CL_26_POS 8
283#define MMC_EXT_CSD_PWR_CL_52_POS 0
284#define MMC_EXT_CSD_PWR_CL_DDR_52_POS 16
285#else
286#define MMC_VOLTAGE_RANGE EMMC_HIGH_VOLTAGE_RANGE
287
288#define MMC_EXT_CSD_PWR_CL_26_INDEX 203
289#define MMC_EXT_CSD_PWR_CL_52_INDEX 202
290#define MMC_EXT_CSD_PWR_CL_DDR_52_INDEX 239
291
292#define MMC_EXT_CSD_PWR_CL_26_POS 24
293#define MMC_EXT_CSD_PWR_CL_52_POS 16
294#define MMC_EXT_CSD_PWR_CL_DDR_52_POS 24
295#endif
296
297/* Frequencies used in the driver for clock divider calculation */
298#define MMC_INIT_FREQ 400000U /* Initialization phase : 400 kHz max */
302
303/* Private macro -------------------------------------------------------------*/
304/* Private variables ---------------------------------------------------------*/
305/* Private function prototypes -----------------------------------------------*/
306/* Private functions ---------------------------------------------------------*/
310static uint32_t MMC_InitCard(MMC_HandleTypeDef *hmmc);
311static uint32_t MMC_PowerON(MMC_HandleTypeDef *hmmc);
312static uint32_t MMC_SendStatus(MMC_HandleTypeDef *hmmc, uint32_t *pCardStatus);
313static uint32_t MMC_ReadExtCSD(MMC_HandleTypeDef *hmmc, uint32_t *pFieldData, uint16_t FieldIndex, uint32_t Timeout);
314static void MMC_PowerOFF(MMC_HandleTypeDef *hmmc);
315static void MMC_Write_IT(MMC_HandleTypeDef *hmmc);
316static void MMC_Read_IT(MMC_HandleTypeDef *hmmc);
317static void MMC_DMATransmitCplt(DMA_HandleTypeDef *hdma);
318static void MMC_DMAReceiveCplt(DMA_HandleTypeDef *hdma);
319static void MMC_DMAError(DMA_HandleTypeDef *hdma);
320static void MMC_DMATxAbort(DMA_HandleTypeDef *hdma);
321static void MMC_DMARxAbort(DMA_HandleTypeDef *hdma);
322static uint32_t MMC_PwrClassUpdate(MMC_HandleTypeDef *hmmc, uint32_t Wide);
326/* Exported functions --------------------------------------------------------*/
330
345
352HAL_StatusTypeDef HAL_MMC_Init(MMC_HandleTypeDef *hmmc)
353{
354 /* Check the MMC handle allocation */
355 if(hmmc == NULL)
356 {
357 return HAL_ERROR;
358 }
359
360 /* Check the parameters */
361 assert_param(IS_SDIO_ALL_INSTANCE(hmmc->Instance));
362 assert_param(IS_SDIO_CLOCK_EDGE(hmmc->Init.ClockEdge));
363 assert_param(IS_SDIO_CLOCK_BYPASS(hmmc->Init.ClockBypass));
364 assert_param(IS_SDIO_CLOCK_POWER_SAVE(hmmc->Init.ClockPowerSave));
365 assert_param(IS_SDIO_BUS_WIDE(hmmc->Init.BusWide));
366 assert_param(IS_SDIO_HARDWARE_FLOW_CONTROL(hmmc->Init.HardwareFlowControl));
367 assert_param(IS_SDIO_CLKDIV(hmmc->Init.ClockDiv));
368
369 if(hmmc->State == HAL_MMC_STATE_RESET)
370 {
371 /* Allocate lock resource and initialize it */
372 hmmc->Lock = HAL_UNLOCKED;
373#if defined (USE_HAL_MMC_REGISTER_CALLBACKS) && (USE_HAL_MMC_REGISTER_CALLBACKS == 1U)
374 /* Reset Callback pointers in HAL_MMC_STATE_RESET only */
375 hmmc->TxCpltCallback = HAL_MMC_TxCpltCallback;
376 hmmc->RxCpltCallback = HAL_MMC_RxCpltCallback;
377 hmmc->ErrorCallback = HAL_MMC_ErrorCallback;
378 hmmc->AbortCpltCallback = HAL_MMC_AbortCallback;
379
380 if(hmmc->MspInitCallback == NULL)
381 {
382 hmmc->MspInitCallback = HAL_MMC_MspInit;
383 }
384
385 /* Init the low level hardware */
386 hmmc->MspInitCallback(hmmc);
387#else
388 /* Init the low level hardware : GPIO, CLOCK, CORTEX...etc */
389 HAL_MMC_MspInit(hmmc);
390#endif
391 }
392
393 hmmc->State = HAL_MMC_STATE_BUSY;
394
395 /* Initialize the Card parameters */
396 if(HAL_MMC_InitCard(hmmc) == HAL_ERROR)
397 {
398 return HAL_ERROR;
399 }
400
401 /* Initialize the error code */
402 hmmc->ErrorCode = HAL_MMC_ERROR_NONE;
403
404 /* Initialize the MMC operation */
405 hmmc->Context = MMC_CONTEXT_NONE;
406
407 /* Initialize the MMC state */
408 hmmc->State = HAL_MMC_STATE_READY;
409
410 /* Configure bus width */
411 if (hmmc->Init.BusWide != SDIO_BUS_WIDE_1B)
412 {
413 if (HAL_MMC_ConfigWideBusOperation(hmmc, hmmc->Init.BusWide) != HAL_OK)
414 {
415 return HAL_ERROR;
416 }
417 }
418
419 return HAL_OK;
420}
421
429HAL_StatusTypeDef HAL_MMC_InitCard(MMC_HandleTypeDef *hmmc)
430{
431 uint32_t errorstate;
432 MMC_InitTypeDef Init;
433 HAL_StatusTypeDef status;
434
435 /* Default SDIO peripheral configuration for MMC card initialization */
436 Init.ClockEdge = SDIO_CLOCK_EDGE_RISING;
437 Init.ClockBypass = SDIO_CLOCK_BYPASS_DISABLE;
438 Init.ClockPowerSave = SDIO_CLOCK_POWER_SAVE_DISABLE;
439 Init.BusWide = SDIO_BUS_WIDE_1B;
440 Init.HardwareFlowControl = SDIO_HARDWARE_FLOW_CONTROL_DISABLE;
441 Init.ClockDiv = SDIO_INIT_CLK_DIV;
442
443 /* Initialize SDIO peripheral interface with default configuration */
444 status = SDIO_Init(hmmc->Instance, Init);
445 if(status == HAL_ERROR)
446 {
447 return HAL_ERROR;
448 }
449
450 /* Disable SDIO Clock */
451 __HAL_MMC_DISABLE(hmmc);
452
453 /* Set Power State to ON */
454 status = SDIO_PowerState_ON(hmmc->Instance);
455 if(status == HAL_ERROR)
456 {
457 return HAL_ERROR;
458 }
459
460 /* Enable MMC Clock */
461 __HAL_MMC_ENABLE(hmmc);
462
463 /* Required power up waiting time before starting the MMC initialization sequence */
464 HAL_Delay(2);
465
466 /* Identify card operating voltage */
467 errorstate = MMC_PowerON(hmmc);
468 if(errorstate != HAL_MMC_ERROR_NONE)
469 {
470 hmmc->State = HAL_MMC_STATE_READY;
471 hmmc->ErrorCode |= errorstate;
472 return HAL_ERROR;
473 }
474
475 /* Card initialization */
476 errorstate = MMC_InitCard(hmmc);
477 if(errorstate != HAL_MMC_ERROR_NONE)
478 {
479 hmmc->State = HAL_MMC_STATE_READY;
480 hmmc->ErrorCode |= errorstate;
481 return HAL_ERROR;
482 }
483
484 /* Set Block Size for Card */
485 errorstate = SDMMC_CmdBlockLength(hmmc->Instance, MMC_BLOCKSIZE);
486 if(errorstate != HAL_MMC_ERROR_NONE)
487 {
488 /* Clear all the static flags */
489 __HAL_MMC_CLEAR_FLAG(hmmc, SDIO_STATIC_FLAGS);
490 hmmc->ErrorCode |= errorstate;
491 hmmc->State = HAL_MMC_STATE_READY;
492 return HAL_ERROR;
493 }
494
495 return HAL_OK;
496}
497
503HAL_StatusTypeDef HAL_MMC_DeInit(MMC_HandleTypeDef *hmmc)
504{
505 /* Check the MMC handle allocation */
506 if(hmmc == NULL)
507 {
508 return HAL_ERROR;
509 }
510
511 /* Check the parameters */
512 assert_param(IS_SDIO_ALL_INSTANCE(hmmc->Instance));
513
514 hmmc->State = HAL_MMC_STATE_BUSY;
515
516 /* Set MMC power state to off */
517 MMC_PowerOFF(hmmc);
518
519#if defined (USE_HAL_MMC_REGISTER_CALLBACKS) && (USE_HAL_MMC_REGISTER_CALLBACKS == 1U)
520 if(hmmc->MspDeInitCallback == NULL)
521 {
522 hmmc->MspDeInitCallback = HAL_MMC_MspDeInit;
523 }
524
525 /* DeInit the low level hardware */
526 hmmc->MspDeInitCallback(hmmc);
527#else
528 /* De-Initialize the MSP layer */
529 HAL_MMC_MspDeInit(hmmc);
530#endif
531
532 hmmc->ErrorCode = HAL_MMC_ERROR_NONE;
533 hmmc->State = HAL_MMC_STATE_RESET;
534
535 return HAL_OK;
536}
537
538
544__weak void HAL_MMC_MspInit(MMC_HandleTypeDef *hmmc)
545{
546 /* Prevent unused argument(s) compilation warning */
547 UNUSED(hmmc);
548
549 /* NOTE : This function Should not be modified, when the callback is needed,
550 the HAL_MMC_MspInit could be implemented in the user file
551 */
552}
553
559__weak void HAL_MMC_MspDeInit(MMC_HandleTypeDef *hmmc)
560{
561 /* Prevent unused argument(s) compilation warning */
562 UNUSED(hmmc);
563
564 /* NOTE : This function Should not be modified, when the callback is needed,
565 the HAL_MMC_MspDeInit could be implemented in the user file
566 */
567}
568
572
587
600HAL_StatusTypeDef HAL_MMC_ReadBlocks(MMC_HandleTypeDef *hmmc, uint8_t *pData, uint32_t BlockAdd, uint32_t NumberOfBlocks, uint32_t Timeout)
601{
602 SDIO_DataInitTypeDef config;
603 uint32_t errorstate;
604 uint32_t tickstart = HAL_GetTick();
605 uint32_t count, data, dataremaining;
606 uint32_t add = BlockAdd;
607 uint8_t *tempbuff = pData;
608
609 if(NULL == pData)
610 {
611 hmmc->ErrorCode |= HAL_MMC_ERROR_PARAM;
612 return HAL_ERROR;
613 }
614
615 if(hmmc->State == HAL_MMC_STATE_READY)
616 {
617 hmmc->ErrorCode = HAL_MMC_ERROR_NONE;
618
619 if((BlockAdd + NumberOfBlocks) > (hmmc->MmcCard.LogBlockNbr))
620 {
621 hmmc->ErrorCode |= HAL_MMC_ERROR_ADDR_OUT_OF_RANGE;
622 return HAL_ERROR;
623 }
624
625 hmmc->State = HAL_MMC_STATE_BUSY;
626
627 /* Initialize data control register */
628 hmmc->Instance->DCTRL = 0U;
629
630 if ((hmmc->MmcCard.CardType) != MMC_HIGH_CAPACITY_CARD)
631 {
632 add *= 512U;
633 }
634
635 /* Configure the MMC DPSM (Data Path State Machine) */
636 config.DataTimeOut = SDMMC_DATATIMEOUT;
637 config.DataLength = NumberOfBlocks * MMC_BLOCKSIZE;
638 config.DataBlockSize = SDIO_DATABLOCK_SIZE_512B;
639 config.TransferDir = SDIO_TRANSFER_DIR_TO_SDIO;
640 config.TransferMode = SDIO_TRANSFER_MODE_BLOCK;
641 config.DPSM = SDIO_DPSM_ENABLE;
642 (void)SDIO_ConfigData(hmmc->Instance, &config);
643
644 /* Read block(s) in polling mode */
645 if(NumberOfBlocks > 1U)
646 {
647 hmmc->Context = MMC_CONTEXT_READ_MULTIPLE_BLOCK;
648
649 /* Read Multi Block command */
650 errorstate = SDMMC_CmdReadMultiBlock(hmmc->Instance, add);
651 }
652 else
653 {
654 hmmc->Context = MMC_CONTEXT_READ_SINGLE_BLOCK;
655
656 /* Read Single Block command */
657 errorstate = SDMMC_CmdReadSingleBlock(hmmc->Instance, add);
658 }
659 if(errorstate != HAL_MMC_ERROR_NONE)
660 {
661 /* Clear all the static flags */
662 __HAL_MMC_CLEAR_FLAG(hmmc, SDIO_STATIC_FLAGS);
663 hmmc->ErrorCode |= errorstate;
664 hmmc->State = HAL_MMC_STATE_READY;
665 return HAL_ERROR;
666 }
667
668 /* Poll on SDIO flags */
669 dataremaining = config.DataLength;
670#if defined(SDIO_STA_STBITERR)
671 while(!__HAL_MMC_GET_FLAG(hmmc, SDIO_FLAG_RXOVERR | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_DATAEND | SDIO_FLAG_STBITERR))
672#else /* SDIO_STA_STBITERR not defined */
673 while(!__HAL_MMC_GET_FLAG(hmmc, SDIO_FLAG_RXOVERR | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_DATAEND))
674#endif /* SDIO_STA_STBITERR */
675 {
676 if(__HAL_MMC_GET_FLAG(hmmc, SDIO_FLAG_RXFIFOHF) && (dataremaining > 0U))
677 {
678 /* Read data from SDIO Rx FIFO */
679 for(count = 0U; count < 8U; count++)
680 {
681 data = SDIO_ReadFIFO(hmmc->Instance);
682 *tempbuff = (uint8_t)(data & 0xFFU);
683 tempbuff++;
684 dataremaining--;
685 *tempbuff = (uint8_t)((data >> 8U) & 0xFFU);
686 tempbuff++;
687 dataremaining--;
688 *tempbuff = (uint8_t)((data >> 16U) & 0xFFU);
689 tempbuff++;
690 dataremaining--;
691 *tempbuff = (uint8_t)((data >> 24U) & 0xFFU);
692 tempbuff++;
693 dataremaining--;
694 }
695 }
696
697 if(((HAL_GetTick()-tickstart) >= Timeout) || (Timeout == 0U))
698 {
699 /* Clear all the static flags */
700 __HAL_MMC_CLEAR_FLAG(hmmc, SDIO_STATIC_FLAGS);
701 hmmc->ErrorCode |= HAL_MMC_ERROR_TIMEOUT;
702 hmmc->State= HAL_MMC_STATE_READY;
703 return HAL_TIMEOUT;
704 }
705 }
706
707 /* Send stop transmission command in case of multiblock read */
708 if(__HAL_MMC_GET_FLAG(hmmc, SDIO_FLAG_DATAEND) && (NumberOfBlocks > 1U))
709 {
710 /* Send stop transmission command */
711 errorstate = SDMMC_CmdStopTransfer(hmmc->Instance);
712 if(errorstate != HAL_MMC_ERROR_NONE)
713 {
714 /* Clear all the static flags */
715 __HAL_MMC_CLEAR_FLAG(hmmc, SDIO_STATIC_FLAGS);
716 hmmc->ErrorCode |= errorstate;
717 hmmc->State = HAL_MMC_STATE_READY;
718 return HAL_ERROR;
719 }
720 }
721
722 /* Get error state */
723 if(__HAL_MMC_GET_FLAG(hmmc, SDIO_FLAG_DTIMEOUT))
724 {
725 /* Clear all the static flags */
726 __HAL_MMC_CLEAR_FLAG(hmmc, SDIO_STATIC_FLAGS);
727 hmmc->ErrorCode |= HAL_MMC_ERROR_DATA_TIMEOUT;
728 hmmc->State = HAL_MMC_STATE_READY;
729 return HAL_ERROR;
730 }
731 else if(__HAL_MMC_GET_FLAG(hmmc, SDIO_FLAG_DCRCFAIL))
732 {
733 /* Clear all the static flags */
734 __HAL_MMC_CLEAR_FLAG(hmmc, SDIO_STATIC_FLAGS);
735 hmmc->ErrorCode |= HAL_MMC_ERROR_DATA_CRC_FAIL;
736 hmmc->State = HAL_MMC_STATE_READY;
737 return HAL_ERROR;
738 }
739 else if(__HAL_MMC_GET_FLAG(hmmc, SDIO_FLAG_RXOVERR))
740 {
741 /* Clear all the static flags */
742 __HAL_MMC_CLEAR_FLAG(hmmc, SDIO_STATIC_FLAGS);
743 hmmc->ErrorCode |= HAL_MMC_ERROR_RX_OVERRUN;
744 hmmc->State = HAL_MMC_STATE_READY;
745 return HAL_ERROR;
746 }
747 else
748 {
749 /* Nothing to do */
750 }
751
752 /* Empty FIFO if there is still any data */
753 while ((__HAL_MMC_GET_FLAG(hmmc, SDIO_FLAG_RXDAVL)) && (dataremaining > 0U))
754 {
755 data = SDIO_ReadFIFO(hmmc->Instance);
756 *tempbuff = (uint8_t)(data & 0xFFU);
757 tempbuff++;
758 dataremaining--;
759 *tempbuff = (uint8_t)((data >> 8U) & 0xFFU);
760 tempbuff++;
761 dataremaining--;
762 *tempbuff = (uint8_t)((data >> 16U) & 0xFFU);
763 tempbuff++;
764 dataremaining--;
765 *tempbuff = (uint8_t)((data >> 24U) & 0xFFU);
766 tempbuff++;
767 dataremaining--;
768
769 if(((HAL_GetTick()-tickstart) >= Timeout) || (Timeout == 0U))
770 {
771 /* Clear all the static flags */
772 __HAL_MMC_CLEAR_FLAG(hmmc, SDIO_STATIC_FLAGS);
773 hmmc->ErrorCode |= HAL_MMC_ERROR_TIMEOUT;
774 hmmc->State= HAL_MMC_STATE_READY;
775 return HAL_ERROR;
776 }
777 }
778
779 /* Clear all the static flags */
780 __HAL_MMC_CLEAR_FLAG(hmmc, SDIO_STATIC_DATA_FLAGS);
781
782 hmmc->State = HAL_MMC_STATE_READY;
783
784 return HAL_OK;
785 }
786 else
787 {
788 hmmc->ErrorCode |= HAL_MMC_ERROR_BUSY;
789 return HAL_ERROR;
790 }
791}
792
805HAL_StatusTypeDef HAL_MMC_WriteBlocks(MMC_HandleTypeDef *hmmc, uint8_t *pData, uint32_t BlockAdd, uint32_t NumberOfBlocks, uint32_t Timeout)
806{
807 SDIO_DataInitTypeDef config;
808 uint32_t errorstate;
809 uint32_t tickstart = HAL_GetTick();
810 uint32_t count, data, dataremaining;
811 uint32_t add = BlockAdd;
812 uint8_t *tempbuff = pData;
813
814 if(NULL == pData)
815 {
816 hmmc->ErrorCode |= HAL_MMC_ERROR_PARAM;
817 return HAL_ERROR;
818 }
819
820 if(hmmc->State == HAL_MMC_STATE_READY)
821 {
822 hmmc->ErrorCode = HAL_MMC_ERROR_NONE;
823
824 if((BlockAdd + NumberOfBlocks) > (hmmc->MmcCard.LogBlockNbr))
825 {
826 hmmc->ErrorCode |= HAL_MMC_ERROR_ADDR_OUT_OF_RANGE;
827 return HAL_ERROR;
828 }
829
830 hmmc->State = HAL_MMC_STATE_BUSY;
831
832 /* Initialize data control register */
833 hmmc->Instance->DCTRL = 0U;
834
835 if ((hmmc->MmcCard.CardType) != MMC_HIGH_CAPACITY_CARD)
836 {
837 add *= 512U;
838 }
839
840 /* Write Blocks in Polling mode */
841 if(NumberOfBlocks > 1U)
842 {
843 hmmc->Context = MMC_CONTEXT_WRITE_MULTIPLE_BLOCK;
844
845 /* Write Multi Block command */
846 errorstate = SDMMC_CmdWriteMultiBlock(hmmc->Instance, add);
847 }
848 else
849 {
850 hmmc->Context = MMC_CONTEXT_WRITE_SINGLE_BLOCK;
851
852 /* Write Single Block command */
853 errorstate = SDMMC_CmdWriteSingleBlock(hmmc->Instance, add);
854 }
855 if(errorstate != HAL_MMC_ERROR_NONE)
856 {
857 /* Clear all the static flags */
858 __HAL_MMC_CLEAR_FLAG(hmmc, SDIO_STATIC_FLAGS);
859 hmmc->ErrorCode |= errorstate;
860 hmmc->State = HAL_MMC_STATE_READY;
861 return HAL_ERROR;
862 }
863
864 /* Configure the MMC DPSM (Data Path State Machine) */
865 config.DataTimeOut = SDMMC_DATATIMEOUT;
866 config.DataLength = NumberOfBlocks * MMC_BLOCKSIZE;
867 config.DataBlockSize = SDIO_DATABLOCK_SIZE_512B;
868 config.TransferDir = SDIO_TRANSFER_DIR_TO_CARD;
869 config.TransferMode = SDIO_TRANSFER_MODE_BLOCK;
870 config.DPSM = SDIO_DPSM_ENABLE;
871 (void)SDIO_ConfigData(hmmc->Instance, &config);
872
873 /* Write block(s) in polling mode */
874 dataremaining = config.DataLength;
875#if defined(SDIO_STA_STBITERR)
876 while(!__HAL_MMC_GET_FLAG(hmmc, SDIO_FLAG_TXUNDERR | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_DATAEND | SDIO_FLAG_STBITERR))
877#else /* SDIO_STA_STBITERR not defined */
878 while(!__HAL_MMC_GET_FLAG(hmmc, SDIO_FLAG_TXUNDERR | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_DATAEND))
879#endif /* SDIO_STA_STBITERR */
880 {
881 if(__HAL_MMC_GET_FLAG(hmmc, SDIO_FLAG_TXFIFOHE) && (dataremaining > 0U))
882 {
883 /* Write data to SDIO Tx FIFO */
884 for(count = 0U; count < 8U; count++)
885 {
886 data = (uint32_t)(*tempbuff);
887 tempbuff++;
888 dataremaining--;
889 data |= ((uint32_t)(*tempbuff) << 8U);
890 tempbuff++;
891 dataremaining--;
892 data |= ((uint32_t)(*tempbuff) << 16U);
893 tempbuff++;
894 dataremaining--;
895 data |= ((uint32_t)(*tempbuff) << 24U);
896 tempbuff++;
897 dataremaining--;
898 (void)SDIO_WriteFIFO(hmmc->Instance, &data);
899 }
900 }
901
902 if(((HAL_GetTick()-tickstart) >= Timeout) || (Timeout == 0U))
903 {
904 /* Clear all the static flags */
905 __HAL_MMC_CLEAR_FLAG(hmmc, SDIO_STATIC_FLAGS);
906 hmmc->ErrorCode |= errorstate;
907 hmmc->State = HAL_MMC_STATE_READY;
908 return HAL_TIMEOUT;
909 }
910 }
911
912 /* Send stop transmission command in case of multiblock write */
913 if(__HAL_MMC_GET_FLAG(hmmc, SDIO_FLAG_DATAEND) && (NumberOfBlocks > 1U))
914 {
915 /* Send stop transmission command */
916 errorstate = SDMMC_CmdStopTransfer(hmmc->Instance);
917 if(errorstate != HAL_MMC_ERROR_NONE)
918 {
919 /* Clear all the static flags */
920 __HAL_MMC_CLEAR_FLAG(hmmc, SDIO_STATIC_FLAGS);
921 hmmc->ErrorCode |= errorstate;
922 hmmc->State = HAL_MMC_STATE_READY;
923 return HAL_ERROR;
924 }
925 }
926
927 /* Get error state */
928 if(__HAL_MMC_GET_FLAG(hmmc, SDIO_FLAG_DTIMEOUT))
929 {
930 /* Clear all the static flags */
931 __HAL_MMC_CLEAR_FLAG(hmmc, SDIO_STATIC_FLAGS);
932 hmmc->ErrorCode |= HAL_MMC_ERROR_DATA_TIMEOUT;
933 hmmc->State = HAL_MMC_STATE_READY;
934 return HAL_ERROR;
935 }
936 else if(__HAL_MMC_GET_FLAG(hmmc, SDIO_FLAG_DCRCFAIL))
937 {
938 /* Clear all the static flags */
939 __HAL_MMC_CLEAR_FLAG(hmmc, SDIO_STATIC_FLAGS);
940 hmmc->ErrorCode |= HAL_MMC_ERROR_DATA_CRC_FAIL;
941 hmmc->State = HAL_MMC_STATE_READY;
942 return HAL_ERROR;
943 }
944 else if(__HAL_MMC_GET_FLAG(hmmc, SDIO_FLAG_TXUNDERR))
945 {
946 /* Clear all the static flags */
947 __HAL_MMC_CLEAR_FLAG(hmmc, SDIO_STATIC_FLAGS);
948 hmmc->ErrorCode |= HAL_MMC_ERROR_TX_UNDERRUN;
949 hmmc->State = HAL_MMC_STATE_READY;
950 return HAL_ERROR;
951 }
952 else
953 {
954 /* Nothing to do */
955 }
956
957 /* Clear all the static flags */
958 __HAL_MMC_CLEAR_FLAG(hmmc, SDIO_STATIC_DATA_FLAGS);
959
960 hmmc->State = HAL_MMC_STATE_READY;
961
962 return HAL_OK;
963 }
964 else
965 {
966 hmmc->ErrorCode |= HAL_MMC_ERROR_BUSY;
967 return HAL_ERROR;
968 }
969}
970
984HAL_StatusTypeDef HAL_MMC_ReadBlocks_IT(MMC_HandleTypeDef *hmmc, uint8_t *pData, uint32_t BlockAdd, uint32_t NumberOfBlocks)
985{
986 SDIO_DataInitTypeDef config;
987 uint32_t errorstate;
988 uint32_t add = BlockAdd;
989
990 if(NULL == pData)
991 {
992 hmmc->ErrorCode |= HAL_MMC_ERROR_PARAM;
993 return HAL_ERROR;
994 }
995
996 if(hmmc->State == HAL_MMC_STATE_READY)
997 {
998 hmmc->ErrorCode = HAL_MMC_ERROR_NONE;
999
1000 if((BlockAdd + NumberOfBlocks) > (hmmc->MmcCard.LogBlockNbr))
1001 {
1002 hmmc->ErrorCode |= HAL_MMC_ERROR_ADDR_OUT_OF_RANGE;
1003 return HAL_ERROR;
1004 }
1005
1006 hmmc->State = HAL_MMC_STATE_BUSY;
1007
1008 /* Initialize data control register */
1009 hmmc->Instance->DCTRL = 0U;
1010
1011 hmmc->pRxBuffPtr = pData;
1012 hmmc->RxXferSize = MMC_BLOCKSIZE * NumberOfBlocks;
1013
1014#if defined(SDIO_STA_STBITERR)
1015 __HAL_MMC_ENABLE_IT(hmmc, (SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_RXOVERR | SDIO_IT_DATAEND | SDIO_FLAG_RXFIFOHF | SDIO_IT_STBITERR));
1016#else /* SDIO_STA_STBITERR not defined */
1017 __HAL_MMC_ENABLE_IT(hmmc, (SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_RXOVERR | SDIO_IT_DATAEND | SDIO_FLAG_RXFIFOHF));
1018#endif /* SDIO_STA_STBITERR */
1019
1020 if ((hmmc->MmcCard.CardType) != MMC_HIGH_CAPACITY_CARD)
1021 {
1022 add *= 512U;
1023 }
1024
1025 /* Configure the MMC DPSM (Data Path State Machine) */
1026 config.DataTimeOut = SDMMC_DATATIMEOUT;
1027 config.DataLength = MMC_BLOCKSIZE * NumberOfBlocks;
1028 config.DataBlockSize = SDIO_DATABLOCK_SIZE_512B;
1029 config.TransferDir = SDIO_TRANSFER_DIR_TO_SDIO;
1030 config.TransferMode = SDIO_TRANSFER_MODE_BLOCK;
1031 config.DPSM = SDIO_DPSM_ENABLE;
1032 (void)SDIO_ConfigData(hmmc->Instance, &config);
1033
1034 /* Read Blocks in IT mode */
1035 if(NumberOfBlocks > 1U)
1036 {
1037 hmmc->Context = (MMC_CONTEXT_READ_MULTIPLE_BLOCK | MMC_CONTEXT_IT);
1038
1039 /* Read Multi Block command */
1040 errorstate = SDMMC_CmdReadMultiBlock(hmmc->Instance, add);
1041 }
1042 else
1043 {
1044 hmmc->Context = (MMC_CONTEXT_READ_SINGLE_BLOCK | MMC_CONTEXT_IT);
1045
1046 /* Read Single Block command */
1047 errorstate = SDMMC_CmdReadSingleBlock(hmmc->Instance, add);
1048 }
1049
1050 if(errorstate != HAL_MMC_ERROR_NONE)
1051 {
1052 /* Clear all the static flags */
1053 __HAL_MMC_CLEAR_FLAG(hmmc, SDIO_STATIC_FLAGS);
1054 hmmc->ErrorCode |= errorstate;
1055 hmmc->State = HAL_MMC_STATE_READY;
1056 return HAL_ERROR;
1057 }
1058
1059 return HAL_OK;
1060 }
1061 else
1062 {
1063 return HAL_BUSY;
1064 }
1065}
1066
1080HAL_StatusTypeDef HAL_MMC_WriteBlocks_IT(MMC_HandleTypeDef *hmmc, uint8_t *pData, uint32_t BlockAdd, uint32_t NumberOfBlocks)
1081{
1082 SDIO_DataInitTypeDef config;
1083 uint32_t errorstate;
1084 uint32_t add = BlockAdd;
1085
1086 if(NULL == pData)
1087 {
1088 hmmc->ErrorCode |= HAL_MMC_ERROR_PARAM;
1089 return HAL_ERROR;
1090 }
1091
1092 if(hmmc->State == HAL_MMC_STATE_READY)
1093 {
1094 hmmc->ErrorCode = HAL_MMC_ERROR_NONE;
1095
1096 if((BlockAdd + NumberOfBlocks) > (hmmc->MmcCard.LogBlockNbr))
1097 {
1098 hmmc->ErrorCode |= HAL_MMC_ERROR_ADDR_OUT_OF_RANGE;
1099 return HAL_ERROR;
1100 }
1101
1102 hmmc->State = HAL_MMC_STATE_BUSY;
1103
1104 /* Initialize data control register */
1105 hmmc->Instance->DCTRL = 0U;
1106
1107 hmmc->pTxBuffPtr = pData;
1108 hmmc->TxXferSize = MMC_BLOCKSIZE * NumberOfBlocks;
1109
1110 /* Enable transfer interrupts */
1111#if defined(SDIO_STA_STBITERR)
1112 __HAL_MMC_ENABLE_IT(hmmc, (SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_TXUNDERR | SDIO_IT_DATAEND | SDIO_FLAG_TXFIFOHE | SDIO_IT_STBITERR));
1113#else /* SDIO_STA_STBITERR not defined */
1114 __HAL_MMC_ENABLE_IT(hmmc, (SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_TXUNDERR | SDIO_IT_DATAEND | SDIO_FLAG_TXFIFOHE));
1115#endif /* SDIO_STA_STBITERR */
1116
1117 if ((hmmc->MmcCard.CardType) != MMC_HIGH_CAPACITY_CARD)
1118 {
1119 add *= 512U;
1120 }
1121
1122 /* Write Blocks in Polling mode */
1123 if(NumberOfBlocks > 1U)
1124 {
1125 hmmc->Context = (MMC_CONTEXT_WRITE_MULTIPLE_BLOCK| MMC_CONTEXT_IT);
1126
1127 /* Write Multi Block command */
1128 errorstate = SDMMC_CmdWriteMultiBlock(hmmc->Instance, add);
1129 }
1130 else
1131 {
1132 hmmc->Context = (MMC_CONTEXT_WRITE_SINGLE_BLOCK | MMC_CONTEXT_IT);
1133
1134 /* Write Single Block command */
1135 errorstate = SDMMC_CmdWriteSingleBlock(hmmc->Instance, add);
1136 }
1137 if(errorstate != HAL_MMC_ERROR_NONE)
1138 {
1139 /* Clear all the static flags */
1140 __HAL_MMC_CLEAR_FLAG(hmmc, SDIO_STATIC_FLAGS);
1141 hmmc->ErrorCode |= errorstate;
1142 hmmc->State = HAL_MMC_STATE_READY;
1143 return HAL_ERROR;
1144 }
1145
1146 /* Configure the MMC DPSM (Data Path State Machine) */
1147 config.DataTimeOut = SDMMC_DATATIMEOUT;
1148 config.DataLength = MMC_BLOCKSIZE * NumberOfBlocks;
1149 config.DataBlockSize = SDIO_DATABLOCK_SIZE_512B;
1150 config.TransferDir = SDIO_TRANSFER_DIR_TO_CARD;
1151 config.TransferMode = SDIO_TRANSFER_MODE_BLOCK;
1152 config.DPSM = SDIO_DPSM_ENABLE;
1153 (void)SDIO_ConfigData(hmmc->Instance, &config);
1154
1155 return HAL_OK;
1156 }
1157 else
1158 {
1159 return HAL_BUSY;
1160 }
1161}
1162
1176HAL_StatusTypeDef HAL_MMC_ReadBlocks_DMA(MMC_HandleTypeDef *hmmc, uint8_t *pData, uint32_t BlockAdd, uint32_t NumberOfBlocks)
1177{
1178 SDIO_DataInitTypeDef config;
1179 uint32_t errorstate;
1180 uint32_t add = BlockAdd;
1181
1182 if(NULL == pData)
1183 {
1184 hmmc->ErrorCode |= HAL_MMC_ERROR_PARAM;
1185 return HAL_ERROR;
1186 }
1187
1188 if(hmmc->State == HAL_MMC_STATE_READY)
1189 {
1190 hmmc->ErrorCode = HAL_MMC_ERROR_NONE;
1191
1192 if((BlockAdd + NumberOfBlocks) > (hmmc->MmcCard.LogBlockNbr))
1193 {
1194 hmmc->ErrorCode |= HAL_MMC_ERROR_ADDR_OUT_OF_RANGE;
1195 return HAL_ERROR;
1196 }
1197
1198 hmmc->State = HAL_MMC_STATE_BUSY;
1199
1200 /* Initialize data control register */
1201 hmmc->Instance->DCTRL = 0U;
1202
1203#if defined(SDIO_STA_STBITERR)
1204 __HAL_MMC_ENABLE_IT(hmmc, (SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_RXOVERR | SDIO_IT_DATAEND | SDIO_IT_STBITERR));
1205#else /* SDIO_STA_STBITERR not defined */
1206 __HAL_MMC_ENABLE_IT(hmmc, (SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_RXOVERR | SDIO_IT_DATAEND));
1207#endif /* SDIO_STA_STBITERR */
1208
1209 /* Set the DMA transfer complete callback */
1210 hmmc->hdmarx->XferCpltCallback = MMC_DMAReceiveCplt;
1211
1212 /* Set the DMA error callback */
1213 hmmc->hdmarx->XferErrorCallback = MMC_DMAError;
1214
1215 /* Set the DMA Abort callback */
1216 hmmc->hdmarx->XferAbortCallback = NULL;
1217
1218 if ((hmmc->MmcCard.CardType) != MMC_HIGH_CAPACITY_CARD)
1219 {
1220 add *= 512U;
1221 }
1222
1223 /* Force DMA Direction */
1224 hmmc->hdmarx->Init.Direction = DMA_PERIPH_TO_MEMORY;
1225 MODIFY_REG(hmmc->hdmarx->Instance->CR, DMA_SxCR_DIR, hmmc->hdmarx->Init.Direction);
1226
1227 /* Enable the DMA Channel */
1228 if(HAL_DMA_Start_IT(hmmc->hdmarx, (uint32_t)&hmmc->Instance->FIFO, (uint32_t)pData, (uint32_t)(MMC_BLOCKSIZE * NumberOfBlocks)/4) != HAL_OK)
1229 {
1230 __HAL_MMC_DISABLE_IT(hmmc, (SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_RXOVERR | SDIO_IT_DATAEND));
1231 __HAL_MMC_CLEAR_FLAG(hmmc, SDIO_STATIC_FLAGS);
1232 hmmc->ErrorCode = HAL_MMC_ERROR_DMA;
1233 hmmc->State = HAL_MMC_STATE_READY;
1234 return HAL_ERROR;
1235 }
1236 else
1237 {
1238 /* Enable MMC DMA transfer */
1239 __HAL_MMC_DMA_ENABLE(hmmc);
1240
1241 /* Configure the MMC DPSM (Data Path State Machine) */
1242 config.DataTimeOut = SDMMC_DATATIMEOUT;
1243 config.DataLength = MMC_BLOCKSIZE * NumberOfBlocks;
1244 config.DataBlockSize = SDIO_DATABLOCK_SIZE_512B;
1245 config.TransferDir = SDIO_TRANSFER_DIR_TO_SDIO;
1246 config.TransferMode = SDIO_TRANSFER_MODE_BLOCK;
1247 config.DPSM = SDIO_DPSM_ENABLE;
1248 (void)SDIO_ConfigData(hmmc->Instance, &config);
1249
1250 /* Read Blocks in DMA mode */
1251 if(NumberOfBlocks > 1U)
1252 {
1253 hmmc->Context = (MMC_CONTEXT_READ_MULTIPLE_BLOCK | MMC_CONTEXT_DMA);
1254
1255 /* Read Multi Block command */
1256 errorstate = SDMMC_CmdReadMultiBlock(hmmc->Instance, add);
1257 }
1258 else
1259 {
1260 hmmc->Context = (MMC_CONTEXT_READ_SINGLE_BLOCK | MMC_CONTEXT_DMA);
1261
1262 /* Read Single Block command */
1263 errorstate = SDMMC_CmdReadSingleBlock(hmmc->Instance, add);
1264 }
1265 if(errorstate != HAL_MMC_ERROR_NONE)
1266 {
1267 /* Clear all the static flags */
1268 __HAL_MMC_CLEAR_FLAG(hmmc, SDIO_STATIC_FLAGS);
1269 __HAL_MMC_DISABLE_IT(hmmc, (SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_RXOVERR | SDIO_IT_DATAEND));
1270 hmmc->ErrorCode = errorstate;
1271 hmmc->State = HAL_MMC_STATE_READY;
1272 return HAL_ERROR;
1273 }
1274
1275 return HAL_OK;
1276 }
1277 }
1278 else
1279 {
1280 return HAL_BUSY;
1281 }
1282}
1283
1297HAL_StatusTypeDef HAL_MMC_WriteBlocks_DMA(MMC_HandleTypeDef *hmmc, uint8_t *pData, uint32_t BlockAdd, uint32_t NumberOfBlocks)
1298{
1299 SDIO_DataInitTypeDef config;
1300 uint32_t errorstate;
1301 uint32_t add = BlockAdd;
1302
1303 if(NULL == pData)
1304 {
1305 hmmc->ErrorCode |= HAL_MMC_ERROR_PARAM;
1306 return HAL_ERROR;
1307 }
1308
1309 if(hmmc->State == HAL_MMC_STATE_READY)
1310 {
1311 hmmc->ErrorCode = HAL_MMC_ERROR_NONE;
1312
1313 if((BlockAdd + NumberOfBlocks) > (hmmc->MmcCard.LogBlockNbr))
1314 {
1315 hmmc->ErrorCode |= HAL_MMC_ERROR_ADDR_OUT_OF_RANGE;
1316 return HAL_ERROR;
1317 }
1318
1319 hmmc->State = HAL_MMC_STATE_BUSY;
1320
1321 /* Initialize data control register */
1322 hmmc->Instance->DCTRL = 0U;
1323
1324 /* Enable MMC Error interrupts */
1325#if defined(SDIO_STA_STBITERR)
1326 __HAL_MMC_ENABLE_IT(hmmc, (SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_TXUNDERR | SDIO_IT_STBITERR));
1327#else /* SDIO_STA_STBITERR not defined */
1328 __HAL_MMC_ENABLE_IT(hmmc, (SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_TXUNDERR));
1329#endif /* SDIO_STA_STBITERR */
1330
1331 /* Set the DMA transfer complete callback */
1332 hmmc->hdmatx->XferCpltCallback = MMC_DMATransmitCplt;
1333
1334 /* Set the DMA error callback */
1335 hmmc->hdmatx->XferErrorCallback = MMC_DMAError;
1336
1337 /* Set the DMA Abort callback */
1338 hmmc->hdmatx->XferAbortCallback = NULL;
1339
1340 if ((hmmc->MmcCard.CardType) != MMC_HIGH_CAPACITY_CARD)
1341 {
1342 add *= 512U;
1343 }
1344
1345
1346 /* Write Blocks in Polling mode */
1347 if(NumberOfBlocks > 1U)
1348 {
1349 hmmc->Context = (MMC_CONTEXT_WRITE_MULTIPLE_BLOCK | MMC_CONTEXT_DMA);
1350
1351 /* Write Multi Block command */
1352 errorstate = SDMMC_CmdWriteMultiBlock(hmmc->Instance, add);
1353 }
1354 else
1355 {
1356 hmmc->Context = (MMC_CONTEXT_WRITE_SINGLE_BLOCK | MMC_CONTEXT_DMA);
1357
1358 /* Write Single Block command */
1359 errorstate = SDMMC_CmdWriteSingleBlock(hmmc->Instance, add);
1360 }
1361 if(errorstate != HAL_MMC_ERROR_NONE)
1362 {
1363 /* Clear all the static flags */
1364 __HAL_MMC_CLEAR_FLAG(hmmc, SDIO_STATIC_FLAGS);
1365 __HAL_MMC_DISABLE_IT(hmmc, (SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_TXUNDERR | SDIO_IT_DATAEND));
1366 hmmc->ErrorCode |= errorstate;
1367 hmmc->State = HAL_MMC_STATE_READY;
1368 return HAL_ERROR;
1369 }
1370
1371 /* Enable SDIO DMA transfer */
1372 __HAL_MMC_DMA_ENABLE(hmmc);
1373
1374 /* Force DMA Direction */
1375 hmmc->hdmatx->Init.Direction = DMA_MEMORY_TO_PERIPH;
1376 MODIFY_REG(hmmc->hdmatx->Instance->CR, DMA_SxCR_DIR, hmmc->hdmatx->Init.Direction);
1377
1378 /* Enable the DMA Channel */
1379 if(HAL_DMA_Start_IT(hmmc->hdmatx, (uint32_t)pData, (uint32_t)&hmmc->Instance->FIFO, (uint32_t)(MMC_BLOCKSIZE * NumberOfBlocks)/4) != HAL_OK)
1380 {
1381 __HAL_MMC_DISABLE_IT(hmmc, (SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT | SDIO_IT_TXUNDERR | SDIO_IT_DATAEND));
1382 __HAL_MMC_CLEAR_FLAG(hmmc, SDIO_STATIC_FLAGS);
1383 hmmc->ErrorCode |= HAL_MMC_ERROR_DMA;
1384 hmmc->State = HAL_MMC_STATE_READY;
1385 return HAL_ERROR;
1386 }
1387 else
1388 {
1389 /* Configure the MMC DPSM (Data Path State Machine) */
1390 config.DataTimeOut = SDMMC_DATATIMEOUT;
1391 config.DataLength = MMC_BLOCKSIZE * NumberOfBlocks;
1392 config.DataBlockSize = SDIO_DATABLOCK_SIZE_512B;
1393 config.TransferDir = SDIO_TRANSFER_DIR_TO_CARD;
1394 config.TransferMode = SDIO_TRANSFER_MODE_BLOCK;
1395 config.DPSM = SDIO_DPSM_ENABLE;
1396 (void)SDIO_ConfigData(hmmc->Instance, &config);
1397
1398 return HAL_OK;
1399 }
1400 }
1401 else
1402 {
1403 return HAL_BUSY;
1404 }
1405}
1406
1416HAL_StatusTypeDef HAL_MMC_Erase(MMC_HandleTypeDef *hmmc, uint32_t BlockStartAdd, uint32_t BlockEndAdd)
1417{
1418 uint32_t errorstate;
1419 uint32_t start_add = BlockStartAdd;
1420 uint32_t end_add = BlockEndAdd;
1421
1422 if(hmmc->State == HAL_MMC_STATE_READY)
1423 {
1424 hmmc->ErrorCode = HAL_MMC_ERROR_NONE;
1425
1426 if(end_add < start_add)
1427 {
1428 hmmc->ErrorCode |= HAL_MMC_ERROR_PARAM;
1429 return HAL_ERROR;
1430 }
1431
1432 if(end_add > (hmmc->MmcCard.LogBlockNbr))
1433 {
1434 hmmc->ErrorCode |= HAL_MMC_ERROR_ADDR_OUT_OF_RANGE;
1435 return HAL_ERROR;
1436 }
1437
1438 hmmc->State = HAL_MMC_STATE_BUSY;
1439
1440 /* Check if the card command class supports erase command */
1441 if(((hmmc->MmcCard.Class) & SDIO_CCCC_ERASE) == 0U)
1442 {
1443 /* Clear all the static flags */
1444 __HAL_MMC_CLEAR_FLAG(hmmc, SDIO_STATIC_FLAGS);
1445 hmmc->ErrorCode |= HAL_MMC_ERROR_REQUEST_NOT_APPLICABLE;
1446 hmmc->State = HAL_MMC_STATE_READY;
1447 return HAL_ERROR;
1448 }
1449
1450 if((SDIO_GetResponse(hmmc->Instance, SDIO_RESP1) & SDMMC_CARD_LOCKED) == SDMMC_CARD_LOCKED)
1451 {
1452 /* Clear all the static flags */
1453 __HAL_MMC_CLEAR_FLAG(hmmc, SDIO_STATIC_FLAGS);
1454 hmmc->ErrorCode |= HAL_MMC_ERROR_LOCK_UNLOCK_FAILED;
1455 hmmc->State = HAL_MMC_STATE_READY;
1456 return HAL_ERROR;
1457 }
1458
1459 if ((hmmc->MmcCard.CardType) != MMC_HIGH_CAPACITY_CARD)
1460 {
1461 start_add *= 512U;
1462 end_add *= 512U;
1463 }
1464
1465 /* Send CMD35 MMC_ERASE_GRP_START with argument as addr */
1466 errorstate = SDMMC_CmdEraseStartAdd(hmmc->Instance, start_add);
1467 if(errorstate != HAL_MMC_ERROR_NONE)
1468 {
1469 /* Clear all the static flags */
1470 __HAL_MMC_CLEAR_FLAG(hmmc, SDIO_STATIC_FLAGS);
1471 hmmc->ErrorCode |= errorstate;
1472 hmmc->State = HAL_MMC_STATE_READY;
1473 return HAL_ERROR;
1474 }
1475
1476 /* Send CMD36 MMC_ERASE_GRP_END with argument as addr */
1477 errorstate = SDMMC_CmdEraseEndAdd(hmmc->Instance, end_add);
1478 if(errorstate != HAL_MMC_ERROR_NONE)
1479 {
1480 /* Clear all the static flags */
1481 __HAL_MMC_CLEAR_FLAG(hmmc, SDIO_STATIC_FLAGS);
1482 hmmc->ErrorCode |= errorstate;
1483 hmmc->State = HAL_MMC_STATE_READY;
1484 return HAL_ERROR;
1485 }
1486
1487 /* Send CMD38 ERASE */
1488 errorstate = SDMMC_CmdErase(hmmc->Instance);
1489 if(errorstate != HAL_MMC_ERROR_NONE)
1490 {
1491 /* Clear all the static flags */
1492 __HAL_MMC_CLEAR_FLAG(hmmc, SDIO_STATIC_FLAGS);
1493 hmmc->ErrorCode |= errorstate;
1494 hmmc->State = HAL_MMC_STATE_READY;
1495 return HAL_ERROR;
1496 }
1497
1498 hmmc->State = HAL_MMC_STATE_READY;
1499
1500 return HAL_OK;
1501 }
1502 else
1503 {
1504 return HAL_BUSY;
1505 }
1506}
1507
1513void HAL_MMC_IRQHandler(MMC_HandleTypeDef *hmmc)
1514{
1515 uint32_t errorstate;
1516 uint32_t context = hmmc->Context;
1517
1518 /* Check for SDIO interrupt flags */
1519 if((__HAL_MMC_GET_FLAG(hmmc, SDIO_FLAG_RXFIFOHF) != RESET) && ((context & MMC_CONTEXT_IT) != 0U))
1520 {
1521 MMC_Read_IT(hmmc);
1522 }
1523
1524 else if(__HAL_MMC_GET_FLAG(hmmc, SDIO_FLAG_DATAEND) != RESET)
1525 {
1526 __HAL_MMC_CLEAR_FLAG(hmmc, SDIO_FLAG_DATAEND);
1527
1528#if defined(SDIO_STA_STBITERR)
1529 __HAL_MMC_DISABLE_IT(hmmc, SDIO_IT_DATAEND | SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT|\
1530 SDIO_IT_TXUNDERR| SDIO_IT_RXOVERR | SDIO_IT_STBITERR);
1531#else /* SDIO_STA_STBITERR not defined */
1532 __HAL_MMC_DISABLE_IT(hmmc, SDIO_IT_DATAEND | SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT |\
1533 SDIO_IT_TXUNDERR | SDIO_IT_RXOVERR | SDIO_IT_TXFIFOHE |\
1534 SDIO_IT_RXFIFOHF);
1535#endif /* SDIO_STA_STBITERR */
1536
1537 hmmc->Instance->DCTRL &= ~(SDIO_DCTRL_DTEN);
1538
1539 if((context & MMC_CONTEXT_DMA) != 0U)
1540 {
1541 if((context & MMC_CONTEXT_WRITE_MULTIPLE_BLOCK) != 0U)
1542 {
1543 errorstate = SDMMC_CmdStopTransfer(hmmc->Instance);
1544 if(errorstate != HAL_MMC_ERROR_NONE)
1545 {
1546 hmmc->ErrorCode |= errorstate;
1547#if defined (USE_HAL_MMC_REGISTER_CALLBACKS) && (USE_HAL_MMC_REGISTER_CALLBACKS == 1U)
1548 hmmc->ErrorCallback(hmmc);
1549#else
1550 HAL_MMC_ErrorCallback(hmmc);
1551#endif
1552 }
1553 }
1554 /* Disable the DMA transfer for transmit request by setting the DMAEN bit
1555 in the MMC DCTRL register */
1556 hmmc->Instance->DCTRL &= (uint32_t)~((uint32_t)SDIO_DCTRL_DMAEN);
1557 /* Clear all the static flags */
1558 __HAL_MMC_CLEAR_FLAG(hmmc, SDIO_STATIC_DATA_FLAGS);
1559 hmmc->State = HAL_MMC_STATE_READY;
1560 hmmc->Context = MMC_CONTEXT_NONE;
1561 if(((context & MMC_CONTEXT_READ_SINGLE_BLOCK) == 0U) && ((context & MMC_CONTEXT_READ_MULTIPLE_BLOCK) == 0U))
1562 {
1563#if defined (USE_HAL_MMC_REGISTER_CALLBACKS) && (USE_HAL_MMC_REGISTER_CALLBACKS == 1U)
1564 hmmc->TxCpltCallback(hmmc);
1565#else
1566 HAL_MMC_TxCpltCallback(hmmc);
1567#endif
1568 }
1569 }
1570 else if((context & MMC_CONTEXT_IT) != 0U)
1571 {
1572 /* Stop Transfer for Write Multi blocks or Read Multi blocks */
1573 if(((context & MMC_CONTEXT_READ_MULTIPLE_BLOCK) != 0U) || ((context & MMC_CONTEXT_WRITE_MULTIPLE_BLOCK) != 0U))
1574 {
1575 errorstate = SDMMC_CmdStopTransfer(hmmc->Instance);
1576 if(errorstate != HAL_MMC_ERROR_NONE)
1577 {
1578 hmmc->ErrorCode |= errorstate;
1579#if defined (USE_HAL_MMC_REGISTER_CALLBACKS) && (USE_HAL_MMC_REGISTER_CALLBACKS == 1U)
1580 hmmc->ErrorCallback(hmmc);
1581#else
1582 HAL_MMC_ErrorCallback(hmmc);
1583#endif
1584 }
1585 }
1586
1587 /* Clear all the static flags */
1588 __HAL_MMC_CLEAR_FLAG(hmmc, SDIO_STATIC_DATA_FLAGS);
1589
1590 hmmc->State = HAL_MMC_STATE_READY;
1591 if(((context & MMC_CONTEXT_READ_SINGLE_BLOCK) != 0U) || ((context & MMC_CONTEXT_READ_MULTIPLE_BLOCK) != 0U))
1592 {
1593#if defined (USE_HAL_MMC_REGISTER_CALLBACKS) && (USE_HAL_MMC_REGISTER_CALLBACKS == 1U)
1594 hmmc->RxCpltCallback(hmmc);
1595#else
1596 HAL_MMC_RxCpltCallback(hmmc);
1597#endif
1598 }
1599 else
1600 {
1601#if defined (USE_HAL_MMC_REGISTER_CALLBACKS) && (USE_HAL_MMC_REGISTER_CALLBACKS == 1U)
1602 hmmc->TxCpltCallback(hmmc);
1603#else
1604 HAL_MMC_TxCpltCallback(hmmc);
1605#endif
1606 }
1607 }
1608 else
1609 {
1610 /* Nothing to do */
1611 }
1612 }
1613
1614 else if((__HAL_MMC_GET_FLAG(hmmc, SDIO_FLAG_TXFIFOHE) != RESET) && ((context & MMC_CONTEXT_IT) != 0U))
1615 {
1616 MMC_Write_IT(hmmc);
1617 }
1618
1619#if defined(SDIO_STA_STBITERR)
1620 else if(__HAL_MMC_GET_FLAG(hmmc, SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_RXOVERR | SDIO_FLAG_TXUNDERR | SDIO_FLAG_STBITERR) != RESET)
1621#else /* SDIO_STA_STBITERR not defined */
1622 else if(__HAL_MMC_GET_FLAG(hmmc, SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_RXOVERR | SDIO_FLAG_TXUNDERR) != RESET)
1623#endif /* SDIO_STA_STBITERR */
1624 {
1625 /* Set Error code */
1626 if(__HAL_MMC_GET_FLAG(hmmc, SDIO_FLAG_DCRCFAIL) != RESET)
1627 {
1628 hmmc->ErrorCode |= HAL_MMC_ERROR_DATA_CRC_FAIL;
1629 }
1630 if(__HAL_MMC_GET_FLAG(hmmc, SDIO_FLAG_DTIMEOUT) != RESET)
1631 {
1632 hmmc->ErrorCode |= HAL_MMC_ERROR_DATA_TIMEOUT;
1633 }
1634 if(__HAL_MMC_GET_FLAG(hmmc, SDIO_FLAG_RXOVERR) != RESET)
1635 {
1636 hmmc->ErrorCode |= HAL_MMC_ERROR_RX_OVERRUN;
1637 }
1638 if(__HAL_MMC_GET_FLAG(hmmc, SDIO_FLAG_TXUNDERR) != RESET)
1639 {
1640 hmmc->ErrorCode |= HAL_MMC_ERROR_TX_UNDERRUN;
1641 }
1642#if defined(SDIO_STA_STBITERR)
1643 if(__HAL_MMC_GET_FLAG(hmmc, SDIO_FLAG_STBITERR) != RESET)
1644 {
1645 hmmc->ErrorCode |= HAL_MMC_ERROR_DATA_TIMEOUT;
1646 }
1647#endif /* SDIO_STA_STBITERR */
1648
1649#if defined(SDIO_STA_STBITERR)
1650 /* Clear All flags */
1651 __HAL_MMC_CLEAR_FLAG(hmmc, SDIO_STATIC_DATA_FLAGS | SDIO_FLAG_STBITERR);
1652
1653 /* Disable all interrupts */
1654 __HAL_MMC_DISABLE_IT(hmmc, SDIO_IT_DATAEND | SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT|\
1655 SDIO_IT_TXUNDERR| SDIO_IT_RXOVERR | SDIO_IT_STBITERR);
1656#else /* SDIO_STA_STBITERR */
1657 /* Clear All flags */
1658 __HAL_MMC_CLEAR_FLAG(hmmc, SDIO_STATIC_DATA_FLAGS);
1659
1660 /* Disable all interrupts */
1661 __HAL_MMC_DISABLE_IT(hmmc, SDIO_IT_DATAEND | SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT|\
1662 SDIO_IT_TXUNDERR| SDIO_IT_RXOVERR);
1663#endif /* SDIO_STA_STBITERR */
1664
1665 hmmc->ErrorCode |= SDMMC_CmdStopTransfer(hmmc->Instance);
1666
1667 if((context & MMC_CONTEXT_IT) != 0U)
1668 {
1669 /* Set the MMC state to ready to be able to start again the process */
1670 hmmc->State = HAL_MMC_STATE_READY;
1671#if defined (USE_HAL_MMC_REGISTER_CALLBACKS) && (USE_HAL_MMC_REGISTER_CALLBACKS == 1U)
1672 hmmc->ErrorCallback(hmmc);
1673#else
1674 HAL_MMC_ErrorCallback(hmmc);
1675#endif /* USE_HAL_MMC_REGISTER_CALLBACKS */
1676 }
1677 else if((context & MMC_CONTEXT_DMA) != 0U)
1678 {
1679 /* Abort the MMC DMA Streams */
1680 if(((context & MMC_CONTEXT_WRITE_SINGLE_BLOCK) != 0U) || ((context & MMC_CONTEXT_WRITE_MULTIPLE_BLOCK) != 0U))
1681 {
1682 if(hmmc->hdmatx != NULL)
1683 {
1684 /* Set the DMA Tx abort callback */
1685 hmmc->hdmatx->XferAbortCallback = MMC_DMATxAbort;
1686 /* Abort DMA in IT mode */
1687 if(HAL_DMA_Abort_IT(hmmc->hdmatx) != HAL_OK)
1688 {
1689 MMC_DMATxAbort(hmmc->hdmatx);
1690 }
1691 }
1692 }
1693 else if(((context & MMC_CONTEXT_READ_SINGLE_BLOCK) != 0U) || ((context & MMC_CONTEXT_READ_MULTIPLE_BLOCK) != 0U))
1694 {
1695 if(hmmc->hdmarx != NULL)
1696 {
1697 /* Set the DMA Rx abort callback */
1698 hmmc->hdmarx->XferAbortCallback = MMC_DMARxAbort;
1699 /* Abort DMA in IT mode */
1700 if(HAL_DMA_Abort_IT(hmmc->hdmarx) != HAL_OK)
1701 {
1702 MMC_DMARxAbort(hmmc->hdmarx);
1703 }
1704 }
1705 }
1706 else
1707 {
1708 hmmc->ErrorCode = HAL_MMC_ERROR_NONE;
1709 hmmc->State = HAL_MMC_STATE_READY;
1710#if defined (USE_HAL_MMC_REGISTER_CALLBACKS) && (USE_HAL_MMC_REGISTER_CALLBACKS == 1U)
1711 hmmc->AbortCpltCallback(hmmc);
1712#else
1713 HAL_MMC_AbortCallback(hmmc);
1714#endif
1715 }
1716 }
1717 else
1718 {
1719 /* Nothing to do */
1720 }
1721 }
1722
1723 else
1724 {
1725 /* Nothing to do */
1726 }
1727}
1728
1734HAL_MMC_StateTypeDef HAL_MMC_GetState(MMC_HandleTypeDef *hmmc)
1735{
1736 return hmmc->State;
1737}
1738
1745uint32_t HAL_MMC_GetError(MMC_HandleTypeDef *hmmc)
1746{
1747 return hmmc->ErrorCode;
1748}
1749
1755__weak void HAL_MMC_TxCpltCallback(MMC_HandleTypeDef *hmmc)
1756{
1757 /* Prevent unused argument(s) compilation warning */
1758 UNUSED(hmmc);
1759
1760 /* NOTE : This function should not be modified, when the callback is needed,
1761 the HAL_MMC_TxCpltCallback can be implemented in the user file
1762 */
1763}
1764
1770__weak void HAL_MMC_RxCpltCallback(MMC_HandleTypeDef *hmmc)
1771{
1772 /* Prevent unused argument(s) compilation warning */
1773 UNUSED(hmmc);
1774
1775 /* NOTE : This function should not be modified, when the callback is needed,
1776 the HAL_MMC_RxCpltCallback can be implemented in the user file
1777 */
1778}
1779
1785__weak void HAL_MMC_ErrorCallback(MMC_HandleTypeDef *hmmc)
1786{
1787 /* Prevent unused argument(s) compilation warning */
1788 UNUSED(hmmc);
1789
1790 /* NOTE : This function should not be modified, when the callback is needed,
1791 the HAL_MMC_ErrorCallback can be implemented in the user file
1792 */
1793}
1794
1800__weak void HAL_MMC_AbortCallback(MMC_HandleTypeDef *hmmc)
1801{
1802 /* Prevent unused argument(s) compilation warning */
1803 UNUSED(hmmc);
1804
1805 /* NOTE : This function should not be modified, when the callback is needed,
1806 the HAL_MMC_AbortCallback can be implemented in the user file
1807 */
1808}
1809
1810#if defined (USE_HAL_MMC_REGISTER_CALLBACKS) && (USE_HAL_MMC_REGISTER_CALLBACKS == 1U)
1826HAL_StatusTypeDef HAL_MMC_RegisterCallback(MMC_HandleTypeDef *hmmc, HAL_MMC_CallbackIDTypeDef CallbackId, pMMC_CallbackTypeDef pCallback)
1827{
1828 HAL_StatusTypeDef status = HAL_OK;
1829
1830 if(pCallback == NULL)
1831 {
1832 /* Update the error code */
1833 hmmc->ErrorCode |= HAL_MMC_ERROR_INVALID_CALLBACK;
1834 return HAL_ERROR;
1835 }
1836
1837 /* Process locked */
1838 __HAL_LOCK(hmmc);
1839
1840 if(hmmc->State == HAL_MMC_STATE_READY)
1841 {
1842 switch (CallbackId)
1843 {
1844 case HAL_MMC_TX_CPLT_CB_ID :
1845 hmmc->TxCpltCallback = pCallback;
1846 break;
1847 case HAL_MMC_RX_CPLT_CB_ID :
1848 hmmc->RxCpltCallback = pCallback;
1849 break;
1850 case HAL_MMC_ERROR_CB_ID :
1851 hmmc->ErrorCallback = pCallback;
1852 break;
1853 case HAL_MMC_ABORT_CB_ID :
1854 hmmc->AbortCpltCallback = pCallback;
1855 break;
1856 case HAL_MMC_MSP_INIT_CB_ID :
1857 hmmc->MspInitCallback = pCallback;
1858 break;
1859 case HAL_MMC_MSP_DEINIT_CB_ID :
1860 hmmc->MspDeInitCallback = pCallback;
1861 break;
1862 default :
1863 /* Update the error code */
1864 hmmc->ErrorCode |= HAL_MMC_ERROR_INVALID_CALLBACK;
1865 /* update return status */
1866 status = HAL_ERROR;
1867 break;
1868 }
1869 }
1870 else if (hmmc->State == HAL_MMC_STATE_RESET)
1871 {
1872 switch (CallbackId)
1873 {
1874 case HAL_MMC_MSP_INIT_CB_ID :
1875 hmmc->MspInitCallback = pCallback;
1876 break;
1877 case HAL_MMC_MSP_DEINIT_CB_ID :
1878 hmmc->MspDeInitCallback = pCallback;
1879 break;
1880 default :
1881 /* Update the error code */
1882 hmmc->ErrorCode |= HAL_MMC_ERROR_INVALID_CALLBACK;
1883 /* update return status */
1884 status = HAL_ERROR;
1885 break;
1886 }
1887 }
1888 else
1889 {
1890 /* Update the error code */
1891 hmmc->ErrorCode |= HAL_MMC_ERROR_INVALID_CALLBACK;
1892 /* update return status */
1893 status = HAL_ERROR;
1894 }
1895
1896 /* Release Lock */
1897 __HAL_UNLOCK(hmmc);
1898 return status;
1899}
1900
1915HAL_StatusTypeDef HAL_MMC_UnRegisterCallback(MMC_HandleTypeDef *hmmc, HAL_MMC_CallbackIDTypeDef CallbackId)
1916{
1917 HAL_StatusTypeDef status = HAL_OK;
1918
1919 /* Process locked */
1920 __HAL_LOCK(hmmc);
1921
1922 if(hmmc->State == HAL_MMC_STATE_READY)
1923 {
1924 switch (CallbackId)
1925 {
1926 case HAL_MMC_TX_CPLT_CB_ID :
1927 hmmc->TxCpltCallback = HAL_MMC_TxCpltCallback;
1928 break;
1929 case HAL_MMC_RX_CPLT_CB_ID :
1930 hmmc->RxCpltCallback = HAL_MMC_RxCpltCallback;
1931 break;
1932 case HAL_MMC_ERROR_CB_ID :
1933 hmmc->ErrorCallback = HAL_MMC_ErrorCallback;
1934 break;
1935 case HAL_MMC_ABORT_CB_ID :
1936 hmmc->AbortCpltCallback = HAL_MMC_AbortCallback;
1937 break;
1938 case HAL_MMC_MSP_INIT_CB_ID :
1939 hmmc->MspInitCallback = HAL_MMC_MspInit;
1940 break;
1941 case HAL_MMC_MSP_DEINIT_CB_ID :
1942 hmmc->MspDeInitCallback = HAL_MMC_MspDeInit;
1943 break;
1944 default :
1945 /* Update the error code */
1946 hmmc->ErrorCode |= HAL_MMC_ERROR_INVALID_CALLBACK;
1947 /* update return status */
1948 status = HAL_ERROR;
1949 break;
1950 }
1951 }
1952 else if (hmmc->State == HAL_MMC_STATE_RESET)
1953 {
1954 switch (CallbackId)
1955 {
1956 case HAL_MMC_MSP_INIT_CB_ID :
1957 hmmc->MspInitCallback = HAL_MMC_MspInit;
1958 break;
1959 case HAL_MMC_MSP_DEINIT_CB_ID :
1960 hmmc->MspDeInitCallback = HAL_MMC_MspDeInit;
1961 break;
1962 default :
1963 /* Update the error code */
1964 hmmc->ErrorCode |= HAL_MMC_ERROR_INVALID_CALLBACK;
1965 /* update return status */
1966 status = HAL_ERROR;
1967 break;
1968 }
1969 }
1970 else
1971 {
1972 /* Update the error code */
1973 hmmc->ErrorCode |= HAL_MMC_ERROR_INVALID_CALLBACK;
1974 /* update return status */
1975 status = HAL_ERROR;
1976 }
1977
1978 /* Release Lock */
1979 __HAL_UNLOCK(hmmc);
1980 return status;
1981}
1982#endif
1983
1987
2002
2011HAL_StatusTypeDef HAL_MMC_GetCardCID(MMC_HandleTypeDef *hmmc, HAL_MMC_CardCIDTypeDef *pCID)
2012{
2013 pCID->ManufacturerID = (uint8_t)((hmmc->CID[0] & 0xFF000000U) >> 24U);
2014
2015 pCID->OEM_AppliID = (uint16_t)((hmmc->CID[0] & 0x00FFFF00U) >> 8U);
2016
2017 pCID->ProdName1 = (((hmmc->CID[0] & 0x000000FFU) << 24U) | ((hmmc->CID[1] & 0xFFFFFF00U) >> 8U));
2018
2019 pCID->ProdName2 = (uint8_t)(hmmc->CID[1] & 0x000000FFU);
2020
2021 pCID->ProdRev = (uint8_t)((hmmc->CID[2] & 0xFF000000U) >> 24U);
2022
2023 pCID->ProdSN = (((hmmc->CID[2] & 0x00FFFFFFU) << 8U) | ((hmmc->CID[3] & 0xFF000000U) >> 24U));
2024
2025 pCID->Reserved1 = (uint8_t)((hmmc->CID[3] & 0x00F00000U) >> 20U);
2026
2027 pCID->ManufactDate = (uint16_t)((hmmc->CID[3] & 0x000FFF00U) >> 8U);
2028
2029 pCID->CID_CRC = (uint8_t)((hmmc->CID[3] & 0x000000FEU) >> 1U);
2030
2031 pCID->Reserved2 = 1U;
2032
2033 return HAL_OK;
2034}
2035
2044HAL_StatusTypeDef HAL_MMC_GetCardCSD(MMC_HandleTypeDef *hmmc, HAL_MMC_CardCSDTypeDef *pCSD)
2045{
2046 uint32_t block_nbr = 0;
2047
2048 pCSD->CSDStruct = (uint8_t)((hmmc->CSD[0] & 0xC0000000U) >> 30U);
2049
2050 pCSD->SysSpecVersion = (uint8_t)((hmmc->CSD[0] & 0x3C000000U) >> 26U);
2051
2052 pCSD->Reserved1 = (uint8_t)((hmmc->CSD[0] & 0x03000000U) >> 24U);
2053
2054 pCSD->TAAC = (uint8_t)((hmmc->CSD[0] & 0x00FF0000U) >> 16U);
2055
2056 pCSD->NSAC = (uint8_t)((hmmc->CSD[0] & 0x0000FF00U) >> 8U);
2057
2058 pCSD->MaxBusClkFrec = (uint8_t)(hmmc->CSD[0] & 0x000000FFU);
2059
2060 pCSD->CardComdClasses = (uint16_t)((hmmc->CSD[1] & 0xFFF00000U) >> 20U);
2061
2062 pCSD->RdBlockLen = (uint8_t)((hmmc->CSD[1] & 0x000F0000U) >> 16U);
2063
2064 pCSD->PartBlockRead = (uint8_t)((hmmc->CSD[1] & 0x00008000U) >> 15U);
2065
2066 pCSD->WrBlockMisalign = (uint8_t)((hmmc->CSD[1] & 0x00004000U) >> 14U);
2067
2068 pCSD->RdBlockMisalign = (uint8_t)((hmmc->CSD[1] & 0x00002000U) >> 13U);
2069
2070 pCSD->DSRImpl = (uint8_t)((hmmc->CSD[1] & 0x00001000U) >> 12U);
2071
2072 pCSD->Reserved2 = 0U;
2073
2074 pCSD->DeviceSize = (((hmmc->CSD[1] & 0x000003FFU) << 2U) | ((hmmc->CSD[2] & 0xC0000000U) >> 30U));
2075
2076 pCSD->MaxRdCurrentVDDMin = (uint8_t)((hmmc->CSD[2] & 0x38000000U) >> 27U);
2077
2078 pCSD->MaxRdCurrentVDDMax = (uint8_t)((hmmc->CSD[2] & 0x07000000U) >> 24U);
2079
2080 pCSD->MaxWrCurrentVDDMin = (uint8_t)((hmmc->CSD[2] & 0x00E00000U) >> 21U);
2081
2082 pCSD->MaxWrCurrentVDDMax = (uint8_t)((hmmc->CSD[2] & 0x001C0000U) >> 18U);
2083
2084 pCSD->DeviceSizeMul = (uint8_t)((hmmc->CSD[2] & 0x00038000U) >> 15U);
2085
2086 if(MMC_ReadExtCSD(hmmc, &block_nbr, 212, 0x0FFFFFFFU) != HAL_OK) /* Field SEC_COUNT [215:212] */
2087 {
2088 return HAL_ERROR;
2089 }
2090
2091 if(hmmc->MmcCard.CardType == MMC_LOW_CAPACITY_CARD)
2092 {
2093 hmmc->MmcCard.BlockNbr = (pCSD->DeviceSize + 1U) ;
2094 hmmc->MmcCard.BlockNbr *= (1UL << ((pCSD->DeviceSizeMul & 0x07U) + 2U));
2095 hmmc->MmcCard.BlockSize = (1UL << (pCSD->RdBlockLen & 0x0FU));
2096 hmmc->MmcCard.LogBlockNbr = (hmmc->MmcCard.BlockNbr) * ((hmmc->MmcCard.BlockSize) / 512U);
2097 hmmc->MmcCard.LogBlockSize = 512U;
2098 }
2099 else if(hmmc->MmcCard.CardType == MMC_HIGH_CAPACITY_CARD)
2100 {
2101 hmmc->MmcCard.BlockNbr = block_nbr;
2102 hmmc->MmcCard.LogBlockNbr = hmmc->MmcCard.BlockNbr;
2103 hmmc->MmcCard.BlockSize = 512U;
2104 hmmc->MmcCard.LogBlockSize = hmmc->MmcCard.BlockSize;
2105 }
2106 else
2107 {
2108 /* Clear all the static flags */
2109 __HAL_MMC_CLEAR_FLAG(hmmc, SDIO_STATIC_FLAGS);
2110 hmmc->ErrorCode |= HAL_MMC_ERROR_UNSUPPORTED_FEATURE;
2111 hmmc->State = HAL_MMC_STATE_READY;
2112 return HAL_ERROR;
2113 }
2114
2115 pCSD->EraseGrSize = (uint8_t)((hmmc->CSD[2] & 0x00004000U) >> 14U);
2116
2117 pCSD->EraseGrMul = (uint8_t)((hmmc->CSD[2] & 0x00003F80U) >> 7U);
2118
2119 pCSD->WrProtectGrSize = (uint8_t)(hmmc->CSD[2] & 0x0000007FU);
2120
2121 pCSD->WrProtectGrEnable = (uint8_t)((hmmc->CSD[3] & 0x80000000U) >> 31U);
2122
2123 pCSD->ManDeflECC = (uint8_t)((hmmc->CSD[3] & 0x60000000U) >> 29U);
2124
2125 pCSD->WrSpeedFact = (uint8_t)((hmmc->CSD[3] & 0x1C000000U) >> 26U);
2126
2127 pCSD->MaxWrBlockLen= (uint8_t)((hmmc->CSD[3] & 0x03C00000U) >> 22U);
2128
2129 pCSD->WriteBlockPaPartial = (uint8_t)((hmmc->CSD[3] & 0x00200000U) >> 21U);
2130
2131 pCSD->Reserved3 = 0;
2132
2133 pCSD->ContentProtectAppli = (uint8_t)((hmmc->CSD[3] & 0x00010000U) >> 16U);
2134
2135 pCSD->FileFormatGroup = (uint8_t)((hmmc->CSD[3] & 0x00008000U) >> 15U);
2136
2137 pCSD->CopyFlag = (uint8_t)((hmmc->CSD[3] & 0x00004000U) >> 14U);
2138
2139 pCSD->PermWrProtect = (uint8_t)((hmmc->CSD[3] & 0x00002000U) >> 13U);
2140
2141 pCSD->TempWrProtect = (uint8_t)((hmmc->CSD[3] & 0x00001000U) >> 12U);
2142
2143 pCSD->FileFormat = (uint8_t)((hmmc->CSD[3] & 0x00000C00U) >> 10U);
2144
2145 pCSD->ECC= (uint8_t)((hmmc->CSD[3] & 0x00000300U) >> 8U);
2146
2147 pCSD->CSD_CRC = (uint8_t)((hmmc->CSD[3] & 0x000000FEU) >> 1U);
2148
2149 pCSD->Reserved4 = 1;
2150
2151 return HAL_OK;
2152}
2153
2161HAL_StatusTypeDef HAL_MMC_GetCardInfo(MMC_HandleTypeDef *hmmc, HAL_MMC_CardInfoTypeDef *pCardInfo)
2162{
2163 pCardInfo->CardType = (uint32_t)(hmmc->MmcCard.CardType);
2164 pCardInfo->Class = (uint32_t)(hmmc->MmcCard.Class);
2165 pCardInfo->RelCardAdd = (uint32_t)(hmmc->MmcCard.RelCardAdd);
2166 pCardInfo->BlockNbr = (uint32_t)(hmmc->MmcCard.BlockNbr);
2167 pCardInfo->BlockSize = (uint32_t)(hmmc->MmcCard.BlockSize);
2168 pCardInfo->LogBlockNbr = (uint32_t)(hmmc->MmcCard.LogBlockNbr);
2169 pCardInfo->LogBlockSize = (uint32_t)(hmmc->MmcCard.LogBlockSize);
2170
2171 return HAL_OK;
2172}
2173
2183HAL_StatusTypeDef HAL_MMC_GetCardExtCSD(MMC_HandleTypeDef *hmmc, uint32_t *pExtCSD, uint32_t Timeout)
2184{
2185 SDIO_DataInitTypeDef config;
2186 uint32_t errorstate;
2187 uint32_t tickstart = HAL_GetTick();
2188 uint32_t count;
2189 uint32_t *tmp_buf;
2190
2191 if(NULL == pExtCSD)
2192 {
2193 hmmc->ErrorCode |= HAL_MMC_ERROR_PARAM;
2194 return HAL_ERROR;
2195 }
2196
2197 if(hmmc->State == HAL_MMC_STATE_READY)
2198 {
2199 hmmc->ErrorCode = HAL_MMC_ERROR_NONE;
2200
2201 hmmc->State = HAL_MMC_STATE_BUSY;
2202
2203 /* Initialize data control register */
2204 hmmc->Instance->DCTRL = 0;
2205
2206 /* Initiaize the destination pointer */
2207 tmp_buf = pExtCSD;
2208
2209 /* Configure the MMC DPSM (Data Path State Machine) */
2210 config.DataTimeOut = SDMMC_DATATIMEOUT;
2211 config.DataLength = 512;
2212 config.DataBlockSize = SDIO_DATABLOCK_SIZE_512B;
2213 config.TransferDir = SDIO_TRANSFER_DIR_TO_SDIO;
2214 config.TransferMode = SDIO_TRANSFER_MODE_BLOCK;
2215 config.DPSM = SDIO_DPSM_ENABLE;
2216 (void)SDIO_ConfigData(hmmc->Instance, &config);
2217
2218 /* Send ExtCSD Read command to Card */
2219 errorstate = SDMMC_CmdSendEXTCSD(hmmc->Instance, 0);
2220 if(errorstate != HAL_MMC_ERROR_NONE)
2221 {
2222 /* Clear all the static flags */
2223 __HAL_MMC_CLEAR_FLAG(hmmc, SDIO_STATIC_FLAGS);
2224 hmmc->ErrorCode |= errorstate;
2225 hmmc->State = HAL_MMC_STATE_READY;
2226 return HAL_ERROR;
2227 }
2228
2229 /* Poll on SDMMC flags */
2230 while(!__HAL_MMC_GET_FLAG(hmmc, SDIO_FLAG_RXOVERR | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_DATAEND))
2231 {
2232 if(__HAL_MMC_GET_FLAG(hmmc, SDIO_FLAG_RXFIFOHF))
2233 {
2234 /* Read data from SDMMC Rx FIFO */
2235 for(count = 0U; count < 8U; count++)
2236 {
2237 *tmp_buf = SDIO_ReadFIFO(hmmc->Instance);
2238 tmp_buf++;
2239 }
2240 }
2241
2242 if(((HAL_GetTick()-tickstart) >= Timeout) || (Timeout == 0U))
2243 {
2244 /* Clear all the static flags */
2245 __HAL_MMC_CLEAR_FLAG(hmmc, SDIO_STATIC_FLAGS);
2246 hmmc->ErrorCode |= HAL_MMC_ERROR_TIMEOUT;
2247 hmmc->State= HAL_MMC_STATE_READY;
2248 return HAL_TIMEOUT;
2249 }
2250 }
2251
2252 /* Get error state */
2253 if(__HAL_MMC_GET_FLAG(hmmc, SDIO_FLAG_DTIMEOUT))
2254 {
2255 /* Clear all the static flags */
2256 __HAL_MMC_CLEAR_FLAG(hmmc, SDIO_STATIC_FLAGS);
2257 hmmc->ErrorCode |= HAL_MMC_ERROR_DATA_TIMEOUT;
2258 hmmc->State = HAL_MMC_STATE_READY;
2259 return HAL_ERROR;
2260 }
2261 else if(__HAL_MMC_GET_FLAG(hmmc, SDIO_FLAG_DCRCFAIL))
2262 {
2263 /* Clear all the static flags */
2264 __HAL_MMC_CLEAR_FLAG(hmmc, SDIO_STATIC_FLAGS);
2265 hmmc->ErrorCode |= HAL_MMC_ERROR_DATA_CRC_FAIL;
2266 hmmc->State = HAL_MMC_STATE_READY;
2267 return HAL_ERROR;
2268 }
2269 else if(__HAL_MMC_GET_FLAG(hmmc, SDIO_FLAG_RXOVERR))
2270 {
2271 /* Clear all the static flags */
2272 __HAL_MMC_CLEAR_FLAG(hmmc, SDIO_STATIC_FLAGS);
2273 hmmc->ErrorCode |= HAL_MMC_ERROR_RX_OVERRUN;
2274 hmmc->State = HAL_MMC_STATE_READY;
2275 return HAL_ERROR;
2276 }
2277 else
2278 {
2279 /* Nothing to do */
2280 }
2281
2282 /* Clear all the static flags */
2283 __HAL_MMC_CLEAR_FLAG(hmmc, SDIO_STATIC_DATA_FLAGS);
2284 hmmc->State = HAL_MMC_STATE_READY;
2285 }
2286
2287 return HAL_OK;
2288}
2289
2301HAL_StatusTypeDef HAL_MMC_ConfigWideBusOperation(MMC_HandleTypeDef *hmmc, uint32_t WideMode)
2302{
2303 uint32_t count;
2304 SDIO_InitTypeDef Init;
2305 uint32_t errorstate;
2306 uint32_t response = 0U;
2307
2308 /* Check the parameters */
2309 assert_param(IS_SDIO_BUS_WIDE(WideMode));
2310
2311 /* Change State */
2312 hmmc->State = HAL_MMC_STATE_BUSY;
2313
2314 errorstate = MMC_PwrClassUpdate(hmmc, WideMode);
2315
2316 if(errorstate == HAL_MMC_ERROR_NONE)
2317 {
2318 if(WideMode == SDIO_BUS_WIDE_8B)
2319 {
2320 errorstate = SDMMC_CmdSwitch(hmmc->Instance, 0x03B70200U);
2321 }
2322 else if(WideMode == SDIO_BUS_WIDE_4B)
2323 {
2324 errorstate = SDMMC_CmdSwitch(hmmc->Instance, 0x03B70100U);
2325 }
2326 else if(WideMode == SDIO_BUS_WIDE_1B)
2327 {
2328 errorstate = SDMMC_CmdSwitch(hmmc->Instance, 0x03B70000U);
2329 }
2330 else
2331 {
2332 /* WideMode is not a valid argument*/
2333 errorstate = HAL_MMC_ERROR_PARAM;
2334 }
2335
2336 /* Check for switch error and violation of the trial number of sending CMD 13 */
2337 if(errorstate == HAL_MMC_ERROR_NONE)
2338 {
2339 /* While card is not ready for data and trial number for sending CMD13 is not exceeded */
2340 count = SDMMC_MAX_TRIAL;
2341 do
2342 {
2343 errorstate = SDMMC_CmdSendStatus(hmmc->Instance, (uint32_t)(((uint32_t)hmmc->MmcCard.RelCardAdd) << 16U));
2344 if(errorstate != HAL_MMC_ERROR_NONE)
2345 {
2346 break;
2347 }
2348
2349 /* Get command response */
2350 response = SDIO_GetResponse(hmmc->Instance, SDIO_RESP1);
2351 count--;
2352 }while(((response & 0x100U) == 0U) && (count != 0U));
2353
2354 /* Check the status after the switch command execution */
2355 if ((count != 0U) && (errorstate == HAL_MMC_ERROR_NONE))
2356 {
2357 /* Check the bit SWITCH_ERROR of the device status */
2358 if ((response & 0x80U) != 0U)
2359 {
2360 errorstate = SDMMC_ERROR_GENERAL_UNKNOWN_ERR;
2361 }
2362 else
2363 {
2364 /* Configure the SDIO peripheral */
2365 Init = hmmc->Init;
2366 Init.BusWide = WideMode;
2367 (void)SDIO_Init(hmmc->Instance, Init);
2368 }
2369 }
2370 else if (count == 0U)
2371 {
2372 errorstate = SDMMC_ERROR_TIMEOUT;
2373 }
2374 else
2375 {
2376 /* Nothing to do */
2377 }
2378 }
2379 }
2380
2381 /* Change State */
2382 hmmc->State = HAL_MMC_STATE_READY;
2383
2384 if(errorstate != HAL_MMC_ERROR_NONE)
2385 {
2386 /* Clear all the static flags */
2387 __HAL_MMC_CLEAR_FLAG(hmmc, SDIO_STATIC_FLAGS);
2388 hmmc->ErrorCode |= errorstate;
2389 return HAL_ERROR;
2390 }
2391
2392 return HAL_OK;
2393}
2394
2400HAL_MMC_CardStateTypeDef HAL_MMC_GetCardState(MMC_HandleTypeDef *hmmc)
2401{
2402 uint32_t cardstate;
2403 uint32_t errorstate;
2404 uint32_t resp1 = 0U;
2405
2406 errorstate = MMC_SendStatus(hmmc, &resp1);
2407 if(errorstate != HAL_MMC_ERROR_NONE)
2408 {
2409 hmmc->ErrorCode |= errorstate;
2410 }
2411
2412 cardstate = ((resp1 >> 9U) & 0x0FU);
2413
2414 return (HAL_MMC_CardStateTypeDef)cardstate;
2415}
2416
2423HAL_StatusTypeDef HAL_MMC_Abort(MMC_HandleTypeDef *hmmc)
2424{
2425 HAL_MMC_CardStateTypeDef CardState;
2426
2427 /* DIsable All interrupts */
2428 __HAL_MMC_DISABLE_IT(hmmc, SDIO_IT_DATAEND | SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT|\
2429 SDIO_IT_TXUNDERR| SDIO_IT_RXOVERR);
2430
2431 /* Clear All flags */
2432 __HAL_MMC_CLEAR_FLAG(hmmc, SDIO_STATIC_DATA_FLAGS);
2433
2434 if((hmmc->hdmatx != NULL) || (hmmc->hdmarx != NULL))
2435 {
2436 /* Disable the MMC DMA request */
2437 hmmc->Instance->DCTRL &= (uint32_t)~((uint32_t)SDIO_DCTRL_DMAEN);
2438
2439 /* Abort the MMC DMA Tx Stream */
2440 if(hmmc->hdmatx != NULL)
2441 {
2442 if(HAL_DMA_Abort(hmmc->hdmatx) != HAL_OK)
2443 {
2444 hmmc->ErrorCode |= HAL_MMC_ERROR_DMA;
2445 }
2446 }
2447 /* Abort the MMC DMA Rx Stream */
2448 if(hmmc->hdmarx != NULL)
2449 {
2450 if(HAL_DMA_Abort(hmmc->hdmarx) != HAL_OK)
2451 {
2452 hmmc->ErrorCode |= HAL_MMC_ERROR_DMA;
2453 }
2454 }
2455 }
2456
2457 hmmc->State = HAL_MMC_STATE_READY;
2458
2459 /* Initialize the MMC operation */
2460 hmmc->Context = MMC_CONTEXT_NONE;
2461
2462 CardState = HAL_MMC_GetCardState(hmmc);
2463 if((CardState == HAL_MMC_CARD_RECEIVING) || (CardState == HAL_MMC_CARD_SENDING))
2464 {
2465 hmmc->ErrorCode = SDMMC_CmdStopTransfer(hmmc->Instance);
2466 }
2467 if(hmmc->ErrorCode != HAL_MMC_ERROR_NONE)
2468 {
2469 return HAL_ERROR;
2470 }
2471 return HAL_OK;
2472}
2473
2480HAL_StatusTypeDef HAL_MMC_Abort_IT(MMC_HandleTypeDef *hmmc)
2481{
2482 HAL_MMC_CardStateTypeDef CardState;
2483
2484 /* DIsable All interrupts */
2485 __HAL_MMC_DISABLE_IT(hmmc, SDIO_IT_DATAEND | SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT|\
2486 SDIO_IT_TXUNDERR| SDIO_IT_RXOVERR);
2487
2488 /* Clear All flags */
2489 __HAL_MMC_CLEAR_FLAG(hmmc, SDIO_STATIC_DATA_FLAGS);
2490
2491 if((hmmc->hdmatx != NULL) || (hmmc->hdmarx != NULL))
2492 {
2493 /* Disable the MMC DMA request */
2494 hmmc->Instance->DCTRL &= (uint32_t)~((uint32_t)SDIO_DCTRL_DMAEN);
2495
2496 /* Abort the MMC DMA Tx Stream */
2497 if(hmmc->hdmatx != NULL)
2498 {
2499 hmmc->hdmatx->XferAbortCallback = MMC_DMATxAbort;
2500 if(HAL_DMA_Abort_IT(hmmc->hdmatx) != HAL_OK)
2501 {
2502 hmmc->hdmatx = NULL;
2503 }
2504 }
2505 /* Abort the MMC DMA Rx Stream */
2506 if(hmmc->hdmarx != NULL)
2507 {
2508 hmmc->hdmarx->XferAbortCallback = MMC_DMARxAbort;
2509 if(HAL_DMA_Abort_IT(hmmc->hdmarx) != HAL_OK)
2510 {
2511 hmmc->hdmarx = NULL;
2512 }
2513 }
2514 }
2515
2516 /* No transfer ongoing on both DMA channels*/
2517 if((hmmc->hdmatx == NULL) && (hmmc->hdmarx == NULL))
2518 {
2519 CardState = HAL_MMC_GetCardState(hmmc);
2520 hmmc->State = HAL_MMC_STATE_READY;
2521
2522 if((CardState == HAL_MMC_CARD_RECEIVING) || (CardState == HAL_MMC_CARD_SENDING))
2523 {
2524 hmmc->ErrorCode = SDMMC_CmdStopTransfer(hmmc->Instance);
2525 }
2526 if(hmmc->ErrorCode != HAL_MMC_ERROR_NONE)
2527 {
2528 return HAL_ERROR;
2529 }
2530 else
2531 {
2532#if defined (USE_HAL_MMC_REGISTER_CALLBACKS) && (USE_HAL_MMC_REGISTER_CALLBACKS == 1U)
2533 hmmc->AbortCpltCallback(hmmc);
2534#else
2535 HAL_MMC_AbortCallback(hmmc);
2536#endif
2537 }
2538 }
2539
2540 return HAL_OK;
2541}
2542
2546
2550
2551/* Private function ----------------------------------------------------------*/
2555
2561static void MMC_DMATransmitCplt(DMA_HandleTypeDef *hdma)
2562{
2563 MMC_HandleTypeDef* hmmc = (MMC_HandleTypeDef* )(hdma->Parent);
2564
2565 /* Enable DATAEND Interrupt */
2566 __HAL_MMC_ENABLE_IT(hmmc, (SDIO_IT_DATAEND));
2567}
2568
2574static void MMC_DMAReceiveCplt(DMA_HandleTypeDef *hdma)
2575{
2576 MMC_HandleTypeDef* hmmc = (MMC_HandleTypeDef* )(hdma->Parent);
2577 uint32_t errorstate;
2578
2579 /* Send stop command in multiblock write */
2580 if(hmmc->Context == (MMC_CONTEXT_READ_MULTIPLE_BLOCK | MMC_CONTEXT_DMA))
2581 {
2582 errorstate = SDMMC_CmdStopTransfer(hmmc->Instance);
2583 if(errorstate != HAL_MMC_ERROR_NONE)
2584 {
2585 hmmc->ErrorCode |= errorstate;
2586#if defined (USE_HAL_MMC_REGISTER_CALLBACKS) && (USE_HAL_MMC_REGISTER_CALLBACKS == 1U)
2587 hmmc->ErrorCallback(hmmc);
2588#else
2589 HAL_MMC_ErrorCallback(hmmc);
2590#endif
2591 }
2592 }
2593
2594 /* Disable the DMA transfer for transmit request by setting the DMAEN bit
2595 in the MMC DCTRL register */
2596 hmmc->Instance->DCTRL &= (uint32_t)~((uint32_t)SDIO_DCTRL_DMAEN);
2597
2598 /* Clear all the static flags */
2599 __HAL_MMC_CLEAR_FLAG(hmmc, SDIO_STATIC_DATA_FLAGS);
2600
2601 hmmc->State = HAL_MMC_STATE_READY;
2602
2603#if defined (USE_HAL_MMC_REGISTER_CALLBACKS) && (USE_HAL_MMC_REGISTER_CALLBACKS == 1U)
2604 hmmc->RxCpltCallback(hmmc);
2605#else
2606 HAL_MMC_RxCpltCallback(hmmc);
2607#endif
2608}
2609
2615static void MMC_DMAError(DMA_HandleTypeDef *hdma)
2616{
2617 MMC_HandleTypeDef* hmmc = (MMC_HandleTypeDef* )(hdma->Parent);
2618 HAL_MMC_CardStateTypeDef CardState;
2619 uint32_t RxErrorCode, TxErrorCode;
2620
2621 /* if DMA error is FIFO error ignore it */
2622 if(HAL_DMA_GetError(hdma) != HAL_DMA_ERROR_FE)
2623 {
2624 RxErrorCode = hmmc->hdmarx->ErrorCode;
2625 TxErrorCode = hmmc->hdmatx->ErrorCode;
2626 if((RxErrorCode == HAL_DMA_ERROR_TE) || (TxErrorCode == HAL_DMA_ERROR_TE))
2627 {
2628 /* Clear All flags */
2629 __HAL_MMC_CLEAR_FLAG(hmmc, SDIO_STATIC_FLAGS);
2630
2631 /* Disable All interrupts */
2632 __HAL_MMC_DISABLE_IT(hmmc, SDIO_IT_DATAEND | SDIO_IT_DCRCFAIL | SDIO_IT_DTIMEOUT|\
2633 SDIO_IT_TXUNDERR| SDIO_IT_RXOVERR);
2634
2635 hmmc->ErrorCode |= HAL_MMC_ERROR_DMA;
2636 CardState = HAL_MMC_GetCardState(hmmc);
2637 if((CardState == HAL_MMC_CARD_RECEIVING) || (CardState == HAL_MMC_CARD_SENDING))
2638 {
2639 hmmc->ErrorCode |= SDMMC_CmdStopTransfer(hmmc->Instance);
2640 }
2641
2642 hmmc->State= HAL_MMC_STATE_READY;
2643 }
2644
2645#if defined (USE_HAL_MMC_REGISTER_CALLBACKS) && (USE_HAL_MMC_REGISTER_CALLBACKS == 1U)
2646 hmmc->ErrorCallback(hmmc);
2647#else
2648 HAL_MMC_ErrorCallback(hmmc);
2649#endif
2650 }
2651}
2652
2658static void MMC_DMATxAbort(DMA_HandleTypeDef *hdma)
2659{
2660 MMC_HandleTypeDef* hmmc = (MMC_HandleTypeDef* )(hdma->Parent);
2661 HAL_MMC_CardStateTypeDef CardState;
2662
2663 if(hmmc->hdmatx != NULL)
2664 {
2665 hmmc->hdmatx = NULL;
2666 }
2667
2668 /* All DMA channels are aborted */
2669 if(hmmc->hdmarx == NULL)
2670 {
2671 CardState = HAL_MMC_GetCardState(hmmc);
2672 hmmc->ErrorCode = HAL_MMC_ERROR_NONE;
2673 hmmc->State = HAL_MMC_STATE_READY;
2674 if((CardState == HAL_MMC_CARD_RECEIVING) || (CardState == HAL_MMC_CARD_SENDING))
2675 {
2676 hmmc->ErrorCode |= SDMMC_CmdStopTransfer(hmmc->Instance);
2677
2678 if(hmmc->ErrorCode != HAL_MMC_ERROR_NONE)
2679 {
2680#if defined (USE_HAL_MMC_REGISTER_CALLBACKS) && (USE_HAL_MMC_REGISTER_CALLBACKS == 1U)
2681 hmmc->AbortCpltCallback(hmmc);
2682#else
2683 HAL_MMC_AbortCallback(hmmc);
2684#endif
2685 }
2686 else
2687 {
2688#if defined (USE_HAL_MMC_REGISTER_CALLBACKS) && (USE_HAL_MMC_REGISTER_CALLBACKS == 1U)
2689 hmmc->ErrorCallback(hmmc);
2690#else
2691 HAL_MMC_ErrorCallback(hmmc);
2692#endif
2693 }
2694 }
2695 }
2696}
2697
2703static void MMC_DMARxAbort(DMA_HandleTypeDef *hdma)
2704{
2705 MMC_HandleTypeDef* hmmc = (MMC_HandleTypeDef* )(hdma->Parent);
2706 HAL_MMC_CardStateTypeDef CardState;
2707
2708 if(hmmc->hdmarx != NULL)
2709 {
2710 hmmc->hdmarx = NULL;
2711 }
2712
2713 /* All DMA channels are aborted */
2714 if(hmmc->hdmatx == NULL)
2715 {
2716 CardState = HAL_MMC_GetCardState(hmmc);
2717 hmmc->ErrorCode = HAL_MMC_ERROR_NONE;
2718 hmmc->State = HAL_MMC_STATE_READY;
2719 if((CardState == HAL_MMC_CARD_RECEIVING) || (CardState == HAL_MMC_CARD_SENDING))
2720 {
2721 hmmc->ErrorCode |= SDMMC_CmdStopTransfer(hmmc->Instance);
2722
2723 if(hmmc->ErrorCode != HAL_MMC_ERROR_NONE)
2724 {
2725#if defined (USE_HAL_MMC_REGISTER_CALLBACKS) && (USE_HAL_MMC_REGISTER_CALLBACKS == 1U)
2726 hmmc->AbortCpltCallback(hmmc);
2727#else
2728 HAL_MMC_AbortCallback(hmmc);
2729#endif
2730 }
2731 else
2732 {
2733#if defined (USE_HAL_MMC_REGISTER_CALLBACKS) && (USE_HAL_MMC_REGISTER_CALLBACKS == 1U)
2734 hmmc->ErrorCallback(hmmc);
2735#else
2736 HAL_MMC_ErrorCallback(hmmc);
2737#endif
2738 }
2739 }
2740 }
2741}
2742
2748static uint32_t MMC_InitCard(MMC_HandleTypeDef *hmmc)
2749{
2750 HAL_MMC_CardCSDTypeDef CSD;
2751 uint32_t errorstate;
2752 uint16_t mmc_rca = 2U;
2753 MMC_InitTypeDef Init;
2754
2755 /* Check the power State */
2756 if(SDIO_GetPowerState(hmmc->Instance) == 0U)
2757 {
2758 /* Power off */
2759 return HAL_MMC_ERROR_REQUEST_NOT_APPLICABLE;
2760 }
2761
2762 /* Send CMD2 ALL_SEND_CID */
2763 errorstate = SDMMC_CmdSendCID(hmmc->Instance);
2764 if(errorstate != HAL_MMC_ERROR_NONE)
2765 {
2766 return errorstate;
2767 }
2768 else
2769 {
2770 /* Get Card identification number data */
2771 hmmc->CID[0U] = SDIO_GetResponse(hmmc->Instance, SDIO_RESP1);
2772 hmmc->CID[1U] = SDIO_GetResponse(hmmc->Instance, SDIO_RESP2);
2773 hmmc->CID[2U] = SDIO_GetResponse(hmmc->Instance, SDIO_RESP3);
2774 hmmc->CID[3U] = SDIO_GetResponse(hmmc->Instance, SDIO_RESP4);
2775 }
2776
2777 /* Send CMD3 SET_REL_ADDR with RCA = 2 (should be greater than 1) */
2778 /* MMC Card publishes its RCA. */
2779 errorstate = SDMMC_CmdSetRelAddMmc(hmmc->Instance, mmc_rca);
2780 if(errorstate != HAL_MMC_ERROR_NONE)
2781 {
2782 return errorstate;
2783 }
2784
2785 /* Get the MMC card RCA */
2786 hmmc->MmcCard.RelCardAdd = mmc_rca;
2787
2788 /* Send CMD9 SEND_CSD with argument as card's RCA */
2789 errorstate = SDMMC_CmdSendCSD(hmmc->Instance, (uint32_t)(hmmc->MmcCard.RelCardAdd << 16U));
2790 if(errorstate != HAL_MMC_ERROR_NONE)
2791 {
2792 return errorstate;
2793 }
2794 else
2795 {
2796 /* Get Card Specific Data */
2797 hmmc->CSD[0U] = SDIO_GetResponse(hmmc->Instance, SDIO_RESP1);
2798 hmmc->CSD[1U] = SDIO_GetResponse(hmmc->Instance, SDIO_RESP2);
2799 hmmc->CSD[2U] = SDIO_GetResponse(hmmc->Instance, SDIO_RESP3);
2800 hmmc->CSD[3U] = SDIO_GetResponse(hmmc->Instance, SDIO_RESP4);
2801 }
2802
2803 /* Get the Card Class */
2804 hmmc->MmcCard.Class = (SDIO_GetResponse(hmmc->Instance, SDIO_RESP2) >> 20U);
2805
2806 /* Select the Card */
2807 errorstate = SDMMC_CmdSelDesel(hmmc->Instance, (uint32_t)(((uint32_t)hmmc->MmcCard.RelCardAdd) << 16U));
2808 if(errorstate != HAL_MMC_ERROR_NONE)
2809 {
2810 return errorstate;
2811 }
2812
2813 /* Get CSD parameters */
2814 if (HAL_MMC_GetCardCSD(hmmc, &CSD) != HAL_OK)
2815 {
2816 return hmmc->ErrorCode;
2817 }
2818
2819 /* While card is not ready for data and trial number for sending CMD13 is not exceeded */
2820 errorstate = SDMMC_CmdSendStatus(hmmc->Instance, (uint32_t)(((uint32_t)hmmc->MmcCard.RelCardAdd) << 16U));
2821 if(errorstate != HAL_MMC_ERROR_NONE)
2822 {
2823 hmmc->ErrorCode |= errorstate;
2824 }
2825
2826 /* Get Extended CSD parameters */
2827 if (HAL_MMC_GetCardExtCSD(hmmc, hmmc->Ext_CSD, SDMMC_DATATIMEOUT) != HAL_OK)
2828 {
2829 return hmmc->ErrorCode;
2830 }
2831
2832 /* While card is not ready for data and trial number for sending CMD13 is not exceeded */
2833 errorstate = SDMMC_CmdSendStatus(hmmc->Instance, (uint32_t)(((uint32_t)hmmc->MmcCard.RelCardAdd) << 16U));
2834 if(errorstate != HAL_MMC_ERROR_NONE)
2835 {
2836 hmmc->ErrorCode |= errorstate;
2837 }
2838
2839 /* Configure the SDIO peripheral */
2840 Init = hmmc->Init;
2841 Init.BusWide = SDIO_BUS_WIDE_1B;
2842 (void)SDIO_Init(hmmc->Instance, Init);
2843
2844 /* All cards are initialized */
2845 return HAL_MMC_ERROR_NONE;
2846}
2847
2855static uint32_t MMC_PowerON(MMC_HandleTypeDef *hmmc)
2856{
2857 __IO uint32_t count = 0U;
2858 uint32_t response = 0U, validvoltage = 0U;
2859 uint32_t errorstate;
2860
2861 /* CMD0: GO_IDLE_STATE */
2862 errorstate = SDMMC_CmdGoIdleState(hmmc->Instance);
2863 if(errorstate != HAL_MMC_ERROR_NONE)
2864 {
2865 return errorstate;
2866 }
2867
2868 while(validvoltage == 0U)
2869 {
2870 if(count++ == SDMMC_MAX_VOLT_TRIAL)
2871 {
2872 return HAL_MMC_ERROR_INVALID_VOLTRANGE;
2873 }
2874
2875 /* SEND CMD1 APP_CMD with voltage range as argument */
2876 errorstate = SDMMC_CmdOpCondition(hmmc->Instance, MMC_VOLTAGE_RANGE);
2877 if(errorstate != HAL_MMC_ERROR_NONE)
2878 {
2879 return HAL_MMC_ERROR_UNSUPPORTED_FEATURE;
2880 }
2881
2882 /* Get command response */
2883 response = SDIO_GetResponse(hmmc->Instance, SDIO_RESP1);
2884
2885 /* Get operating voltage*/
2886 validvoltage = (((response >> 31U) == 1U) ? 1U : 0U);
2887 }
2888
2889 /* When power routine is finished and command returns valid voltage */
2890 if (((response & (0xFF000000U)) >> 24U) == 0xC0U)
2891 {
2892 hmmc->MmcCard.CardType = MMC_HIGH_CAPACITY_CARD;
2893 }
2894 else
2895 {
2896 hmmc->MmcCard.CardType = MMC_LOW_CAPACITY_CARD;
2897 }
2898
2899 return HAL_MMC_ERROR_NONE;
2900}
2901
2907static void MMC_PowerOFF(MMC_HandleTypeDef *hmmc)
2908{
2909 /* Set Power State to OFF */
2910 (void)SDIO_PowerState_OFF(hmmc->Instance);
2911}
2912
2920static uint32_t MMC_SendStatus(MMC_HandleTypeDef *hmmc, uint32_t *pCardStatus)
2921{
2922 uint32_t errorstate;
2923
2924 if(pCardStatus == NULL)
2925 {
2926 return HAL_MMC_ERROR_PARAM;
2927 }
2928
2929 /* Send Status command */
2930 errorstate = SDMMC_CmdSendStatus(hmmc->Instance, (uint32_t)(hmmc->MmcCard.RelCardAdd << 16U));
2931 if(errorstate != HAL_MMC_ERROR_NONE)
2932 {
2933 return errorstate;
2934 }
2935
2936 /* Get MMC card status */
2937 *pCardStatus = SDIO_GetResponse(hmmc->Instance, SDIO_RESP1);
2938
2939 return HAL_MMC_ERROR_NONE;
2940}
2941
2950static uint32_t MMC_ReadExtCSD(MMC_HandleTypeDef *hmmc, uint32_t *pFieldData, uint16_t FieldIndex, uint32_t Timeout)
2951{
2952 SDIO_DataInitTypeDef config;
2953 uint32_t errorstate;
2954 uint32_t tickstart = HAL_GetTick();
2955 uint32_t count;
2956 uint32_t i = 0;
2957 uint32_t tmp_data;
2958
2959 hmmc->ErrorCode = HAL_MMC_ERROR_NONE;
2960
2961 /* Initialize data control register */
2962 hmmc->Instance->DCTRL = 0;
2963
2964 /* Configure the MMC DPSM (Data Path State Machine) */
2965 config.DataTimeOut = SDMMC_DATATIMEOUT;
2966 config.DataLength = 512;
2967 config.DataBlockSize = SDIO_DATABLOCK_SIZE_512B;
2968 config.TransferDir = SDIO_TRANSFER_DIR_TO_SDIO;
2969 config.TransferMode = SDIO_TRANSFER_MODE_BLOCK;
2970 config.DPSM = SDIO_DPSM_ENABLE;
2971 (void)SDIO_ConfigData(hmmc->Instance, &config);
2972
2973 /* Set Block Size for Card */
2974 errorstate = SDMMC_CmdSendEXTCSD(hmmc->Instance, 0);
2975 if(errorstate != HAL_MMC_ERROR_NONE)
2976 {
2977 /* Clear all the static flags */
2978 __HAL_MMC_CLEAR_FLAG(hmmc, SDIO_STATIC_FLAGS);
2979 hmmc->ErrorCode |= errorstate;
2980 hmmc->State = HAL_MMC_STATE_READY;
2981 return HAL_ERROR;
2982 }
2983
2984 /* Poll on SDMMC flags */
2985 while(!__HAL_MMC_GET_FLAG(hmmc, SDIO_FLAG_RXOVERR | SDIO_FLAG_DCRCFAIL | SDIO_FLAG_DTIMEOUT | SDIO_FLAG_DATAEND))
2986 {
2987 if(__HAL_MMC_GET_FLAG(hmmc, SDIO_FLAG_RXFIFOHF))
2988 {
2989 /* Read data from SDMMC Rx FIFO */
2990 for(count = 0U; count < 8U; count++)
2991 {
2992 tmp_data = SDIO_ReadFIFO(hmmc->Instance);
2993 /* eg : SEC_COUNT : FieldIndex = 212 => i+count = 53 */
2994 /* DEVICE_TYPE : FieldIndex = 196 => i+count = 49 */
2995 if ((i + count) == ((uint32_t)FieldIndex/4U))
2996 {
2997 *pFieldData = tmp_data;
2998 }
2999 }
3000 i += 8U;
3001 }
3002
3003 if(((HAL_GetTick()-tickstart) >= Timeout) || (Timeout == 0U))
3004 {
3005 /* Clear all the static flags */
3006 __HAL_MMC_CLEAR_FLAG(hmmc, SDIO_STATIC_FLAGS);
3007 hmmc->ErrorCode |= HAL_MMC_ERROR_TIMEOUT;
3008 hmmc->State= HAL_MMC_STATE_READY;
3009 return HAL_TIMEOUT;
3010 }
3011 }
3012
3013 /* Get error state */
3014 if (__HAL_MMC_GET_FLAG(hmmc, SDIO_FLAG_DTIMEOUT))
3015 {
3016 /* Clear all the static flags */
3017 __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_FLAGS);
3018 hmmc->ErrorCode |= HAL_MMC_ERROR_DATA_TIMEOUT;
3019 hmmc->State = HAL_MMC_STATE_READY;
3020 return HAL_ERROR;
3021 }
3022 else if (__HAL_MMC_GET_FLAG(hmmc, SDIO_FLAG_DCRCFAIL))
3023 {
3024 /* Clear all the static flags */
3025 __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_FLAGS);
3026 hmmc->ErrorCode |= HAL_MMC_ERROR_DATA_CRC_FAIL;
3027 hmmc->State = HAL_MMC_STATE_READY;
3028 return HAL_ERROR;
3029 }
3030 else if (__HAL_MMC_GET_FLAG(hmmc, SDIO_FLAG_RXOVERR))
3031 {
3032 /* Clear all the static flags */
3033 __HAL_MMC_CLEAR_FLAG(hmmc, SDMMC_STATIC_FLAGS);
3034 hmmc->ErrorCode |= HAL_MMC_ERROR_RX_OVERRUN;
3035 hmmc->State = HAL_MMC_STATE_READY;
3036 return HAL_ERROR;
3037 }
3038 else
3039 {
3040 /* Nothing to do */
3041 }
3042
3043 /* While card is not ready for data and trial number for sending CMD13 is not exceeded */
3044 errorstate = SDMMC_CmdSendStatus(hmmc->Instance, (uint32_t)(((uint32_t)hmmc->MmcCard.RelCardAdd) << 16));
3045 if(errorstate != HAL_MMC_ERROR_NONE)
3046 {
3047 hmmc->ErrorCode |= errorstate;
3048 }
3049
3050 /* Clear all the static flags */
3051 __HAL_MMC_CLEAR_FLAG(hmmc, SDIO_STATIC_DATA_FLAGS);
3052
3053 hmmc->State = HAL_MMC_STATE_READY;
3054
3055 return HAL_OK;
3056}
3057
3058
3065static void MMC_Read_IT(MMC_HandleTypeDef *hmmc)
3066{
3067 uint32_t count, data, dataremaining;
3068 uint8_t* tmp;
3069
3070 tmp = hmmc->pRxBuffPtr;
3071 dataremaining = hmmc->RxXferSize;
3072
3073 if (dataremaining > 0U)
3074 {
3075 /* Read data from SDIO Rx FIFO */
3076 for(count = 0U; count < 8U; count++)
3077 {
3078 data = SDIO_ReadFIFO(hmmc->Instance);
3079 *tmp = (uint8_t)(data & 0xFFU);
3080 tmp++;
3081 dataremaining--;
3082 *tmp = (uint8_t)((data >> 8U) & 0xFFU);
3083 tmp++;
3084 dataremaining--;
3085 *tmp = (uint8_t)((data >> 16U) & 0xFFU);
3086 tmp++;
3087 dataremaining--;
3088 *tmp = (uint8_t)((data >> 24U) & 0xFFU);
3089 tmp++;
3090 dataremaining--;
3091 }
3092
3093 hmmc->pRxBuffPtr = tmp;
3094 hmmc->RxXferSize = dataremaining;
3095 }
3096}
3097
3104static void MMC_Write_IT(MMC_HandleTypeDef *hmmc)
3105{
3106 uint32_t count, data, dataremaining;
3107 uint8_t* tmp;
3108
3109 tmp = hmmc->pTxBuffPtr;
3110 dataremaining = hmmc->TxXferSize;
3111
3112 if (dataremaining > 0U)
3113 {
3114 /* Write data to SDIO Tx FIFO */
3115 for(count = 0U; count < 8U; count++)
3116 {
3117 data = (uint32_t)(*tmp);
3118 tmp++;
3119 dataremaining--;
3120 data |= ((uint32_t)(*tmp) << 8U);
3121 tmp++;
3122 dataremaining--;
3123 data |= ((uint32_t)(*tmp) << 16U);
3124 tmp++;
3125 dataremaining--;
3126 data |= ((uint32_t)(*tmp) << 24U);
3127 tmp++;
3128 dataremaining--;
3129 (void)SDIO_WriteFIFO(hmmc->Instance, &data);
3130 }
3131
3132 hmmc->pTxBuffPtr = tmp;
3133 hmmc->TxXferSize = dataremaining;
3134 }
3135}
3136
3144static uint32_t MMC_PwrClassUpdate(MMC_HandleTypeDef *hmmc, uint32_t Wide)
3145{
3146 uint32_t count;
3147 uint32_t response = 0U;
3148 uint32_t errorstate = HAL_MMC_ERROR_NONE;
3149 uint32_t power_class, supported_pwr_class;
3150
3151 if((Wide == SDIO_BUS_WIDE_8B) || (Wide == SDIO_BUS_WIDE_4B))
3152 {
3153 power_class = 0U; /* Default value after power-on or software reset */
3154
3155 /* Read the PowerClass field of the Extended CSD register */
3156 if(MMC_ReadExtCSD(hmmc, &power_class, 187, SDMMC_DATATIMEOUT) != HAL_OK) /* Field POWER_CLASS [187] */
3157 {
3158 errorstate = SDMMC_ERROR_GENERAL_UNKNOWN_ERR;
3159 }
3160 else
3161 {
3162 power_class = ((power_class >> 24U) & 0x000000FFU);
3163 }
3164
3165 /* Get the supported PowerClass field of the Extended CSD register */
3166 /* Field PWR_CL_26_xxx [201 or 203] */
3167 supported_pwr_class = ((hmmc->Ext_CSD[(MMC_EXT_CSD_PWR_CL_26_INDEX/4)] >> MMC_EXT_CSD_PWR_CL_26_POS) & 0x000000FFU);
3168
3169 if(errorstate == HAL_MMC_ERROR_NONE)
3170 {
3171 if(Wide == SDIO_BUS_WIDE_8B)
3172 {
3173 /* Bit [7:4] : power class for 8-bits bus configuration - Bit [3:0] : power class for 4-bits bus configuration */
3174 supported_pwr_class = (supported_pwr_class >> 4U);
3175 }
3176
3177 if ((power_class & 0x0FU) != (supported_pwr_class & 0x0FU))
3178 {
3179 /* Need to change current power class */
3180 errorstate = SDMMC_CmdSwitch(hmmc->Instance, (0x03BB0000U | ((supported_pwr_class & 0x0FU) << 8U)));
3181
3182 if(errorstate == HAL_MMC_ERROR_NONE)
3183 {
3184 /* While card is not ready for data and trial number for sending CMD13 is not exceeded */
3185 count = SDMMC_MAX_TRIAL;
3186 do
3187 {
3188 errorstate = SDMMC_CmdSendStatus(hmmc->Instance, (uint32_t)(((uint32_t)hmmc->MmcCard.RelCardAdd) << 16U));
3189 if(errorstate != HAL_MMC_ERROR_NONE)
3190 {
3191 break;
3192 }
3193
3194 /* Get command response */
3195 response = SDIO_GetResponse(hmmc->Instance, SDIO_RESP1);
3196 count--;
3197 }while(((response & 0x100U) == 0U) && (count != 0U));
3198
3199 /* Check the status after the switch command execution */
3200 if ((count != 0U) && (errorstate == HAL_MMC_ERROR_NONE))
3201 {
3202 /* Check the bit SWITCH_ERROR of the device status */
3203 if ((response & 0x80U) != 0U)
3204 {
3205 errorstate = SDMMC_ERROR_UNSUPPORTED_FEATURE;
3206 }
3207 }
3208 else if (count == 0U)
3209 {
3210 errorstate = SDMMC_ERROR_TIMEOUT;
3211 }
3212 else
3213 {
3214 /* Nothing to do */
3215 }
3216 }
3217 }
3218 }
3219 }
3220
3221 return errorstate;
3222}
3223
3227
3228#endif /* SDIO */
3229
3230#endif /* HAL_MMC_MODULE_ENABLED */
3231
3235
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