Programming

#include <avr/io.h>

// specific definitions to set the speed
#define SLOW 0xF0
#define FAST 0xF1

// port definitions for the SD card as it is on my board
#define PORT_SPI PORTB // values port b 
#define DDR_SPI DDRB // direction port b 
#define DD_SS   DDB2 // pin 10 also known as CS
#define DD_MOSI DDB3 // pin 11
#define DD_MISO DDB4 // pin 12
#define DD_SCK  DDB5 // pin 13
#define DD_SDIN DDB1

// silly little macro
#define CLEAR_SS()      CLEAR_BIT( PORT_SPI, DD_SS )
#define SET_SS()        SET_BIT( PORT_SPI, DD_SS )

uint8_t SPI_INIT = 0;
void SPI_init( void );

// Set the speed of the SPI interface
void SPI_set_speed( uint8_t speed )
{
	if( SPI_INIT == 0 ) SPI_init(); // if we aren't initialised then do so

	if ( speed == SLOW ) 
	{
		// setting 011 = fosc/128 = 16MHz/128 = 125KHz
		SET_BIT( SPCR, SPR0 );
		SET_BIT( SPCR, SPR1 );
		CLEAR_BIT( SPSR, SPI2X );
	}
	else if ( speed == FAST ) 
	{
		// Setting 100 = fosc/2 = 16MHz/2 = 8MHz
		CLEAR_BIT( SPCR, SPR0 );
		CLEAR_BIT( SPCR, SPR1 );
		SET_BIT( SPSR, SPI2X );
	}
}

// Don't call this directly. All the other functions will
void SPI_init( void )
{
	SPI_INIT = 1; // we are initialised, so... yay!

	// Set SS high. SS low activates a transfer.
	// Set SS, MOSI and SCK as output pins
	// Set MISO as input
	SET_BIT( PORT_SPI, DD_SS ); 
	SET_BIT( DDR_SPI, DD_SS ); 
	CLEAR_BIT( DDR_SPI, DD_MISO ); 
	SET_BIT( DDR_SPI, DD_MOSI );
	SET_BIT( DDR_SPI, DD_SCK );

	// Note, SD cards need to do less than 400KHz during SD card initialisation
	// 16MHz / 32 = 500KHz
	// 16MHz / 64 = 250KHz
	// 16MHz / 128 = 125KHz
	// We could use 64 or 128. I don't know any advantage of either
	SPI_set_speed( SLOW );

	// Set this to be the Master and enable SPI
	SET_BIT( SPCR, MSTR );
	SET_BIT( SPCR, SPE );
}

// This is the core SPI data transfer. To get data we must send data as well!
uint8_t SPI_send_get( uint8_t data )
{
	if( SPI_INIT == 0 ) SPI_init(); // initialise SPI. Means we don't have to call init elsewhere
	
	SPDR = data; // put data in register to send
	while ( ! ( SPSR & _BV( SPIF ) ) ); // wait for transmission to complete
	return SPDR; // read received data
}

// load data into the register to send and wait for the transmit to complete
void SPI_send( uint8_t data )
{
	SPI_send_get( data );
}

// 0xFF is a dummy value that the SD card ignores
uint8_t SPI_get( void )
{
	return SPI_send_get( 0xFF ); // dummy value to send
}

#define BUSY_STATE 0

// Definitions for SD card commands
#define CMD0 0
#define CMD8 8		// not valid for 1.x cards I think
#define CMD9 9		// Card to respond with CSD 
#define CMD16 16	// Set block length for next command
#define CMD17 17	// Read single block
#define CMD24 24	// Send a block to sd card
#define CMD55 55	// Next command is ACMD

// Enter initialising, 0x80 is for the code to recognise it as ACMD so it knows to send the CMD55 before
#define ACMD41 0x80 | 41

// SD card sends this byte as an identifier
#define START_BLOCK 0xFE

// Used to simplify a match for isValidResponse function
#define DIRECT_MATCH	0x00
#define BITS_SET	0x01
#define BITS_NOTSET	0x02
#define ANY_GOOD_BYTE	0x03

// defining ACMDs to have MSB set.
// A valid CMD for SD card has MSB unset so we are stealing it :D
// Make sure you use makeCMD!

#define isACMD( data ) data & 0x80
#define makeCMD( data ) data & 0x7F

#define VALID_R_BYTE BITS_NOTSET << 8 | 0x80
#define READY_STATE DIRECT_MATCH << 8 | 0
#define IDLE_STATE DIRECT_MATCH << 8  | 1
#define ANY_BYTE ANY_GOOD_BYTE << 8 | 2

uint8_t SD_INIT = 0;

/*
Data Read:
Using single blocks: CMD17
	Send CMD16 to set the amount of data to get
	Send CMD17 
	Card will respond with a token
	Card will send the data with 2 bytes of CRC or a data error token

Data Write:
Using single blocks: CMD24
	Send CMD24
	Card will response with a token
	Send Start token
	Send Data
	Card sends data-response token 
	Card sends a stream of busy tokens while saving data
	Should send CMD13 to see if saving went ok
*/

void sd_init( void )
{
	SD_INIT = 1;
	uint8_t response;

	// We need to send at least 74 clicks 
	// SS must be high during these 74 clicks
	int i = 0;
	for ( ; i < 10; i++ ) SPI_send( 0xFF );

	// send required init commands
	CLEAR_SS();

	// Send Command 0, and we want the card to get into an idle state so it tries again a few times
	response = send_command_r( CMD0, 0, IDLE_STATE );
	if ( !isValidResponse( response, IDLE_STATE ) ) // If it fails we can't use this card as it is
	{
		SD_INIT = 0;
		return;
	}

	// The card is in an idle state now!

	// Send CMD8, if we get back a valid byte we don't know continue on.
	// It means a pre version 3 card.
	response = send_command_r( CMD8, 0x000001AA, VALID_R_BYTE );
	if ( isValidResponse( response, VALID_R_BYTE ) ) // SD card knows CMD8
	{
		uint8_t R7[4];
		R7[0] = SPI_get(); // command version
		R7[1] = SPI_get();
		R7[2] = SPI_get();
		R7[3] = SPI_get();
	}
	else  // I'm going to require a current SD card because the new ones support single byte writes
	{
		SD_INIT = 0;
		return;
	}

	// Send ACMD41 to get out of an idle state
	response = send_command_r( ACMD41, 0, READY_STATE );
	if ( !isValidResponse( response, READY_STATE ) )
	{
	        // we sent a reasonable amount of ACMD41s and didn't get back a ready state
		SD_INIT = 0;
		return;
	}

	SET_SS(); // we are done sending and receiving data

	SPI_set_speed( FAST );
	// after we want to jump up to a nice speed
	// we should now be ready to read write to the card

}

// this function eats up a bunch of data after a read command is sent until we see the start token 0xFE
uint8_t get_data_start()
{
	uint16_t timeout = 0xFFFF;
	uint8_t response = 0xFF;
	while ( --timeout > 0 )
	{
		response = SPI_get();
		if ( response == 0xFE ) break;
	}
	return response;
}

// Send a cmd over the SPI lines
// Wait until there is a valid response
uint8_t send_command( uint8_t data, uint32_t args )
{
        if ( SD_INIT == 0) sd_init();
        // send a command and print out what we get as a response
        // I think that we send a command and wait for the response to not be FF
        // the return that response and let somewhere else handle it.
        // each command is different so maybe have a different function for each command
        // I run with CRC disabled so It is set for the two instructions that require CRC.

        SPI_send( 0x40 | data );
        SPI_send( args >> 24  );
        SPI_send( args >> 16  );
        SPI_send( args >> 8  );
        SPI_send( args );
        switch( data )
        {
                case CMD8: // only valid for 0x000001AA
                        SPI_send( 0x87 );
                        break;
                default:
                        SPI_send( 0x95 ); // Its disabled except for the CMD0 so we can leave it as this
                        break;
        }

        // Waiting for a valid packet to come back
        uint16_t response = 0xFF;
        uint16_t timeout = 0xFFFF;
        while( response == 0xFF && --timeout > 0 )
        {
                response = SPI_get();
        }

        // if response == 0xFF there has been a timeout
        return response;
}

// this function sends a command and expects a specific response
// to make this simpler there is the isValidResponse which does the matching of the
// required response data
uint8_t send_command_r( uint8_t data, uint32_t args, uint16_t required_response )
{
	uint8_t response;
	uint16_t timeout = 0xFFFF;
	// we want a specific response. If we don't get it send the command again
	// do while loop saves a duplicate line :P
	do 
	{
		// if this is ACMD we need to send CMD55 first.
		// CMD55 sends back R1, but we are going to ignore it...
		if ( isACMD( data ) )
		{
			send_command( CMD55, 0 );
		}
		// makeCMD strips out the ACMD identifier if it has one
		response = send_command( makeCMD( data ), args );
	}
	while ( --timeout > 0 && !isValidResponse( response, required_response ) );

	return response;
}

// helper function for simplifying a while loop
uint8_t isValidResponse( uint8_t data, uint16_t validtype )
{
	// valid type is two bytes, the high byte is the type of match to do
	// the low byte is the valid data
	uint8_t match_type = validtype >> 8;
	uint8_t valid_data = validtype & 0xFF; // I probably don't need to mask but anyways
	switch( match_type )
	{
		case DIRECT_MATCH:	return data == validtype;
		case BITS_SET:		return data & valid_data;
		case BITS_NOTSET:	return !( data & valid_data );  
		case ANY_GOOD_BYTE:	return !( data == 0xFF );
		default:		return 0;
	}

}

// read 1 block (512 bytes) of data into the buffer
// start_loc must be block aligned.
uint8_t read_block( unsigned int start_loc, uint8_t *buffer )
{
        if ( start_loc % 512 != 0 ){
                return 0; // need to be at the start of a block
        }
        uint8_t response;
        uint32_t length = 512;

        // Set that we are sending data
        CLEAR_SS();

        // Set the block length to be 512bytes
        send_command_r( CMD16, length, VALID_R_BYTE );

        // send the get data command
        send_command_r( CMD17, start_loc, VALID_R_BYTE );
        // eat up all empty bytes
        get_data_start( );

        // now we get the data
        if ( buffer ) // don't bother if we have a null pointer
        {
                uint32_t x = 0;
                while( x < length ) buffer[x++] = SPI_get();

                response = SPI_get(); // crc byte
                response = SPI_get(); // crc byte
        }
        SET_SS();
        return 1;
}

// similar to the read block
// writes the 512 bytes of buffer to the sd card at start_loc
// this function waits for the SD card to write the data
uint8_t write_block( unsigned int start_loc, uint8_t *buffer )
{
        if ( start_loc % 512 != 0 ){
                return 0; // need to be at the start of a block
        }
        uint8_t response = 0xFF;
        uint32_t length = 512;

        CLEAR_SS();
        // Set the block length to be 512
        send_command_r( CMD16, length, VALID_R_BYTE );

        // send the write data command
        send_command_r( CMD24, start_loc, VALID_R_BYTE );
        
        // we send a start token then the data
        SPI_send( START_BLOCK );

        // now send data
        uint32_t x = 0;
        while( x < length ) SPI_send( buffer[x++] );

        SPI_send( 0x95 ); // crc byte
        SPI_send( 0x95 ); // crc byte

        uint16_t timeout = 0xFFFF;
        while( --timeout > 0 )
        {
                response = SPI_get();

                // first bit must be 1  and 4th bit must be 0
                //if ( !(response & 0x1) && response & 0x10 )
                if ( response != 0xFF )
                        break;
        }

        timeout = 0xFFFF;
        while ( --timeout > 0 && SPI_get() != BUSY_STATE ); // eat up busy bytes

        // I should check send status ( cmd13 )
        SET_SS();
        if ( (response & 0xF) == 5 ) 
        {
                // Data accepted
                return 1;
        }
        else if ( (response & 0xF) == 11 ) 
        {
                // Data CRC Error
                return 0;
        }
        else if ( (response & 0xF) == 13 ) 
        {
                // Data Write error
                return 0;
        }
        else 
        {
                // Not sure what the status is
                return 0;
        }

        return 0;
}

// F_CPU is passed down from the Makefile
#define BAUD 9600
#define MYUBRR F_CPU/16/BAUD-1
#include <avr/io.h>
#include <stdio.h>
// setup USART
void USART_init( void )
{
        unsigned int ubrr = MYUBRR; // from datasheet
	// Disable USART so we can configure it
	UCSR0B = 0; // turn everything off
	// Set baud rate defined by MYUBRR
	UBRR0H = ( uint8_t ) ( ubrr >> 8 );
	UBRR0L = ( uint8_t ) ( ubrr );
	// Turn off double speed
	UCSR0A &= ~(1 << U2X0);
	// Enable TX/RX
	UCSR0B |= 1 << RXEN0 | 1 << TXEN0;
	// Asynchronous, No Parity, 2 stop bits, 8 databits
	UCSR0C = 1 << USBS0 | 1 << UCSZ01 | 1 << UCSZ00;
}
// send a byte 
// Only works on 8bits or less frame size
// The return and parameter types are required by printf
int USART_transmit( char data, FILE *stream )
{
        // simple copy from page 185 of the data sheet
        // Wait for empty transmit buffer 
        while ( !( UCSR0A & (1<<UDRE0)) );
        // Put data into buffer, sends the data 
        UDR0 = data;
}
// this is how we tell printf to output to USART (can be replace to output to lcd or something)
// Also need the stdout line in main
// Set to write because I don't handle input. and I probably would do input from another function
FILE usart_print = FDEV_SETUP_STREAM( USART_transmit, NULL, _FDEV_SETUP_WRITE );
int main( void )
{
	stdout = &usart_print; // this is also needed so printf works
	printf( "You should be able to see this over the serial port\n\r", x );
	for(;;){ // infinite loop 
	}
        return 0;
}

screen /dev/tty.usbserial-XXXXX # whatever the device filename is