历史上的今天
今天是：2025年01月31日（星期五）
2019年01月31日 | 【stm32f407】SD协议（三）-源码
2019-01-31 来源：eefocus
一．硬件连接
上图为stm32的CPU引脚图
上图为SD卡的接线
二．源码
Sdio_sdcard.h
//SDIO相关标志位,拷贝自:stm32f4xx_sdio.h
#defineSDIO_FLAG_CCRCFAIL ((uint32_t)0x00000001)
#defineSDIO_FLAG_DCRCFAIL ((uint32_t)0x00000002)
#defineSDIO_FLAG_CTIMEOUT ((uint32_t)0x00000004)
#defineSDIO_FLAG_DTIMEOUT ((uint32_t)0x00000008)
#defineSDIO_FLAG_TXUNDERR ((uint32_t)0x00000010)
#defineSDIO_FLAG_RXOVERR ((uint32_t)0x00000020)
#defineSDIO_FLAG_CMDREND ((uint32_t)0x00000040)
#defineSDIO_FLAG_CMDSENT ((uint32_t)0x00000080)
#defineSDIO_FLAG_DATAEND ((uint32_t)0x00000100)
#defineSDIO_FLAG_STBITERR ((uint32_t)0x00000200)
#defineSDIO_FLAG_DBCKEND ((uint32_t)0x00000400)
#defineSDIO_FLAG_CMDACT ((uint32_t)0x00000800)
#defineSDIO_FLAG_TXACT ((uint32_t)0x00001000)
#defineSDIO_FLAG_RXACT ((uint32_t)0x00002000)
#defineSDIO_FLAG_TXFIFOHE ((uint32_t)0x00004000)
#defineSDIO_FLAG_RXFIFOHF ((uint32_t)0x00008000)
#defineSDIO_FLAG_TXFIFOF ((uint32_t)0x00010000)
#defineSDIO_FLAG_RXFIFOF ((uint32_t)0x00020000)
#defineSDIO_FLAG_TXFIFOE ((uint32_t)0x00040000)
#defineSDIO_FLAG_RXFIFOE ((uint32_t)0x00080000)
#defineSDIO_FLAG_TXDAVL ((uint32_t)0x00100000)
#defineSDIO_FLAG_RXDAVL ((uint32_t)0x00200000)
#defineSDIO_FLAG_SDIOIT ((uint32_t)0x00400000)
#defineSDIO_FLAG_CEATAEND ((uint32_t)0x00800000)
//用户配置区
//SDIO时钟计算公式:SDIO_CK时钟=SDIOCLK/[clkdiv+2];其中,SDIOCLK固定为48Mhz
//使用DMA模式的时候,传输速率可以到48Mhz(bypasson时),不过如果你的卡不是高速
//卡,可能也会出错,出错就请降低时钟
#defineSDIO_INIT_CLK_DIV 0x76 //SDIO初始化频率，最大400Kh
#defineSDIO_TRANSFER_CLK_DIV 0x00 //SDIO传输频率,该值太小可能会导致读写文件出错
////////////////////////////////////////////////////////////////////////////////////////////////////
//SDIO工作模式定义,通过SD_SetDeviceMode函数设置.
#defineSD_POLLING_MODE 0 //查询模式,该模式下,如果读写有问题,建议增大SDIO_TRANSFER_CLK_DIV的设置.
#defineSD_DMA_MODE 1 //DMA模式,该模式下,如果读写有问题,建议增大SDIO_TRANSFER_CLK_DIV的设置.
//SDIO 各种错误枚举定义
typedefenum
{
//特殊错误定义
SD_CMD_CRC_FAIL = (1), /*!< Commandresponse received (but CRC check failed) */
SD_DATA_CRC_FAIL = (2), /*!< Data bock sent/received(CRC check Failed) */
SD_CMD_RSP_TIMEOUT = (3), /*!< Commandresponse timeout */
SD_DATA_TIMEOUT = (4), /*!< Data timeout */
SD_TX_UNDERRUN = (5), /*!< TransmitFIFO under-run */
SD_RX_OVERRUN = (6), /*!< ReceiveFIFO over-run */
SD_START_BIT_ERR = (7), /*!< Start bit notdetected on all data signals in widE bus mode */
SD_CMD_OUT_OF_RANGE = (8), /*!< CMD's argumentwas out of range.*/
SD_ADDR_MISALIGNED = (9), /*!< Misalignedaddress */
SD_BLOCK_LEN_ERR = (10), /*!< Transferredblock length is not allowed for the card or the number of transferred bytesdoes not match the block length */
SD_ERASE_SEQ_ERR = (11), /*!< An error inthe sequence of erase command occurs.*/
SD_BAD_ERASE_PARAM = (12), /*!< An Invalidselection for erase groups */
SD_WRITE_PROT_VIOLATION = (13), /*!< Attempt to programa write protect block */
SD_LOCK_UNLOCK_FAILED = (14), /*!< Sequence orpassword error has been detected in unlock command or if there was an attemptto access a locked card */
SD_COM_CRC_FAILED = (15), /*!< CRC check ofthe previous command failed */
SD_ILLEGAL_CMD = (16), /*!< Command isnot legal for the card state */
SD_CARD_ECC_FAILED = (17), /*!< Card internalECC was applied but failed to correct the data */
SD_CC_ERROR = (18), /*!< Internal cardcontroller error */
SD_GENERAL_UNKNOWN_ERROR = (19), /*!< General or Unknownerror */
SD_STREAM_READ_UNDERRUN = (20), /*!< The card could notsustain data transfer in stream read operation. */
SD_STREAM_WRITE_OVERRUN = (21), /*!< The card could notsustain data programming in stream mode */
SD_CID_CSD_OVERWRITE = (22), /*!< CID/CSDoverwrite error */
SD_WP_ERASE_SKIP = (23), /*!< only partialaddress space was erased */
SD_CARD_ECC_DISABLED = (24), /*!< Command has beenexecuted without using internal ECC */
SD_ERASE_RESET = (25), /*!< Erasesequence was cleared before executing because an out of erase sequence command wasreceived */
SD_AKE_SEQ_ERROR = (26), /*!< Error insequence of authentication. */
SD_INVALID_VOLTRANGE = (27),
SD_ADDR_OUT_OF_RANGE = (28),
SD_SWITCH_ERROR = (29),
SD_SDIO_DISABLED = (30),
SD_SDIO_FUNCTION_BUSY = (31),
SD_SDIO_FUNCTION_FAILED = (32),
SD_SDIO_UNKNOWN_FUNCTION = (33),
//标准错误定义
SD_INTERNAL_ERROR,
SD_NOT_CONFIGURED,
SD_REQUEST_PENDING,
SD_REQUEST_NOT_APPLICABLE,
SD_INVALID_PARAMETER,
SD_UNSUPPORTED_FEATURE,
SD_UNSUPPORTED_HW,
SD_ERROR,
SD_OK = 0
}SD_Error;
//SD卡CSD寄存器数据
typedefstruct
{
u8 CSDStruct; /*!< CSDstructure */
u8 SysSpecVersion; /*! u8 Reserved1; /*! u8 TAAC; /*!< Dataread access-time 1 */ u8 NSAC; /*!< Dataread 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; /*! u8 WrBlockMisalign; /*! u8 RdBlockMisalign; /*!< Readblock misalignment */ u8 DSRImpl; /*!< DSRimplemented */ u8 Reserved2; /*! 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; /*! u8 EraseGrSize; /*! u8 EraseGrMul; /*! u8 WrProtectGrSize; /*! u8 WrProtectGrEnable; /*! u8 ManDeflECC; /*!< Manufacturerdefault ECC */ u8 WrSpeedFact; /*! u8 MaxWrBlockLen; /*!< Max.write data block length */ u8 WriteBlockPaPartial; /*! u8 Reserved3; /*! u8 ContentProtectAppli; /*! u8 FileFormatGrouop; /*!< Fileformat group */ u8 CopyFlag; /*!< Copyflag (OTP) */ u8 PermWrProtect; /*! u8 TempWrProtect; /*!< Temporary write protection */ u8 FileFormat; /*!< FileFormat */ u8 ECC; /*!< ECCcode */ u8 CSD_CRC; /*!< CSDCRC */ u8 Reserved4; /*! }SD_CSD; //SD卡CID寄存器数据 typedefstruct { u8 ManufacturerID; /*! u16 OEM_AppliID; /*!< OEM/Application ID */ u32 ProdName1; /*!< Product Name part1 */ u8 ProdName2; /*! u8 ProdRev; /*! u32 ProdSN; /*!< Product Serial Number */ u8 Reserved1; /*! u16 ManufactDate; /*!< Manufacturing Date */ u8 CID_CRC; /*!< CIDCRC */ u8 Reserved2; /*! } SD_CID; //SD卡状态 typedefenum { SD_CARD_READY = ((uint32_t)0x00000001), SD_CARD_IDENTIFICATION = ((uint32_t)0x00000002), SD_CARD_STANDBY = ((uint32_t)0x00000003), SD_CARD_TRANSFER = ((uint32_t)0x00000004), SD_CARD_SENDING = ((uint32_t)0x00000005), SD_CARD_RECEIVING = ((uint32_t)0x00000006), SD_CARD_PROGRAMMING = ((uint32_t)0x00000007), SD_CARD_DISCONNECTED = ((uint32_t)0x00000008), SD_CARD_ERROR = ((uint32_t)0x000000FF) }SDCardState; //SD卡信息,包括CSD,CID等数据 typedefstruct { SD_CSD SD_csd; SD_CID SD_cid; long long CardCapacity; //SD卡容量,单位:字节,最大支持2^64字节大小的卡. u32 CardBlockSize; //SD卡块大小 u16 RCA; //卡相对地址 u8 CardType; //卡类型 }SD_CardInfo; externSD_CardInfo SDCardInfo;//SD卡信息 //////////////////////////////////////////////////////////////////////////////////////////////////// //SDIO 指令集 #defineSD_CMD_GO_IDLE_STATE ((u8)0) #defineSD_CMD_SEND_OP_COND ((u8)1) #defineSD_CMD_ALL_SEND_CID ((u8)2) #defineSD_CMD_SET_REL_ADDR ((u8)3) /*!< SDIO_SEND_REL_ADDR for SD Card */ #defineSD_CMD_SET_DSR ((u8)4) #defineSD_CMD_SDIO_SEN_OP_COND ((u8)5) #defineSD_CMD_HS_SWITCH ((u8)6) #defineSD_CMD_SEL_DESEL_CARD ((u8)7) #defineSD_CMD_HS_SEND_EXT_CSD ((u8)8) #define SD_CMD_SEND_CSD ((u8)9) #defineSD_CMD_SEND_CID ((u8)10) #defineSD_CMD_READ_DAT_UNTIL_STOP ((u8)11) /*!< SD Card doesn't support it */ #defineSD_CMD_STOP_TRANSMISSION ((u8)12) #defineSD_CMD_SEND_STATUS ((u8)13) #defineSD_CMD_HS_BUSTEST_READ ((u8)14) #defineSD_CMD_GO_INACTIVE_STATE ((u8)15) #defineSD_CMD_SET_BLOCKLEN ((u8)16) #defineSD_CMD_READ_SINGLE_BLOCK ((u8)17) #defineSD_CMD_READ_MULT_BLOCK ((u8)18) #defineSD_CMD_HS_BUSTEST_WRITE ((u8)19) #defineSD_CMD_WRITE_DAT_UNTIL_STOP ((u8)20) #defineSD_CMD_SET_BLOCK_COUNT ((u8)23) #defineSD_CMD_WRITE_SINGLE_BLOCK ((u8)24) #defineSD_CMD_WRITE_MULT_BLOCK ((u8)25) #defineSD_CMD_PROG_CID ((u8)26) #defineSD_CMD_PROG_CSD ((u8)27) #defineSD_CMD_SET_WRITE_PROT ((u8)28) #defineSD_CMD_CLR_WRITE_PROT ((u8)29) #defineSD_CMD_SEND_WRITE_PROT ((u8)30) #defineSD_CMD_SD_ERASE_GRP_START ((u8)32) /*!< To set the address of the first write block to be erased. (For SD card only) */ #defineSD_CMD_SD_ERASE_GRP_END ((u8)33) /*!< To set the address of the last write block of the continuous range to be erased. (For SD card only) */ #defineSD_CMD_ERASE_GRP_START ((u8)35) /*!< To set the address of the first write block to be erased. (For MMC card only spec 3.31) */ #defineSD_CMD_ERASE_GRP_END ((u8)36) /*!< To set the address of the last write block of the continuous range to be erased. (For MMC card only spec 3.31) */ #defineSD_CMD_ERASE ((u8)38) #defineSD_CMD_FAST_IO ((u8)39) /*!< SD Card doesn't support it */ #defineSD_CMD_GO_IRQ_STATE ((u8)40) /*!< SD Card doesn't support it */ #defineSD_CMD_LOCK_UNLOCK ((u8)42) #defineSD_CMD_APP_CMD ((u8)55) #defineSD_CMD_GEN_CMD ((u8)56) #defineSD_CMD_NO_CMD ((u8)64) /** * @brief Following commands are SD CardSpecific commands. * SDIO_APP_CMD ：CMD55 should be sent before sending these commands. */ #defineSD_CMD_APP_SD_SET_BUSWIDTH ((u8)6) /*!< For SD Card only*/ #defineSD_CMD_SD_APP_STAUS ((u8)13) /*!< For SD Card only */ #defineSD_CMD_SD_APP_SEND_NUM_WRITE_BLOCKS ((u8)22) /*!< For SD Card only */ #defineSD_CMD_SD_APP_OP_COND ((u8)41) /*!< For SD Card only */ #defineSD_CMD_SD_APP_SET_CLR_CARD_DETECT ((u8)42) /*!< For SD Card only */ #defineSD_CMD_SD_APP_SEND_SCR ((u8)51) /*!< For SD Card only */ #defineSD_CMD_SDIO_RW_DIRECT ((u8)52) /*!< For SD I/O Card only */ #defineSD_CMD_SDIO_RW_EXTENDED ((u8)53) /*!< For SD I/O Card only */ /** * @brief Following commands are SD CardSpecific security commands. * SDIO_APP_CMD should be sent beforesending these commands. */ #defineSD_CMD_SD_APP_GET_MKB ((u8)43) /*!< For SD Card only */ #defineSD_CMD_SD_APP_GET_MID ((u8)44) /*!< For SD Card only */ #define SD_CMD_SD_APP_SET_CER_RN1 ((u8)45) /*!< For SD Cardonly */ #defineSD_CMD_SD_APP_GET_CER_RN2 ((u8)46) /*!< For SD Card only */ #defineSD_CMD_SD_APP_SET_CER_RES2 ((u8)47) /*!< For SD Card only */ #define SD_CMD_SD_APP_GET_CER_RES1 ((u8)48) /*!< For SD Cardonly */ #defineSD_CMD_SD_APP_SECURE_READ_MULTIPLE_BLOCK ((u8)18) /*!< For SD Card only */ #defineSD_CMD_SD_APP_SECURE_WRITE_MULTIPLE_BLOCK ((u8)25) /*!< For SD Card only */ #defineSD_CMD_SD_APP_SECURE_ERASE ((u8)38) /*!< For SD Card only */ #defineSD_CMD_SD_APP_CHANGE_SECURE_AREA ((u8)49) /*!< For SD Card only */ #defineSD_CMD_SD_APP_SECURE_WRITE_MKB ((u8)48) /*!< For SD Card only */ //支持的SD卡定义 #defineSDIO_STD_CAPACITY_SD_CARD_V1_1 ((u32)0x00000000) #defineSDIO_STD_CAPACITY_SD_CARD_V2_0 ((u32)0x00000001) #defineSDIO_HIGH_CAPACITY_SD_CARD ((u32)0x00000002) #defineSDIO_MULTIMEDIA_CARD ((u32)0x00000003) #defineSDIO_SECURE_DIGITAL_IO_CARD ((u32)0x00000004) #defineSDIO_HIGH_SPEED_MULTIMEDIA_CARD ((u32)0x00000005) #defineSDIO_SECURE_DIGITAL_IO_COMBO_CARD ((u32)0x00000006) #defineSDIO_HIGH_CAPACITY_MMC_CARD ((u32)0x00000007) //SDIO相关参数定义 #defineNULL 0 #defineSDIO_STATIC_FLAGS ((u32)0x000005FF) #defineSDIO_CMD0TIMEOUT ((u32)0x00010000) #defineSDIO_DATATIMEOUT ((u32)0xFFFFFFFF) #defineSDIO_FIFO_Address ((u32)0x40018080) //Maskfor errors Card Status R1 (OCR Register) #defineSD_OCR_ADDR_OUT_OF_RANGE ((u32)0x80000000) #defineSD_OCR_ADDR_MISALIGNED ((u32)0x40000000) #defineSD_OCR_BLOCK_LEN_ERR ((u32)0x20000000) #defineSD_OCR_ERASE_SEQ_ERR ((u32)0x10000000) #defineSD_OCR_BAD_ERASE_PARAM ((u32)0x08000000) #defineSD_OCR_WRITE_PROT_VIOLATION ((u32)0x04000000) #defineSD_OCR_LOCK_UNLOCK_FAILED ((u32)0x01000000) #defineSD_OCR_COM_CRC_FAILED ((u32)0x00800000) #defineSD_OCR_ILLEGAL_CMD ((u32)0x00400000) #defineSD_OCR_CARD_ECC_FAILED ((u32)0x00200000) #defineSD_OCR_CC_ERROR ((u32)0x00100000) #defineSD_OCR_GENERAL_UNKNOWN_ERROR ((u32)0x00080000) #defineSD_OCR_STREAM_READ_UNDERRUN ((u32)0x00040000) #defineSD_OCR_STREAM_WRITE_OVERRUN ((u32)0x00020000) #defineSD_OCR_CID_CSD_OVERWRIETE ((u32)0x00010000) #defineSD_OCR_WP_ERASE_SKIP ((u32)0x00008000) #defineSD_OCR_CARD_ECC_DISABLED ((u32)0x00004000) #defineSD_OCR_ERASE_RESET ((u32)0x00002000) #defineSD_OCR_AKE_SEQ_ERROR ((u32)0x00000008) #defineSD_OCR_ERRORBITS ((u32)0xFDFFE008) //Masks forR6 Response #defineSD_R6_GENERAL_UNKNOWN_ERROR ((u32)0x00002000) #defineSD_R6_ILLEGAL_CMD ((u32)0x00004000) #defineSD_R6_COM_CRC_FAILED ((u32)0x00008000) #defineSD_VOLTAGE_WINDOW_SD ((u32)0x80100000) #defineSD_HIGH_CAPACITY ((u32)0x40000000) #defineSD_STD_CAPACITY ((u32)0x00000000) #defineSD_CHECK_PATTERN ((u32)0x000001AA) #defineSD_VOLTAGE_WINDOW_MMC ((u32)0x80FF8000) #defineSD_MAX_VOLT_TRIAL ((u32)0x0000FFFF) #defineSD_ALLZERO ((u32)0x00000000) #defineSD_WIDE_BUS_SUPPORT ((u32)0x00040000) #defineSD_SINGLE_BUS_SUPPORT ((u32)0x00010000) #defineSD_CARD_LOCKED ((u32)0x02000000) #defineSD_CARD_PROGRAMMING ((u32)0x00000007) #defineSD_CARD_RECEIVING ((u32)0x00000006) #defineSD_DATATIMEOUT ((u32)0xFFFFFFFF) #defineSD_0TO7BITS ((u32)0x000000FF) #defineSD_8TO15BITS ((u32)0x0000FF00) #defineSD_16TO23BITS ((u32)0x00FF0000) #defineSD_24TO31BITS ((u32)0xFF000000) #defineSD_MAX_DATA_LENGTH ((u32)0x01FFFFFF) #defineSD_HALFFIFO ((u32)0x00000008) #defineSD_HALFFIFOBYTES ((u32)0x00000020) //CommandClass Supported #defineSD_CCCC_LOCK_UNLOCK ((u32)0x00000080) #defineSD_CCCC_WRITE_PROT ((u32)0x00000040) #defineSD_CCCC_ERASE ((u32)0x00000020) //CMD8指令 #defineSDIO_SEND_IF_COND ((u32)0x00000008) //////////////////////////////////////////////////////////////////////////////////////////////////// //相关函数定义 SD_ErrorSD_Init(void); void SDIO_Clock_Set(u8clkdiv); SD_ErrorSD_PowerON(void); SD_ErrorSD_PowerOFF(void); SD_ErrorSD_InitializeCards(void); SD_ErrorSD_GetCardInfo(SD_CardInfo *cardinfo); SD_ErrorSD_EnableWideBusOperation(u32 wmode); SD_ErrorSD_SetDeviceMode(u32 mode); SD_ErrorSD_SelectDeselect(u32 addr); SD_ErrorSD_SendStatus(uint32_t *pcardstatus); SDCardStateSD_GetState(void); SD_ErrorSD_ReadBlock(u8 *buf,long long addr,u16 blksize); SD_ErrorSD_ReadMultiBlocks(u8 *buf,long long addr,u16 blksize,u32 nblks); SD_ErrorSD_WriteBlock(u8 *buf,long long addr, u16 blksize); SD_ErrorSD_WriteMultiBlocks(u8 *buf,long long addr,u16 blksize,u32 nblks); SD_ErrorSD_ProcessIRQSrc(void); voidSD_DMA_Config(u32*mbuf,u32 bufsize,u32 dir); //voidSD_DMA_Config(u32*mbuf,u32 bufsize,u8 dir); u8SD_ReadDisk(u8*buf,u32 sector,u8 cnt); //读SD卡,fatfs/usb调用 u8 SD_WriteDisk(u8*buf,u32 sector,u8 cnt); //写SD卡,fatfs/usb调用 sdio_sdcard.c /*用于sdio初始化的结构体*/ SDIO_InitTypeDefSDIO_InitStructure; SDIO_CmdInitTypeDefSDIO_CmdInitStructure; SDIO_DataInitTypeDefSDIO_DataInitStructure; SD_ErrorCmdError(void); SD_ErrorCmdResp7Error(void); SD_ErrorCmdResp1Error(u8 cmd); SD_ErrorCmdResp3Error(void); SD_ErrorCmdResp2Error(void); SD_ErrorCmdResp6Error(u8 cmd,u16*prca); SD_ErrorSDEnWideBus(u8 enx); SD_ErrorIsCardProgramming(u8 *pstatus); SD_ErrorFindSCR(u16 rca,u32 *pscr); u8convert_from_bytes_to_power_of_two(u16 NumberOfBytes); static u8CardType=SDIO_STD_CAPACITY_SD_CARD_V1_1; //SD卡类型（默认为1.x卡） staticu32 CSD_Tab[4],CID_Tab[4],RCA=0; //SD卡CSD,CID以及相对地址(RCA)数据 static u8DeviceMode=SD_DMA_MODE; //工作模式,注意,工作模式必须通过SD_SetDeviceMode,后才算数.这里只是定义一个默认的模式(SD_DMA_MODE) static u8StopCondition=0; //是否发送停止传输标志位,DMA多块读写的时候用到 volatileSD_Error TransferError=SD_OK; //数据传输错误标志,DMA读写时使用 volatileu8 TransferEnd=0; //传输结束标志,DMA读写时使用 SD_CardInfoSDCardInfo; //SD卡信息 //SD_ReadDisk/SD_WriteDisk函数专用buf,当这两个函数的数据缓存区地址不是4字节对齐的时候, //需要用到该数组,确保数据缓存区地址是4字节对齐的. __align(4)u8 SDIO_DATA_BUFFER[512]; voidSDIO_Register_Deinit() { SDIO->POWER=0x00000000; SDIO->CLKCR=0x00000000; SDIO->ARG=0x00000000; SDIO->CMD=0x00000000; SDIO->DTIMER=0x00000000; SDIO->DLEN=0x00000000; SDIO->DCTRL=0x00000000; SDIO->ICR=0x00C007FF; SDIO->MASK=0x00000000; } //初始化SD卡 //返回值:错误代码;(0,无错误) SD_ErrorSD_Init(void) { GPIO_InitTypeDef GPIO_InitStructure; NVIC_InitTypeDef NVIC_InitStructure; SD_Error errorstatus=SD_OK; u8 clkdiv=0; RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOC|RCC_AHB1Periph_GPIOD|RCC_AHB1Periph_DMA2,ENABLE);//使能GPIOC,GPIOD DMA2时钟 RCC_APB2PeriphClockCmd(RCC_APB2Periph_SDIO,ENABLE);//SDIO时钟使能 RCC_APB2PeriphResetCmd(RCC_APB2Periph_SDIO,ENABLE);//SDIO复位 GPIO_InitStructure.GPIO_Pin=GPIO_Pin_8|GPIO_Pin_9|GPIO_Pin_10|GPIO_Pin_11|GPIO_Pin_12; //PC8,9,10,11,12复用功能输出 GPIO_InitStructure.GPIO_Mode =GPIO_Mode_AF;//复用功能 GPIO_InitStructure.GPIO_Speed =GPIO_Speed_50MHz;//100M GPIO_InitStructure.GPIO_OType =GPIO_OType_PP; GPIO_InitStructure.GPIO_PuPd =GPIO_PuPd_UP;//上拉 GPIO_Init(GPIOC, &GPIO_InitStructure);//PC8,9,10,11,12复用功能输出 GPIO_InitStructure.GPIO_Pin=GPIO_Pin_2; GPIO_Init(GPIOD,&GPIO_InitStructure);//PD2复用功能输出 //引脚复用映射设置 GPIO_PinAFConfig(GPIOC,GPIO_PinSource8,GPIO_AF_SDIO);//PC8,AF12 GPIO_PinAFConfig(GPIOC,GPIO_PinSource9,GPIO_AF_SDIO); GPIO_PinAFConfig(GPIOC,GPIO_PinSource10,GPIO_AF_SDIO); GPIO_PinAFConfig(GPIOC,GPIO_PinSource11,GPIO_AF_SDIO); GPIO_PinAFConfig(GPIOC,GPIO_PinSource12,GPIO_AF_SDIO); GPIO_PinAFConfig(GPIOD,GPIO_PinSource2,GPIO_AF_SDIO); RCC_APB2PeriphResetCmd(RCC_APB2Periph_SDIO,DISABLE);//SDIO结束复位 //SDIO外设寄存器设置为默认值 SDIO_Register_Deinit(); NVIC_InitStructure.NVIC_IRQChannel =SDIO_IRQn; NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=0;//抢占优先级3 NVIC_InitStructure.NVIC_IRQChannelSubPriority=0; //子优先级3 NVIC_InitStructure.NVIC_IRQChannelCmd =ENABLE; //IRQ通道使能 NVIC_Init(&NVIC_InitStructure); //根据指定的参数初始化VIC寄存器、 errorstatus=SD_PowerON(); //SD卡上电 if(errorstatus==SD_OK)errorstatus=SD_InitializeCards(); //初始化SD卡 if(errorstatus==SD_OK)errorstatus=SD_GetCardInfo(&SDCardInfo); //获取卡信息 if(errorstatus==SD_OK)errorstatus=SD_SelectDeselect((u32)(SDCardInfo.RCA<<16));//选中SD卡 if(errorstatus==SD_OK)errorstatus=SD_EnableWideBusOperation(SDIO_BusWide_4b); //4位宽度,如果是MMC卡,则不能用4位模式 if((errorstatus==SD_OK)||(SDIO_MULTIMEDIA_CARD==CardType)) { if(SDCardInfo.CardType==SDIO_STD_CAPACITY_SD_CARD_V1_1||SDCardInfo.CardType==SDIO_STD_CAPACITY_SD_CARD_V2_0) { clkdiv=SDIO_TRANSFER_CLK_DIV+2; //V1.1/V2.0卡，设置最高48/4=12Mhz }elseclkdiv=SDIO_TRANSFER_CLK_DIV; //SDHC等其他卡，设置最高48/2=24Mhz SDIO_Clock_Set(clkdiv); //设置时钟频率,SDIO时钟计算公式:SDIO_CK时钟=SDIOCLK/[clkdiv+2];其中,SDIOCLK固定为48Mhz //errorstatus=SD_SetDeviceMode(SD_DMA_MODE); //设置为DMA模式 errorstatus=SD_SetDeviceMode(SD_POLLING_MODE);//设置为查询模式 } return errorstatus; } //SDIO时钟初始化设置 //clkdiv:时钟分频系数 //CK时钟=SDIOCLK/[clkdiv+2];(SDIOCLK时钟固定为48Mhz) void SDIO_Clock_Set(u8clkdiv) { u32 tmpreg=SDIO->CLKCR; tmpreg&=0XFFFFFF00; tmpreg|=clkdiv; SDIO->CLKCR=tmpreg; } //卡上电 //查询所有SDIO接口上的卡设备,并查询其电压和配置时钟 //返回值:错误代码;(0,无错误) SD_ErrorSD_PowerON(void) { u8i=0; SD_Error errorstatus=SD_OK; u32 response=0,count=0,validvoltage=0; u32 SDType=SD_STD_CAPACITY; /*初始化时的时钟不能大于400KHz*/ SDIO_InitStructure.SDIO_ClockDiv =SDIO_INIT_CLK_DIV; /* HCLK = 72MHz,SDIOCLK = 72MHz, SDIO_CK = HCLK/(178 + 2) = 400 KHz */ SDIO_InitStructure.SDIO_ClockEdge = SDIO_ClockEdge_Rising; SDIO_InitStructure.SDIO_ClockBypass =SDIO_ClockBypass_Disable; //不使用bypass模式，直接用HCLK进行分频得到SDIO_CK SDIO_InitStructure.SDIO_ClockPowerSave =SDIO_ClockPowerSave_Disable; // 空闲时不关闭时钟电源 SDIO_InitStructure.SDIO_BusWide =SDIO_BusWide_1b; //1位数据线 SDIO_InitStructure.SDIO_HardwareFlowControl =SDIO_HardwareFlowControl_Disable;//硬件流 SDIO_Init(&SDIO_InitStructure); SDIO_SetPowerState(SDIO_PowerState_ON); //上电状态,开启卡时钟 SDIO->CLKCR|=1<<8; //SDIOCK使能 for(i=0;i<74;i++) { SDIO_CmdInitStructure.SDIO_Argument= 0x0;//发送CMD0进入IDLE STAGE模式命令. SDIO_CmdInitStructure.SDIO_CmdIndex =SD_CMD_GO_IDLE_STATE; //cmd0 SDIO_CmdInitStructure.SDIO_Response =SDIO_Response_No; //无响应 SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No; SDIO_CmdInitStructure.SDIO_CPSM =SDIO_CPSM_Enable; //则CPSM在开始发送命令之前等待数据传输结束。 SDIO_SendCommand(&SDIO_CmdInitStructure); //写命令进命令寄存器 errorstatus=CmdError(); if(errorstatus==SD_OK)break; } if(errorstatus)returnerrorstatus;//返回错误状态 SDIO_CmdInitStructure.SDIO_Argument =SD_CHECK_PATTERN; //发送CMD8,短响应,检查SD卡接口特性 SDIO_CmdInitStructure.SDIO_CmdIndex =SDIO_SEND_IF_COND; //cmd8 SDIO_CmdInitStructure.SDIO_Response =SDIO_Response_Short; //r7 SDIO_CmdInitStructure.SDIO_Wait =SDIO_Wait_No; //关闭等待中断 SDIO_CmdInitStructure.SDIO_CPSM =SDIO_CPSM_Enable; SDIO_SendCommand(&SDIO_CmdInitStructure); errorstatus=CmdResp7Error(); //等待R7响应 if(errorstatus==SD_OK) //R7响应正常 { CardType=SDIO_STD_CAPACITY_SD_CARD_V2_0; //SD 2.0卡 SDType=SD_HIGH_CAPACITY; //高容量卡 } SDIO_CmdInitStructure.SDIO_Argument = 0x00;//发送CMD55,短响应 SDIO_CmdInitStructure.SDIO_CmdIndex =SD_CMD_APP_CMD; SDIO_CmdInitStructure.SDIO_Response =SDIO_Response_Short; SDIO_CmdInitStructure.SDIO_Wait =SDIO_Wait_No; SDIO_CmdInitStructure.SDIO_CPSM =SDIO_CPSM_Enable; SDIO_SendCommand(&SDIO_CmdInitStructure); //发送CMD55,短响应 errorstatus=CmdResp1Error(SD_CMD_APP_CMD); //等待R1响应 if(errorstatus==SD_OK)//SD2.0/SD 1.1,否则为MMC卡 { //SD卡,发送ACMD41SD_APP_OP_COND,参数为:0x80100000 while((!validvoltage)&&(count { SDIO_CmdInitStructure.SDIO_Argument = 0x00;//发送CMD55,短响应 SDIO_CmdInitStructure.SDIO_CmdIndex =SD_CMD_APP_CMD; //CMD55 SDIO_CmdInitStructure.SDIO_Response =SDIO_Response_Short; SDIO_CmdInitStructure.SDIO_Wait =SDIO_Wait_No; SDIO_CmdInitStructure.SDIO_CPSM =SDIO_CPSM_Enable; SDIO_SendCommand(&SDIO_CmdInitStructure); //发送CMD55,短响应 errorstatus=CmdResp1Error(SD_CMD_APP_CMD); //等待R1响应 if(errorstatus!=SD_OK)returnerrorstatus; //响应错误 //acmd41，命令参数由支持的电压范围及HCS位组成，HCS位置一来区分卡是SDSc还是sdhc SDIO_CmdInitStructure.SDIO_Argument =SD_VOLTAGE_WINDOW_SD | SDType; //发送ACMD41,短响应 SDIO_CmdInitStructure.SDIO_CmdIndex =SD_CMD_SD_APP_OP_COND; SDIO_CmdInitStructure.SDIO_Response =SDIO_Response_Short; //r3 SDIO_CmdInitStructure.SDIO_Wait =SDIO_Wait_No; SDIO_CmdInitStructure.SDIO_CPSM =SDIO_CPSM_Enable; SDIO_SendCommand(&SDIO_CmdInitStructure); errorstatus=CmdResp3Error(); //等待R3响应 if(errorstatus!=SD_OK)returnerrorstatus; //响应错误 response=SDIO->RESP1;; //得到响应 validvoltage=(((response>>31)==1)?1:0); //判断SD卡上电是否完成 count++; } if(count>=SD_MAX_VOLT_TRIAL) { errorstatus=SD_INVALID_VOLTRANGE; return errorstatus; } if(response&=SD_HIGH_CAPACITY) { CardType=SDIO_HIGH_CAPACITY_SD_CARD; } }else//MMC卡 { //MMC卡,发送CMD1SDIO_SEND_OP_COND,参数为:0x80FF8000 while((!validvoltage)&&(count { SDIO_CmdInitStructure.SDIO_Argument= SD_VOLTAGE_WINDOW_MMC;//发送CMD1,短响应 SDIO_CmdInitStructure.SDIO_CmdIndex =SD_CMD_SEND_OP_COND; SDIO_CmdInitStructure.SDIO_Response =SDIO_Response_Short; //r3 SDIO_CmdInitStructure.SDIO_Wait =SDIO_Wait_No; SDIO_CmdInitStructure.SDIO_CPSM =SDIO_CPSM_Enable; SDIO_SendCommand(&SDIO_CmdInitStructure); errorstatus=CmdResp3Error(); //等待R3响应 if(errorstatus!=SD_OK)returnerrorstatus; //响应错误 response=SDIO->RESP1;; //得到响应 validvoltage=(((response>>31)==1)?1:0); count++; } if(count>=SD_MAX_VOLT_TRIAL) { errorstatus=SD_INVALID_VOLTRANGE; return errorstatus; } CardType=SDIO_MULTIMEDIA_CARD; } return(errorstatus); } //SD卡 Power OFF //返回值:错误代码;(0,无错误) SD_ErrorSD_PowerOFF(void) { SDIO_SetPowerState(SDIO_PowerState_OFF);//SDIO电源关闭,时钟停止 return SD_OK; } //初始化所有的卡,并让卡进入就绪状态 //返回值:错误代码 SD_ErrorSD_InitializeCards(void) { SD_Errorerrorstatus=SD_OK; u16 rca = 0x01; if (SDIO_GetPowerState() ==SDIO_PowerState_OFF) //检查电源状态,确保为上电状态 { errorstatus = SD_REQUEST_NOT_APPLICABLE; return(errorstatus); } if(SDIO_SECURE_DIGITAL_IO_CARD!=CardType) //非SECURE_DIGITAL_IO_CARD { SDIO_CmdInitStructure.SDIO_Argument= 0x0;//发送CMD2,取得CID,长响应 SDIO_CmdInitStructure.SDIO_CmdIndex =SD_CMD_ALL_SEND_CID; SDIO_CmdInitStructure.SDIO_Response =SDIO_Response_Long; SDIO_CmdInitStructure.SDIO_Wait =SDIO_Wait_No; SDIO_CmdInitStructure.SDIO_CPSM =SDIO_CPSM_Enable; SDIO_SendCommand(&SDIO_CmdInitStructure);//发送CMD2,取得CID,长响应 errorstatus=CmdResp2Error(); //等待R2响应 if(errorstatus!=SD_OK)returnerrorstatus; //响应错误 CID_Tab[0]=SDIO->RESP1; CID_Tab[1]=SDIO->RESP2; CID_Tab[2]=SDIO->RESP3; CID_Tab[3]=SDIO->RESP4; } if((SDIO_STD_CAPACITY_SD_CARD_V1_1==CardType)||(SDIO_STD_CAPACITY_SD_CARD_V2_0==CardType)||(SDIO_SECURE_DIGITAL_IO_COMBO_CARD==CardType)||(SDIO_HIGH_CAPACITY_SD_CARD==CardType))//判断卡类型 { SDIO_CmdInitStructure.SDIO_Argument= 0x00;//发送CMD3,短响应 SDIO_CmdInitStructure.SDIO_CmdIndex =SD_CMD_SET_REL_ADDR; //cmd3 SDIO_CmdInitStructure.SDIO_Response =SDIO_Response_Short; //r6 SDIO_CmdInitStructure.SDIO_Wait =SDIO_Wait_No; SDIO_CmdInitStructure.SDIO_CPSM =SDIO_CPSM_Enable; SDIO_SendCommand(&SDIO_CmdInitStructure); //发送CMD3,短响应 errorstatus=CmdResp6Error(SD_CMD_SET_REL_ADDR,&rca);//等待R6响应 if(errorstatus!=SD_OK)returnerrorstatus; //响应错误 } if (SDIO_MULTIMEDIA_CARD==CardType) { SDIO_CmdInitStructure.SDIO_Argument =(u32)(rca<<16);//发送CMD3,短响应 SDIO_CmdInitStructure.SDIO_CmdIndex =SD_CMD_SET_REL_ADDR; //cmd3 SDIO_CmdInitStructure.SDIO_Response =SDIO_Response_Short; //r6 SDIO_CmdInitStructure.SDIO_Wait =SDIO_Wait_No; SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable; SDIO_SendCommand(&SDIO_CmdInitStructure); //发送CMD3,短响应 errorstatus=CmdResp2Error(); //等待R2响应 if(errorstatus!=SD_OK)returnerrorstatus; //响应错误 } if(SDIO_SECURE_DIGITAL_IO_CARD!=CardType) //非SECURE_DIGITAL_IO_CARD { RCA = rca; SDIO_CmdInitStructure.SDIO_Argument =(uint32_t)(rca << 16);//发送CMD9+卡RCA,取得CSD,长响应 SDIO_CmdInitStructure.SDIO_CmdIndex =SD_CMD_SEND_CSD; SDIO_CmdInitStructure.SDIO_Response =SDIO_Response_Long; SDIO_CmdInitStructure.SDIO_Wait =SDIO_Wait_No; SDIO_CmdInitStructure.SDIO_CPSM =SDIO_CPSM_Enable; SDIO_SendCommand(&SDIO_CmdInitStructure); errorstatus=CmdResp2Error(); //等待R2响应 if(errorstatus!=SD_OK)returnerrorstatus; //响应错误 CSD_Tab[0]=SDIO->RESP1; CSD_Tab[1]=SDIO->RESP2; CSD_Tab[2]=SDIO->RESP3; CSD_Tab[3]=SDIO->RESP4; } return SD_OK;//卡初始化成功 } //得到卡信息 //cardinfo:卡信息存储区 //返回值:错误状态 SD_ErrorSD_GetCardInfo(SD_CardInfo *cardinfo) { SD_Errorerrorstatus=SD_OK; u8 tmp=0; cardinfo->CardType=(u8)CardType; //卡类型 cardinfo->RCA=(u16)RCA; //卡RCA值 tmp=(u8)((CSD_Tab[0]&0xFF000000)>>24); cardinfo->SD_csd.CSDStruct=(tmp&0xC0)>>6; //CSD结构 cardinfo->SD_csd.SysSpecVersion=(tmp&0x3C)>>2; //2.0协议还没定义这部分(为保留),应该是后续协议定义的 cardinfo->SD_csd.Reserved1=tmp&0x03; //2个保留位 tmp=(u8)((CSD_Tab[0]&0x00FF0000)>>16); //第1个字节 cardinfo->SD_csd.TAAC=tmp; //数据读时间1 tmp=(u8)((CSD_Tab[0]&0x0000FF00)>>8); //第2个字节 cardinfo->SD_csd.NSAC=tmp; //数据读时间2 tmp=(u8)(CSD_Tab[0]&0x000000FF); //第3个字节 cardinfo->SD_csd.MaxBusClkFrec=tmp; //传输速度 tmp=(u8)((CSD_Tab[1]&0xFF000000)>>24); //第4个字节 cardinfo->SD_csd.CardComdClasses=tmp<<4; //卡指令类高四位 tmp=(u8)((CSD_Tab[1]&0x00FF0000)>>16); //第5个字节 cardinfo->SD_csd.CardComdClasses|=(tmp&0xF0)>>4;//卡指令类低四位 cardinfo->SD_csd.RdBlockLen=tmp&0x0F; //最大读取数据长度 tmp=(u8)((CSD_Tab[1]&0x0000FF00)>>8); //第6个字节 cardinfo->SD_csd.PartBlockRead=(tmp&0x80)>>7; //允许分块读 cardinfo->SD_csd.WrBlockMisalign=(tmp&0x40)>>6; //写块错位 cardinfo->SD_csd.RdBlockMisalign=(tmp&0x20)>>5; //读块错位 cardinfo->SD_csd.DSRImpl=(tmp&0x10)>>4; cardinfo->SD_csd.Reserved2=0; //保留 if((CardType==SDIO_STD_CAPACITY_SD_CARD_V1_1)||(CardType==SDIO_STD_CAPACITY_SD_CARD_V2_0)||(SDIO_MULTIMEDIA_CARD==CardType))//标准1.1/2.0卡/MMC卡 { cardinfo->SD_csd.DeviceSize=(tmp&0x03)<<10; //C_SIZE(12位) tmp=(u8)(CSD_Tab[1]&0x000000FF); //第7个字节 cardinfo->SD_csd.DeviceSize|=(tmp)<<2; tmp=(u8)((CSD_Tab[2]&0xFF000000)>>24); //第8个字节 cardinfo->SD_csd.DeviceSize|=(tmp&0xC0)>>6; cardinfo->SD_csd.MaxRdCurrentVDDMin=(tmp&0x38)>>3; cardinfo->SD_csd.MaxRdCurrentVDDMax=(tmp&0x07); tmp=(u8)((CSD_Tab[2]&0x00FF0000)>>16); //第9个字节 cardinfo->SD_csd.MaxWrCurrentVDDMin=(tmp&0xE0)>>5; cardinfo->SD_csd.MaxWrCurrentVDDMax=(tmp&0x1C)>>2; cardinfo->SD_csd.DeviceSizeMul=(tmp&0x03)<<1;//C_SIZE_MULT tmp=(u8)((CSD_Tab[2]&0x0000FF00)>>8); //第10个字节 cardinfo->SD_csd.DeviceSizeMul|=(tmp&0x80)>>7; cardinfo->CardCapacity=(cardinfo->SD_csd.DeviceSize+1);//计算卡容量 cardinfo->CardCapacity*=(1<<(cardinfo->SD_csd.DeviceSizeMul+2)); cardinfo->CardBlockSize=1<<(cardinfo->SD_csd.RdBlockLen);//块大小 cardinfo->CardCapacity*=cardinfo->CardBlockSize; }else if(CardType==SDIO_HIGH_CAPACITY_SD_CARD) //高容量卡 { tmp=(u8)(CSD_Tab[1]&0x000000FF); //第7个字节 cardinfo->SD_csd.DeviceSize=(tmp&0x3F)<<16;//C_SIZE tmp=(u8)((CSD_Tab[2]&0xFF000000)>>24); //第8个字节 cardinfo->SD_csd.DeviceSize|=(tmp<<8); tmp=(u8)((CSD_Tab[2]&0x00FF0000)>>16); //第9个字节 cardinfo->SD_csd.DeviceSize|=(tmp); tmp=(u8)((CSD_Tab[2]&0x0000FF00)>>8); //第10个字节 cardinfo->CardCapacity=(longlong)(cardinfo->SD_csd.DeviceSize+1)*512*1024;//计算卡容量 cardinfo->CardBlockSize=512; //块大小固定为512字节 } cardinfo->SD_csd.EraseGrSize=(tmp&0x40)>>6; cardinfo->SD_csd.EraseGrMul=(tmp&0x3F)<<1; tmp=(u8)(CSD_Tab[2]&0x000000FF); //第11个字节 cardinfo->SD_csd.EraseGrMul|=(tmp&0x80)>>7; cardinfo->SD_csd.WrProtectGrSize=(tmp&0x7F); tmp=(u8)((CSD_Tab[3]&0xFF000000)>>24); //第12个字节 cardinfo->SD_csd.WrProtectGrEnable=(tmp&0x80)>>7; cardinfo->SD_csd.ManDeflECC=(tmp&0x60)>>5; cardinfo->SD_csd.WrSpeedFact=(tmp&0x1C)>>2; cardinfo->SD_csd.MaxWrBlockLen=(tmp&0x03)<<2; tmp=(u8)((CSD_Tab[3]&0x00FF0000)>>16); //第13个字节 cardinfo->SD_csd.MaxWrBlockLen|=(tmp&0xC0)>>6; cardinfo->SD_csd.WriteBlockPaPartial=(tmp&0x20)>>5; cardinfo->SD_csd.Reserved3=0; cardinfo->SD_csd.ContentProtectAppli=(tmp&0x01); tmp=(u8)((CSD_Tab[3]&0x0000FF00)>>8); //第14个字节 cardinfo->SD_csd.FileFormatGrouop=(tmp&0x80)>>7; cardinfo->SD_csd.CopyFlag=(tmp&0x40)>>6; cardinfo->SD_csd.PermWrProtect=(tmp&0x20)>>5; cardinfo->SD_csd.TempWrProtect=(tmp&0x10)>>4; cardinfo->SD_csd.FileFormat=(tmp&0x0C)>>2; cardinfo->SD_csd.ECC=(tmp&0x03); tmp=(u8)(CSD_Tab[3]&0x000000FF); //第15个字节 cardinfo->SD_csd.CSD_CRC=(tmp&0xFE)>>1; cardinfo->SD_csd.Reserved4=1; tmp=(u8)((CID_Tab[0]&0xFF000000)>>24); //第0个字节 cardinfo->SD_cid.ManufacturerID=tmp; tmp=(u8)((CID_Tab[0]&0x00FF0000)>>16); //第1个字节 cardinfo->SD_cid.OEM_AppliID=tmp<<8; tmp=(u8)((CID_Tab[0]&0x000000FF00)>>8); //第2个字节 cardinfo->SD_cid.OEM_AppliID|=tmp; tmp=(u8)(CID_Tab[0]&0x000000FF); //第3个字节 cardinfo->SD_cid.ProdName1=tmp<<24; tmp=(u8)((CID_Tab[1]&0xFF000000)>>24); //第4个字节 cardinfo->SD_cid.ProdName1|=tmp<<16; tmp=(u8)((CID_Tab[1]&0x00FF0000)>>16); //第5个字节 cardinfo->SD_cid.ProdName1|=tmp<<8; tmp=(u8)((CID_Tab[1]&0x0000FF00)>>8); //第6个字节 cardinfo->SD_cid.ProdName1|=tmp; tmp=(u8)(CID_Tab[1]&0x000000FF); //第7个字节 cardinfo->SD_cid.ProdName2=tmp; tmp=(u8)((CID_Tab[2]&0xFF000000)>>24); //第8个字节 cardinfo->SD_cid.ProdRev=tmp; tmp=(u8)((CID_Tab[2]&0x00FF0000)>>16); //第9个字节 cardinfo->SD_cid.ProdSN=tmp<<24; tmp=(u8)((CID_Tab[2]&0x0000FF00)>>8); //第10个字节 cardinfo->SD_cid.ProdSN|=tmp<<16; tmp=(u8)(CID_Tab[2]&0x000000FF); //第11个字节 cardinfo->SD_cid.ProdSN|=tmp<<8; tmp=(u8)((CID_Tab[3]&0xFF000000)>>24); //第12个字节 cardinfo->SD_cid.ProdSN|=tmp; tmp=(u8)((CID_Tab[3]&0x00FF0000)>>16); //第13个字节 cardinfo->SD_cid.Reserved1|=(tmp&0xF0)>>4; cardinfo->SD_cid.ManufactDate=(tmp&0x0F)<<8; tmp=(u8)((CID_Tab[3]&0x0000FF00)>>8); //第14个字节 cardinfo->SD_cid.ManufactDate|=tmp; tmp=(u8)(CID_Tab[3]&0x000000FF); //第15个字节 cardinfo->SD_cid.CID_CRC=(tmp&0xFE)>>1; cardinfo->SD_cid.Reserved2=1; return errorstatus; } //设置SDIO总线宽度(MMC卡不支持4bit模式) //wmode:位宽模式.0,1位数据宽度;1,4位数据宽度;2,8位数据宽度 //返回值:SD卡错误状态 //设置SDIO总线宽度(MMC卡不支持4bit模式) // @arg SDIO_BusWide_8b: 8-bit data transfer(Only for MMC) // @arg SDIO_BusWide_4b: 4-bit data transfer // @arg SDIO_BusWide_1b: 1-bit data transfer (默认) //返回值:SD卡错误状态 SD_ErrorSD_EnableWideBusOperation(u32 WideMode) { SD_Errorerrorstatus=SD_OK; if (SDIO_MULTIMEDIA_CARD == CardType) { errorstatus = SD_UNSUPPORTED_FEATURE; return(errorstatus); } elseif((SDIO_STD_CAPACITY_SD_CARD_V1_1==CardType)||(SDIO_STD_CAPACITY_SD_CARD_V2_0==CardType)||(SDIO_HIGH_CAPACITY_SD_CARD==CardType)) { if (SDIO_BusWide_8b == WideMode) //2.0 sd不支持8bits { errorstatus = SD_UNSUPPORTED_FEATURE; return(errorstatus); } else { errorstatus=SDEnWideBus(WideMode); if(SD_OK==errorstatus) { SDIO->CLKCR&=~(3<<11); //清除之前的位宽设置 SDIO->CLKCR|=WideMode;//1位/4位总线宽度 SDIO->CLKCR|=0<<14; //不开启硬件流控制 } } } return errorstatus; } //设置SD卡工作模式 //Mode: //返回值:错误状态 SD_ErrorSD_SetDeviceMode(u32 Mode) { SD_Error errorstatus = SD_OK; if((Mode==SD_DMA_MODE)||(Mode==SD_POLLING_MODE))DeviceMode=Mode; else errorstatus=SD_INVALID_PARAMETER; return errorstatus; } //选卡 //发送CMD7,选择相对地址(rca)为addr的卡,取消其他卡.如果为0,则都不选择. //addr:卡的RCA地址 SD_ErrorSD_SelectDeselect(u32 addr) { SDIO_CmdInitStructure.SDIO_Argument = addr;//发送CMD7,选择卡,短响应 SDIO_CmdInitStructure.SDIO_CmdIndex =SD_CMD_SEL_DESEL_CARD; SDIO_CmdInitStructure.SDIO_Response =SDIO_Response_Short; SDIO_CmdInitStructure.SDIO_Wait =SDIO_Wait_No; SDIO_CmdInitStructure.SDIO_CPSM =SDIO_CPSM_Enable; SDIO_SendCommand(&SDIO_CmdInitStructure);//发送CMD7,选择卡,短响应 returnCmdResp1Error(SD_CMD_SEL_DESEL_CARD); } //SD卡读取一个块 //buf:读数据缓存区(必须4字节对齐!!) //addr:读取地址 //blksize:块大小 SD_ErrorSD_ReadBlock(u8 *buf,long long addr,u16 blksize) { SD_Error errorstatus=SD_OK; u8 power; u32 count=0,*tempbuff=(u32*)buf;//转换为u32指针 u32 timeout=SDIO_DATATIMEOUT; if(NULL==buf) return SD_INVALID_PARAMETER; SDIO->DCTRL=0x0; //数据控制寄存器清零(关DMA) if(CardType==SDIO_HIGH_CAPACITY_SD_CARD)//大容量卡 { blksize=512; addr>>=9; } SDIO_DataInitStructure.SDIO_DataBlockSize=SDIO_DataBlockSize_1b ;//清除DPSM状态机配置 SDIO_DataInitStructure.SDIO_DataLength= 0 ; SDIO_DataInitStructure.SDIO_DataTimeOut=SD_DATATIMEOUT ; SDIO_DataInitStructure.SDIO_DPSM=SDIO_DPSM_Enable; SDIO_DataInitStructure.SDIO_TransferDir=SDIO_TransferDir_ToCard; SDIO_DataInitStructure.SDIO_TransferMode=SDIO_TransferMode_Block; SDIO_DataConfig(&SDIO_DataInitStructure); if(SDIO->RESP1&SD_CARD_LOCKED)returnSD_LOCK_UNLOCK_FAILED;//卡锁了 if((blksize>0)&&(blksize<=2048)&&((blksize&(blksize-1))==0)) { power=convert_from_bytes_to_power_of_two(blksize); SDIO_CmdInitStructure.SDIO_Argument= blksize; SDIO_CmdInitStructure.SDIO_CmdIndex =SD_CMD_SET_BLOCKLEN; SDIO_CmdInitStructure.SDIO_Response =SDIO_Response_Short; SDIO_CmdInitStructure.SDIO_Wait =SDIO_Wait_No; SDIO_CmdInitStructure.SDIO_CPSM =SDIO_CPSM_Enable; SDIO_SendCommand(&SDIO_CmdInitStructure);//发送CMD16+设置数据长度为blksize,短响应 errorstatus=CmdResp1Error(SD_CMD_SET_BLOCKLEN); //等待R1响应 if(errorstatus!=SD_OK)returnerrorstatus; //响应错误 }else return SD_INVALID_PARAMETER; SDIO_DataInitStructure.SDIO_DataBlockSize= power<<4 ;//清除DPSM状态机配置 SDIO_DataInitStructure.SDIO_DataLength= blksize ; SDIO_DataInitStructure.SDIO_DataTimeOut=SD_DATATIMEOUT ; SDIO_DataInitStructure.SDIO_DPSM=SDIO_DPSM_Enable; SDIO_DataInitStructure.SDIO_TransferDir=SDIO_TransferDir_ToSDIO; SDIO_DataInitStructure.SDIO_TransferMode=SDIO_TransferMode_Block; SDIO_DataConfig(&SDIO_DataInitStructure); SDIO_CmdInitStructure.SDIO_Argument = addr; SDIO_CmdInitStructure.SDIO_CmdIndex =SD_CMD_READ_SINGLE_BLOCK; SDIO_CmdInitStructure.SDIO_Response =SDIO_Response_Short; SDIO_CmdInitStructure.SDIO_Wait =SDIO_Wait_No; SDIO_CmdInitStructure.SDIO_CPSM =SDIO_CPSM_Enable; SDIO_SendCommand(&SDIO_CmdInitStructure);//发送CMD17+从addr地址出读取数据,短响应 errorstatus=CmdResp1Error(SD_CMD_READ_SINGLE_BLOCK);//等待R1响应 if(errorstatus!=SD_OK)returnerrorstatus; //响应错误 if(DeviceMode==SD_POLLING_MODE) //查询模式,轮询数据 { INTX_DISABLE();//关闭总中断(POLLING模式,严禁中断打断SDIO读写操作!!!) while(!(SDIO->STA&((1<<5)|(1<<1)|(1<<3)|(1<<10)|(1<<9))))//无上溢/CRC/超时/完成(标志)/起始位错误 { if(SDIO_GetFlagStatus(SDIO_FLAG_RXFIFOHF)!= RESET) //接收区半满,表示至少存了8个字 { for(count=0;count<8;count++) //循环读取数据 { *(tempbuff+count)=SDIO->FIFO; } tempbuff+=8; timeout=0X7FFFFF; //读数据溢出时间 }else //处理超时 { if(timeout==0)returnSD_DATA_TIMEOUT; timeout--; } } if(SDIO_GetFlagStatus(SDIO_FLAG_DTIMEOUT)!= RESET) //数据超时错误 { SDIO_ClearFlag(SDIO_FLAG_DTIMEOUT); //清错误标志 returnSD_DATA_TIMEOUT; }elseif(SDIO_GetFlagStatus(SDIO_FLAG_DCRCFAIL) != RESET) //数据块CRC错误 { SDIO_ClearFlag(SDIO_FLAG_DCRCFAIL); //清错误标志 returnSD_DATA_CRC_FAIL; }elseif(SDIO_GetFlagStatus(SDIO_FLAG_RXOVERR) != RESET) //接收fifo上溢错误 { SDIO_ClearFlag(SDIO_FLAG_RXOVERR); //清错误标志 returnSD_RX_OVERRUN; }elseif(SDIO_GetFlagStatus(SDIO_FLAG_STBITERR) != RESET) //接收起始位错误 { SDIO_ClearFlag(SDIO_FLAG_STBITERR);//清错误标志 returnSD_START_BIT_ERR; } while(SDIO_GetFlagStatus(SDIO_FLAG_RXDAVL)!= RESET) //FIFO里面,还存在可用数据 { *tempbuff=SDIO->FIFO; //循环读取数据 tempbuff++; } INTX_ENABLE();//开启总中断 SDIO_ClearFlag(SDIO_STATIC_FLAGS);//清除所有标记 }else if(DeviceMode==SD_DMA_MODE) { TransferError=SD_OK; StopCondition=0; //单块读,不需要发送停止传输指令 TransferEnd=0; //传输结束标置位，在中断服务置1 SDIO->MASK|=(1<<1)|(1<<3)|(1<<8)|(1<<5)|(1<<9); //配置需要的中断 SDIO->DCTRL|=1<<3; //SDIODMA使能 SD_DMA_Config((u32*)buf,blksize,DMA_DIR_PeripheralToMemory); while(((DMA2->LISR&(1<<27))==RESET)&&(TransferEnd==0)&&(TransferError==SD_OK)&&timeout)timeout--;//等待传输完成 if(timeout==0)returnSD_DATA_TIMEOUT;//超时 if(TransferError!=SD_OK)errorstatus=TransferError; } returnerrorstatus; } //SD卡读取多个块 //buf:读数据缓存区 //addr:读取地址 //blksize:块大小 //nblks:要读取的块数 //返回值:错误状态 __align(4)u32 *tempbuff; SD_ErrorSD_ReadMultiBlocks(u8 *buf,long long addr,u16 blksize,u32 nblks) { SD_Error errorstatus=SD_OK; u8 power; u32 count=0; u32 timeout=SDIO_DATATIMEOUT; tempbuff=(u32*)buf;//转换为u32指针 SDIO->DCTRL=0x0; //数据控制寄存器清零(关DMA) if(CardType==SDIO_HIGH_CAPACITY_SD_CARD)//大容量卡 { blksize=512; addr>>=9; } SDIO_DataInitStructure.SDIO_DataBlockSize= 0; ;//清除DPSM状态机配置 SDIO_DataInitStructure.SDIO_DataLength= 0 ; SDIO_DataInitStructure.SDIO_DataTimeOut=SD_DATATIMEOUT ; SDIO_DataInitStructure.SDIO_DPSM=SDIO_DPSM_Enable; SDIO_DataInitStructure.SDIO_TransferDir=SDIO_TransferDir_ToCard; SDIO_DataInitStructure.SDIO_TransferMode=SDIO_TransferMode_Block; SDIO_DataConfig(&SDIO_DataInitStructure); if(SDIO->RESP1&SD_CARD_LOCKED)returnSD_LOCK_UNLOCK_FAILED;//卡锁了 if((blksize>0)&&(blksize<=2048)&&((blksize&(blksize-1))==0)) { power=convert_from_bytes_to_power_of_two(blksize); SDIO_CmdInitStructure.SDIO_Argument = blksize;//发送CMD16+设置数据长度为blksize,短响应 SDIO_CmdInitStructure.SDIO_CmdIndex= SD_CMD_SET_BLOCKLEN; SDIO_CmdInitStructure.SDIO_Response= SDIO_Response_Short; SDIO_CmdInitStructure.SDIO_Wait= SDIO_Wait_No; SDIO_CmdInitStructure.SDIO_CPSM= SDIO_CPSM_Enable; SDIO_SendCommand(&SDIO_CmdInitStructure); errorstatus=CmdResp1Error(SD_CMD_SET_BLOCKLEN); //等待R1响应 if(errorstatus!=SD_OK)returnerrorstatus; //响应错误 }else return SD_INVALID_PARAMETER; if(nblks>1) //多块读 { if(nblks*blksize>SD_MAX_DATA_LENGTH)returnSD_INVALID_PARAMETER;//判断是否超过最大接收长度 SDIO_DataInitStructure.SDIO_DataBlockSize=power<<4; ;//nblks*blksize,512块大小,卡到控制器 SDIO_DataInitStructure.SDIO_DataLength= nblks*blksize; SDIO_DataInitStructure.SDIO_DataTimeOut=SD_DATATIMEOUT; SDIO_DataInitStructure.SDIO_DPSM=SDIO_DPSM_Enable; SDIO_DataInitStructure.SDIO_TransferDir=SDIO_TransferDir_ToSDIO; SDIO_DataInitStructure.SDIO_TransferMode=SDIO_TransferMode_Block; SDIO_DataConfig(&SDIO_DataInitStructure); SDIO_CmdInitStructure.SDIO_Argument= addr;//发送CMD18+从addr地址出读取数据,短响应 SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_READ_MULT_BLOCK; SDIO_CmdInitStructure.SDIO_Response =SDIO_Response_Short; SDIO_CmdInitStructure.SDIO_Wait =SDIO_Wait_No; SDIO_CmdInitStructure.SDIO_CPSM =SDIO_CPSM_Enable; SDIO_SendCommand(&SDIO_CmdInitStructure); errorstatus=CmdResp1Error(SD_CMD_READ_MULT_BLOCK);//等待R1响应 if(errorstatus!=SD_OK)returnerrorstatus; //响应错误 if(DeviceMode==SD_POLLING_MODE) { INTX_DISABLE();//关闭总中断(POLLING模式,严禁中断打断SDIO读写操作!!!) while(!(SDIO->STA&((1<<5)|(1<<1)|(1<<3)|(1<<8)|(1<<9))))//无上溢/CRC/超时/完成(标志)/起始位错误 { if(SDIO_GetFlagStatus(SDIO_FLAG_RXFIFOHF)!= RESET) //接收区半满,表示至少存了8个字 { for(count=0;count<8;count++) //循环读取数据 { *(tempbuff+count)=SDIO->FIFO; } tempbuff+=8; timeout=0X7FFFFF; //读数据溢出时间 }else //处理超时 { if(timeout==0)return SD_DATA_TIMEOUT; timeout--; } } if(SDIO_GetFlagStatus(SDIO_FLAG_DTIMEOUT)!= RESET) //数据超时错误 { SDIO_ClearFlag(SDIO_FLAG_DTIMEOUT); //清错误标志 returnSD_DATA_TIMEOUT; }else if(SDIO_GetFlagStatus(SDIO_FLAG_DCRCFAIL)!= RESET) //数据块CRC错误 { SDIO_ClearFlag(SDIO_FLAG_DCRCFAIL); //清错误标志 returnSD_DATA_CRC_FAIL; }elseif(SDIO_GetFlagStatus(SDIO_FLAG_RXOVERR) != RESET) //接收fifo上溢错误 { SDIO_ClearFlag(SDIO_FLAG_RXOVERR); //清错误标志 returnSD_RX_OVERRUN; }elseif(SDIO_GetFlagStatus(SDIO_FLAG_STBITERR) != RESET) //接收起始位错误 { SDIO_ClearFlag(SDIO_FLAG_STBITERR);//清错误标志 returnSD_START_BIT_ERR; } while(SDIO_GetFlagStatus(SDIO_FLAG_RXDAVL)!= RESET) //FIFO里面,还存在可用数据 { *tempbuff=SDIO->FIFO; //循环读取数据 tempbuff++; } if(SDIO_GetFlagStatus(SDIO_FLAG_DATAEND)!= RESET) //接收结束 { if((SDIO_STD_CAPACITY_SD_CARD_V1_1==CardType)||(SDIO_STD_CAPACITY_SD_CARD_V2_0==CardType)||(SDIO_HIGH_CAPACITY_SD_CARD==CardType)) { SDIO_CmdInitStructure.SDIO_Argument= 0;//发送CMD12+结束传输 SDIO_CmdInitStructure.SDIO_CmdIndex =SD_CMD_STOP_TRANSMISSION; SDIO_CmdInitStructure.SDIO_Response= SDIO_Response_Short; SDIO_CmdInitStructure.SDIO_Wait= SDIO_Wait_No; SDIO_CmdInitStructure.SDIO_CPSM= SDIO_CPSM_Enable; SDIO_SendCommand(&SDIO_CmdInitStructure); errorstatus=CmdResp1Error(SD_CMD_STOP_TRANSMISSION);//等待R1响应 if(errorstatus!=SD_OK)returnerrorstatus; } } INTX_ENABLE();//开启总中断 SDIO_ClearFlag(SDIO_STATIC_FLAGS);//清除所有标记 }elseif(DeviceMode==SD_DMA_MODE) { TransferError=SD_OK; StopCondition=1; //多块读,需要发送停止传输指令 TransferEnd=0; //传输结束标置位，在中断服务置1 SDIO->MASK|=(1<<1)|(1<<3)|(1<<8)|(1<<5)|(1<<9); //配置需要的中断 SDIO->DCTRL|=1<<3; //SDIODMA使能 SD_DMA_Config((u32*)buf,nblks*blksize,DMA_DIR_PeripheralToMemory); while(((DMA2->LISR&(1<<27))==RESET)&&timeout)timeout--;//等待传输完成 if(timeout==0)returnSD_DATA_TIMEOUT;//超时 while((TransferEnd==0)&&(TransferError==SD_OK)); if(TransferError!=SD_OK)errorstatus=TransferError; } } return errorstatus; } //SD卡写1个块 //buf:数据缓存区 //addr:写地址 //blksize:块大小 //返回值:错误状态 SD_Error SD_WriteBlock(u8*buf,long long addr, u16 blksize) { SD_Error errorstatus = SD_OK; u8 power=0,cardstate=0; u32 timeout=0,bytestransferred=0; u32 cardstatus=0,count=0,restwords=0; u32 tlen=blksize; //总长度(字节) u32*tempbuff=(u32*)buf; if(buf==NULL)returnSD_INVALID_PARAMETER;//参数错误 SDIO->DCTRL=0x0; //数据控制寄存器清零(关DMA) SDIO_DataInitStructure.SDIO_DataBlockSize=0; ;//清除DPSM状态机配置 SDIO_DataInitStructure.SDIO_DataLength=0 ; SDIO_DataInitStructure.SDIO_DataTimeOut=SD_DATATIMEOUT; SDIO_DataInitStructure.SDIO_DPSM=SDIO_DPSM_Enable; SDIO_DataInitStructure.SDIO_TransferDir=SDIO_TransferDir_ToCard; SDIO_DataInitStructure.SDIO_TransferMode=SDIO_TransferMode_Block; SDIO_DataConfig(&SDIO_DataInitStructure); if(SDIO->RESP1&SD_CARD_LOCKED)returnSD_LOCK_UNLOCK_FAILED;//卡锁了 if(CardType==SDIO_HIGH_CAPACITY_SD_CARD) //大容量卡 { blksize=512; addr>>=9; } if((blksize>0)&&(blksize<=2048)&&((blksize&(blksize-1))==0)) { power=convert_from_bytes_to_power_of_two(blksize); SDIO_CmdInitStructure.SDIO_Argument= blksize;//发送CMD16+设置数据长度为blksize,短响应 SDIO_CmdInitStructure.SDIO_CmdIndex= SD_CMD_SET_BLOCKLEN; SDIO_CmdInitStructure.SDIO_Response= SDIO_Response_Short; SDIO_CmdInitStructure.SDIO_Wait= SDIO_Wait_No; SDIO_CmdInitStructure.SDIO_CPSM= SDIO_CPSM_Enable; SDIO_SendCommand(&SDIO_CmdInitStructure); errorstatus=CmdResp1Error(SD_CMD_SET_BLOCKLEN); //等待R1响应 if(errorstatus!=SD_OK)returnerrorstatus; //响应错误 }else return SD_INVALID_PARAMETER; SDIO_CmdInitStructure.SDIO_Argument= (u32)RCA<<16;//发送CMD13,查询卡的状态,短响应 SDIO_CmdInitStructure.SDIO_CmdIndex =SD_CMD_SEND_STATUS; SDIO_CmdInitStructure.SDIO_Response= SDIO_Response_Short; SDIO_CmdInitStructure.SDIO_Wait= SDIO_Wait_No; SDIO_CmdInitStructure.SDIO_CPSM= SDIO_CPSM_Enable; SDIO_SendCommand(&SDIO_CmdInitStructure); errorstatus=CmdResp1Error(SD_CMD_SEND_STATUS); //等待R1响应 if(errorstatus!=SD_OK)returnerrorstatus; cardstatus=SDIO->RESP1; timeout=SD_DATATIMEOUT; while(((cardstatus&0x00000100)==0)&&(timeout>0)) //检查READY_FOR_DATA位是否置位 { timeout--; SDIO_CmdInitStructure.SDIO_Argument= (u32)RCA<<16;//发送CMD13,查询卡的状态,短响应 SDIO_CmdInitStructure.SDIO_CmdIndex= SD_CMD_SEND_STATUS; SDIO_CmdInitStructure.SDIO_Response= SDIO_Response_Short; SDIO_CmdInitStructure.SDIO_Wait= SDIO_Wait_No; SDIO_CmdInitStructure.SDIO_CPSM= SDIO_CPSM_Enable; SDIO_SendCommand(&SDIO_CmdInitStructure); errorstatus=CmdResp1Error(SD_CMD_SEND_STATUS); //等待R1响应 if(errorstatus!=SD_OK)returnerrorstatus; cardstatus=SDIO->RESP1; } if(timeout==0)return SD_ERROR; SDIO_CmdInitStructure.SDIO_Argument= addr;//发送CMD24,写单块指令,短响应 SDIO_CmdInitStructure.SDIO_CmdIndex= SD_CMD_WRITE_SINGLE_BLOCK; SDIO_CmdInitStructure.SDIO_Response= SDIO_Response_Short; SDIO_CmdInitStructure.SDIO_Wait= SDIO_Wait_No; SDIO_CmdInitStructure.SDIO_CPSM= SDIO_CPSM_Enable; SDIO_SendCommand(&SDIO_CmdInitStructure); errorstatus=CmdResp1Error(SD_CMD_WRITE_SINGLE_BLOCK);//等待R1响应 if(errorstatus!=SD_OK)returnerrorstatus; StopCondition=0; //单块写,不需要发送停止传输指令 SDIO_DataInitStructure.SDIO_DataBlockSize=power<<4; ; //blksize, 控制器到卡 SDIO_DataInitStructure.SDIO_DataLength=blksize ; SDIO_DataInitStructure.SDIO_DataTimeOut=SD_DATATIMEOUT; SDIO_DataInitStructure.SDIO_DPSM=SDIO_DPSM_Enable; SDIO_DataInitStructure.SDIO_TransferDir=SDIO_TransferDir_ToCard; SDIO_DataInitStructure.SDIO_TransferMode=SDIO_TransferMode_Block; SDIO_DataConfig(&SDIO_DataInitStructure); timeout=SDIO_DATATIMEOUT; if (DeviceMode == SD_POLLING_MODE) { INTX_DISABLE();//关闭总中断(POLLING模式,严禁中断打断SDIO读写操作!!!) while(!(SDIO->STA&((1<<10)|(1<<4)|(1<<1)|(1<<3)|(1<<9))))//数据块发送成功/下溢/CRC/超时/起始位错误 { if(SDIO_GetFlagStatus(SDIO_FLAG_TXFIFOHE)!= RESET) //发送区半空,表示至少存了8个字 { if((tlen-bytestransferred) { restwords=((tlen-bytestransferred)%4==0)?((tlen-bytestransferred)/4):((tlen-bytestransferred)/4+1); for(count=0;count { SDIO->FIFO=*tempbuff; } }else { for(count=0;count<8;count++) { SDIO->FIFO=*(tempbuff+count); } tempbuff+=8; bytestransferred+=32; } timeout=0X3FFFFFFF; //写数据溢出时间 }else { if(timeout==0)returnSD_DATA_TIMEOUT; timeout--; } } if(SDIO_GetFlagStatus(SDIO_FLAG_DTIMEOUT)!= RESET) //数据超时错误 { SDIO_ClearFlag(SDIO_FLAG_DTIMEOUT); //清错误标志 returnSD_DATA_TIMEOUT; }elseif(SDIO_GetFlagStatus(SDIO_FLAG_DCRCFAIL) != RESET) //数据块CRC错误 { SDIO_ClearFlag(SDIO_FLAG_DCRCFAIL); //清错误标志 returnSD_DATA_CRC_FAIL; }elseif(SDIO_GetFlagStatus(SDIO_FLAG_TXUNDERR) != RESET) //接收fifo下溢错误 { SDIO_ClearFlag(SDIO_FLAG_TXUNDERR); //清错误标志 returnSD_TX_UNDERRUN; }elseif(SDIO_GetFlagStatus(SDIO_FLAG_STBITERR) != RESET) //接收起始位错误 { SDIO_ClearFlag(SDIO_FLAG_STBITERR);//清错误标志 returnSD_START_BIT_ERR; } INTX_ENABLE();//开启总中断 SDIO_ClearFlag(SDIO_STATIC_FLAGS);//清除所有标记 }else if(DeviceMode==SD_DMA_MODE) { TransferError=SD_OK; StopCondition=0; //单块写,不需要发送停止传输指令 TransferEnd=0; //传输结束标置位，在中断服务置1 SDIO->MASK|=(1<<1)|(1<<3)|(1<<8)|(1<<4)|(1<<9); //配置产生数据接收完成中断 SD_DMA_Config((u32*)buf,blksize,DMA_DIR_MemoryToPeripheral); //SDIO DMA配置 SDIO->DCTRL|=1<<3; //SDIODMA使能. while(((DMA2->LISR&(1<<27))==RESET)&&timeout)timeout--;//等待传输完成 if(timeout==0) { SD_Init(); //重新初始化SD卡,可以解决写入死机的问题 returnSD_DATA_TIMEOUT; //超时 } timeout=SDIO_DATATIMEOUT; while((TransferEnd==0)&&(TransferError==SD_OK)&&timeout)timeout--; if(timeout==0)returnSD_DATA_TIMEOUT; //超时 if(TransferError!=SD_OK)returnTransferError; } SDIO_ClearFlag(SDIO_STATIC_FLAGS);//清除所有标记 errorstatus=IsCardProgramming(&cardstate); while((errorstatus==SD_OK)&&((cardstate==SD_CARD_PROGRAMMING)||(cardstate==SD_CARD_RECEIVING))) { errorstatus=IsCardProgramming(&cardstate); } return errorstatus; } //SD卡写多个块 //buf:数据缓存区 //addr:写地址 //blksize:块大小 //nblks:要写入的块数 //返回值:错误状态 SD_ErrorSD_WriteMultiBlocks(u8 *buf,long long addr,u16 blksize,u32 nblks) { SD_Error errorstatus = SD_OK; u8 power = 0, cardstate = 0; u32 timeout=0,bytestransferred=0; u32 count = 0, restwords = 0; u32 tlen=nblks*blksize; //总长度(字节) u32 *tempbuff = (u32*)buf; if(buf==NULL)return SD_INVALID_PARAMETER; //参数错误 SDIO->DCTRL=0x0; //数据控制寄存器清零(关DMA) SDIO_DataInitStructure.SDIO_DataBlockSize=0; ; //清除DPSM状态机配置 SDIO_DataInitStructure.SDIO_DataLength=0 ; SDIO_DataInitStructure.SDIO_DataTimeOut=SD_DATATIMEOUT; SDIO_DataInitStructure.SDIO_DPSM=SDIO_DPSM_Enable; SDIO_DataInitStructure.SDIO_TransferDir=SDIO_TransferDir_ToCard; SDIO_DataInitStructure.SDIO_TransferMode=SDIO_TransferMode_Block; SDIO_DataConfig(&SDIO_DataInitStructure); if(SDIO->RESP1&SD_CARD_LOCKED)returnSD_LOCK_UNLOCK_FAILED;//卡锁了 if(CardType==SDIO_HIGH_CAPACITY_SD_CARD)//大容量卡 { blksize=512; addr>>=9; } if((blksize>0)&&(blksize<=2048)&&((blksize&(blksize-1))==0)) { power=convert_from_bytes_to_power_of_two(blksize); SDIO_CmdInitStructure.SDIO_Argument= blksize; //发送CMD16+设置数据长度为blksize,短响应 SDIO_CmdInitStructure.SDIO_CmdIndex= SD_CMD_SET_BLOCKLEN; SDIO_CmdInitStructure.SDIO_Response= SDIO_Response_Short; SDIO_CmdInitStructure.SDIO_Wait= SDIO_Wait_No; SDIO_CmdInitStructure.SDIO_CPSM= SDIO_CPSM_Enable; SDIO_SendCommand(&SDIO_CmdInitStructure); errorstatus=CmdResp1Error(SD_CMD_SET_BLOCKLEN); //等待R1响应 if(errorstatus!=SD_OK)returnerrorstatus; //响应错误 }else return SD_INVALID_PARAMETER; if(nblks>1) { if(nblks*blksize>SD_MAX_DATA_LENGTH)returnSD_INVALID_PARAMETER; if((SDIO_STD_CAPACITY_SD_CARD_V1_1==CardType)||(SDIO_STD_CAPACITY_SD_CARD_V2_0==CardType)||(SDIO_HIGH_CAPACITY_SD_CARD==CardType)) { //提高性能 SDIO_CmdInitStructure.SDIO_Argument= (u32)RCA<<16; //发送ACMD55,短响应 SDIO_CmdInitStructure.SDIO_CmdIndex= SD_CMD_APP_CMD; SDIO_CmdInitStructure.SDIO_Response= SDIO_Response_Short; SDIO_CmdInitStructure.SDIO_Wait= SDIO_Wait_No; SDIO_CmdInitStructure.SDIO_CPSM= SDIO_CPSM_Enable; SDIO_SendCommand(&SDIO_CmdInitStructure); errorstatus=CmdResp1Error(SD_CMD_APP_CMD); //等待R1响应 if(errorstatus!=SD_OK)returnerrorstatus; SDIO_CmdInitStructure.SDIO_Argument=nblks; //发送CMD23,设置块数量,短响应 SDIO_CmdInitStructure.SDIO_CmdIndex= SD_CMD_SET_BLOCK_COUNT; SDIO_CmdInitStructure.SDIO_Response= SDIO_Response_Short; SDIO_CmdInitStructure.SDIO_Wait= SDIO_Wait_No; SDIO_CmdInitStructure.SDIO_CPSM= SDIO_CPSM_Enable; SDIO_SendCommand(&SDIO_CmdInitStructure); errorstatus=CmdResp1Error(SD_CMD_SET_BLOCK_COUNT);//等待R1响应 if(errorstatus!=SD_OK)returnerrorstatus; } SDIO_CmdInitStructure.SDIO_Argument=addr; //发送CMD25,多块写指令,短响应 SDIO_CmdInitStructure.SDIO_CmdIndex= SD_CMD_WRITE_MULT_BLOCK; SDIO_CmdInitStructure.SDIO_Response= SDIO_Response_Short; SDIO_CmdInitStructure.SDIO_Wait= SDIO_Wait_No; SDIO_CmdInitStructure.SDIO_CPSM= SDIO_CPSM_Enable; SDIO_SendCommand(&SDIO_CmdInitStructure); errorstatus=CmdResp1Error(SD_CMD_WRITE_MULT_BLOCK); //等待R1响应 if(errorstatus!=SD_OK)returnerrorstatus; SDIO_DataInitStructure.SDIO_DataBlockSize= power<<4; ; //blksize, 控制器到卡 SDIO_DataInitStructure.SDIO_DataLength=nblks*blksize ; SDIO_DataInitStructure.SDIO_DataTimeOut=SD_DATATIMEOUT; SDIO_DataInitStructure.SDIO_DPSM=SDIO_DPSM_Enable; SDIO_DataInitStructure.SDIO_TransferDir=SDIO_TransferDir_ToCard; SDIO_DataInitStructure.SDIO_TransferMode=SDIO_TransferMode_Block; SDIO_DataConfig(&SDIO_DataInitStructure); if(DeviceMode==SD_POLLING_MODE) { timeout=SDIO_DATATIMEOUT; INTX_DISABLE();//关闭总中断(POLLING模式,严禁中断打断SDIO读写操作!!!) while(!(SDIO->STA&((1<<4)|(1<<1)|(1<<8)|(1<<3)|(1<<9))))//下溢/CRC/数据结束/超时/起始位错误 { if(SDIO_GetFlagStatus(SDIO_FLAG_TXFIFOHE)!= RESET) //发送区半空,表示至少存了8字(32字节) { if((tlen-bytestransferred) { restwords=((tlen-bytestransferred)%4==0)?((tlen-bytestransferred)/4):((tlen-bytestransferred)/4+1); for(count=0;count { SDIO->FIFO=*tempbuff; } }else //发送区半空,可以发送至少8字(32字节)数据 { for(count=0;count { SDIO->FIFO=*(tempbuff+count); } tempbuff+=SD_HALFFIFO; bytestransferred+=SD_HALFFIFOBYTES; } timeout=0X3FFFFFFF; //写数据溢出时间 }else { if(timeout==0)returnSD_DATA_TIMEOUT; timeout--; } } if(SDIO_GetFlagStatus(SDIO_FLAG_DTIMEOUT)!= RESET) //数据超时错误 { SDIO_ClearFlag(SDIO_FLAG_DTIMEOUT); //清错误标志 returnSD_DATA_TIMEOUT; }elseif(SDIO_GetFlagStatus(SDIO_FLAG_DCRCFAIL) != RESET) //数据块CRC错误 { SDIO_ClearFlag(SDIO_FLAG_DCRCFAIL); //清错误标志 return SD_DATA_CRC_FAIL; }elseif(SDIO_GetFlagStatus(SDIO_FLAG_TXUNDERR) != RESET) //接收fifo下溢错误 { SDIO_ClearFlag(SDIO_FLAG_TXUNDERR); //清错误标志 returnSD_TX_UNDERRUN; }elseif(SDIO_GetFlagStatus(SDIO_FLAG_STBITERR) != RESET) //接收起始位错误 { SDIO_ClearFlag(SDIO_FLAG_STBITERR);//清错误标志 returnSD_START_BIT_ERR; } if(SDIO_GetFlagStatus(SDIO_FLAG_DATAEND)!= RESET) //发送结束 { if((SDIO_STD_CAPACITY_SD_CARD_V1_1==CardType)||(SDIO_STD_CAPACITY_SD_CARD_V2_0==CardType)||(SDIO_HIGH_CAPACITY_SD_CARD==CardType)) { SDIO_CmdInitStructure.SDIO_Argument=0;//发送CMD12+结束传输 SDIO_CmdInitStructure.SDIO_CmdIndex= SD_CMD_STOP_TRANSMISSION; SDIO_CmdInitStructure.SDIO_Response= SDIO_Response_Short; SDIO_CmdInitStructure.SDIO_Wait= SDIO_Wait_No; SDIO_CmdInitStructure.SDIO_CPSM= SDIO_CPSM_Enable; SDIO_SendCommand(&SDIO_CmdInitStructure); errorstatus=CmdResp1Error(SD_CMD_STOP_TRANSMISSION);//等待R1响应 if(errorstatus!=SD_OK)returnerrorstatus; } } INTX_ENABLE();//开启总中断 SDIO_ClearFlag(SDIO_STATIC_FLAGS);//清除所有标记 }else if(DeviceMode==SD_DMA_MODE) { TransferError=SD_OK; StopCondition=1; //多块写,需要发送停止传输指令 TransferEnd=0; //传输结束标置位，在中断服务置1 SDIO->MASK|=(1<<1)|(1<<3)|(1<<8)|(1<<4)|(1<<9); //配置产生数据接收完成中断 SD_DMA_Config((u32*)buf,nblks*blksize,DMA_DIR_MemoryToPeripheral); //SDIO DMA配置 SDIO->DCTRL|=1<<3; //SDIODMA使能. timeout=SDIO_DATATIMEOUT; while(((DMA2->LISR&(1<<27))==RESET)&&timeout)timeout--;//等待传输完成 if(timeout==0) //超时 { SD_Init(); //重新初始化SD卡,可以解决写入死机的问题 returnSD_DATA_TIMEOUT; //超时 } timeout=SDIO_DATATIMEOUT; while((TransferEnd==0)&&(TransferError==SD_OK)&&timeout)timeout--; if(timeout==0)returnSD_DATA_TIMEOUT; //超时 if(TransferError!=SD_OK)returnTransferError; } } SDIO_ClearFlag(SDIO_STATIC_FLAGS);//清除所有标记 errorstatus=IsCardProgramming(&cardstate); while((errorstatus==SD_OK)&&((cardstate==SD_CARD_PROGRAMMING)||(cardstate==SD_CARD_RECEIVING))) { errorstatus=IsCardProgramming(&cardstate); } return errorstatus; } //SDIO中断服务函数 voidSDIO_IRQHandler(void) { SD_ProcessIRQSrc();//处理所有SDIO相关中断 } //SDIO中断处理函数 //处理SDIO传输过程中的各种中断事务 //返回值:错误代码 SD_ErrorSD_ProcessIRQSrc(void) { if(SDIO_GetFlagStatus(SDIO_FLAG_DATAEND)!= RESET)//接收完成中断 { if (StopCondition==1) { SDIO_CmdInitStructure.SDIO_Argument=0;//发送CMD12+结束传输 SDIO_CmdInitStructure.SDIO_CmdIndex= SD_CMD_STOP_TRANSMISSION; SDIO_CmdInitStructure.SDIO_Response= SDIO_Response_Short; SDIO_CmdInitStructure.SDIO_Wait= SDIO_Wait_No; SDIO_CmdInitStructure.SDIO_CPSM= SDIO_CPSM_Enable; SDIO_SendCommand(&SDIO_CmdInitStructure); TransferError=CmdResp1Error(SD_CMD_STOP_TRANSMISSION); }else TransferError = SD_OK; SDIO->ICR|=1<<8;//清除完成中断标记 SDIO->MASK&=~((1<<1)|(1<<3)|(1<<8)|(1<<14)|(1<<15)|(1<<4)|(1<<5)|(1<<9));//关闭相关中断 TransferEnd= 1; return(TransferError); } if(SDIO_GetFlagStatus(SDIO_FLAG_DCRCFAIL)!= RESET)//数据CRC错误 { SDIO_ClearFlag(SDIO_FLAG_DCRCFAIL); //清错误标志 SDIO->MASK&=~((1<<1)|(1<<3)|(1<<8)|(1<<14)|(1<<15)|(1<<4)|(1<<5)|(1<<9));//关闭相关中断 TransferError = SD_DATA_CRC_FAIL; return(SD_DATA_CRC_FAIL); } if(SDIO_GetFlagStatus(SDIO_FLAG_DTIMEOUT)!= RESET)//数据超时错误 { SDIO_ClearFlag(SDIO_FLAG_DTIMEOUT); //清中断标志 SDIO->MASK&=~((1<<1)|(1<<3)|(1<<8)|(1<<14)|(1<<15)|(1<<4)|(1<<5)|(1<<9));//关闭相关中断 TransferError = SD_DATA_TIMEOUT; return(SD_DATA_TIMEOUT); } if(SDIO_GetFlagStatus(SDIO_FLAG_RXOVERR)!= RESET)//FIFO上溢错误 { SDIO_ClearFlag(SDIO_FLAG_RXOVERR); //清中断标志 SDIO->MASK&=~((1<<1)|(1<<3)|(1<<8)|(1<<14)|(1<<15)|(1<<4)|(1<<5)|(1<<9));//关闭相关中断 TransferError = SD_RX_OVERRUN; return(SD_RX_OVERRUN); } if(SDIO_GetFlagStatus(SDIO_FLAG_TXUNDERR)!= RESET)//FIFO下溢错误 { SDIO_ClearFlag(SDIO_FLAG_TXUNDERR); //清中断标志 SDIO->MASK&=~((1<<1)|(1<<3)|(1<<8)|(1<<14)|(1<<15)|(1<<4)|(1<<5)|(1<<9));//关闭相关中断 TransferError = SD_TX_UNDERRUN; return(SD_TX_UNDERRUN); } if(SDIO_GetFlagStatus(SDIO_FLAG_STBITERR)!= RESET)//起始位错误 { SDIO_ClearFlag(SDIO_FLAG_STBITERR); //清中断标志 SDIO->MASK&=~((1<<1)|(1<<3)|(1<<8)|(1<<14)|(1<<15)|(1<<4)|(1<<5)|(1<<9));//关闭相关中断 TransferError = SD_START_BIT_ERR; return(SD_START_BIT_ERR); } return(SD_OK); } //检查CMD0的执行状态 //返回值:sd卡错误码 SD_ErrorCmdError(void) { SD_Error errorstatus = SD_OK; u32 timeout=SDIO_CMD0TIMEOUT; while(timeout--) { if(SDIO_GetFlagStatus(SDIO_FLAG_CMDSENT)!= RESET)break; //命令已发送(无需响应) } if(timeout==0)returnSD_CMD_RSP_TIMEOUT; SDIO_ClearFlag(SDIO_STATIC_FLAGS);//清除所有标记 return errorstatus; } //检查R7响应的错误状态 //返回值:sd卡错误码 SD_ErrorCmdResp7Error(void) { SD_Error errorstatus=SD_OK; u32 status; u32 timeout=SDIO_CMD0TIMEOUT; while(timeout--) { status=SDIO->STA; if(status&((1<<0)|(1<<2)|(1<<6)))break;//CRC错误/命令响应超时/已经收到响应(CRC校验成功) } if((timeout==0)||(status&(1<<2))) //响应超时 { errorstatus=SD_CMD_RSP_TIMEOUT; //当前卡不是2.0兼容卡,或者不支持设定的电压范围 SDIO_ClearFlag(SDIO_FLAG_CTIMEOUT); //清除命令响应超时标志 return errorstatus; } if(status&1<<6) //成功接收到响应 { errorstatus=SD_OK; SDIO_ClearFlag(SDIO_FLAG_CMDREND); //清除响应标志 } return errorstatus; } //检查R1响应的错误状态 //cmd:当前命令 //返回值:sd卡错误码 SD_ErrorCmdResp1Error(u8 cmd) { u32status; while(1) { status=SDIO->STA; if(status&((1<<0)|(1<<2)|(1<<6)))break;//CRC错误/命令响应超时/已经收到响应(CRC校验成功) } if(SDIO_GetFlagStatus(SDIO_FLAG_CTIMEOUT)!= RESET) //响应超时 { SDIO_ClearFlag(SDIO_FLAG_CTIMEOUT); //清除命令响应超时标志 return SD_CMD_RSP_TIMEOUT; } if(SDIO_GetFlagStatus(SDIO_FLAG_CCRCFAIL)!= RESET) //CRC错误 { SDIO_ClearFlag(SDIO_FLAG_CCRCFAIL); //清除标志 return SD_CMD_CRC_FAIL; } if(SDIO->RESPCMD!=cmd)returnSD_ILLEGAL_CMD;//命令不匹配 SDIO_ClearFlag(SDIO_STATIC_FLAGS);//清除所有标记 return(SD_Error)(SDIO->RESP1&SD_OCR_ERRORBITS);//返回卡响应 } //检查R3响应的错误状态 //返回值:错误状态 SD_ErrorCmdResp3Error(void) { u32 status; while(1) { status=SDIO->STA; if(status&((1<<0)|(1<<2)|(1<<6)))break;//CRC错误/命令响应超时/已经收到响应(CRC校验成功) } if(SDIO_GetFlagStatus(SDIO_FLAG_CTIMEOUT)!= RESET) //响应超时 { SDIO_ClearFlag(SDIO_FLAG_CTIMEOUT); //清除命令响应超时标志 return SD_CMD_RSP_TIMEOUT; } SDIO_ClearFlag(SDIO_STATIC_FLAGS);//清除所有标记 returnSD_OK; } //检查R2响应的错误状态 //返回值:错误状态 SD_ErrorCmdResp2Error(void) { SD_Error errorstatus=SD_OK; u32 status; u32 timeout=SDIO_CMD0TIMEOUT; while(timeout--) { status=SDIO->STA; if(status&((1<<0)|(1<<2)|(1<<6)))break;//CRC错误/命令响应超时/已经收到响应(CRC校验成功) } if((timeout==0)||(status&(1<<2))) //响应超时 { errorstatus=SD_CMD_RSP_TIMEOUT; SDIO_ClearFlag(SDIO_FLAG_CTIMEOUT); //清除命令响应超时标志 return errorstatus; } if(SDIO_GetFlagStatus(SDIO_FLAG_CCRCFAIL)!= RESET) //CRC错误 { errorstatus=SD_CMD_CRC_FAIL; SDIO_ClearFlag(SDIO_FLAG_CCRCFAIL); //清除响应标志 } SDIO_ClearFlag(SDIO_STATIC_FLAGS);//清除所有标记 returnerrorstatus; } //检查R6响应的错误状态 //cmd:之前发送的命令 //prca:卡返回的RCA地址 //返回值:错误状态 SD_ErrorCmdResp6Error(u8 cmd,u16*prca) { SD_Error errorstatus=SD_OK; u32 status; u32 rspr1; while(1) { status=SDIO->STA; if(status&((1<<0)|(1<<2)|(1<<6)))break;//CRC错误/命令响应超时/已经收到响应(CRC校验成功) } if(SDIO_GetFlagStatus(SDIO_FLAG_CTIMEOUT)!= RESET) //响应超时 { SDIO_ClearFlag(SDIO_FLAG_CTIMEOUT); //清除命令响应超时标志 return SD_CMD_RSP_TIMEOUT; } if(SDIO_GetFlagStatus(SDIO_FLAG_CCRCFAIL)!= RESET) //CRC错误 { SDIO_ClearFlag(SDIO_FLAG_CCRCFAIL); //清除响应标志 returnSD_CMD_CRC_FAIL; } if(SDIO->RESPCMD!=cmd) //判断是否响应cmd命令 { returnSD_ILLEGAL_CMD; } SDIO_ClearFlag(SDIO_STATIC_FLAGS);//清除所有标记 rspr1=SDIO->RESP1; //得到响应 if(SD_ALLZERO==(rspr1&(SD_R6_GENERAL_UNKNOWN_ERROR|SD_R6_ILLEGAL_CMD|SD_R6_COM_CRC_FAILED))) { *prca=(u16)(rspr1>>16); //右移16位得到,rca return errorstatus; } if(rspr1&SD_R6_GENERAL_UNKNOWN_ERROR)returnSD_GENERAL_UNKNOWN_ERROR; if(rspr1&SD_R6_ILLEGAL_CMD)returnSD_ILLEGAL_CMD; if(rspr1&SD_R6_COM_CRC_FAILED)returnSD_COM_CRC_FAILED; return errorstatus; } //SDIO使能宽总线模式 //enx:0,不使能;1,使能; //返回值:错误状态 SD_ErrorSDEnWideBus(u8 enx) { SD_Error errorstatus = SD_OK; u32scr[2]={0,0}; u8 arg=0X00; if(enx)arg=0X02; else arg=0X00; if(SDIO->RESP1&SD_CARD_LOCKED)returnSD_LOCK_UNLOCK_FAILED;//SD卡处于LOCKED状态 errorstatus=FindSCR(RCA,scr); //得到SCR寄存器数据 if(errorstatus!=SD_OK)returnerrorstatus; if((scr[1]&SD_WIDE_BUS_SUPPORT)!=SD_ALLZERO) //支持宽总线 { SDIO_CmdInitStructure.SDIO_Argument =(uint32_t) RCA << 16;//发送CMD55+RCA,短响应 SDIO_CmdInitStructure.SDIO_CmdIndex =SD_CMD_APP_CMD; SDIO_CmdInitStructure.SDIO_Response =SDIO_Response_Short; SDIO_CmdInitStructure.SDIO_Wait =SDIO_Wait_No; SDIO_CmdInitStructure.SDIO_CPSM =SDIO_CPSM_Enable; SDIO_SendCommand(&SDIO_CmdInitStructure); errorstatus=CmdResp1Error(SD_CMD_APP_CMD); if(errorstatus!=SD_OK)return errorstatus; SDIO_CmdInitStructure.SDIO_Argument = arg;//发送ACMD6,短响应,参数:10,4位;00,1位. SDIO_CmdInitStructure.SDIO_CmdIndex =SD_CMD_APP_SD_SET_BUSWIDTH; SDIO_CmdInitStructure.SDIO_Response =SDIO_Response_Short; SDIO_CmdInitStructure.SDIO_Wait =SDIO_Wait_No; SDIO_CmdInitStructure.SDIO_CPSM =SDIO_CPSM_Enable; SDIO_SendCommand(&SDIO_CmdInitStructure); errorstatus=CmdResp1Error(SD_CMD_APP_SD_SET_BUSWIDTH); return errorstatus; }else return SD_REQUEST_NOT_APPLICABLE; //不支持宽总线设置 } //检查卡是否正在执行写操作 //pstatus:当前状态. //返回值:错误代码 SD_ErrorIsCardProgramming(u8 *pstatus) { vu32respR1 = 0, status = 0; SDIO_CmdInitStructure.SDIO_Argument =(uint32_t) RCA << 16; //卡相对地址参数 SDIO_CmdInitStructure.SDIO_CmdIndex =SD_CMD_SEND_STATUS;//发送CMD13 SDIO_CmdInitStructure.SDIO_Response =SDIO_Response_Short; SDIO_CmdInitStructure.SDIO_Wait =SDIO_Wait_No; SDIO_CmdInitStructure.SDIO_CPSM =SDIO_CPSM_Enable; SDIO_SendCommand(&SDIO_CmdInitStructure); status=SDIO->STA; while(!(status&((1<<0)|(1<<6)|(1<<2))))status=SDIO->STA;//等待操作完成 if(SDIO_GetFlagStatus(SDIO_FLAG_CCRCFAIL)!= RESET) //CRC检测失败 { SDIO_ClearFlag(SDIO_FLAG_CCRCFAIL); //清除错误标记 return SD_CMD_CRC_FAIL; } if(SDIO_GetFlagStatus(SDIO_FLAG_CTIMEOUT)!= RESET) //命令超时 { SDIO_ClearFlag(SDIO_FLAG_CTIMEOUT); //清除错误标记 return SD_CMD_RSP_TIMEOUT; } if(SDIO->RESPCMD!=SD_CMD_SEND_STATUS)returnSD_ILLEGAL_CMD; SDIO_ClearFlag(SDIO_STATIC_FLAGS);//清除所有标记 respR1=SDIO->RESP1; *pstatus=(u8)((respR1>>9)&0x0000000F); return SD_OK; } //读取当前卡状态 //pcardstatus:卡状态 //返回值:错误代码 SD_ErrorSD_SendStatus(uint32_t *pcardstatus) { SD_Error errorstatus = SD_OK; if(pcardstatus==NULL) { errorstatus=SD_INVALID_PARAMETER; return errorstatus; } SDIO_CmdInitStructure.SDIO_Argument =(uint32_t) RCA << 16;//发送CMD13,短响应 SDIO_CmdInitStructure.SDIO_CmdIndex =SD_CMD_SEND_STATUS; SDIO_CmdInitStructure.SDIO_Response =SDIO_Response_Short; SDIO_CmdInitStructure.SDIO_Wait =SDIO_Wait_No; SDIO_CmdInitStructure.SDIO_CPSM =SDIO_CPSM_Enable; SDIO_SendCommand(&SDIO_CmdInitStructure); errorstatus=CmdResp1Error(SD_CMD_SEND_STATUS); //查询响应状态 if(errorstatus!=SD_OK)returnerrorstatus; *pcardstatus=SDIO->RESP1;//读取响应值 return errorstatus; } //返回SD卡的状态 //返回值:SD卡状态 SDCardStateSD_GetState(void) { u32 resp1=0; if(SD_SendStatus(&resp1)!=SD_OK)returnSD_CARD_ERROR; else return(SDCardState)((resp1>>9) & 0x0F); } //查找SD卡的SCR寄存器值 //rca:卡相对地址 //pscr:数据缓存区(存储SCR内容) //返回值:错误状态 SD_ErrorFindSCR(u16 rca,u32 *pscr) { u32 index = 0; SD_Error errorstatus = SD_OK; u32 tempscr[2]={0,0}; SDIO_CmdInitStructure.SDIO_Argument =(uint32_t)8; //发送CMD16,短响应,设置Block Size为8字节 SDIO_CmdInitStructure.SDIO_CmdIndex =SD_CMD_SET_BLOCKLEN; // cmd16 SDIO_CmdInitStructure.SDIO_Response =SDIO_Response_Short; //r1 SDIO_CmdInitStructure.SDIO_Wait =SDIO_Wait_No; SDIO_CmdInitStructure.SDIO_CPSM =SDIO_CPSM_Enable; SDIO_SendCommand(&SDIO_CmdInitStructure); errorstatus=CmdResp1Error(SD_CMD_SET_BLOCKLEN); if(errorstatus!=SD_OK)returnerrorstatus; SDIO_CmdInitStructure.SDIO_Argument =(uint32_t) RCA << 16; SDIO_CmdInitStructure.SDIO_CmdIndex =SD_CMD_APP_CMD;//发送CMD55,短响应 SDIO_CmdInitStructure.SDIO_Response =SDIO_Response_Short; SDIO_CmdInitStructure.SDIO_Wait =SDIO_Wait_No; SDIO_CmdInitStructure.SDIO_CPSM =SDIO_CPSM_Enable; SDIO_SendCommand(&SDIO_CmdInitStructure); errorstatus=CmdResp1Error(SD_CMD_APP_CMD); if(errorstatus!=SD_OK)returnerrorstatus; SDIO_DataInitStructure.SDIO_DataTimeOut =SD_DATATIMEOUT; SDIO_DataInitStructure.SDIO_DataLength =8; //8个字节长度,block为8字节,SD卡到SDIO. SDIO_DataInitStructure.SDIO_DataBlockSize =SDIO_DataBlockSize_8b ; //块大小8byte SDIO_DataInitStructure.SDIO_TransferDir =SDIO_TransferDir_ToSDIO; SDIO_DataInitStructure.SDIO_TransferMode =SDIO_TransferMode_Block; SDIO_DataInitStructure.SDIO_DPSM =SDIO_DPSM_Enable; SDIO_DataConfig(&SDIO_DataInitStructure); SDIO_CmdInitStructure.SDIO_Argument = 0x0; SDIO_CmdInitStructure.SDIO_CmdIndex =SD_CMD_SD_APP_SEND_SCR; //发送ACMD51,短响应,参数为0 SDIO_CmdInitStructure.SDIO_Response =SDIO_Response_Short; //r1 SDIO_CmdInitStructure.SDIO_Wait =SDIO_Wait_No; SDIO_CmdInitStructure.SDIO_CPSM =SDIO_CPSM_Enable; SDIO_SendCommand(&SDIO_CmdInitStructure); errorstatus=CmdResp1Error(SD_CMD_SD_APP_SEND_SCR); if(errorstatus!=SD_OK)returnerrorstatus; while(!(SDIO->STA&(SDIO_FLAG_RXOVERR|SDIO_FLAG_DCRCFAIL|SDIO_FLAG_DTIMEOUT|SDIO_FLAG_DBCKEND|SDIO_FLAG_STBITERR))) { if(SDIO_GetFlagStatus(SDIO_FLAG_RXDAVL)!= RESET)//接收FIFO数据可用 { *(tempscr+index)=SDIO->FIFO; //读取FIFO内容 index++; if(index>=2)break; } } if(SDIO_GetFlagStatus(SDIO_FLAG_DTIMEOUT)!= RESET) //数据超时错误 { SDIO_ClearFlag(SDIO_FLAG_DTIMEOUT); //清错误标志 returnSD_DATA_TIMEOUT; }elseif(SDIO_GetFlagStatus(SDIO_FLAG_DCRCFAIL) != RESET) //数据块CRC错误 { SDIO_ClearFlag(SDIO_FLAG_DCRCFAIL); //清错误标志 returnSD_DATA_CRC_FAIL; }elseif(SDIO_GetFlagStatus(SDIO_FLAG_RXOVERR) != RESET) //接收fifo上溢错误 { SDIO_ClearFlag(SDIO_FLAG_RXOVERR); //清错误标志 returnSD_RX_OVERRUN; }elseif(SDIO_GetFlagStatus(SDIO_FLAG_STBITERR) != RESET) //接收起始位错误 { SDIO_ClearFlag(SDIO_FLAG_STBITERR);//清错误标志 returnSD_START_BIT_ERR; } SDIO_ClearFlag(SDIO_STATIC_FLAGS);//清除所有标记 //把数据顺序按8位为单位倒过来. *(pscr+1)=((tempscr[0]&SD_0TO7BITS)<<24)|((tempscr[0]&SD_8TO15BITS)<<8)|((tempscr[0]&SD_16TO23BITS)>>8)|((tempscr[0]&SD_24TO31BITS)>>24); *(pscr)=((tempscr[1]&SD_0TO7BITS)<<24)|((tempscr[1]&SD_8TO15BITS)<<8)|((tempscr[1]&SD_16TO23BITS)>>8)|((tempscr[1]&SD_24TO31BITS)>>24); returnerrorstatus; } //得到NumberOfBytes以2为底的指数. //NumberOfBytes:字节数. //返回值:以2为底的指数值 u8convert_from_bytes_to_power_of_two(u16 NumberOfBytes) { u8 count=0; while(NumberOfBytes!=1) { NumberOfBytes>>=1; count++; } return count; } //配置SDIODMA //mbuf:存储器地址 //bufsize:传输数据量 //dir:方向;DMA_DIR_MemoryToPeripheral 存储器-->SDIO(写数据);DMA_DIR_PeripheralToMemorySDIO-->存储器(读数据); voidSD_DMA_Config(u32*mbuf,u32 bufsize,u32 dir) { DMA_InitTypeDef DMA_InitStructure; while (DMA_GetCmdStatus(DMA2_Stream3)!= DISABLE){}//等待DMA可配置 DMA_DeInit(DMA2_Stream3);//清空之前该stream3上的所有中断标志 DMA_InitStructure.DMA_Channel =DMA_Channel_4; //通道选择 DMA_InitStructure.DMA_PeripheralBaseAddr =(u32)&SDIO->FIFO;//DMA外设地址 DMA_InitStructure.DMA_Memory0BaseAddr =(u32)mbuf;//DMA 存储器0地址 DMA_InitStructure.DMA_DIR = dir;//存储器到外设模式 DMA_InitStructure.DMA_BufferSize = 0;//数据传输量 DMA_InitStructure.DMA_PeripheralInc =DMA_PeripheralInc_Disable;//外设非增量模式 DMA_InitStructure.DMA_MemoryInc =DMA_MemoryInc_Enable;//存储器增量模式 DMA_InitStructure.DMA_PeripheralDataSize =DMA_PeripheralDataSize_Word;//外设数据长度:32位 DMA_InitStructure.DMA_MemoryDataSize =DMA_MemoryDataSize_Word;//存储器数据长度:32位 DMA_InitStructure.DMA_Mode =DMA_Mode_Normal;// 使用普通模式 DMA_InitStructure.DMA_Priority =DMA_Priority_VeryHigh;//最高优先级 DMA_InitStructure.DMA_FIFOMode =DMA_FIFOMode_Enable; //FIFO使能 DMA_InitStructure.DMA_FIFOThreshold =DMA_FIFOThreshold_Full;//全FIFO DMA_InitStructure.DMA_MemoryBurst =DMA_MemoryBurst_INC4;//外设突发4次传输 DMA_InitStructure.DMA_PeripheralBurst =DMA_PeripheralBurst_INC4;//存储器突发4次传输 DMA_Init(DMA2_Stream3,&DMA_InitStructure);//初始化DMA Stream DMA_FlowControllerConfig(DMA2_Stream3,DMA_FlowCtrl_Peripheral);//外设流控制 DMA_Cmd(DMA2_Stream3 ,ENABLE);//开启DMA传输 } //读SD卡 //buf:读数据缓存区 //sector:扇区地址 //cnt:扇区个数 //返回值:错误状态;0,正常;其他,错误代码; u8SD_ReadDisk(u8*buf,u32 sector,u8 cnt) { u8 sta=SD_OK; long long lsector=sector; u8 n; lsector<<=9; if((u32)buf%4!=0) { for(n=0;n { sta=SD_ReadBlock(SDIO_DATA_BUFFER,lsector+512*n,512);//单个sector的读操作 memcpy(buf,SDIO_DATA_BUFFER,512); buf+=512; } }else { if(cnt==1)sta=SD_ReadBlock(buf,lsector,512); //单个sector的读操作 elsesta=SD_ReadMultiBlocks(buf,lsector,512,cnt);//多个sector } return sta; } //写SD卡 //buf:写数据缓存区 //sector:扇区地址 //cnt:扇区个数 //返回值:错误状态;0,正常;其他,错误代码; u8SD_WriteDisk(u8*buf,u32 sector,u8 cnt) { u8 sta=SD_OK; u8 n; long long lsector=sector; lsector<<=9; if((u32)buf%4!=0) { for(n=0;n { memcpy(SDIO_DATA_BUFFER,buf,512); sta=SD_WriteBlock(SDIO_DATA_BUFFER,lsector+512*n,512);//单个sector的写操作 buf+=512; } }else { if(cnt==1)sta=SD_WriteBlock(buf,lsector,512); //单个sector的写操作 elsesta=SD_WriteMultiBlocks(buf,lsector,512,cnt); //多个sector } return sta; }
史海拾趣
|
单片机的外部结构： 1、 DIP40双列直插； 2、 P0，P1，P2，P3四个8位准双向I/O引脚；（作为I/O输入时，要先输出高电平） 3、 电源VCC（PIN40）和地线GND（PIN20）； 4、 高电平复位RESET（PIN9）；（10uF电容接VCC与RESET，即可实现上电复位） ...… 查看全部问答＞ |
|
1.Protel VS PowerPCB 曾和PADS的工程师一块工作过半个月，当时我做Protel的技术支持，我们两家下一步可能都要做Veribest的代理，所以遇到一起了。听说PADS有不少很顺手的功能，用惯了上瘾，问那个哥儿们是不是这样，人家很谦虚，说 ...… 查看全部问答＞ |
|
在WinCE上，EVC或其它开发工具,如何写多种语言(中英等多国语言)版程序 请问, 在WinCE上，EVC或其它开发工具,如何写多种语言(中英等多国语言)版程序? 请给一些思路. 谢谢.… 查看全部问答＞ |
|
关于在Marvell PXA310上USB HOST PORT3 的问题 我在 310 上可以正常使用 USB HOST PORT 2 (OTG) ,但是使用 USB HOST PORT 3 时，终端输出如下信息 usb 1-3: new full speed USB device using pxa27x-ohci and address 84 usb 1-3: device descriptor read/64, error -62 ...… 查看全部问答＞ |
|
现在很多芯片只能在CCSv4上支持，但是CCSv4已经和CCSv3.3是完全不同的架构，是基于eclipse架构的。所以调试界面与CCSv3.3是完全不同的。 TI有CCSv4的培训视频链接http://e2e.ti.com/cn/media/p/2090.aspx。 主要还是需要亲自调试，多使用。个人觉 ...… 查看全部问答＞ |
|
和ZigBee无线自组网相比WiMi-net无线自组网的优势 关于ZigBee技术，我们都知道ZigBee是一种技术规范，是一类产品的统称。由于ZigBee本身是一个非常庞大的体系， 不同实现厂家由于编码水平不同，对于ZigBee规范理解的不同，异常处理机制健壮程度不同，在特定的情况下其链路的智能程度也 ...… 查看全部问答＞ |
|
ZigBee协调器网络的建立 一、协调器网络的建立 1、 网络的格式化 A：初始化的能量阀值为16。通过设置ZDApp_event_loop任务中的事件ID为ZDO_NETWORK_INIT以便执行B。 ...… 查看全部问答＞ |
|
采样率1M以上，而信号的频率范围仅37k——43k，FFT会算出大量的零，请问有办法进计算指定范围的频谱吗？ 目前硬件是STM32F103ZET6，可以加硬件的。 谢谢！… 查看全部问答＞ |