microSD card in SPI mode timing - c

Question

I'm writing and reading values on a SD card in SPI mode. The frequency for writing and reading blocks of 512 bytes is set to 10Mhz. For writing a block it takes about 5ms and timing between blocks is about 10 ms.
Is any way to improve the speed of writing?
void sd_card_write_block(uint16 blockNumber, uint8* buffer)
{
uint16 blockLow = 0;
uint16 blockHigh = 0;
uint8 dummy = 0;
uint8 result = 0;
uint8 data_block_start_byte = 0;
uint8 write_command[SD_CMD_SIZE] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
uint8 dummy_buffer[DUMMY_BUFFER_LENGTH] = {0xFF, 0xFF, 0xFF, 0xFF,0xFF, 0xFF, 0xFF, 0xFF};
uint8 i = 0;
uint8 check_response[CHECK_RESPONSE_SIZE] = {0x00, 0x00, 0x00};
uint8 check_response1[CHECK_RESPONSE_SIZE] = {0x00, 0x00, 0x00};
uint8 r1 = 0;
uint16 retry = 0;
uint8 response1 = 0;
dummy = 0xFF;
//initialize the dummy buffer to keep MOSI pin High
for(i = 0; i < DUMMY_BUFFER_LENGTH; i++)
{
dummy_buffer[i] = 0xFF;
}
//set CS pin low
spi_select_slave( &spi_master_instance, &slave, true);
//send three clock cycles with MOSI HIGH (Ncs)
spi_write_buffer_wait( &spi_master_instance, dummy_buffer, NCS_LENGTH);
//block size was set in sd_init
blockLow = ((blockNumber & 0x003F) << 9);
blockHigh = ((blockNumber & 0xFFC0) >> 7);
//send SD CMD24(WRITE_SINGLE_BLOCK) to write the data to SD card
write_command[0] = 0x58;
//high block address bits, blockHigh HIGH and LOW
write_command[1] = (blockHigh >> 0x08);
write_command[2] = (blockHigh & 0xFF);
//low block address bits, blockLow HIGH and LOW
write_command[3] = (blockLow >> 0x08);
write_command[4] = (blockLow & 0xFF);
//checksum is no longer required but send 0xFF
write_command[5] = 0xFF;
spi_write_buffer_wait( &spi_master_instance, write_command, SD_CMD_SIZE);
spi_transceive_buffer_wait( &spi_master_instance, dummy_buffer, check_response, CHECK_RESPONSE_SIZE);
//send three clock cycles with MOSI High
spi_write_buffer_wait( &spi_master_instance, dummy_buffer, DUMMY_BUFFER_LENGTH);
//set bit 0 to 0 which indicates the beginning of the data block
data_block_start_byte = DATA_BLOCK_START_TOKEN;
spi_transceive_buffer_wait( &spi_master_instance, &data_block_start_byte, &result, SD_RESPONSE_SIZE);
/*takes so long because its similar to transreceivea and it discards the rx*/
spi_write_buffer_wait( &spi_master_instance, buffer, SD_BLOCK_LENGTH);
//read the microSD card response
spi_transceive_buffer_wait( &spi_master_instance, dummy_buffer, check_response1, CHECK_RESPONSE_SIZE);
do
{
// write dummy byte
spi_transceive_buffer_wait( &spi_master_instance, &dummy, &response1, SD_RESPONSE_SIZE);
r1 = response1;
// do retry counter
retry++;
if(retry > MAX_TIMEOUT)
{
spi_select_slave( &spi_master_instance, &slave, false);
break;
}
}
while(r1 == END_OF_BLOCK_RESPONSE);
//set the CS High
spi_select_slave( &spi_master_instance, &slave, false);
}

Answer 1

You can't, atleast not by much. The reason being that the SPI mode itself is the bottleneck. So, you can use a few tricks here and there to get that speed up, but you really won't be benifitting much from it. I'd advise you to use SDIO if you really need that much speed (It's not as complicated as you might think). If you're using an AVR, try the xmega lineup (Don't quote me on that, I'm not quite informed in the AVR, since I use ARMs), or switch to another lineup completely.

Answer 2

In order to get high write speeds, you need to:
- use a faster clock
- use a wider bus
- Write larger blocks (2k or 4k) at a time
In other words, you pretty much need to use the SDIO spec.
There's also ways to begin a large sequential transaction and not end it until all the data has been received (but maybe that's in the SDIO spec and not the SPI command interface). These sort of hints tells the controller that it can prepare a large section of the flash and not commit the write buffer until it's full.
And even then, you can end up with "very long" write cycles occasionally, so you cannot rely upon an SD card to stream high speed data off in real time without buffers on your side to handle the latency blips.

Answer 3

You should have posted your spi_write_buffer_wait code but consider something like this:
Rearange the stuff in your actual write function where you send the data. Think about it. You have to wait until the SD Card indicates you, that the byte was written successfully. Use this "useless" wait time to prepare the next data.
/* write a single block */
for ( i = MMC_BLOCKLEN; i > 0; i-- ) {
uint8_t data = *buffer;
buffer++;
wait_till_send_done();
xmit_byte ( data );
}
wait_till_send_done();
There you prepare the byte to send and also move the pointer one byte forward before you start waiting for the SD Card to indicate its successfull writing of the previous byte.
It is also a good idea to check the generated ASM code...
If you are about to write more than 512bytes of data, consider using multiblock writes (4k blocks for example at once).
Usually SD cards have internal block sizes of more than 512bytes. So to write 512 bytes, they have to internally read for example 4k, exchange your 512bytes and write everything back... so to write more data at once is always a good idea...