MMC/SD/SDHC card raw access

Collaboration diagram for MMC/SD/SDHC card raw access:

Files
file	sd_raw.c
file	sd_raw.h
file	sd_raw_config.h
Modules
	MMC/SD configuration
Data Structures
struct	sd_raw_info
Defines
#define	SD_RAW_FORMAT_HARDDISK   0
#define	SD_RAW_FORMAT_SUPERFLOPPY   1
#define	SD_RAW_FORMAT_UNIVERSAL   2
#define	SD_RAW_FORMAT_UNKNOWN   3
Typedefs
typedef uint8_t(*	sd_raw_read_interval_handler_t )(uint8_t *buffer, offset_t offset, void *p)
typedef uintptr_t(*	sd_raw_write_interval_handler_t )(uint8_t *buffer, offset_t offset, void *p)
Functions
uint8_t	sd_raw_init ()
uint8_t	sd_raw_available ()
uint8_t	sd_raw_locked ()
static void	sd_raw_send_byte (uint8_t b)
static uint8_t	sd_raw_rec_byte ()
static uint8_t	sd_raw_send_command (uint8_t command, uint32_t arg)
uint8_t	sd_raw_read (offset_t offset, uint8_t *buffer, uintptr_t length)
uint8_t	sd_raw_read_interval (offset_t offset, uint8_t *buffer, uintptr_t interval, uintptr_t length, sd_raw_read_interval_handler_t callback, void *p)
uint8_t	sd_raw_write (offset_t offset, const uint8_t *buffer, uintptr_t length)
uint8_t	sd_raw_write_interval (offset_t offset, uint8_t *buffer, uintptr_t length, sd_raw_write_interval_handler_t callback, void *p)
uint8_t	sd_raw_sync ()
uint8_t	sd_raw_get_info (struct sd_raw_info *info)

---

Detailed Description

This module implements read and write access to MMC, SD and SDHC cards. It serves as a low-level driver for the higher level modules such as partition and file system access.

---

Define Documentation

#define SD_RAW_FORMAT_HARDDISK   0

The card's layout is harddisk-like, which means it contains a master boot record with a partition table.

Definition at line 38 of file sd_raw.h.

#define SD_RAW_FORMAT_SUPERFLOPPY   1

The card contains a single filesystem and no partition table.

Definition at line 42 of file sd_raw.h.

#define SD_RAW_FORMAT_UNIVERSAL   2

The card's layout follows the Universal File Format.

Definition at line 46 of file sd_raw.h.

#define SD_RAW_FORMAT_UNKNOWN   3

The card's layout is unknown.

Definition at line 50 of file sd_raw.h.

---

Typedef Documentation

typedef uint8_t(* sd_raw_read_interval_handler_t)(uint8_t *buffer, offset_t offset, void *p)

Definition at line 124 of file sd_raw.h.

typedef uintptr_t(* sd_raw_write_interval_handler_t)(uint8_t *buffer, offset_t offset, void *p)

Definition at line 125 of file sd_raw.h.

---

Function Documentation

uint8_t sd_raw_available

(

)

Checks wether a memory card is located in the slot.

Returns:

1 if the card is available, 0 if it is not.

Definition at line 346 of file sd_raw.c.

References get_pin_available.

{
    return get_pin_available() == 0x00;
}

uint8_t sd_raw_get_info

(

struct sd_raw_info *

info

)

Reads informational data from the card.

This function reads and returns the card's registers containing manufacturing and status information.

Note:

: The information retrieved by this function is not required in any way to operate on the card, but it might be nice to display some of the data to the user.

Parameters:

[in]

info

A pointer to the structure into which to save the information.

Returns:

0 on failure, 1 on success.

Definition at line 866 of file sd_raw.c.

References sd_raw_info::capacity, CMD_SEND_CID, CMD_SEND_CSD, sd_raw_info::flag_copy, sd_raw_info::flag_write_protect, sd_raw_info::flag_write_protect_temp, sd_raw_info::format, sd_raw_info::manufacturer, sd_raw_info::manufacturing_month, sd_raw_info::manufacturing_year, sd_raw_info::oem, sd_raw_info::product, sd_raw_info::revision, sd_raw_card_type, sd_raw_rec_byte(), sd_raw_send_command(), SD_RAW_SPEC_2, and sd_raw_info::serial.

Referenced by WaspSD::print_disk_info().

{
        uint16_t i=0;

//     if(!info || !sd_raw_available())
//         return 0;
        
        if(!info )
        return 0;

    memset(info, 0, sizeof(*info));

    select_card();

    /* read cid register */
    if(sd_raw_send_command(CMD_SEND_CID, 0))
    {
        unselect_card();
        return 0;
    }
    while(sd_raw_rec_byte() != 0xfe);
    for( i = 0; i < 18; ++i)
    {
        uint8_t b = sd_raw_rec_byte();

        switch(i)
        {
            case 0:
                info->manufacturer = b;
                break;
            case 1:
            case 2:
                info->oem[i - 1] = b;
                break;
            case 3:
            case 4:
            case 5:
            case 6:
            case 7:
                info->product[i - 3] = b;
                break;
            case 8:
                info->revision = b;
                break;
            case 9:
            case 10:
            case 11:
            case 12:
                info->serial |= (uint32_t) b << ((12 - i) * 8);
                break;
            case 13:
                info->manufacturing_year = b << 4;
                break;
            case 14:
                info->manufacturing_year |= b >> 4;
                info->manufacturing_month = b & 0x0f;
                break;
        }
    }

    /* read csd register */
    uint8_t csd_read_bl_len = 0;
    uint8_t csd_c_size_mult = 0;
#if SD_RAW_SDHC
    uint16_t csd_c_size = 0;
#else
    uint32_t csd_c_size = 0;
#endif
    if(sd_raw_send_command(CMD_SEND_CSD, 0))
    {
        unselect_card();
        return 0;
    }
    while(sd_raw_rec_byte() != 0xfe);
    for( i = 0; i < 18; ++i)
    {
        uint8_t b = sd_raw_rec_byte();

        if(i == 14)
        {
            if(b & 0x40)
                info->flag_copy = 1;
            if(b & 0x20)
                info->flag_write_protect = 1;
            if(b & 0x10)
                info->flag_write_protect_temp = 1;
            info->format = (b & 0x0c) >> 2;
        }
        else
        {
#if SD_RAW_SDHC
            if(sd_raw_card_type & (1 << SD_RAW_SPEC_2))
            {
                switch(i)
                {
                    case 7:
                        b &= 0x3f;
                    case 8:
                    case 9:
                        csd_c_size <<= 8;
                        csd_c_size |= b;
                        break;
                }
                if(i == 9)
                {
                    ++csd_c_size;
                    info->capacity = (offset_t) csd_c_size * 512 * 1024;
                }
            }
            else
#endif
            {
                switch(i)
                {
                    case 5:
                        csd_read_bl_len = b & 0x0f;
                        break;
                    case 6:
                        csd_c_size = b & 0x03;
                        csd_c_size <<= 8;
                        break;
                    case 7:
                        csd_c_size |= b;
                        csd_c_size <<= 2;
                        break;
                    case 8:
                        csd_c_size |= b >> 6;
                        ++csd_c_size;
                        break;
                    case 9:
                        csd_c_size_mult = b & 0x03;
                        csd_c_size_mult <<= 1;
                        break;
                    case 10:
                        csd_c_size_mult |= b >> 7;

                        info->capacity = (uint32_t) csd_c_size << (csd_c_size_mult + csd_read_bl_len + 2);

                        break;
                }
            }
        }
    }

    unselect_card();

    return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

uint8_t sd_raw_init

(

)

Initializes memory card communication.

Returns:

0 on failure, 1 on success.

Definition at line 173 of file sd_raw.c.

References CMD_APP, CMD_GO_IDLE_STATE, CMD_READ_OCR, CMD_SD_SEND_OP_COND, CMD_SEND_IF_COND, CMD_SEND_OP_COND, CMD_SET_BLOCKLEN, configure_pin_available, R1_IDLE_STATE, R1_ILL_COMMAND, raw_block, raw_block_address, raw_block_written, sd_raw_card_type, sd_raw_read(), sd_raw_rec_byte(), sd_raw_send_command(), SD_RAW_SPEC_1, SD_RAW_SPEC_2, and SD_RAW_SPEC_SDHC.

Referenced by WaspSD::init().

{
    /* enable inputs for reading card status */
      configure_pin_available();
      

//FIXME: in Wasp we dont lock the card
//    configure_pin_locked();

        /* initialize SPI with lowest frequency; max. 400kHz during identification mode of card */
        SPCR = (0 << SPIE) | /* SPI Interrupt Enable */
        (1 << SPE)  | /* SPI Enable */
        (0 << DORD) | /* Data Order: MSB first */
        (1 << MSTR) | /* Master mode */
        (0 << CPOL) | /* Clock Polarity: SCK low when idle */
        (0 << CPHA) | /* Clock Phase: sample on rising SCK edge */
        (1 << SPR1) | /* Clock Frequency: f_OSC / 128 */
        (1 << SPR0);
        SPSR &= ~(1 << SPI2X); /* No doubled clock frequency */

    /* enable outputs for MOSI, SCK, SS, input for MISO */
    configure_pin_mosi();
    configure_pin_sck();
    configure_pin_ss();
    configure_pin_miso();


/*    unselect_card();*/

    /* initialization procedure */
    sd_raw_card_type = 0;
    
        // Already checked in WaspSD library
        //     if(!sd_raw_available())
        //         return 0;

    uint16_t i=0;
    /* card needs 74 cycles minimum to start up */
    for(i = 0; i < 10; ++i)
    {
        /* wait 8 clock cycles */
        sd_raw_rec_byte();
    }

    /* address card */
    select_card();

    /* reset card */
    uint8_t response;
    for( i = 0; ; ++i)
    {
        response = sd_raw_send_command(CMD_GO_IDLE_STATE, 0);
        if(response == (1 << R1_IDLE_STATE))
            break;

        if(i == 0x1ff)
        {
            unselect_card();
            return 0;
        }
    }

#if SD_RAW_SDHC
    /* check for version of SD card specification */
    response = sd_raw_send_command(CMD_SEND_IF_COND, 0x100 /* 2.7V - 3.6V */ | 0xaa /* test pattern */);
    if((response & (1 << R1_ILL_COMMAND)) == 0)
    {
        sd_raw_rec_byte();
        sd_raw_rec_byte();
        if((sd_raw_rec_byte() & 0x01) == 0)
            return 0; /* card operation voltage range doesn't match */
        if(sd_raw_rec_byte() != 0xaa)
            return 0; /* wrong test pattern */

        /* card conforms to SD 2 card specification */
        sd_raw_card_type |= (1 << SD_RAW_SPEC_2);
    }
    else
#endif
    {
        /* determine SD/MMC card type */
        sd_raw_send_command(CMD_APP, 0);
        response = sd_raw_send_command(CMD_SD_SEND_OP_COND, 0);
        if((response & (1 << R1_ILL_COMMAND)) == 0)
        {
            /* card conforms to SD 1 card specification */
            sd_raw_card_type |= (1 << SD_RAW_SPEC_1);
        }
        else
        {
            /* MMC card */
        }
    }

    /* wait for card to get ready */
    for( i = 0; ; ++i)
    {
        if(sd_raw_card_type & ((1 << SD_RAW_SPEC_1) | (1 << SD_RAW_SPEC_2)))
        {
            uint32_t arg = 0;
#if SD_RAW_SDHC
            if(sd_raw_card_type & (1 << SD_RAW_SPEC_2))
                arg = 0x40000000;
#endif
            sd_raw_send_command(CMD_APP, 0);
            response = sd_raw_send_command(CMD_SD_SEND_OP_COND, arg);
        }
        else
        {
            response = sd_raw_send_command(CMD_SEND_OP_COND, 0);
        }

        if((response & (1 << R1_IDLE_STATE)) == 0)
            break;

        if(i == 0x7fff)
        {
            unselect_card();
            return 0;
        }
    }

#if SD_RAW_SDHC
    if(sd_raw_card_type & (1 << SD_RAW_SPEC_2))
    {
        if(sd_raw_send_command(CMD_READ_OCR, 0))
        {
            unselect_card();
            return 0;
        }

        if(sd_raw_rec_byte() & 0x40)
            sd_raw_card_type |= (1 << SD_RAW_SPEC_SDHC);

        sd_raw_rec_byte();
        sd_raw_rec_byte();
        sd_raw_rec_byte();
    }
#endif

    /* set block size to 512 bytes */
    if(sd_raw_send_command(CMD_SET_BLOCKLEN, 512))
    {
        unselect_card();
        return 0;
    }

    /* deaddress card */
    unselect_card();

    /* switch to highest SPI frequency possible */
    SPCR &= ~((1 << SPR1) | (1 << SPR0)); /* Clock Frequency: f_OSC / 4 */
    SPSR |= (1 << SPI2X); /* Doubled Clock Frequency: f_OSC / 2 */

#if !SD_RAW_SAVE_RAM
    /* the first block is likely to be accessed first, so precache it here */
    raw_block_address = (offset_t) -1;
#if SD_RAW_WRITE_BUFFERING
    raw_block_written = 1;
#endif
    if(!sd_raw_read(0, raw_block, sizeof(raw_block)))
        return 0;
#endif

    return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

uint8_t sd_raw_locked

(

)

Checks wether the memory card is locked for write access.

Returns:

1 if the card is locked, 0 if it is not.

Definition at line 357 of file sd_raw.c.

References get_pin_locked.

{
    return get_pin_locked() == 0x00;
}

uint8_t sd_raw_read	(	offset_t	offset,
		uint8_t *	buffer,
		uintptr_t	length
	)

Reads raw data from the card.

Parameters:

[in]	offset	The offset from which to read.
[out]	buffer	The buffer into which to write the data.
[in]	length	The number of bytes to read.

Returns:

0 on failure, 1 on success.

See also:

sd_raw_read_interval, sd_raw_write, sd_raw_write_interval

Definition at line 450 of file sd_raw.c.

References CMD_READ_SINGLE_BLOCK, raw_block, raw_block_address, sd_raw_card_type, sd_raw_rec_byte(), sd_raw_send_command(), SD_RAW_SPEC_SDHC, and sd_raw_sync().

Referenced by WaspSD::init(), sd_raw_init(), sd_raw_read_interval(), and sd_raw_write().

{
    offset_t block_address;
    uint16_t block_offset;
    uint16_t read_length;
    uint16_t i=0;

    while(length > 0)
    {
        /* determine byte count to read at once */
        block_offset = offset & 0x01ff;
        block_address = offset - block_offset;
        read_length = 512 - block_offset; /* read up to block border */
        if(read_length > length)
            read_length = length;
        
#if !SD_RAW_SAVE_RAM
        /* check if the requested data is cached */
        if(block_address != raw_block_address)
#endif
        {
#if SD_RAW_WRITE_BUFFERING
            if(!sd_raw_sync())
                return 0;
#endif

            /* address card */
            select_card();

            /* send single block request */
#if SD_RAW_SDHC
            if(sd_raw_send_command(CMD_READ_SINGLE_BLOCK, (sd_raw_card_type & (1 << SD_RAW_SPEC_SDHC) ? block_address / 512 : block_address)))
#else
            if(sd_raw_send_command(CMD_READ_SINGLE_BLOCK, block_address))
#endif
            {
                unselect_card();
                return 0;
            }

            /* wait for data block (start byte 0xfe) */
            while(sd_raw_rec_byte() != 0xfe);

#if SD_RAW_SAVE_RAM
            /* read byte block */
            uint16_t read_to = block_offset + read_length;
            for( i = 0; i < 512; ++i)
            {
                uint8_t b = sd_raw_rec_byte();
                if(i >= block_offset && i < read_to)
                    *buffer++ = b;
            }
#else
            /* read byte block */
            uint8_t* cache = raw_block;
            for( i = 0; i < 512; ++i)
                *cache++ = sd_raw_rec_byte();
            raw_block_address = block_address;

            memcpy(buffer, raw_block + block_offset, read_length);
            buffer += read_length;
#endif
            
            /* read crc16 */
            sd_raw_rec_byte();
            sd_raw_rec_byte();
            
            /* deaddress card */
            unselect_card();

            /* let card some time to finish */
            sd_raw_rec_byte();
        }
#if !SD_RAW_SAVE_RAM
        else
        {
            /* use cached data */
            memcpy(buffer, raw_block + block_offset, read_length);
            buffer += read_length;
        }
#endif

        length -= read_length;
        offset += read_length;
    }

    return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

uint8_t sd_raw_read_interval	(	offset_t	offset,
		uint8_t *	buffer,
		uintptr_t	interval,
		uintptr_t	length,
		sd_raw_read_interval_handler_t	callback,
		void *	p
	)

Continuously reads units of interval bytes and calls a callback function.

This function starts reading at the specified offset. Every interval bytes, it calls the callback function with the associated data buffer.

By returning zero, the callback may stop reading.

Note:

Within the callback function, you can not start another read or write operation.

This function only works if the following conditions are met:

• (offset - (offset % 512)) % interval == 0
• length % interval == 0

Parameters:

[in]	offset	Offset from which to start reading.
[in]	buffer	Pointer to a buffer which is at least interval bytes in size.
[in]	interval	Number of bytes to read before calling the callback function.
[in]	length	Number of bytes to read altogether.
[in]	callback	The function to call every interval bytes.
[in]	p	An opaque pointer directly passed to the callback function.

Returns:

0 on failure, 1 on success

See also:

sd_raw_write_interval, sd_raw_read, sd_raw_write

Definition at line 563 of file sd_raw.c.

References CMD_READ_SINGLE_BLOCK, sd_raw_card_type, sd_raw_read(), sd_raw_rec_byte(), sd_raw_send_command(), and SD_RAW_SPEC_SDHC.

Referenced by WaspSD::init().

{
    if(!buffer || interval == 0 || length < interval || !callback)
        return 0;

#if !SD_RAW_SAVE_RAM
    while(length >= interval)
    {
        /* as reading is now buffered, we directly
         * hand over the request to sd_raw_read()
         */
        if(!sd_raw_read(offset, buffer, interval))
            return 0;
        if(!callback(buffer, offset, p))
            break;
        offset += interval;
        length -= interval;
    }

    return 1;
#else
    /* address card */
    select_card();

    uint16_t block_offset;
    uint16_t read_length;
    uint8_t* buffer_cur;
    uint8_t finished = 0;
    uint16_t i=0;

    do
    {
        /* determine byte count to read at once */
        block_offset = offset & 0x01ff;
        read_length = 512 - block_offset;
        
        /* send single block request */
#if SD_RAW_SDHC
        if(sd_raw_send_command(CMD_READ_SINGLE_BLOCK, (sd_raw_card_type & (1 << SD_RAW_SPEC_SDHC) ? offset / 512 : offset - block_offset)))
#else
        if(sd_raw_send_command(CMD_READ_SINGLE_BLOCK, offset - block_offset))
#endif
        {
            unselect_card();
            return 0;
        }

        /* wait for data block (start byte 0xfe) */
        while(sd_raw_rec_byte() != 0xfe);

        /* read up to the data of interest */
        for( i = 0; i < block_offset; ++i)
            sd_raw_rec_byte();

        /* read interval bytes of data and execute the callback */
        do
        {
            if(read_length < interval || length < interval)
                break;

            buffer_cur = buffer;
            for( i = 0; i < interval; ++i)
                *buffer_cur++ = sd_raw_rec_byte();

            if(!callback(buffer, offset + (512 - read_length), p))
            {
                finished = 1;
                break;
            }

            read_length -= interval;
            length -= interval;

        } while(read_length > 0 && length > 0);
        
        /* read rest of data block */
        while(read_length-- > 0)
            sd_raw_rec_byte();
        
        /* read crc16 */
        sd_raw_rec_byte();
        sd_raw_rec_byte();

        if(length < interval)
            break;

        offset = offset - block_offset + 512;

    } while(!finished);
    
    /* deaddress card */
    unselect_card();

    /* let card some time to finish */
    sd_raw_rec_byte();

    return 1;
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

uint8_t sd_raw_rec_byte

(

)

[static]

Receives a raw byte from the memory card.

Returns:

The byte which should be read.

See also:

sd_raw_send_byte

Definition at line 384 of file sd_raw.c.

Referenced by sd_raw_get_info(), sd_raw_init(), sd_raw_read(), sd_raw_read_interval(), sd_raw_send_command(), and sd_raw_write().

{
    /* send dummy data for receiving some */
    SPDR = 0xff;
    while(!(SPSR & (1 << SPIF)));
    SPSR &= ~(1 << SPIF);

    return SPDR;
}

Here is the caller graph for this function:

void sd_raw_send_byte

(

uint8_t

b

)

[static]

Sends a raw byte to the memory card.

Parameters:

[in]

b

The byte to sent.

See also:

sd_raw_rec_byte

Definition at line 369 of file sd_raw.c.

Referenced by sd_raw_send_command(), and sd_raw_write().

{
    SPDR = b;
    /* wait for byte to be shifted out */
    while(!(SPSR & (1 << SPIF)));
    SPSR &= ~(1 << SPIF);
}

Here is the caller graph for this function:

uint8_t sd_raw_send_command	(	uint8_t	command,
		uint32_t	arg
	)			[static]

Send a command to the memory card which responses with a R1 response (and possibly others).

Parameters:

[in]	command	The command to send.
[in]	arg	The argument for command.

Returns:

The command answer.

Definition at line 402 of file sd_raw.c.

References CMD_GO_IDLE_STATE, CMD_SEND_IF_COND, sd_raw_rec_byte(), and sd_raw_send_byte().

Referenced by sd_raw_get_info(), sd_raw_init(), sd_raw_read(), sd_raw_read_interval(), and sd_raw_write().

{
    uint8_t response;

    /* wait some clock cycles */
    sd_raw_rec_byte();

    /* send command via SPI */
    sd_raw_send_byte(0x40 | command);
    sd_raw_send_byte((arg >> 24) & 0xff);
    sd_raw_send_byte((arg >> 16) & 0xff);
    sd_raw_send_byte((arg >> 8) & 0xff);
    sd_raw_send_byte((arg >> 0) & 0xff);
    switch(command)
    {
        case CMD_GO_IDLE_STATE:
           sd_raw_send_byte(0x95);
           break;
        case CMD_SEND_IF_COND:
           sd_raw_send_byte(0x87);
           break;
        default:
           sd_raw_send_byte(0xff);
           break;
    }
    
    /* receive response */
    uint8_t i=0;
    for( i = 0; i < 10; ++i)
    {
        response = sd_raw_rec_byte();
        if(response != 0xff)
            break;
    }

    return response;
}

Here is the call graph for this function:

Here is the caller graph for this function:

uint8_t sd_raw_sync

(

)

Writes the write buffer's content to the card.

Note:

When write buffering is enabled, you should call this function before disconnecting the card to ensure all remaining data has been written.

Returns:

0 on failure, 1 on success.

See also:

sd_raw_write

Definition at line 838 of file sd_raw.c.

References raw_block, raw_block_address, raw_block_written, and sd_raw_write().

Referenced by sd_raw_read(), and sd_raw_write().

{
#if SD_RAW_WRITE_BUFFERING
    if(raw_block_written)
        return 1;
    if(!sd_raw_write(raw_block_address, raw_block, sizeof(raw_block)))
        return 0;
    raw_block_written = 1;
#endif
    return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

uint8_t sd_raw_write	(	offset_t	offset,
		const uint8_t *	buffer,
		uintptr_t	length
	)

Writes raw data to the card.

Note:

If write buffering is enabled, you might have to call sd_raw_sync() before disconnecting the card to ensure all remaining data has been written.

Parameters:

[in]	offset	The offset where to start writing.
[in]	buffer	The buffer containing the data to be written.
[in]	length	The number of bytes to write.

Returns:

0 on failure, 1 on success.

See also:

sd_raw_write_interval, sd_raw_read, sd_raw_read_interval

Definition at line 678 of file sd_raw.c.

References CMD_WRITE_SINGLE_BLOCK, raw_block, raw_block_address, raw_block_written, sd_raw_card_type, sd_raw_read(), sd_raw_rec_byte(), sd_raw_send_byte(), sd_raw_send_command(), SD_RAW_SPEC_SDHC, and sd_raw_sync().

Referenced by WaspSD::init(), sd_raw_sync(), and sd_raw_write_interval().

{
//     if(sd_raw_locked())
//         return 0;

    offset_t block_address;
    uint16_t block_offset;
    uint16_t write_length;
    uint16_t i=0;

    while(length > 0)
    {
        /* determine byte count to write at once */
        block_offset = offset & 0x01ff;
        block_address = offset - block_offset;
        write_length = 512 - block_offset; /* write up to block border */
        if(write_length > length)
            write_length = length;
        
        /* Merge the data to write with the content of the block.
         * Use the cached block if available.
         */
        if(block_address != raw_block_address)
        {
#if SD_RAW_WRITE_BUFFERING
            if(!sd_raw_sync())
                return 0;
#endif

            if(block_offset || write_length < 512)
            {
                if(!sd_raw_read(block_address, raw_block, sizeof(raw_block))){
                    return 0;
                }
            }
            raw_block_address = block_address;
        }

        if(buffer != raw_block)
        {
            memcpy(raw_block + block_offset, buffer, write_length);

#if SD_RAW_WRITE_BUFFERING
            raw_block_written = 0;

            if(length == write_length){
                return 1;
            }
#endif
        }

        /* address card */
        select_card();

        /* send single block request */
#if SD_RAW_SDHC
        if(sd_raw_send_command(CMD_WRITE_SINGLE_BLOCK, (sd_raw_card_type & (1 << SD_RAW_SPEC_SDHC) ? block_address / 512 : block_address)))
#else
        if(sd_raw_send_command(CMD_WRITE_SINGLE_BLOCK, block_address))
#endif
        {
            unselect_card();
            return 0;
        }

        /* send start byte */
        sd_raw_send_byte(0xfe);

        /* write byte block */
        uint8_t* cache = raw_block;
        for( i = 0; i < 512; ++i)
            sd_raw_send_byte(*cache++);

        /* write dummy crc16 */
        sd_raw_send_byte(0xff);
        sd_raw_send_byte(0xff);

        /* wait while card is busy */
        while(sd_raw_rec_byte() != 0xff);
        sd_raw_rec_byte();

        /* deaddress card */
        unselect_card();

        buffer += write_length;
        offset += write_length;
        length -= write_length;

#if SD_RAW_WRITE_BUFFERING
        raw_block_written = 1;
#endif
    }
    return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

uint8_t sd_raw_write_interval	(	offset_t	offset,
		uint8_t *	buffer,
		uintptr_t	length,
		sd_raw_write_interval_handler_t	callback,
		void *	p
	)

Writes a continuous data stream obtained from a callback function.

This function starts writing at the specified offset. To obtain the next bytes to write, it calls the callback function. The callback fills the provided data buffer and returns the number of bytes it has put into the buffer.

By returning zero, the callback may stop writing.

Parameters:

[in]	offset	Offset where to start writing.
[in]	buffer	Pointer to a buffer which is used for the callback function.
[in]	length	Number of bytes to write in total. May be zero for endless writes.
[in]	callback	The function used to obtain the bytes to write.
[in]	p	An opaque pointer directly passed to the callback function.

Returns:

0 on failure, 1 on success

See also:

sd_raw_read_interval, sd_raw_write, sd_raw_read

Definition at line 793 of file sd_raw.c.

References sd_raw_write().

Referenced by WaspSD::init().

{
#if SD_RAW_SAVE_RAM
    #error "SD_RAW_WRITE_SUPPORT is not supported together with SD_RAW_SAVE_RAM"
#endif

    if(!buffer || !callback)
        return 0;

    uint8_t endless = (length == 0);
    while(endless || length > 0)
    {
        uint16_t bytes_to_write = callback(buffer, offset, p);
        if(!bytes_to_write)
            break;
        if(!endless && bytes_to_write > length)
            return 0;

        /* as writing is always buffered, we directly
         * hand over the request to sd_raw_write()
         */
        if(!sd_raw_write(offset, buffer, bytes_to_write))
            return 0;

        offset += bytes_to_write;
        length -= bytes_to_write;
    }

    return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function: