504 lines
30 KiB
C
504 lines
30 KiB
C
////////////////////////////////////////////////////////////////////////////////
|
|
/// @file hal_gpio.h
|
|
/// @author AE TEAM
|
|
/// @brief THIS FILE CONTAINS ALL THE FUNCTIONS PROTOTYPES FOR THE GPIO
|
|
/// FIRMWARE LIBRARY.
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @attention
|
|
///
|
|
/// THE EXISTING FIRMWARE IS ONLY FOR REFERENCE, WHICH IS DESIGNED TO PROVIDE
|
|
/// CUSTOMERS WITH CODING INFORMATION ABOUT THEIR PRODUCTS SO THEY CAN SAVE
|
|
/// TIME. THEREFORE, MINDMOTION SHALL NOT BE LIABLE FOR ANY DIRECT, INDIRECT OR
|
|
/// CONSEQUENTIAL DAMAGES ABOUT ANY CLAIMS ARISING OUT OF THE CONTENT OF SUCH
|
|
/// HARDWARE AND/OR THE USE OF THE CODING INFORMATION CONTAINED HEREIN IN
|
|
/// CONNECTION WITH PRODUCTS MADE BY CUSTOMERS.
|
|
///
|
|
/// <H2><CENTER>© COPYRIGHT MINDMOTION </CENTER></H2>
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
// Define to prevent recursive inclusion
|
|
#ifndef __HAL_SDIO_H
|
|
#define __HAL_SDIO_H
|
|
|
|
// Files includes
|
|
#include "mm32_reg.h"
|
|
|
|
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @addtogroup MM32_Hardware_Abstract_Layer
|
|
/// @{
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @defgroup GPIO_HAL
|
|
/// @brief GPIO HAL modules
|
|
/// @{
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @defgroup GPIO_Exported_Types
|
|
/// @{
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief Output Maximum frequency selection
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
#define SDIO_FLAG_CCRCFAIL ((u32)0x00000001)
|
|
#define SDIO_FLAG_DCRCFAIL ((u32)0x00000002)
|
|
#define SDIO_FLAG_CTIMEOUT ((u32)0x00000004)
|
|
#define SDIO_FLAG_DTIMEOUT ((u32)0x00000008)
|
|
#define SDIO_FLAG_TXUNDERR ((u32)0x00000010)
|
|
#define SDIO_FLAG_RXOVERR ((u32)0x00000020)
|
|
#define SDIO_FLAG_CMDREND ((u32)0x00000040)
|
|
#define SDIO_FLAG_CMDSENT ((u32)0x00000080)
|
|
#define SDIO_FLAG_DATAEND ((u32)0x00000100)
|
|
#define SDIO_FLAG_STBITERR ((u32)0x00000200)
|
|
#define SDIO_FLAG_DBCKEND ((u32)0x00000400)
|
|
#define SDIO_FLAG_CMDACT ((u32)0x00000800)
|
|
#define SDIO_FLAG_TXACT ((u32)0x00001000)
|
|
#define SDIO_FLAG_RXACT ((u32)0x00002000)
|
|
#define SDIO_FLAG_TXFIFOHE ((u32)0x00004000)
|
|
#define SDIO_FLAG_RXFIFOHF ((u32)0x00008000)
|
|
#define SDIO_FLAG_TXFIFOF ((u32)0x00010000)
|
|
#define SDIO_FLAG_RXFIFOF ((u32)0x00020000)
|
|
#define SDIO_FLAG_TXFIFOE ((u32)0x00040000)
|
|
#define SDIO_FLAG_RXFIFOE ((u32)0x00080000)
|
|
#define SDIO_FLAG_TXDAVL ((u32)0x00100000)
|
|
#define SDIO_FLAG_RXDAVL ((u32)0x00200000)
|
|
#define SDIO_FLAG_SDIOIT ((u32)0x00400000)
|
|
#define SDIO_FLAG_CEATAEND ((u32)0x00800000)
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//SDIO working mode define ,SDIO working mode definition, set through the SD_SetDevice Mode function.
|
|
#define SD_POLLING_MODE 0 /// Query mode. In this mode, it is recommended to increase the setting of SDIO_TRANSFER_CLK_DIV if there are problems with reading and writing.
|
|
#define SD_DMA_MODE 1 /// In DMA mode, it is recommended to increase the setting of SDIO_TRANSFER_CLK_DIV if there are problems with reading and writing.
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief SDIO Various error enumeration definitions
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
typedef enum {
|
|
SD_CMD_CRC_FAIL = 1, ///< Command response received (but CRC check failed)
|
|
SD_DATA_CRC_FAIL, ///< Data bock sent/received (CRC check Failed)
|
|
SD_CMD_RSP_TIMEOUT, ///< Command response timeout
|
|
SD_DATA_TIMEOUT, ///< Data time out
|
|
SD_TX_UNDERRUN, ///< Transmit FIFO under-run
|
|
SD_RX_OVERRUN, ///< Receive FIFO over-run
|
|
SD_START_BIT_ERR, ///< Start bit not detected on all data signals in widE bus mode
|
|
SD_CMD_OUT_OF_RANGE, ///< CMD's argument was out of range.
|
|
SD_ADDR_MISALIGNED, ///< Misaligned address
|
|
SD_BLOCK_LEN_ERR, ///< Transferred block length is not allowed for the card or the number of transferred bytes does not match the block length
|
|
SD_ERASE_SEQ_ERR, ///< An error in the sequence of erase command occurs.
|
|
SD_BAD_ERASE_PARAM, ///< An Invalid selection for erase groups
|
|
SD_WRITE_PROT_VIOLATION, ///< Attempt to program a write protect block
|
|
SD_LOCK_UNLOCK_FAILED, ///< Sequence or password error has been detected in unlock command or if there was an attempt to access a locked card
|
|
SD_COM_CRC_FAILED, ///< CRC check of the previous command failed
|
|
SD_ILLEGAL_CMD, ///< Command is not legal for the card state
|
|
SD_CARD_ECC_FAILED, ///< Card internal ECC was applied but failed to correct the data
|
|
SD_CC_ERROR, ///< Internal card controller error
|
|
SD_GENERAL_UNKNOWN_ERROR, ///< General or Unknown error
|
|
SD_STREAM_READ_UNDERRUN, ///< The card could not sustain data transfer in stream read operation.
|
|
SD_STREAM_WRITE_OVERRUN, ///< The card could not sustain data programming in stream mode
|
|
SD_CID_CSD_OVERWRITE, ///< CID/CSD overwrite error
|
|
SD_WP_ERASE_SKIP, ///< only partial address space was erased
|
|
SD_CARD_ECC_DISABLED, ///< Command has been executed without using internal ECC
|
|
SD_ERASE_RESET, ///< Erase sequence was cleared before executing because an out of erase sequence command was received
|
|
SD_AKE_SEQ_ERROR, ///< Error in sequence of authentication.
|
|
SD_INVALID_VOLTRANGE, ///< SD invalid voltage range,
|
|
SD_ADDR_OUT_OF_RANGE, ///< SD addresses are out of range,
|
|
SD_SWITCH_ERROR, ///< SD switch error,
|
|
SD_SDIO_DISABLED, ///< SD SDIO disability,
|
|
SD_SDIO_FUNCTION_BUSY, ///< SD SDIO function busy,
|
|
SD_SDIO_FUNCTION_FAILED, ///< SD SDIO failed,
|
|
SD_SDIO_UNKNOWN_FUNCTION, ///< SDIO unknown function,
|
|
SD_INTERNAL_ERROR, ///< SD internal error,
|
|
SD_NOT_CONFIGURED, ///< SD is not configured,
|
|
SD_REQUEST_PENDING, ///< The SD request waits,
|
|
SD_REQUEST_NOT_APPLICABLE, ///< The SD requirement does not apply,
|
|
SD_INVALID_PARAMETER, ///< Invalid SD parameter,
|
|
SD_UNSUPPORTED_FEATURE, ///< Features not supported by SD,
|
|
SD_UNSUPPORTED_HW, ///< HW not supported by SD,
|
|
SD_ERROR, ///< SD error
|
|
SD_OK = 0 ///< SD OK
|
|
} SD_Error;
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief SD card CSD register data
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
typedef struct {
|
|
u8 CSDStruct; ///< CSD structure
|
|
u8 SysSpecVersion; ///< System specification version
|
|
u8 Reserved1; ///< Reserved
|
|
u8 TAAC; ///< Data read access-time 1
|
|
u8 NSAC; ///< Data read access-time 2 in CLK cycles
|
|
u8 MaxBusClkFrec; ///< Max. bus clock frequency
|
|
u16 CardComdClasses; ///< Card command classes
|
|
u8 RdBlockLen; ///< Max. read data block length
|
|
u8 PartBlockRead; ///< Partial blocks for read allowed
|
|
u8 WrBlockMisalign; ///< Write block misalignment
|
|
u8 RdBlockMisalign; ///< Read block misalignment
|
|
u8 DSRImpl; ///< DSR implemented
|
|
u8 Reserved2; ///< Reserved
|
|
u32 DeviceSize; ///< Device Size
|
|
u8 MaxRdCurrentVDDMin; ///< Max. read current @ VDD min
|
|
u8 MaxRdCurrentVDDMax; ///< Max. read current @ VDD max
|
|
u8 MaxWrCurrentVDDMin; ///< Max. write current @ VDD min
|
|
u8 MaxWrCurrentVDDMax; ///< Max. write current @ VDD max
|
|
u8 DeviceSizeMul; ///< Device size multiplier
|
|
u8 EraseGrSize; ///< Erase group size
|
|
u8 EraseGrMul; ///< Erase group size multiplier
|
|
u8 WrProtectGrSize; ///< Write protect group size
|
|
u8 WrProtectGrEnable; ///< Write protect group enable
|
|
u8 ManDeflECC; ///< Manufacturer default ECC
|
|
u8 WrSpeedFact; ///< Write speed factor
|
|
u8 MaxWrBlockLen; ///< Max. write data block length
|
|
u8 WriteBlockPaPartial; ///< Partial blocks for write allowed
|
|
u8 Reserved3; ///< Reserded
|
|
u8 ContentProtectAppli; ///< Content protection application
|
|
u8 FileFormatGrouop; ///< File format group
|
|
u8 CopyFlag; ///< Copy flag (OTP)
|
|
u8 PermWrProtect; ///< Permanent write protection
|
|
u8 TempWrProtect; ///< Temporary write protection
|
|
u8 FileFormat; ///< File Format
|
|
u8 ECC; ///< ECC code
|
|
u8 CSD_CRC; ///< CSD CRC
|
|
u8 Reserved4; ///< always 1
|
|
} SD_CSD;
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief SD card CID register data
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
typedef struct {
|
|
u8 ManufacturerID; ///< ManufacturerID
|
|
u16 OEM_AppliID; ///< OEM/Application ID
|
|
u32 ProdName1; ///< Product Name part1
|
|
u8 ProdName2; ///< Product Name part2
|
|
u8 ProdRev; ///< Product Revision
|
|
u32 ProdSN; ///< Product Serial Number
|
|
u8 Reserved1; ///< Reserved1
|
|
u16 ManufactDate; ///< Manufacturing Date
|
|
u8 CID_CRC; ///< CID CRC
|
|
u8 Reserved2; ///< always 1
|
|
} SD_CID;
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief SD state
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
typedef enum {
|
|
SD_CARD_READY = ((u32)0x00000001),
|
|
SD_CARD_IDENTIFICATION = ((u32)0x00000002),
|
|
SD_CARD_STANDBY = ((u32)0x00000003),
|
|
SD_CARD_TRANSFER = ((u32)0x00000004),
|
|
SD_CARD_SENDING = ((u32)0x00000005),
|
|
SD_CARD_RECEIVING = ((u32)0x00000006),
|
|
SD_CARD_PROGRAMMING = ((u32)0x00000007),
|
|
SD_CARD_DISCONNECTED = ((u32)0x00000008),
|
|
SD_CARD_ERROR = ((u32)0x000000FF)
|
|
} SDCardState;
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief SD message ,include CSD,CID data
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
typedef struct {
|
|
SD_CSD SD_csd;
|
|
SD_CID SD_cid;
|
|
long long CardCapacity;
|
|
u32 CardBlockSize;
|
|
u16 RCA;
|
|
u8 CardType;
|
|
} SD_CardInfo;
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief SDIO init
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
typedef struct {
|
|
u8 SDIO_MDEN;
|
|
u8 SDIO_DATWT;
|
|
u8 SDIO_SelPTSM;
|
|
u8 SDIO_CLKSP;
|
|
u8 SDIO_OUTM;
|
|
u8 SDIO_SelSM;
|
|
u8 SDIO_OPMSel;
|
|
} SDIO_InitTypeDef;
|
|
|
|
typedef struct {
|
|
u32 SDIO_Argument; ///Specifies the SDIO command argument which is sent
|
|
///to a card as part of a command message. If a command
|
|
///contains an argument, it must be loaded into this register
|
|
///before writing the command to the command register
|
|
|
|
u32 SDIO_CmdIndex; ///Specifies the SDIO command index. It must be lower than 0x40.
|
|
|
|
u32 SDIO_Response; ///Specifies the SDIO response type.
|
|
///This parameter can be a value of @ref SDIO_Response_Type
|
|
|
|
u32 SDIO_Wait; ///Specifies whether SDIO wait-for-interrupt request is enabled or disabled.
|
|
///This parameter can be a value of @ref SDIO_Wait_Interrupt_State
|
|
|
|
/// u32 SDIO_CPSM; ///Specifies whether SDIO Command path state machine (CPSM)
|
|
///is enabled or disabled.
|
|
///This parameter can be a value of @ref SDIO_CPSM_State
|
|
} SDIO_CmdInitTypeDef;
|
|
typedef struct {
|
|
u32 SDIO_DataTimeOut; // < Specifies the data timeout period in card bus clock periods.
|
|
//
|
|
u32 SDIO_DataLength; // < Specifies the number of data bytes to be transferred.
|
|
//
|
|
u32 SDIO_DataBlockSize; // < Specifies the data block size for block transfer.
|
|
// This parameter can be a value of @ref SDIO_Data_Block_Size
|
|
//
|
|
u32 SDIO_TransferDir; // < Specifies the data transfer direction, whether the transfer
|
|
// is a read or write.
|
|
// This parameter can be a value of @ref SDIO_Transfer_Direction
|
|
//
|
|
// u32 SDIO_TransferMode; // < Specifies whether data transfer is in stream or block mode.
|
|
// // This parameter can be a value of @ref SDIO_Transfer_Type
|
|
// //
|
|
// u32 SDIO_DPSM; // < Specifies whether SDIO Data path state machine (DPSM)
|
|
// // is enabled or disabled.
|
|
// // This parameter can be a value of @ref SDIO_DPSM_State
|
|
} SDIO_DataInitTypeDef;
|
|
|
|
|
|
|
|
extern SD_CardInfo SDCardInfo;
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @defgroup SDIO ָinstruction set
|
|
/// @{
|
|
#define SD_CMD_GO_IDLE_STATE ((u8)0)
|
|
#define SD_CMD_SEND_OP_COND ((u8)1)
|
|
#define SD_CMD_ALL_SEND_CID ((u8)2)
|
|
#define SD_CMD_SET_REL_ADDR ((u8)3)
|
|
#define SD_CMD_SET_DSR ((u8)4)
|
|
#define SD_CMD_SDIO_SEN_OP_COND ((u8)5)
|
|
#define SD_CMD_HS_SWITCH ((u8)6)
|
|
#define SD_CMD_SEL_DESEL_CARD ((u8)7)
|
|
#define SD_CMD_HS_SEND_EXT_CSD ((u8)8)
|
|
#define SD_CMD_SEND_CSD ((u8)9)
|
|
#define SD_CMD_SEND_CID ((u8)10)
|
|
#define SD_CMD_READ_DAT_UNTIL_STOP ((u8)11)
|
|
#define SD_CMD_STOP_TRANSMISSION ((u8)12)
|
|
#define SD_CMD_SEND_STATUS ((u8)13)
|
|
#define SD_CMD_HS_BUSTEST_READ ((u8)14)
|
|
#define SD_CMD_GO_INACTIVE_STATE ((u8)15)
|
|
#define SD_CMD_SET_BLOCKLEN ((u8)16)
|
|
#define SD_CMD_READ_SINGLE_BLOCK ((u8)17)
|
|
#define SD_CMD_READ_MULT_BLOCK ((u8)18)
|
|
#define SD_CMD_HS_BUSTEST_WRITE ((u8)19)
|
|
#define SD_CMD_WRITE_DAT_UNTIL_STOP ((u8)20)
|
|
#define SD_CMD_SET_BLOCK_COUNT ((u8)23)
|
|
#define SD_CMD_WRITE_SINGLE_BLOCK ((u8)24)
|
|
#define SD_CMD_WRITE_MULT_BLOCK ((u8)25)
|
|
#define SD_CMD_PROG_CID ((u8)26)
|
|
#define SD_CMD_PROG_CSD ((u8)27)
|
|
#define SD_CMD_SET_WRITE_PROT ((u8)28)
|
|
#define SD_CMD_CLR_WRITE_PROT ((u8)29)
|
|
#define SD_CMD_SEND_WRITE_PROT ((u8)30)
|
|
#define SD_CMD_SD_ERASE_GRP_START ((u8)32)
|
|
#define SD_CMD_SD_ERASE_GRP_END ((u8)33)
|
|
#define SD_CMD_ERASE_GRP_START ((u8)35)
|
|
#define SD_CMD_ERASE_GRP_END ((u8)36)
|
|
#define SD_CMD_ERASE ((u8)38)
|
|
#define SD_CMD_FAST_IO ((u8)39)
|
|
#define SD_CMD_GO_IRQ_STATE ((u8)40)
|
|
#define SD_CMD_LOCK_UNLOCK ((u8)42)
|
|
#define SD_CMD_APP_CMD ((u8)55)
|
|
#define SD_CMD_GEN_CMD ((u8)56)
|
|
#define SD_CMD_NO_CMD ((u8)64)
|
|
/// @}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @defgroup Following commands are SD Card Specific commands.
|
|
/// @{
|
|
#define SD_CMD_APP_SD_SET_BUSWIDTH ((u8)6)
|
|
#define SD_CMD_SD_APP_STAUS ((u8)13)
|
|
#define SD_CMD_SD_APP_SEND_NUM_WRITE_BLOCKS ((u8)22)
|
|
#define SD_CMD_SD_APP_OP_COND ((u8)41)
|
|
#define SD_CMD_SD_APP_SET_CLR_CARD_DETECT ((u8)42)
|
|
#define SD_CMD_SD_APP_SEND_SCR ((u8)51)
|
|
#define SD_CMD_SDIO_RW_DIRECT ((u8)52)
|
|
#define SD_CMD_SDIO_RW_EXTENDED ((u8)53)
|
|
|
|
#define SD_CMD_SD_APP_GET_MKB ((u8)43)
|
|
#define SD_CMD_SD_APP_GET_MID ((u8)44)
|
|
#define SD_CMD_SD_APP_SET_CER_RN1 ((u8)45)
|
|
#define SD_CMD_SD_APP_GET_CER_RN2 ((u8)46)
|
|
#define SD_CMD_SD_APP_SET_CER_RES2 ((u8)47)
|
|
#define SD_CMD_SD_APP_GET_CER_RES1 ((u8)48)
|
|
#define SD_CMD_SD_APP_SECURE_READ_MULTIPLE_BLOCK ((u8)18)
|
|
#define SD_CMD_SD_APP_SECURE_WRITE_MULTIPLE_BLOCK ((u8)25)
|
|
#define SD_CMD_SD_APP_SECURE_ERASE ((u8)38)
|
|
#define SD_CMD_SD_APP_CHANGE_SECURE_AREA ((u8)49)
|
|
#define SD_CMD_SD_APP_SECURE_WRITE_MKB ((u8)48)
|
|
/// @}
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @defgroup SD support define.
|
|
/// @{
|
|
#define SDIO_STD_CAPACITY_SD_CARD_V1_1 ((u32)0x00000000)
|
|
#define SDIO_STD_CAPACITY_SD_CARD_V2_0 ((u32)0x00000001)
|
|
#define SDIO_HIGH_CAPACITY_SD_CARD ((u32)0x00000002)
|
|
#define SDIO_MULTIMEDIA_CARD ((u32)0x00000003)
|
|
#define SDIO_SECURE_DIGITAL_IO_CARD ((u32)0x00000004)
|
|
#define SDIO_HIGH_SPEED_MULTIMEDIA_CARD ((u32)0x00000005)
|
|
#define SDIO_SECURE_DIGITAL_IO_COMBO_CARD ((u32)0x00000006)
|
|
#define SDIO_HIGH_CAPACITY_MMC_CARD ((u32)0x00000007)
|
|
/// @}
|
|
|
|
#ifndef NULL
|
|
#define NULL 0
|
|
#endif
|
|
#define SDIO_STATIC_FLAGS ((u32)0x000005FF)
|
|
#define SDIO_CMD0TIMEOUT ((u32)0x00010000)
|
|
#define SDIO_DATATIMEOUT ((u32)0xFFFFFFFF)
|
|
#define SDIO_FIFO_Address ((u32)0x40018080)
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @defgroup Mask for errors Card Status R1 (OCR Register)
|
|
/// @{
|
|
#define SD_OCR_ADDR_OUT_OF_RANGE ((u32)0x80000000)
|
|
#define SD_OCR_ADDR_MISALIGNED ((u32)0x40000000)
|
|
#define SD_OCR_BLOCK_LEN_ERR ((u32)0x20000000)
|
|
#define SD_OCR_ERASE_SEQ_ERR ((u32)0x10000000)
|
|
#define SD_OCR_BAD_ERASE_PARAM ((u32)0x08000000)
|
|
#define SD_OCR_WRITE_PROT_VIOLATION ((u32)0x04000000)
|
|
#define SD_OCR_LOCK_UNLOCK_FAILED ((u32)0x01000000)
|
|
#define SD_OCR_COM_CRC_FAILED ((u32)0x00800000)
|
|
#define SD_OCR_ILLEGAL_CMD ((u32)0x00400000)
|
|
#define SD_OCR_CARD_ECC_FAILED ((u32)0x00200000)
|
|
#define SD_OCR_CC_ERROR ((u32)0x00100000)
|
|
#define SD_OCR_GENERAL_UNKNOWN_ERROR ((u32)0x00080000)
|
|
#define SD_OCR_STREAM_READ_UNDERRUN ((u32)0x00040000)
|
|
#define SD_OCR_STREAM_WRITE_OVERRUN ((u32)0x00020000)
|
|
#define SD_OCR_CID_CSD_OVERWRIETE ((u32)0x00010000)
|
|
#define SD_OCR_WP_ERASE_SKIP ((u32)0x00008000)
|
|
#define SD_OCR_CARD_ECC_DISABLED ((u32)0x00004000)
|
|
#define SD_OCR_ERASE_RESET ((u32)0x00002000)
|
|
#define SD_OCR_AKE_SEQ_ERROR ((u32)0x00000008)
|
|
#define SD_OCR_ERRORBITS ((u32)0xFDFFE008)
|
|
/// @}
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @defgroup Masks for R6 Response
|
|
/// @{
|
|
#define SD_R6_GENERAL_UNKNOWN_ERROR ((u32)0x00002000)
|
|
#define SD_R6_ILLEGAL_CMD ((u32)0x00004000)
|
|
#define SD_R6_COM_CRC_FAILED ((u32)0x00008000)
|
|
/// @}
|
|
#define SD_VOLTAGE_WINDOW_SD ((u32)0x80100000)
|
|
#define SD_HIGH_CAPACITY ((u32)0x40000000)
|
|
#define SD_STD_CAPACITY ((u32)0x00000000)
|
|
#define SD_CHECK_PATTERN ((u32)0x000001AA)
|
|
#define SD_VOLTAGE_WINDOW_MMC ((u32)0x80FF8000)
|
|
|
|
#define SD_MAX_VOLT_TRIAL ((u32)0x0000FFFF)
|
|
#define SD_ALLZERO ((u32)0x00000000)
|
|
|
|
#define SD_WIDE_BUS_SUPPORT ((u32)0x00040000)
|
|
#define SD_SINGLE_BUS_SUPPORT ((u32)0x00010000)
|
|
#define SD_CARD_LOCKED ((u32)0x02000000)
|
|
#define SD_CARD_PROGRAMMING ((u32)0x00000007)
|
|
#define SD_CARD_RECEIVING ((u32)0x00000006)
|
|
#define SD_DATATIMEOUT ((u32)0xFFFFFFFF)
|
|
#define SD_0TO7BITS ((u32)0x000000FF)
|
|
#define SD_8TO15BITS ((u32)0x0000FF00)
|
|
#define SD_16TO23BITS ((u32)0x00FF0000)
|
|
#define SD_24TO31BITS ((u32)0xFF000000)
|
|
#define SD_MAX_DATA_LENGTH ((u32)0x01FFFFFF)
|
|
|
|
#define SD_HALFFIFO ((u32)0x00000008)
|
|
#define SD_HALFFIFOBYTES ((u32)0x00000020)
|
|
|
|
#define SD_CCCC_LOCK_UNLOCK ((u32)0x00000080)
|
|
#define SD_CCCC_WRITE_PROT ((u32)0x00000040)
|
|
#define SD_CCCC_ERASE ((u32)0x00000020)
|
|
|
|
|
|
#define SDIO_SEND_IF_COND ((u32)0x00000008)
|
|
|
|
#define SDIO_Response_No ((u32)0x00)
|
|
#define SDIO_Response_Short ((u32)0x01)
|
|
#define SDIO_Response_Long ((u32)0x03)
|
|
|
|
#define SDIO_DataBlockSize_1b ((u32)0x00000000)
|
|
#define SDIO_DataBlockSize_2b ((u32)0x00000001)
|
|
#define SDIO_DataBlockSize_4b ((u32)0x00000002)
|
|
#define SDIO_DataBlockSize_8b ((u32)0x00000003)
|
|
#define SDIO_DataBlockSize_16b ((u32)0x00000004)
|
|
#define SDIO_DataBlockSize_32b ((u32)0x00000005)
|
|
#define SDIO_DataBlockSize_64b ((u32)0x00000006)
|
|
#define SDIO_DataBlockSize_128b ((u32)0x00000007)
|
|
#define SDIO_DataBlockSize_256b ((u32)0x00000008)
|
|
#define SDIO_DataBlockSize_512b ((u32)0x00000009)
|
|
#define SDIO_DataBlockSize_1024b ((u32)0x0000000A)
|
|
#define SDIO_DataBlockSize_2048b ((u32)0x0000000B)
|
|
#define SDIO_DataBlockSize_4096b ((u32)0x0000000C)
|
|
#define SDIO_DataBlockSize_8192b ((u32)0x0000000D)
|
|
#define SDIO_DataBlockSize_16384b ((u32)0x0000000E)
|
|
//Define the data block length when the block data transfer mode is selected:
|
|
//0000: (0 decimal) lock length = 2^0 = 1 byte
|
|
//0001: (1 decimal) lock length = 2^1 = 2 bytes
|
|
//0010: (2 decimal) lock length = 2^2 = 4 bytes
|
|
//0011: (3 decimal) lock length = 2^3 = 8 bytes
|
|
//0100: (4 decimal) lock length = 2^4 = 16 bytes
|
|
//0101: (5 decimal) lock length = 2^5 = 32 bytes
|
|
//0110: (6 decimal) lock length = 2^6 = 64 bytes
|
|
//0111: (7 decimal) lock length = 2^7 = 128 bytes
|
|
//1000: (8 decimal) lock length = 2^8 = 256 bytes
|
|
//1001: (9 decimal) lock length = 2^9 = 512 bytes
|
|
//1010: (10 decimal) lock length = 2^10 = 1024 bytes
|
|
//1011: (11 decimal) lock length = 2^11 = 2048 bytes
|
|
//1100: (12 decimal) lock length = 2^12 = 4096 bytes
|
|
//1101: (13 decimal) lock length = 2^13 = 8192 bytes
|
|
//1110: (14 decimal) lock length = 2^14 = 16384 bytes
|
|
//1111: (15 decimal) reserved
|
|
|
|
|
|
#define SDIO_TransferDir_ToCard ((u32)0x00000000)
|
|
#define SDIO_TransferDir_ToSDIO ((u32)0x00000002)
|
|
|
|
#define SDIO_Wait_No ((u32)0x00000000) // SDIO No Wait, TimeOut is enabled
|
|
#define SDIO_Wait_IT ((u32)0x00000100) //SDIO Wait Interrupt Request
|
|
#define SDIO_Wait_Pend ((u32)0x00000200) // SDIO Wait End of transfer
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @defgroup I2C_Exported_Functions
|
|
/// @{
|
|
void SDIO_DeInit(void);
|
|
void SDIO_StructInit(SDIO_InitTypeDef* SDIO_InitStruct);
|
|
void SDIO_ClockSet(u32 value);
|
|
void SDIO_Init(SDIO_InitTypeDef* SDIO_InitStruct);
|
|
void SDIO_ITConfig(u32 SDIO_IT, FunctionalState state);
|
|
void SDIO_CRCConfig(u32 SDIO_CRC, FunctionalState state);
|
|
void SDIO_Clock_Set(u8 clkdiv);
|
|
void SDIO_Send_Cmd(u8 cmdindex, u8 waitrsp, u32 arg);
|
|
SD_Error SD_PowerOFF(void);
|
|
SD_Error CmdError(void);
|
|
SD_Error CmdResp2Error(void);
|
|
SD_Error CmdResp3Error(void);
|
|
SD_Error CmdResp6Error(u8 cmd, u16* prca);
|
|
SD_Error CmdResp7Error(void);
|
|
SD_Error CmdResp1Error(u8 cmd);
|
|
void SDIO_Send_Data_Cfg(u32 datatimeout, u32 datalen, u8 blksize, u8 dir);
|
|
void SDIO_ClearITPendingBit(u32 SDIO_IT);
|
|
FlagStatus SDIO_GetFlagStatus(u32 SDIO_FLAG);
|
|
u32 SDIO_GetTimeOutCounter(void);
|
|
u32 SDIO_ReadData(void);
|
|
void SDIO_WriteData(u32 tempbuff);
|
|
void SDIO_DMACmd(FunctionalState state);
|
|
/// @}
|
|
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
|
|
/// @}
|
|
|
|
/// @}
|
|
|
|
/// @}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
#endif
|
|
////////////////////////////////////////////////////////////////////////////////
|