stm32f7xx_hal_sd.h

Go to the documentation of this file.

/* Define to prevent recursive inclusion -------------------------------------*/
#ifndef __STM32F7xx_HAL_SD_H
#define __STM32F7xx_HAL_SD_H

#ifdef __cplusplus
 extern "C" {
#endif

/* Includes ------------------------------------------------------------------*/
#include "stm32f7xx_ll_sdmmc.h"

/* Exported types ------------------------------------------------------------*/ 
#define SD_InitTypeDef      SDMMC_InitTypeDef 
#define SD_TypeDef          SDMMC_TypeDef

typedef struct
{
  SD_TypeDef                   *Instance;        
  SD_InitTypeDef               Init;             
  HAL_LockTypeDef              Lock;             
  uint32_t                     CardType;         
  uint32_t                     RCA;              
  uint32_t                     CSD[4];           
  uint32_t                     CID[4];           
  __IO uint32_t                SdTransferCplt;   
  __IO uint32_t                SdTransferErr;    
  __IO uint32_t                DmaTransferCplt;  
  __IO uint32_t                SdOperation;      
  DMA_HandleTypeDef            *hdmarx;          
  DMA_HandleTypeDef            *hdmatx;          
}SD_HandleTypeDef;
typedef struct
{
  __IO uint8_t  CSDStruct;            
  __IO uint8_t  SysSpecVersion;       
  __IO uint8_t  Reserved1;            
  __IO uint8_t  TAAC;                 
  __IO uint8_t  NSAC;                 
  __IO uint8_t  MaxBusClkFrec;        
  __IO uint16_t CardComdClasses;      
  __IO uint8_t  RdBlockLen;           
  __IO uint8_t  PartBlockRead;        
  __IO uint8_t  WrBlockMisalign;      
  __IO uint8_t  RdBlockMisalign;      
  __IO uint8_t  DSRImpl;              
  __IO uint8_t  Reserved2;            
  __IO uint32_t DeviceSize;           
  __IO uint8_t  MaxRdCurrentVDDMin;   
  __IO uint8_t  MaxRdCurrentVDDMax;   
  __IO uint8_t  MaxWrCurrentVDDMin;   
  __IO uint8_t  MaxWrCurrentVDDMax;   
  __IO uint8_t  DeviceSizeMul;        
  __IO uint8_t  EraseGrSize;          
  __IO uint8_t  EraseGrMul;           
  __IO uint8_t  WrProtectGrSize;      
  __IO uint8_t  WrProtectGrEnable;    
  __IO uint8_t  ManDeflECC;           
  __IO uint8_t  WrSpeedFact;          
  __IO uint8_t  MaxWrBlockLen;        
  __IO uint8_t  WriteBlockPaPartial;  
  __IO uint8_t  Reserved3;            
  __IO uint8_t  ContentProtectAppli;  
  __IO uint8_t  FileFormatGrouop;     
  __IO uint8_t  CopyFlag;             
  __IO uint8_t  PermWrProtect;        
  __IO uint8_t  TempWrProtect;        
  __IO uint8_t  FileFormat;           
  __IO uint8_t  ECC;                  
  __IO uint8_t  CSD_CRC;              
  __IO uint8_t  Reserved4;            
}HAL_SD_CSDTypedef;
typedef struct
{
  __IO uint8_t  ManufacturerID;  
  __IO uint16_t OEM_AppliID;     
  __IO uint32_t ProdName1;       
  __IO uint8_t  ProdName2;       
  __IO uint8_t  ProdRev;         
  __IO uint32_t ProdSN;          
  __IO uint8_t  Reserved1;       
  __IO uint16_t ManufactDate;    
  __IO uint8_t  CID_CRC;         
  __IO uint8_t  Reserved2;       
}HAL_SD_CIDTypedef;
typedef struct
{
  __IO uint8_t  DAT_BUS_WIDTH;           
  __IO uint8_t  SECURED_MODE;            
  __IO uint16_t SD_CARD_TYPE;            
  __IO uint32_t SIZE_OF_PROTECTED_AREA;  
  __IO uint8_t  SPEED_CLASS;             
  __IO uint8_t  PERFORMANCE_MOVE;        
  __IO uint8_t  AU_SIZE;                 
  __IO uint16_t ERASE_SIZE;              
  __IO uint8_t  ERASE_TIMEOUT;           
  __IO uint8_t  ERASE_OFFSET;            
}HAL_SD_CardStatusTypedef;
typedef struct
{
  HAL_SD_CSDTypedef   SD_csd;         
  HAL_SD_CIDTypedef   SD_cid;         
  uint64_t            CardCapacity;   
  uint32_t            CardBlockSize;  
  uint16_t            RCA;            
  uint8_t             CardType;       
}HAL_SD_CardInfoTypedef;
typedef enum
{
  SD_CMD_CRC_FAIL                    = (1),   
  SD_DATA_CRC_FAIL                   = (2),   
  SD_CMD_RSP_TIMEOUT                 = (3),   
  SD_DATA_TIMEOUT                    = (4),   
  SD_TX_UNDERRUN                     = (5),   
  SD_RX_OVERRUN                      = (6),   
  SD_START_BIT_ERR                   = (7),   
  SD_CMD_OUT_OF_RANGE                = (8),   
  SD_ADDR_MISALIGNED                 = (9),   
  SD_BLOCK_LEN_ERR                   = (10),  
  SD_ERASE_SEQ_ERR                   = (11),  
  SD_BAD_ERASE_PARAM                 = (12),  
  SD_WRITE_PROT_VIOLATION            = (13),  
  SD_LOCK_UNLOCK_FAILED              = (14),  
  SD_COM_CRC_FAILED                  = (15),  
  SD_ILLEGAL_CMD                     = (16),  
  SD_CARD_ECC_FAILED                 = (17),  
  SD_CC_ERROR                        = (18),  
  SD_GENERAL_UNKNOWN_ERROR           = (19),  
  SD_STREAM_READ_UNDERRUN            = (20),  
  SD_STREAM_WRITE_OVERRUN            = (21),  
  SD_CID_CSD_OVERWRITE               = (22),  
  SD_WP_ERASE_SKIP                   = (23),  
  SD_CARD_ECC_DISABLED               = (24),  
  SD_ERASE_RESET                     = (25),  
  SD_AKE_SEQ_ERROR                   = (26),  
  SD_INVALID_VOLTRANGE               = (27),
  SD_ADDR_OUT_OF_RANGE               = (28),
  SD_SWITCH_ERROR                    = (29),
  SD_SDMMC_DISABLED                  = (30),
  SD_SDMMC_FUNCTION_BUSY             = (31),
  SD_SDMMC_FUNCTION_FAILED           = (32),
  SD_SDMMC_UNKNOWN_FUNCTION          = (33),

  SD_INTERNAL_ERROR                  = (34),
  SD_NOT_CONFIGURED                  = (35),
  SD_REQUEST_PENDING                 = (36),
  SD_REQUEST_NOT_APPLICABLE          = (37),
  SD_INVALID_PARAMETER               = (38),
  SD_UNSUPPORTED_FEATURE             = (39),
  SD_UNSUPPORTED_HW                  = (40),
  SD_ERROR                           = (41),
  SD_OK                              = (0) 

}HAL_SD_ErrorTypedef;
typedef enum
{
  SD_TRANSFER_OK    = 0,  
  SD_TRANSFER_BUSY  = 1,  
  SD_TRANSFER_ERROR = 2   
}HAL_SD_TransferStateTypedef;
typedef enum
{
  SD_CARD_READY                  = ((uint32_t)0x00000001U),  
  SD_CARD_IDENTIFICATION         = ((uint32_t)0x00000002U),  
  SD_CARD_STANDBY                = ((uint32_t)0x00000003U),  
  SD_CARD_TRANSFER               = ((uint32_t)0x00000004U),  
  SD_CARD_SENDING                = ((uint32_t)0x00000005U),  
  SD_CARD_RECEIVING              = ((uint32_t)0x00000006U),  
  SD_CARD_PROGRAMMING            = ((uint32_t)0x00000007U),  
  SD_CARD_DISCONNECTED           = ((uint32_t)0x00000008U),  
  SD_CARD_ERROR                  = ((uint32_t)0x000000FFU)   
}HAL_SD_CardStateTypedef;
typedef enum
{
  SD_READ_SINGLE_BLOCK    = 0U,  
  SD_READ_MULTIPLE_BLOCK  = 1U,  
  SD_WRITE_SINGLE_BLOCK   = 2U,  
  SD_WRITE_MULTIPLE_BLOCK = 3U   
}HAL_SD_OperationTypedef;
/* Exported constants --------------------------------------------------------*/
#define SD_CMD_GO_IDLE_STATE                       ((uint8_t)0U)   
#define SD_CMD_SEND_OP_COND                        ((uint8_t)1U)   
#define SD_CMD_ALL_SEND_CID                        ((uint8_t)2U)   
#define SD_CMD_SET_REL_ADDR                        ((uint8_t)3U)   
#define SD_CMD_SET_DSR                             ((uint8_t)4U)   
#define SD_CMD_SDMMC_SEN_OP_COND                   ((uint8_t)5U)   
#define SD_CMD_HS_SWITCH                           ((uint8_t)6U)   
#define SD_CMD_SEL_DESEL_CARD                      ((uint8_t)7U)   
#define SD_CMD_HS_SEND_EXT_CSD                     ((uint8_t)8U)   
#define SD_CMD_SEND_CSD                            ((uint8_t)9U)   
#define SD_CMD_SEND_CID                            ((uint8_t)10U)  
#define SD_CMD_READ_DAT_UNTIL_STOP                 ((uint8_t)11U)  
#define SD_CMD_STOP_TRANSMISSION                   ((uint8_t)12U)  
#define SD_CMD_SEND_STATUS                         ((uint8_t)13U)  
#define SD_CMD_HS_BUSTEST_READ                     ((uint8_t)14U) 
#define SD_CMD_GO_INACTIVE_STATE                   ((uint8_t)15U)  
#define SD_CMD_SET_BLOCKLEN                        ((uint8_t)16U)  
#define SD_CMD_READ_SINGLE_BLOCK                   ((uint8_t)17U)  
#define SD_CMD_READ_MULT_BLOCK                     ((uint8_t)18U)  
#define SD_CMD_HS_BUSTEST_WRITE                    ((uint8_t)19U)  
#define SD_CMD_WRITE_DAT_UNTIL_STOP                ((uint8_t)20U)  
#define SD_CMD_SET_BLOCK_COUNT                     ((uint8_t)23U)  
#define SD_CMD_WRITE_SINGLE_BLOCK                  ((uint8_t)24U)  
#define SD_CMD_WRITE_MULT_BLOCK                    ((uint8_t)25U)  
#define SD_CMD_PROG_CID                            ((uint8_t)26U)  
#define SD_CMD_PROG_CSD                            ((uint8_t)27U)  
#define SD_CMD_SET_WRITE_PROT                      ((uint8_t)28U)  
#define SD_CMD_CLR_WRITE_PROT                      ((uint8_t)29U)  
#define SD_CMD_SEND_WRITE_PROT                     ((uint8_t)30U)  
#define SD_CMD_SD_ERASE_GRP_START                  ((uint8_t)32U)  
#define SD_CMD_SD_ERASE_GRP_END                    ((uint8_t)33U)  
#define SD_CMD_ERASE_GRP_START                     ((uint8_t)35U)  
#define SD_CMD_ERASE_GRP_END                       ((uint8_t)36U)  
#define SD_CMD_ERASE                               ((uint8_t)38U)  
#define SD_CMD_FAST_IO                             ((uint8_t)39U)  
#define SD_CMD_GO_IRQ_STATE                        ((uint8_t)40U)  
#define SD_CMD_LOCK_UNLOCK                         ((uint8_t)42U)  
#define SD_CMD_APP_CMD                             ((uint8_t)55U)  
#define SD_CMD_GEN_CMD                             ((uint8_t)56U)  
#define SD_CMD_NO_CMD                              ((uint8_t)64U) 

#define SD_CMD_APP_SD_SET_BUSWIDTH                 ((uint8_t)6U)   
#define SD_CMD_SD_APP_STATUS                       ((uint8_t)13U)  
#define SD_CMD_SD_APP_SEND_NUM_WRITE_BLOCKS        ((uint8_t)22U)  
#define SD_CMD_SD_APP_OP_COND                      ((uint8_t)41U)  
#define SD_CMD_SD_APP_SET_CLR_CARD_DETECT          ((uint8_t)42U)  
#define SD_CMD_SD_APP_SEND_SCR                     ((uint8_t)51U)  
#define SD_CMD_SDMMC_RW_DIRECT                     ((uint8_t)52U)  
#define SD_CMD_SDMMC_RW_EXTENDED                   ((uint8_t)53U)  
#define SD_CMD_SD_APP_GET_MKB                      ((uint8_t)43U)  
#define SD_CMD_SD_APP_GET_MID                      ((uint8_t)44U)  
#define SD_CMD_SD_APP_SET_CER_RN1                  ((uint8_t)45U)  
#define SD_CMD_SD_APP_GET_CER_RN2                  ((uint8_t)46U)  
#define SD_CMD_SD_APP_SET_CER_RES2                 ((uint8_t)47U)  
#define SD_CMD_SD_APP_GET_CER_RES1                 ((uint8_t)48U)  
#define SD_CMD_SD_APP_SECURE_READ_MULTIPLE_BLOCK   ((uint8_t)18U)  
#define SD_CMD_SD_APP_SECURE_WRITE_MULTIPLE_BLOCK  ((uint8_t)25U)  
#define SD_CMD_SD_APP_SECURE_ERASE                 ((uint8_t)38U)  
#define SD_CMD_SD_APP_CHANGE_SECURE_AREA           ((uint8_t)49U)  
#define SD_CMD_SD_APP_SECURE_WRITE_MKB             ((uint8_t)48U)  
#define STD_CAPACITY_SD_CARD_V1_1             ((uint32_t)0x00000000U)
#define STD_CAPACITY_SD_CARD_V2_0             ((uint32_t)0x00000001U)
#define HIGH_CAPACITY_SD_CARD                 ((uint32_t)0x00000002U)
#define MULTIMEDIA_CARD                       ((uint32_t)0x00000003U)
#define SECURE_DIGITAL_IO_CARD                ((uint32_t)0x00000004U)
#define HIGH_SPEED_MULTIMEDIA_CARD            ((uint32_t)0x00000005U)
#define SECURE_DIGITAL_IO_COMBO_CARD          ((uint32_t)0x00000006U)
#define HIGH_CAPACITY_MMC_CARD                ((uint32_t)0x00000007U)

/* Exported macro ------------------------------------------------------------*/
#define __HAL_SD_SDMMC_ENABLE(__HANDLE__) __SDMMC_ENABLE((__HANDLE__)->Instance)

#define __HAL_SD_SDMMC_DISABLE(__HANDLE__) __SDMMC_DISABLE((__HANDLE__)->Instance)

#define __HAL_SD_SDMMC_DMA_ENABLE(__HANDLE__) __SDMMC_DMA_ENABLE((__HANDLE__)->Instance)

#define __HAL_SD_SDMMC_DMA_DISABLE(__HANDLE__)  __SDMMC_DMA_DISABLE((__HANDLE__)->Instance)
 
#define __HAL_SD_SDMMC_ENABLE_IT(__HANDLE__, __INTERRUPT__) __SDMMC_ENABLE_IT((__HANDLE__)->Instance, (__INTERRUPT__))

#define __HAL_SD_SDMMC_DISABLE_IT(__HANDLE__, __INTERRUPT__) __SDMMC_DISABLE_IT((__HANDLE__)->Instance, (__INTERRUPT__))

#define __HAL_SD_SDMMC_GET_FLAG(__HANDLE__, __FLAG__) __SDMMC_GET_FLAG((__HANDLE__)->Instance, (__FLAG__))

#define __HAL_SD_SDMMC_CLEAR_FLAG(__HANDLE__, __FLAG__) __SDMMC_CLEAR_FLAG((__HANDLE__)->Instance, (__FLAG__))

#define __HAL_SD_SDMMC_GET_IT(__HANDLE__, __INTERRUPT__) __SDMMC_GET_IT((__HANDLE__)->Instance, (__INTERRUPT__))

#define __HAL_SD_SDMMC_CLEAR_IT(__HANDLE__, __INTERRUPT__) __SDMMC_CLEAR_IT((__HANDLE__)->Instance, (__INTERRUPT__))

/* Exported functions --------------------------------------------------------*/
HAL_SD_ErrorTypedef HAL_SD_Init(SD_HandleTypeDef *hsd, HAL_SD_CardInfoTypedef *SDCardInfo);
HAL_StatusTypeDef   HAL_SD_DeInit (SD_HandleTypeDef *hsd);
void HAL_SD_MspInit(SD_HandleTypeDef *hsd);
void HAL_SD_MspDeInit(SD_HandleTypeDef *hsd);
/* Blocking mode: Polling */
HAL_SD_ErrorTypedef HAL_SD_ReadBlocks(SD_HandleTypeDef *hsd, uint32_t *pReadBuffer, uint64_t ReadAddr, uint32_t BlockSize, uint32_t NumberOfBlocks);
HAL_SD_ErrorTypedef HAL_SD_WriteBlocks(SD_HandleTypeDef *hsd, uint32_t *pWriteBuffer, uint64_t WriteAddr, uint32_t BlockSize, uint32_t NumberOfBlocks);
HAL_SD_ErrorTypedef HAL_SD_Erase(SD_HandleTypeDef *hsd, uint64_t startaddr, uint64_t endaddr);

/* Non-Blocking mode: Interrupt */
void HAL_SD_IRQHandler(SD_HandleTypeDef *hsd);

/* Callback in non blocking modes (DMA) */
void HAL_SD_DMA_RxCpltCallback(DMA_HandleTypeDef *hdma);
void HAL_SD_DMA_RxErrorCallback(DMA_HandleTypeDef *hdma);
void HAL_SD_DMA_TxCpltCallback(DMA_HandleTypeDef *hdma);
void HAL_SD_DMA_TxErrorCallback(DMA_HandleTypeDef *hdma);
void HAL_SD_XferCpltCallback(SD_HandleTypeDef *hsd);
void HAL_SD_XferErrorCallback(SD_HandleTypeDef *hsd);

/* Non-Blocking mode: DMA */
HAL_SD_ErrorTypedef HAL_SD_ReadBlocks_DMA(SD_HandleTypeDef *hsd, uint32_t *pReadBuffer, uint64_t ReadAddr, uint32_t BlockSize, uint32_t NumberOfBlocks);
HAL_SD_ErrorTypedef HAL_SD_WriteBlocks_DMA(SD_HandleTypeDef *hsd, uint32_t *pWriteBuffer, uint64_t WriteAddr, uint32_t BlockSize, uint32_t NumberOfBlocks);
HAL_SD_ErrorTypedef HAL_SD_CheckWriteOperation(SD_HandleTypeDef *hsd, uint32_t Timeout);
HAL_SD_ErrorTypedef HAL_SD_CheckReadOperation(SD_HandleTypeDef *hsd, uint32_t Timeout);
HAL_SD_ErrorTypedef HAL_SD_Get_CardInfo(SD_HandleTypeDef *hsd, HAL_SD_CardInfoTypedef *pCardInfo);
HAL_SD_ErrorTypedef HAL_SD_WideBusOperation_Config(SD_HandleTypeDef *hsd, uint32_t WideMode);
HAL_SD_ErrorTypedef HAL_SD_StopTransfer(SD_HandleTypeDef *hsd);
HAL_SD_ErrorTypedef HAL_SD_HighSpeed (SD_HandleTypeDef *hsd);
/* Peripheral State functions  ************************************************/
HAL_SD_ErrorTypedef HAL_SD_SendSDStatus(SD_HandleTypeDef *hsd, uint32_t *pSDstatus);
HAL_SD_ErrorTypedef HAL_SD_GetCardStatus(SD_HandleTypeDef *hsd, HAL_SD_CardStatusTypedef *pCardStatus);
HAL_SD_TransferStateTypedef HAL_SD_GetStatus(SD_HandleTypeDef *hsd);
/* Private types -------------------------------------------------------------*/
/* Private defines -----------------------------------------------------------*/
/* Private variables ---------------------------------------------------------*/
/* Private constants ---------------------------------------------------------*/
/* Private macros ------------------------------------------------------------*/
/* Private functions prototypes ----------------------------------------------*/
/* Private functions ---------------------------------------------------------*/
#ifdef __cplusplus
}
#endif


#endif /* __STM32F7xx_HAL_SD_H */ 

/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/