/**
* @name SD_WriteDisk
* @description 写SD卡扇区
* @param buf 数据缓冲区
sector 扇区号
cnt 要写入的扇区数目
* @return 操作结果，1 成功；其他，失败
* @notice
*/
u8 SD_WriteDisk(u8 *buf, u32 sector, u8 cnt)
{
u8 r1;
if(SD_Type != SD_TYPE_V2HC)
sector *= 512;//转换为字节地址
if(cnt == 1)
{
r1 = SD_SendCmd(CMD24,sector,0X01);//读命令
if(r1 == 0)//指令发送成功
{
r1 = SD_SendBlock(buf,0xFE);//写512个字节
}
}
else
{
if(SD_Type != SD_TYPE_MMC)
{
SD_SendCmd(CMD55,0,0X01);
SD_SendCmd(CMD23,cnt,0X01);//发送指令
}
r1 = SD_SendCmd(CMD25,sector,0X01);//连续读命令
if(r1 == 0)
{
do
{
r1 = SD_SendBlock(buf,0xFC);//接收512个字节
buf += 512;
}while(--cnt && r1 == 1);
r1 = SD_SendBlock(0,0xFD);//接收512个字节
}
}
SD_DisSelect();//取消片选
return r1;//
}
/**
* @brief Erases the specified memory area of the given SD card.
* @param StartAddr: Start byte address
* @param EndAddr: End byte address
* @retval SD status
*/
uint8_t BSP_SD_Erase(uint32_t StartAddr, uint32_t EndAddr)
{
uint8_t rvalue = SD_RESPONSE_FAILURE;
/* Send CMD32 (Erase group start) and check if the SD acknowledged the erase command: R1 response (0x00: no errors) */
if (!SD_SendCmd(SD_CMD_SD_ERASE_GRP_START, StartAddr, 0xFF, SD_RESPONSE_NO_ERROR))
{
/* Send CMD33 (Erase group end) and Check if the SD acknowledged the erase command: R1 response (0x00: no errors) */
if (!SD_SendCmd(SD_CMD_SD_ERASE_GRP_END, EndAddr, 0xFF, SD_RESPONSE_NO_ERROR))
{
/* Send CMD38 (Erase) and Check if the SD acknowledged the erase command: R1 response (0x00: no errors) */
if (!SD_SendCmd(SD_CMD_ERASE, 0, 0xFF, SD_RESPONSE_NO_ERROR))
{
/* Verify that SD card is ready to use after the specific command ERASE */
rvalue = (uint8_t)SD_IO_WaitResponse(SD_RESPONSE_NO_ERROR);
}
}
}
/* Return the response */
if (rvalue == SD_RESPONSE_NO_ERROR)
{
return MSD_OK;
}
else
{
return MSD_ERROR;
}
}
/**
* @name SD_ReadDisk
* @description 读SD卡扇区
* @param buf 数据缓冲区
sector 扇区号
cnt 要读取的扇区数目
* @return 操作结果，1 成功；其他，失败
* @notice
*/
u8 SD_ReadDisk(u8 *buf, u32 sector, u8 cnt)
{
u8 r1;
if(SD_Type != SD_TYPE_V2HC)
sector <<= 9;//转换为字节地址
if(cnt == 1)
{
r1 = SD_SendCmd(CMD17, sector, 0X01);//读命令
if(r1 == 0)//指令发送成功
{
r1 = SD_RecvData(buf, 512);//接收512个字节
}
}
else
{
r1 = SD_SendCmd(CMD18, sector, 0X01);//连续读命令
do
{
r1 = SD_RecvData(buf, 512);//接收512个字节
buf += 512;
}while(--cnt && r1 == 1);
SD_SendCmd(CMD12, 0, 0X01); //发送停止命令
}
SD_DisSelect();//取消片选
return r1;//
}
/**
* @brief Reads multiple block of data from the SD.
* @param pBuffer: pointer to the buffer that receives the data read from the
* SD.
* @param ReadAddr: SD's internal address to read from.
* @param BlockSize: the SD card Data block size.
* @param NumberOfBlocks: number of blocks to be read.
* @retval The SD Response:
* - SD_RESPONSE_FAILURE: Sequence failed
* - SD_RESPONSE_NO_ERROR: Sequence succeed
*/
SD_Error SD_ReadMultiBlocks(uint8_t* pBuffer, uint32_t ReadAddr, uint16_t BlockSize, uint32_t NumberOfBlocks)
{
uint32_t i = 0, Offset = 0;
SD_Error rvalue = SD_RESPONSE_FAILURE;
/*!< SD chip select low */
SD_CS_LOW();
/*!< Data transfer */
while (NumberOfBlocks--)
{
if(flag_SDHC == 1)
{
/*!< Send CMD17 (SD_CMD_READ_SINGLE_BLOCK) to read one block */
SD_SendCmd (SD_CMD_READ_SINGLE_BLOCK,(ReadAddr + Offset)/512, 0xFF);
}
else
{
/*!< Send CMD17 (SD_CMD_READ_SINGLE_BLOCK) to read one block */
SD_SendCmd (SD_CMD_READ_SINGLE_BLOCK, ReadAddr + Offset, 0xFF);
}
/*!< Check if the SD acknowledged the read block command: R1 response (0x00: no errors) */
if (SD_GetResponse(SD_RESPONSE_NO_ERROR))
{
return SD_RESPONSE_FAILURE;
}
/*!< Now look for the data token to signify the start of the data */
if (!SD_GetResponse(SD_START_DATA_SINGLE_BLOCK_READ))
{
/*!< Read the SD block data : read NumByteToRead data */
for (i = 0; i < BlockSize; i++)
{
/*!< Read the pointed data */
*pBuffer = SD_ReadByte();
/*!< Point to the next location where the byte read will be saved */
pBuffer++;
}
/*!< Set next read address*/
Offset += 512;
/*!< get CRC bytes (not really needed by us, but required by SD) */
SD_ReadByte();
SD_ReadByte();
/*!< Set response value to success */
rvalue = SD_RESPONSE_NO_ERROR;
}
else
{
/*!< Set response value to failure */
rvalue = SD_RESPONSE_FAILURE;
}
}
/*!< SD chip select high */
SD_CS_HIGH();
/*!< Send dummy byte: 8 Clock pulses of delay */
SD_WriteByte(SD_DUMMY_BYTE);
/*!< Returns the reponse */
return rvalue;
}
/**
* @brief Returns the SD status.
* @param None
* @retval The SD status.
*/
uint8_t BSP_SD_GetStatus(void)
{
#if !defined (SD_GET_STATUS_WORKAROUND)
uint16_t status = 0;
/* Send CMD13 (SD_SEND_STATUS) to get SD status */
SD_SendCmd(SD_CMD_SEND_STATUS, 0, 0xFF, SD_NO_RESPONSE_EXPECTED);
status = SD_IO_ReadByte();
status |= (uint16_t)(SD_IO_ReadByte() << 8);
/* Send Dummy Byte */
SD_IO_WriteDummy();
/* Find SD status according to card state */
if (status == SD_RESPONSE_NO_ERROR)
{
return MSD_OK;
}
else
{
return MSD_ERROR;
}
#else
/* This is a temporary workaround for this issue: on some STM32 Nucleo boards
reading the SD card status will return an error */
return MSD_OK;
#endif /* SD_GET_STATUS_WORKAROUND */
}
/**
* @brief Write a buffer (many blocks) in the SD card.
* @note The amount of data to write should be a multiple of SD card BLOCK
* size (512 Byte).
* @param pBuffer : pointer to the buffer containing the data to be written on the SD.
* @param WriteAddr : address to write on.
* @param NumByteToWrite : number of data to write.
* @retval SD Response:
* - SD_RESPONSE_FAILURE: Sequence failed.
* - SD_RESPONSE_NO_ERROR: Sequence succeed.
*/
uint8_t SD_WriteBuffer(uint8_t *pBuffer, uint32_t WriteAddr, uint32_t NumByteToWrite)
{
uint32_t i = 0, NbrOfBlock = 0, Offset = 0;
uint8_t rvalue = SD_RESPONSE_FAILURE;
/* Calculate number of blocks to write */
NbrOfBlock = NumByteToWrite / SD_BLOCK_SIZE;
/* SD chip select low */
SD_CS_LOW();
/* Data transfer */
while (NbrOfBlock--)
{
/* Send CMD24 (SD_WRITE_BLOCK) to write blocks */
SD_SendCmd(SD_CMD_WRITE_SINGLE_BLOCK, WriteAddr + Offset, 0xFF);
/* Check if the SD acknowledged the write block command: R1 response (0x00: no errors) */
if (SD_GetResponse(SD_RESPONSE_NO_ERROR))
{
return SD_RESPONSE_FAILURE;
}
/* Send dummy byte */
SD_WriteByte(SD_DUMMY_BYTE);
/* Send the data token to signify the start of the data */
SD_WriteByte(SD_START_DATA_SINGLE_BLOCK_WRITE);
/* Write the block data to SD : write count data by block */
for (i = 0; i < SD_BLOCK_SIZE; i++)
{
/* Send the pointed byte */
SD_WriteByte(*pBuffer);
/* Point to the next location where the byte read will be saved */
pBuffer++;
}
/* Set next write address */
Offset += 512;
/* Put CRC bytes (not really needed by us, but required by SD) */
SD_ReadByte();
SD_ReadByte();
/* Read data response */
if (SD_GetDataResponse() == SD_DATA_OK)
{
/* Set response value to success */
rvalue = SD_RESPONSE_NO_ERROR;
}
else
{
/* Set response value to failure */
rvalue = SD_RESPONSE_FAILURE;
}
}
/* SD chip select high */
SD_CS_HIGH();
/* Send dummy byte: 8 Clock pulses of delay */
SD_WriteByte(SD_DUMMY_BYTE);
/* Returns the response */
return rvalue;
}
/**
* @brief Writes a block on the SD
* @param pBuffer: pointer to the buffer containing the data to be written on
* the SD.
* @param WriteAddr: address to write on.
* @param BlockSize: the SD card Data block size.
* @retval The SD Response:
* - SD_RESPONSE_FAILURE: Sequence failed
* - SD_RESPONSE_NO_ERROR: Sequence succeed
*/
uint8_t SD_WriteBlock(uint8_t* pBuffer, uint32_t WriteAddr, uint16_t BlockSize)
{
uint32_t i = 0;
uint8_t rvalue = SD_RESPONSE_FAILURE;
/*!< SD chip select low */
SD_CS_LOW();
/*!< Send CMD24 (SD_CMD_WRITE_SINGLE_BLOCK) to write multiple block */
SD_SendCmd(SD_CMD_WRITE_SINGLE_BLOCK, WriteAddr, 0xFF);
/*!< Check if the SD acknowledged the write block command: R1 response (0x00: no errors) */
if (!SD_GetResponse(SD_RESPONSE_NO_ERROR))
{
/*!< Send a dummy byte */
SD_WriteByte(SD_DUMMY_BYTE);
/*!< Send the data token to signify the start of the data */
SD_WriteByte(0xFE);
/*!< Write the block data to SD : write count data by block */
for (i = 0; i < BlockSize; i++)
{
/*!< Send the pointed byte */
SD_WriteByte(*pBuffer);
/*!< Point to the next location where the byte read will be saved */
pBuffer++;
}
/* Send DUMMY bytes when the number of data to be written are lower
than the SD card BLOCK size (512 Byte) */
for (; i != SD_BLOCK_SIZE; i++)
{
/* Send the pointed byte */
SD_WriteByte(SD_DUMMY_BYTE);
}
/*!< Put CRC bytes (not really needed by us, but required by SD) */
SD_ReadByte();
SD_ReadByte();
/*!< Read data response */
if (SD_GetDataResponse() == SD_DATA_OK)
{
rvalue = SD_RESPONSE_NO_ERROR;
}
}
/*!< SD chip select high */
SD_CS_HIGH();
/*!< Send dummy byte: 8 Clock pulses of delay */
SD_WriteByte(SD_DUMMY_BYTE);
/*!< Returns the response */
return rvalue;
}
/**
* @brief Put SD in Idle state.
* @param None
* @retval The SD Response:
* - SD_RESPONSE_FAILURE: Sequence failed
* - SD_RESPONSE_NO_ERROR: Sequence succeed
*/
SD_Error SD_GoIdleState(void)
{
/*!< SD chip select low */
SD_CS_LOW();
/*!< Send CMD0 (SD_CMD_GO_IDLE_STATE) to put SD in SPI mode */
SD_SendCmd(SD_CMD_GO_IDLE_STATE, 0, 0x95);
/*!< Wait for In Idle State Response (R1 Format) equal to 0x01 */
if (SD_GetResponse(SD_IN_IDLE_STATE))
{
/*!< No Idle State Response: return response failue */
return SD_RESPONSE_FAILURE;
}
/*----------Activates the card initialization process-----------*/
do
{
/*!< SD chip select high */
SD_CS_HIGH();
/*!< Send Dummy byte 0xFF */
SD_WriteByte(SD_DUMMY_BYTE);
/*!< SD chip select low */
SD_CS_LOW();
/*!< Send CMD1 (Activates the card process) until response equal to 0x0 */
SD_SendCmd(SD_CMD_SEND_OP_COND, 0, 0xFF);
/*!< Wait for no error Response (R1 Format) equal to 0x00 */
}
while (SD_GetResponse(SD_RESPONSE_NO_ERROR));
/*!< SD chip select high */
SD_CS_HIGH();
/*!< Send dummy byte 0xFF */
SD_WriteByte(SD_DUMMY_BYTE);
return SD_RESPONSE_NO_ERROR;
}
/**
* @brief Reads a block of data from the SD.
* @param pBuffer: pointer to the buffer that receives the data read from the
* SD.
* @param ReadAddr: SD's internal address to read from.
* @param BlockSize: the SD card Data block size.
* @retval The SD Response:
* - SD_RESPONSE_FAILURE: Sequence failed
* - SD_RESPONSE_NO_ERROR: Sequence succeed
*/
uint8_t SD_ReadBlock(uint8_t* pBuffer, uint32_t ReadAddr, uint16_t BlockSize)
{
uint32_t i = 0;
uint8_t rvalue = SD_RESPONSE_FAILURE;
/*!< SD chip select low */
SD_CS_LOW();
/*!< Send CMD17 (SD_CMD_READ_SINGLE_BLOCK) to read one block */
SD_SendCmd(SD_CMD_READ_SINGLE_BLOCK, ReadAddr, 0xFF);
/*!< Check if the SD acknowledged the read block command: R1 response (0x00: no errors) */
if (!SD_GetResponse(SD_RESPONSE_NO_ERROR))
{
/*!< Now look for the data token to signify the start of the data */
if (!SD_GetResponse(SD_START_DATA_SINGLE_BLOCK_READ))
{
/*!< Read the SD block data : read NumByteToRead data */
for (i = 0; i < BlockSize; i++)
{
/*!< Save the received data */
*pBuffer = SD_ReadByte();
/*!< Point to the next location where the byte read will be saved */
pBuffer++;
}
/*!< Get CRC bytes (not really needed by us, but required by SD) */
SD_ReadByte();
SD_ReadByte();
/*!< Set response value to success */
rvalue = SD_RESPONSE_NO_ERROR;
}
}
/*!< SD chip select high */
SD_CS_HIGH();
/*!< Send dummy byte: 8 Clock pulses of delay */
SD_WriteByte(SD_DUMMY_BYTE);
/*!< Returns the response */
return rvalue;
}
/**
* @brief Returns the SD status.
* @param None
* @retval The SD status.
*/
uint16_t SD_GetStatus(void)
{
uint16_t Status = 0;
/*!< SD chip select low */
SD_CS_LOW();
/*!< Send CMD13 (SD_SEND_STATUS) to get SD status */
SD_SendCmd(SD_CMD_SEND_STATUS, 0, 0xFF);
Status = SD_ReadByte();
Status |= (uint16_t)(SD_ReadByte() << 8);
/*!< SD chip select high */
SD_CS_HIGH();
/*!< Send dummy byte 0xFF */
SD_WriteByte(SD_DUMMY_BYTE);
return Status;
}
/**
* @brief Read the CID card register.
* Reading the contents of the CID register in SPI mode is a simple
* read-block transaction.
* @param SD_cid: pointer on an CID register structure
* @retval The SD Response:
* - SD_RESPONSE_FAILURE: Sequence failed
* - SD_RESPONSE_NO_ERROR: Sequence succeed
*/
SD_Error SD_GetCIDRegister(SD_CID* SD_cid)
{
uint32_t i = 0;
SD_Error rvalue = SD_RESPONSE_FAILURE;
uint8_t CID_Tab[16];
/*!< SD chip select low */
SD_CS_LOW();
/*!< Send CMD10 (CID register) */
SD_SendCmd(SD_CMD_SEND_CID, 0, 0xFF);
/*!< Wait for response in the R1 format (0x00 is no errors) */
if (!SD_GetResponse(SD_RESPONSE_NO_ERROR))
{
if (!SD_GetResponse(SD_START_DATA_SINGLE_BLOCK_READ))
{
/*!< Store CID register value on CID_Tab */
for (i = 0; i < 16; i++)
{
CID_Tab[i] = SD_ReadByte();
}
}
/*!< Get CRC bytes (not really needed by us, but required by SD) */
SD_WriteByte(SD_DUMMY_BYTE);
SD_WriteByte(SD_DUMMY_BYTE);
/*!< Set response value to success */
rvalue = SD_RESPONSE_NO_ERROR;
}
/*!< SD chip select high */
SD_CS_HIGH();
/*!< Send dummy byte: 8 Clock pulses of delay */
SD_WriteByte(SD_DUMMY_BYTE);
/*!< Byte 0 */
SD_cid->ManufacturerID = CID_Tab[0];
/*!< Byte 1 */
SD_cid->OEM_AppliID = CID_Tab[1] << 8;
/*!< Byte 2 */
SD_cid->OEM_AppliID |= CID_Tab[2];
/*!< Byte 3 */
SD_cid->ProdName1 = CID_Tab[3] << 24;
/*!< Byte 4 */
SD_cid->ProdName1 |= CID_Tab[4] << 16;
/*!< Byte 5 */
SD_cid->ProdName1 |= CID_Tab[5] << 8;
/*!< Byte 6 */
SD_cid->ProdName1 |= CID_Tab[6];
/*!< Byte 7 */
SD_cid->ProdName2 = CID_Tab[7];
/*!< Byte 8 */
SD_cid->ProdRev = CID_Tab[8];
/*!< Byte 9 */
SD_cid->ProdSN = CID_Tab[9] << 24;
/*!< Byte 10 */
SD_cid->ProdSN |= CID_Tab[10] << 16;
/*!< Byte 11 */
SD_cid->ProdSN |= CID_Tab[11] << 8;
/*!< Byte 12 */
SD_cid->ProdSN |= CID_Tab[12];
/*!< Byte 13 */
SD_cid->Reserved1 |= (CID_Tab[13] & 0xF0) >> 4;
SD_cid->ManufactDate = (CID_Tab[13] & 0x0F) << 8;
/*!< Byte 14 */
SD_cid->ManufactDate |= CID_Tab[14];
/*!< Byte 15 */
SD_cid->CID_CRC = (CID_Tab[15] & 0xFE) >> 1;
SD_cid->Reserved2 = 1;
/*!< Return the reponse */
return rvalue;
}
/**
* @brief Read the CSD card register.
* Reading the contents of the CSD register in SPI mode is a simple
* read-block transaction.
* @param SD_csd: pointer on an SCD register structure
* @retval The SD Response:
* - SD_RESPONSE_FAILURE: Sequence failed
* - SD_RESPONSE_NO_ERROR: Sequence succeed
*/
SD_Error SD_GetCSDRegister(SD_CSD* SD_csd)
{
uint32_t i = 0;
SD_Error rvalue = SD_RESPONSE_FAILURE;
uint8_t CSD_Tab[16];
/*!< SD chip select low */
SD_CS_LOW();
/*!< Send CMD9 (CSD register) or CMD10(CSD register) */
SD_SendCmd(SD_CMD_SEND_CSD, 0, 0xFF);
/*!< Wait for response in the R1 format (0x00 is no errors) */
if (!SD_GetResponse(SD_RESPONSE_NO_ERROR))
{
if (!SD_GetResponse(SD_START_DATA_SINGLE_BLOCK_READ))
{
for (i = 0; i < 16; i++)
{
/*!< Store CSD register value on CSD_Tab */
CSD_Tab[i] = SD_ReadByte();
}
}
/*!< Get CRC bytes (not really needed by us, but required by SD) */
SD_WriteByte(SD_DUMMY_BYTE);
SD_WriteByte(SD_DUMMY_BYTE);
/*!< Set response value to success */
rvalue = SD_RESPONSE_NO_ERROR;
}
/*!< SD chip select high */
SD_CS_HIGH();
/*!< Send dummy byte: 8 Clock pulses of delay */
SD_WriteByte(SD_DUMMY_BYTE);
/*!< Byte 0 */
SD_csd->CSDStruct = (CSD_Tab[0] & 0xC0) >> 6;
SD_csd->SysSpecVersion = (CSD_Tab[0] & 0x3C) >> 2;
SD_csd->Reserved1 = CSD_Tab[0] & 0x03;
/*!< Byte 1 */
SD_csd->TAAC = CSD_Tab[1];
/*!< Byte 2 */
SD_csd->NSAC = CSD_Tab[2];
/*!< Byte 3 */
SD_csd->MaxBusClkFrec = CSD_Tab[3];
/*!< Byte 4 */
SD_csd->CardComdClasses = CSD_Tab[4] << 4;
/*!< Byte 5 */
SD_csd->CardComdClasses |= (CSD_Tab[5] & 0xF0) >> 4;
SD_csd->RdBlockLen = CSD_Tab[5] & 0x0F;
/*!< Byte 6 */
SD_csd->PartBlockRead = (CSD_Tab[6] & 0x80) >> 7;
SD_csd->WrBlockMisalign = (CSD_Tab[6] & 0x40) >> 6;
SD_csd->RdBlockMisalign = (CSD_Tab[6] & 0x20) >> 5;
SD_csd->DSRImpl = (CSD_Tab[6] & 0x10) >> 4;
SD_csd->Reserved2 = 0; /*!< Reserved */
SD_csd->DeviceSize = (CSD_Tab[6] & 0x03) << 10;
/*!< Byte 7 */
SD_csd->DeviceSize |= (CSD_Tab[7]) << 2;
/*!< Byte 8 */
SD_csd->DeviceSize |= (CSD_Tab[8] & 0xC0) >> 6;
SD_csd->MaxRdCurrentVDDMin = (CSD_Tab[8] & 0x38) >> 3;
SD_csd->MaxRdCurrentVDDMax = (CSD_Tab[8] & 0x07);
/*!< Byte 9 */
SD_csd->MaxWrCurrentVDDMin = (CSD_Tab[9] & 0xE0) >> 5;
SD_csd->MaxWrCurrentVDDMax = (CSD_Tab[9] & 0x1C) >> 2;
SD_csd->DeviceSizeMul = (CSD_Tab[9] & 0x03) << 1;
/*!< Byte 10 */
SD_csd->DeviceSizeMul |= (CSD_Tab[10] & 0x80) >> 7;
SD_csd->EraseGrSize = (CSD_Tab[10] & 0x40) >> 6;
SD_csd->EraseGrMul = (CSD_Tab[10] & 0x3F) << 1;
/*!< Byte 11 */
SD_csd->EraseGrMul |= (CSD_Tab[11] & 0x80) >> 7;
SD_csd->WrProtectGrSize = (CSD_Tab[11] & 0x7F);
/*!< Byte 12 */
SD_csd->WrProtectGrEnable = (CSD_Tab[12] & 0x80) >> 7;
SD_csd->ManDeflECC = (CSD_Tab[12] & 0x60) >> 5;
SD_csd->WrSpeedFact = (CSD_Tab[12] & 0x1C) >> 2;
SD_csd->MaxWrBlockLen = (CSD_Tab[12] & 0x03) << 2;
/*!< Byte 13 */
SD_csd->MaxWrBlockLen |= (CSD_Tab[13] & 0xC0) >> 6;
SD_csd->WriteBlockPaPartial = (CSD_Tab[13] & 0x20) >> 5;
SD_csd->Reserved3 = 0;
SD_csd->ContentProtectAppli = (CSD_Tab[13] & 0x01);
/*!< Byte 14 */
SD_csd->FileFormatGrouop = (CSD_Tab[14] & 0x80) >> 7;
SD_csd->CopyFlag = (CSD_Tab[14] & 0x40) >> 6;
SD_csd->PermWrProtect = (CSD_Tab[14] & 0x20) >> 5;
SD_csd->TempWrProtect = (CSD_Tab[14] & 0x10) >> 4;
SD_csd->FileFormat = (CSD_Tab[14] & 0x0C) >> 2;
SD_csd->ECC = (CSD_Tab[14] & 0x03);
/*!< Byte 15 */
SD_csd->CSD_CRC = (CSD_Tab[15] & 0xFE) >> 1;
SD_csd->Reserved4 = 1;
/*!< Return the reponse */
return rvalue;
}
/**
* @brief 初始化SD，使其进入工作模式
* @param
* @retval 0 卡错误
*/
u8 SD_Init(void)
{
int i;
u8 r1; //存放命令响应
u16 retry; //存放超时计数
u8 buf[4]; //临时缓冲区
/* SD卡初始化阶段，CLK时钟最大不能超过400KHz */
SD_SPI_SetLowSpeed();
/* 上电延时至少74个时钟周期 */
for(i = 0; i < 10; ++i)
SD_SPI_ReadWriteByte(SD_DUMMY_BYTE);
retry = 20;
while((r1 = SD_SendCmd(CMD0, 0, 0x95)) != 0x01 && retry-- > 0) //进入IDLE状态，等待正确返回
;
if(r1 == 0x01) //进入IDLE状态成功
{
//根据SD卡工作电压区分SD卡种类
if(SD_SendCmd(CMD8, 0x1AA, 0x87) == 1) //SD V2.0
{
for(i = 0;i < 4;i++)
buf[i] = SD_SPI_ReadWriteByte(SD_DUMMY_BYTE); //Get trailing return value of R7 resp
if(buf[2] == 0X01 && buf[3] == 0XAA) //卡是否支持2.7~3.6V
{
retry=0XFFFE;
do
{
SD_SendCmd(CMD55, 0, 0X01); //发送CMD55
r1 = SD_SendCmd(CMD41, 0x40000000, 0X01); //发送CMD41
}while(r1 && retry--);
if(retry && SD_SendCmd(CMD58, 0, 0X01) == 0) //鉴别SD2.0卡版本开始
{
for(i = 0;i < 4;i++)
buf[i] = SD_SPI_ReadWriteByte(0XFF);//得到OCR值
if(buf[0] & 0x40) //检查CCS
SD_Type = SD_TYPE_V2HC;
else
SD_Type = SD_TYPE_V2;
}
}
}
else //SD V1.x/ MMC V3
{
SD_SendCmd(CMD55, 0, 0X01); //发送CMD55
r1 = SD_SendCmd(CMD41, 0, 0X01); //发送CMD41
if(r1 <= 1)
{
SD_Type = SD_TYPE_V1;
retry = 0XFFFE;
do //等待退出IDLE模式
{
SD_SendCmd(CMD55, 0, 0X01); //发送CMD55
r1 = SD_SendCmd(CMD41, 0, 0X01);//发送CMD41
}while(r1 && retry--);
}
else //MMC卡不支持CMD55+CMD41识别
{
SD_Type = SD_TYPE_MMC;//MMC V3
retry = 0XFFFE;
do //等待退出IDLE模式
{
r1 = SD_SendCmd(CMD1,0,0X01);//发送CMD1
}while(r1 && retry--);
}
if(retry == 0 || SD_SendCmd(CMD16, 512, 0X01) != 0)
SD_Type = SD_TYPE_ERR;//错误的卡
}
}
SD_DisSelect(); //取消片选
SD_SPI_SetHighSpeed(); //正常传输设置为高速
if(SD_Type) //卡错误，返回0
return 0;
else if(r1)
return r1;
else
return 0xaa; //其他错误
}
/**
* @brief Read the CSD card register.
* Reading the contents of the CSD register in SPI mode is a simple
* read-block transaction.
* @param SD_csd: pointer on an SCD register structure
* @retval The SD Response:
* - SD_RESPONSE_FAILURE: Sequence failed
* - SD_RESPONSE_NO_ERROR: Sequence succeed
*/
SD_Error SD_GetCSDRegister(SD_CSD* SD_csd)
{
uint32_t i = 0;
SD_Error rvalue = SD_RESPONSE_FAILURE;
uint8_t CSD_Tab[16];
uint32_t CardCapacity;
static uint32_t times = 0;
/*!< SD chip select low */
SD_CS_LOW();
/*!< Send CMD9 (CSD register) or CMD10(CSD register) */
SD_SendCmd(SD_CMD_SEND_CSD, 0, 0xFF);
/*!< Wait for response in the R1 format (0x00 is no errors) */
if (!SD_GetResponse(SD_RESPONSE_NO_ERROR))
{
if (!SD_GetResponse(SD_START_DATA_SINGLE_BLOCK_READ))
{
for (i = 0; i < 16; i++)
{
/*!< Store CSD register value on CSD_Tab */
CSD_Tab[i] = SD_ReadByte();
//if(0 == times)
//{
// printf("\n\r CSD_Tab[%d] 0x%X", i, CSD_Tab[i]);
//}
}
}
/*!< Get CRC bytes (not really needed by us, but required by SD) */
SD_WriteByte(SD_DUMMY_BYTE);
SD_WriteByte(SD_DUMMY_BYTE);
/*!< Set response value to success */
rvalue = SD_RESPONSE_NO_ERROR;
}
else
{
return rvalue;
}
/*!< SD chip select high */
SD_CS_HIGH();
/*!< Send dummy byte: 8 Clock pulses of delay */
SD_WriteByte(SD_DUMMY_BYTE);
/*!< Byte 0 */
SD_csd->CSDStruct = (CSD_Tab[0] & 0xC0) >> 6;
SD_csd->SysSpecVersion = (CSD_Tab[0] & 0x3C) >> 2;
SD_csd->Reserved1 = CSD_Tab[0] & 0x03;
if(0 == times)
{
if(SD_csd->CSDStruct == 1)
{
//printf("\n\r SDHC CSD Version 2.0 Acess AS SD High Capacity.");
flag_SDHC = 1;
}
else
{
//printf("\n\r SDSC CSD Version 1.0 Acess AS SD Standard Capacity.");
flag_SDHC = 0;
}
}
/*!< Byte 1 */
SD_csd->TAAC = CSD_Tab[1];
/*!< Byte 2 */
SD_csd->NSAC = CSD_Tab[2];
/*!< Byte 3 */
SD_csd->MaxBusClkFrec = CSD_Tab[3];
/*!< Byte 4 */
SD_csd->CardComdClasses = CSD_Tab[4] << 4;
/*!< Byte 5 */
SD_csd->CardComdClasses |= (CSD_Tab[5] & 0xF0) >> 4;
SD_csd->RdBlockLen = CSD_Tab[5] & 0x0F;
/*!< Byte 6 */
SD_csd->PartBlockRead = (CSD_Tab[6] & 0x80) >> 7;
SD_csd->WrBlockMisalign = (CSD_Tab[6] & 0x40) >> 6;
SD_csd->RdBlockMisalign = (CSD_Tab[6] & 0x20) >> 5;
SD_csd->DSRImpl = (CSD_Tab[6] & 0x10) >> 4;
SD_csd->Reserved2 = 0; /*!< Reserved */
if(flag_SDHC == 0)
{
SD_csd->DeviceSize = (CSD_Tab[6] & 0x03) << 10;
/*!< Byte 7 */
SD_csd->DeviceSize |= (CSD_Tab[7]) << 2;
/*!< Byte 8 */
SD_csd->DeviceSize |= (CSD_Tab[8] & 0xC0) >> 6;
}
