Write a block to SD with SPI, strange response from SD - c

Question

Here is my code for writing a 512byte block into an SD card. The code works fine, but when I check that everything went good (by reading the response by SD), I read 0xFF.
That values should be something like (from SD reference manual):
‘010’—Data accepted.
‘101’—Data rejected due to a CRC error.
‘110’—Data rejected due to a Write Error
This is the code:
uint8_t SdCard_SendBlock(uint32_t block, uint8_t * data)
{
switch (sd_write_blk_machine.fields.state)
{
case WRITE_START:
//Enable Card
GPIOC_PDOR &= ~GPIO_PDOR_PDO(GPIO_PIN(10));
sd_cmd_arg.sd_cmd_tot_argument = block << SD_BLOCK_SHIFT;
sd_write_blk_machine.fields.state = WRITE_SEND_CMD24;
/*INIZIALIZZO LE VARIABILI LOCALI*/
write_send_data_counter = 0;
sd_cmd_machine.sd_cmd_machine = 0;
break;
case WRITE_SEND_CMD24:
send_command_return = SdSendCmd(CMD24|0x40,ASPECTED_OK_RESPONSE);
if( send_command_return == SDCARD_CMD_FAILS)
{
//Disable Card
GPIOC_PDOR |= GPIO_PDOR_PDO(GPIO_PIN(10));
sd_write_blk_machine.fields.complete = 1;
system_error.flags.sdcard_error = SDCARD_WRITE_FAIL;
return(SDCARD_WRITE_FAIL);
}
sd_write_blk_machine.fields.state = WRITE_SEND_START_TOKEN;
}
break;
case WRITE_SEND_START_TOKEN:
Spi_writeData(SPI0,SD_TOK_WRITE_SBLOCK); //SD_TOK_WRITE_SBLOCK = 0xFE ,
spi_control_machine.spi_control_machine = 0;
sd_write_blk_machine.fields.state = WRITE_SEND_DATA;
break;
case WRITE_SEND_DATA:
if (write_send_data_counter < SDCARD_BLOCK_SIZE) //SDCARD_BLOCK_SIZE = 512 byte
{
Spi_writeData(SPI0, data[write_send_data_counter]);
{
spi_control_machine.spi_control_machine = 0;
write_send_data_counter++;
}
}
else
sd_write_blk_machine.fields.state = WRITE_SEND_IDLE_1;
break;
case WRITE_SEND_IDLE_1:
Spi_writeData(SPI0,0xFF); // 0xFF = SPI_IDLE
sd_write_blk_machine.fields.state = WRITE_SEND_IDLE_2;
break;
case WRITE_SEND_IDLE_2:
Spi_writeData(SPI0,0xFF); // 0xFF = SPI_IDLE
sd_write_blk_machine.fields.state = WRITE_READ_RESPONSE_TOKEN;
break;
case WRITE_READ_RESPONSE_TOKEN:
/*Every data block written to the card will be acknowledged by a data response token. It is one byte long
and has the following format:
x x x 0 Status 1
The meaning of the status bits is defined as follows:
010 - Data accepted.
101 - Data rejected due to a CRC error.
110 - Data Rejected due to a Write Error*/
spi_control_machine.spi_control_machine = 0;
Spi_readData(SPI0, &write_read_response); // HERE IS THE PROBLEM !!!! write_read_response = 0xFF
if ( (write_read_response & 0x0F) != SD_ACCEPTED_WRITE_DATA )
{
//disabilita carta
GPIOC_PDOR |= GPIO_PDOR_PDO(GPIO_PIN(10));
system_error.flags.sdcard_error = SDCARD_WRITE_FAIL;
sd_write_blk_machine.fields.complete = 1;
SendBlockReturn=0;
return (SDCARD_WRITE_FAIL);
}
sd_write_blk_machine.fields.complete = 1;
status.flags.sdwrite_wait_attemp = 1;
SendBlockReturn=1;
return (TERMINATE_OK);
break;
}
The issue is in the last case of the switch.

Answer 1

It looks like the card is returning 0xFF until it has completed the write. According to the Physical Layer Simplified Specification in section 7.2.4:
As long as the card is busy programming, a continuous stream of busy tokens will be sent to the host (Effectively holding the DataOut line low).
That said, I'm not sure why the card isn't returning the '010' accepted response first - it could be a case of the card manufacturer not following the spec.
What you want to do is repeatedly call Spi_readData until it the returned byte becomes 0 or '010' accepted.

Answer 2

If you look at the diagrams on the SD specification the busy tokens come after the data response, what you're seeing is normal, after you send the last byte you should keep reading data until you get the data response token, then the card will start programming and you'll get the busy tokens until the programming completes. When the card is programming you'll read 0's (data line is held LOW). After you transfer the last byte I don't think the spec says what the state of the data line will be, I always get 0xFF too but you should not count on it so just keep checking for the response token until you get it.