/** * @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; }
// Send a command to the SD Card // uiCmdIndex : Command index. 0 to 63 // uiArgument : Command argument void SD_SendCommand(UINT8 uiCmdIndex, UINT32 uiArgument) { // Send command UINT8 uiCmdByte = 64 + (uiCmdIndex & 63); SD_WriteByte(uiCmdByte); // Send argument int i; for (i = 0; i < 4; i++) { SD_WriteByte((uiArgument >> 24) & 0xff); uiArgument = uiArgument << 8; } SD_WriteByte(0x95); // Hard coded CRC }
/** * @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 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 Initializes the SD/SD communication. * @param None * @retval The SD Response: * - SD_RESPONSE_FAILURE: Sequence failed * - SD_RESPONSE_NO_ERROR: Sequence succeed */ SD_Error SD_Init(void) { uint32_t i = 0; /*!< Initialize SD_SPI */ SD_LowLevel_Init(); /*!< SD chip select high */ SD_CS_HIGH(); /*!< Send dummy byte 0xFF, 10 times with CS high */ /*!< Rise CS and MOSI for 80 clocks cycles */ for (i = 0; i <= 9; i++) { /*!< Send dummy byte 0xFF */ SD_WriteByte(SD_DUMMY_BYTE); } /*------------Put SD in SPI mode--------------*/ /*!< SD initialized and set to SPI mode properly */ return (SD_GoIdleState()); }
/** * @brief Initializes the SD/SD communication. * @param None * @retval The SD Response: * - SD_RESPONSE_FAILURE: Sequence failed * - SD_RESPONSE_NO_ERROR: Sequence succeed */ SD_Error SD_Init(void) { uint32_t TimeOut, i = 0; SD_Error Status = SD_RESPONSE_NO_ERROR; /*!< Initialize SD_SPI 初始化SPI相应管脚与处理器的SPI接口 */ //printf("(SD Init in SPI mode)"); SD_LowLevel_Init(); SD_SPI_SetSpeedLow(); //rt_kprintf("sd_init 0\n"); /*------------Put SD in SPI mode--------------*/ /*!< SD initialized and set to SPI mode properly */ TimeOut = 0; do { /*!< SD chip select high */ SD_CS_HIGH(); /*!< Send dummy byte 0xFF, 10 times with CS high */ /*!< Rise CS and MOSI for 80 clocks cycles */ for (i = 0; i <= 9; i++) { /*!< Send dummy byte 0xFF */ SD_WriteByte(SD_DUMMY_BYTE); } Status = SD_GoIdleState(); //rt_kprintf("sd_init 1 %d\n",(uint32_t)Status); if(TimeOut > 6) { break; } TimeOut++; }while(Status); SD_SPI_SetSpeedHi(); return (Status); }
/** * @brief Send 5 bytes command to the SD card. * @param Cmd: The user expected command to send to SD card. * @param Arg: The command argument. * @param Crc: The CRC. * @retval None */ void SD_SendCmd(uint8_t Cmd, uint32_t Arg, uint8_t Crc) { uint32_t i = 0x00; uint8_t Frame[6]; Frame[0] = (Cmd | 0x40); /*!< Construct byte 1 */ Frame[1] = (uint8_t)(Arg >> 24); /*!< Construct byte 2 */ Frame[2] = (uint8_t)(Arg >> 16); /*!< Construct byte 3 */ Frame[3] = (uint8_t)(Arg >> 8); /*!< Construct byte 4 */ Frame[4] = (uint8_t)(Arg); /*!< Construct byte 5 */ Frame[5] = (Crc); /*!< Construct CRC: byte 6 */ for (i = 0; i < 6; i++) { SD_WriteByte(Frame[i]); /*!< Send the Cmd bytes */ } }
/** * @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 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; }