AVR+SD-Card: inititialisierung klappt nur bei einer von 3 karten

[Martin S. (msperl)]

Hallo!

Ich versuche jetzt gerade eine andere als meine bisher verwendetet SD 
Karte anzusprechen und stoße auf das Problem das meine bisherige 
Initialisierungs-Routine sich an dieser (und auch einer Weiteren) 
verschluckt.

Und ich verstehe nicht ganz wieso...

Hier die init routine:

        uint8_t i,r;
        SET(MMC_CS);
        for(i=0;i<32;i++) { uspi_getc(); }
        _delay_us(1);
        RESET(MMC_CS);

        /* now go idle via CMD0 - GO IDLE_STATE */
        uint8_t c=0;
        while(mmc_cmd(CMD0,0,0,0,0)!=1) { 
                /* after 16 tries fall asleep and wait for reboot */
                if ((c++)>16) { mmc_error(); }
        }

        /* check SD card version via CMD8 */
        while(1) {
                /* try CMD8 - SEND_IF_COND */
                if (
                        mmc_cmd_crc7(CMD8,0x40,0,0x01,0xaa,0x15) 
                        == (4 | 1)
                        ) {
                        /* if it is BAD, then we are of type 1 */
                        mmc_type=1;
                        break;
                }
                /* otherwise read 4 byte */
                r=uspi_getc();
                uspi_getc();
                uspi_getc();
                if (uspi_getc() == 0xaa) {
                        mmc_type=2;
                        break;
                }
                if (r|0x40) { mmc_type|=IS_SDHC; }
        }

        /* send out SD Card type so far on "normal" SPI */
        /* and depending on the type send ACMD with different args */
        if ((mmc_type&0x0f)==2) {
                do {
                        /* for type 2 cards use ACMD41*/
                        r=mmc_acmd(ACMD41,0x40,0x00,0x00,0x00);
                } while (r);
        } else {
                do {
                        /* for type 1 cards use CMD1 */
                        r=mmc_cmd(CMD1,0x00,0x00,0x00,0x00);
                } while (r);
        }
        /* check for SDHC card */
        if ((mmc_type&0x0f)==2) {
                /* read OCR */
                if (mmc_cmd_crc7(CMD58,0,0,0,0,0x87)==0) {
                        /* of SDHC type */
                        if ((uspi_getc()&0xc0)!=0xc0) {
                                mmc_type|=IS_SDHC;
                        }
                        uspi_getc();
                        uspi_getc();
                        uspi_getc();
                }
        }

        /* pull CS high, as we have finished */
        SET(MMC_CS);

Das Problem ist die schleife:

                do {
                        /* for type 2 cards use ACMD41*/
                        r=mmc_acmd(ACMD41,0x40,0x00,0x00,0x00);
                } while (r);

bei der einen 2G-Karte die funktioniert, braucht es ca 0.25 sekunden bis 
endlich 0 zurück kommt. Die anderen beiden Karten (4G und 2G, aber schon 
recht alt) verbleiben für mehr als meine 8 Sekunden Watchdog timeout in 
der Schleife...

Am SPI bus kommt bei den beiden nicht-funktionierenden Karten folgendes 
in einer quasi-Endlos-Schleife:

0x77 -> 0xff
0x00 -> 0xff
0x00 -> 0xff
0x00 -> 0xff
0x00 -> 0xff
0x95 -> 0xff
0xff -> 0xff
0xff -> 0x01
;---------------------
0x69 -> 0xff
0x40 -> 0xff
0x00 -> 0xff
0x00 -> 0xff
0x00 -> 0xff
0x95 -> 0xff
0xff -> 0xff
0xff -> 0x01

Bei der funktionierenden kommt wie schon gesagt irgendwann statt 0x01 
dann 0x00 und es geht weiter mit CMD58...

Hat jemand eine Idee, was da falsch sein könnte?

Danke,
      Martin

P.s: vieleicht das noch:
* Funktionierend:
** Transcend micro - 2GB
* nicht funktionierend:
** Kingston micro - 2GB - 3-4 Jahre alt
** No-Name microHC 4GB

[Chris L. (kingkernel)]

Um dir helfen zu können brauchen wir den ganzen code + schaltplan!
hast du mal an die üblichen stolpersteine gedacht?
- im Init nicht mehr als 400kHz SPI-Frequenz
- Pullup an der MISO-Leitung

[Jim M. (turboj)]

mmc_cmd_crc7(CMD8,0x40,0,0x01,0xaa,0x15)

Das stimmt so nicht, das 0x40 setzt ein als "reserved" markiertes Bit, 
siehe Spezifikation auf sdcard.org. Da muss 0x00 rein, die Checksumme 
ist dann 0x87.

Dashalb funktionieren die neuren Karten alle nicht, die kennen das CMD8 
aber mögen das falsch gesetzte Bit nicht.

[Martin S. (msperl)]

Danke für die Hinweise!

Irgendwie lag die Versorgungsspannung Spannung auf der SD Karte unter 
den erwarteten 3.3V und das scheinen nicht alle Karten genau so gut zu 
verkraften...

Jetzt (bei 3.27V) funktionieren die 3 Karten korrekt...

Danke für die Tipps!

Allerdings habe ich jetzt mit einer 4ten Karte (frisch gekaufte SANDisk 
Ultra - 4GB, die hoffentlich schneller beim schreiben ist) jetzt das 
Problem, daß mir diese beim ACMD41 statt mit 0x01 oder 0x00 mit 0x05 
antwortet - Illegal Command bei einer 4GB Karte? (Um den Verdacht zu 
überprüfen, dass die Karte "gefälscht" ist, habe ich sie mit Dateien mit 
schon bekannter md5-prüfsumme auf das maximale Volumen gefüllt und 
nachher die Prüfsummen von den dateien auf der Karte ermitteln lassen - 
100% Übereinstimmung bei allen Dateien...)

Vielleicht finde ich da ja auch noch irgendwie eine Lösung - nur nicht 
mehr heute...

Martin

[Martin S. (msperl)]

P.s: im code ist CMD8 ist zurückgesetzt auf 
mmc_cmd_crc7(CMD8,0x00,0x00,0x01,0xaa,0x87) - habe ich irgendwann 
gesetzt, nachdem ich in einer doku dieses Bit als "host-SDHC" fähig 
gelesen habe. War ursprünglich auch mit 0x00...

[Martin S. (msperl)]

OK - was es bedurfte um die Karte aus dem 0x05 zu bekommen war zwischen 
CMD55 und CMD41 ein paar 0xff - in meinem Fall habe ich 4 gewählt - zu 
schicken...

Jetzt hapert es aber beim schreiben - Ultra sind anders...

[Martin S. (msperl)]

OK, was mich jetzt viel mehr wundert ist das diese ULTRA Karte mir die 
"akzeptiert" Antwort (0x05) auf meinen "Block write schon zu schicken 
scheint, wenn ich das erste Byte der "fake" CRC7 schicke (ob ich jetzt 
0x55,0xaa oder 0xff,0xff schicke ist egal)...

Das kommt mir erst bei dieser Karte vor - die anderen 3 Karten schicken 
0x05 es erst nach dem Ende der 2 CRC7 byte.

Hat das schon jemand gesehen?

Danke, Martin