SPI - Multiblock-Read von SD-Card

[Oliver L. (ollil)]

Hallo,

ich versuche mich gerade an einer Multiblock-Implementation, doch 
irgendwie komme ich nicht auf einen grünen Zweig.

Nach der Initialisierung der Karte führe ich praktisch folgendes durch:

- Adresse = 0
A: sende CMD18 mit der zu lesenden Adresse 
"von-hinten-nach-vorne-gedreht"
B: sende 0xFF und warte bis bis 0xFE gelesen wird
B: sende 512 mal 0xFF und schreibe das gelesene als Ergebniss weg
B: sende 2 mal 0xFF und schmeisse das Ergebniss weg (die CRC)

B wird nun in Summe 8 mal ausgeführt (8 Blöcke gelesen)

- sende CMD12 mit Argument 0
- erhöhe Adresse um Adresse+(8*512)
Nun gehts wieder zurück zu A.

Problem:

Nachdem ich nun 3 mal 8 Blöcke gelesen habe, nimmt die Karte mein CMD12 
nicht mehr an....

Ich habe nun vor das senden des CMD12 noch mal ein senden von 0xFF 
eingebaut.

Nun kann ich 6 mal 8 Blöcke lesen - dann nimmt die Karte wieder mein 
CMD12 nicht an.

Das was ich jeweils gelesen habe ist korrekt und entspricht genau dem, 
was in den ersten 3*8 oder 6*9 Blöcken der Karte gespeichert ist.


Wenn ich noch ein weiteres 0xFF vor dem CMD12 sende, dann komme ich über 
einen Durchlauf von "B" nicht hinaus.

Also - wie genau muss die Abfolge aussehen für nen Multiblock-Read?
Ich habe auch versucht, mit CMD23 vorher die Blockanzahl zu setzen, und 
dann ohne Stop-CMD zu arbeiten, das funktionierte aber auch nicht...

[Oliver L. (ollil)]

noch nie einer Multibyte-Commandos für ne SD-Card implementiert? ;)

[Oliver L. (ollil)]

So... multiblock-write habe ich nun endlich hinbekommen.... read noch 
nicht. Hier mal mein write-code:

uint8_t mmc_write_multiblock ( uint32_t addr, uint8_t *Buffer, uint8_t numblocks )
{
    uint8_t resp;
    uint8_t cmd[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF };
#ifdef SPI_CRC
    uint16_t crc;
#endif

    MMC_Enable();

#ifdef MMC_PRESET_MULTIBLOCKCOUNT
    // wait until Card is ready
    do {
        SPDR = 0xff;
        while ( ! ( SPSR & ( 1 << SPIF ) ) );
    } while ( !SPDR );

    //CMD55
    cmd[0] = 0x40 + 55;
    mmc_write_command ( cmd, 1 );

    //CMD23
    cmd[0] = 0x40 + 23;
    cmd[4] = numblocks;
    mmc_write_command ( cmd, 1 );

    // wait until Card is ready
    do {
        SPDR = 0xff;
        while ( ! ( SPSR & ( 1 << SPIF ) ) );
    } while ( !SPDR );
#endif

    addr = addr << 9; //addr = addr * 512

    //CMD25
    cmd[0] = 0x40 + 25;
    cmd[1] = ( ( addr & 0xFF000000 ) >> 24 );
    cmd[2] = ( ( addr & 0x00FF0000 ) >> 16 );
    cmd[3] = ( ( addr & 0x0000FF00 ) >> 8 );
    cmd[4] = 0;

    resp =  mmc_write_command ( cmd, 1 );
    if ( resp > 1 ) {
        return ( 1 );
    }

    for ( uint8_t n = numblocks; n > 0; n-- ) {
#ifdef SPI_CRC
        crc = crc16 ( Buffer, 512 );
#endif
        // wait until Card is ready
        do {
            SPDR = 0xff;
            while ( ! ( SPSR & ( 1 << SPIF ) ) );
        } while ( !SPDR );

        // Send multi-block start-token
        SPDR = 0xFC;

        //actually transfer the data
        for ( uint16_t i = 512; i; i-- ) {
            uint8_t data = *Buffer;
            Buffer++;
            while ( ! ( SPSR & ( 1 << SPIF ) ) );
            SPDR = data;
        }

        // send  CRC
        while ( ! ( SPSR & ( 1 << SPIF ) ) );
#ifdef SPI_CRC
        SPDR = crc >> 8;
        while ( ! ( SPSR & ( 1 << SPIF ) ) );
        SPDR = crc & 0xFF;
#else
        SPDR = 0xff;
        while ( ! ( SPSR & ( 1 << SPIF ) ) );
        SPDR = 0xff;
#endif

#ifdef MMC_PRESET_MULTIBLOCKCOUNT
        // Pad 8
        SPDR = 0xff;
#endif
        while ( ! ( SPSR & ( 1 << SPIF ) ) );

        // Get response
        SPDR = 0xff;
        while ( ! ( SPSR & ( 1 << SPIF ) ) );
        resp = SPDR;
        if ( ( resp & 0x0E ) != 4 )
            return ( 2 );
    }

    // wait until Card is ready
    do {
        SPDR = 0xff;
        while ( ! ( SPSR & ( 1 << SPIF ) ) );
    } while ( !SPDR );

    // Send "transfer stop byte"
    SPDR = 0xFD;
    while ( ! ( SPSR & ( 1 << SPIF ) ) );

    // Pad 8
    SPDR = 0xff;
    while ( ! ( SPSR & ( 1 << SPIF ) ) );

    // wait until Card is ready
    do {
        SPDR = 0xff;
        while ( ! ( SPSR & ( 1 << SPIF ) ) );
    } while ( !SPDR );

    MMC_Disable();

    return ( 0 );
}