FatFS check_fs ergibt immer FR_NO_FILESYSTEM

[Patrick B. (p51d)]

Hallo zusammen

Ich bin langsam aber sicher am verzweifeln... Mein aktuelles Projekt 
sollte mal mit SD-Karten zu tun haben.
Die viel gerühmte FatFS (0.13b) habe ich nun auf meinem STM32F091 mit 
Atollic Truestudio und J-Link aufgesetzt und Chans Beispiel angepasst.

Nur leider stolpere ich immer wieder über den gleichen Fehler: Sobald 
check_fs aufgerufen wird (ob das forciert über f_mount oder nachträglich 
bei f_open ist, spielt keine Rolle), erhalte ich NACH dem erfolgreichen 
lesen des MBR einen FR_NO_FILESYTEM Fehler beim suchen der Partitionen 
(Offset wird als 8192 identifiziert).
Da scheitert es immer an der move_window Funktion...

Zur Kontrolle habe ich nun alles mögliche ausprobiert:
-Die micro SD Karte HC  class 10 mit 4GB in allen Varianten am PC 
formatiert...
-Den MBR über winHex analysiert und mit dem SPI-Buffer verglichen sowie 
den Logic-Analyzer angeschlossen.

Nun wirds richtig schräg: Der MBR sieht auf dem PC komplett anders aus. 
SPI-Buffer und Bus-Aktionen stimmen überein.

Die Funktionen disk_initialize und disk_read geben immer ein OK zurück. 
Also grundsätzlich funktioniert alles.
Dass das SPI auch läuft ist gemäss Logic Analyzer auch ersichtlich.
Initialisierungsfrequenz ist <400kHz und später wird mit 12,5MHz 
getacktet.

Hat da jemand einen Tipp?

///////////////////////////////////////////////////////////////////////////
/// Initialize MMC interface
///////////////////////////////////////////////////////////////////////////
static void init_spi(void)
{
  GPIO_InitTypeDef oGpioStruct;
  RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOB, ENABLE);

  // Card Detect Pin
  oGpioStruct.GPIO_Pin = GPIO_Pin_0;
  oGpioStruct.GPIO_Mode = GPIO_Mode_IN;
  oGpioStruct.GPIO_Speed = GPIO_Speed_2MHz;
  oGpioStruct.GPIO_OType = GPIO_OType_PP;
  oGpioStruct.GPIO_PuPd = GPIO_PuPd_UP;
  GPIO_Init(GPIOB, &oGpioStruct);

  // Chip Select
  oGpioStruct.GPIO_Pin = GPIO_Pin_12;
  oGpioStruct.GPIO_Mode = GPIO_Mode_OUT;
  oGpioStruct.GPIO_Speed = GPIO_Speed_50MHz;
  oGpioStruct.GPIO_OType = GPIO_OType_PP;
  oGpioStruct.GPIO_PuPd = GPIO_PuPd_UP;
  GPIO_Init(GPIOB, &oGpioStruct);

  // SPI
  oGpioStruct.GPIO_Pin = GPIO_Pin_13 | GPIO_Pin_14 | GPIO_Pin_15;
  oGpioStruct.GPIO_Mode = GPIO_Mode_AF;
  oGpioStruct.GPIO_Speed = GPIO_Speed_50MHz;
  oGpioStruct.GPIO_OType = GPIO_OType_PP;
  oGpioStruct.GPIO_PuPd = GPIO_PuPd_UP;
  GPIO_Init(GPIOB, &oGpioStruct);
  GPIO_PinAFConfig(GPIOB, GPIO_PinSource13, GPIO_AF_0);
  GPIO_PinAFConfig(GPIOB, GPIO_PinSource14, GPIO_AF_0);
  GPIO_PinAFConfig(GPIOB, GPIO_PinSource15, GPIO_AF_0);


  SPI_InitTypeDef  SPI_InitStructure;
  RCC_APB1PeriphClockCmd(RCC_APB1Periph_SPI2, ENABLE);
  SPI_I2S_DeInit(SPI2);
  SPI_StructInit(&SPI_InitStructure);
  SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
  SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;
  SPI_InitStructure.SPI_CPOL = SPI_CPOL_Low;
  SPI_InitStructure.SPI_CPHA = SPI_CPHA_1Edge;
  SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;
  SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_128;
  SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
  SPI_InitStructure.SPI_CRCPolynomial = 7;
  SPI_InitStructure.SPI_Mode = SPI_Mode_Master;
  SPI_Init(SPI2, &SPI_InitStructure);
  SPI_RxFIFOThresholdConfig(SPI2, SPI_RxFIFOThreshold_QF); // Set RXNE Flag at 8-Bit
  SPI_Cmd(SPI2, ENABLE);
  
  CS_HIGH();      // Set CS# high

  for(m__u32Timer1 = 10; m__u32Timer1; );  // Wait for 10ms
}


///////////////////////////////////////////////////////////////////////////
/// Exchange a byte 
///
/// \param dat  Data to send
///////////////////////////////////////////////////////////////////////////
inline static BYTE xchg_spi(BYTE dat)
{
  const uint32_t spixbase = (uint32_t)SPI2 + 0x0C;
  while ((SPI2->SR & SPI_I2S_FLAG_TXE) == 0);
  *(__IO uint8_t *) spixbase = dat;
  while ((SPI2->SR & SPI_I2S_FLAG_RXNE) == 0);    // Wait for end of the transaction
  return (*(__IO uint8_t *) spixbase);        // Return received byte
}


///////////////////////////////////////////////////////////////////////////
/// Receive multiple byte
///
/// \param buff    Pointer to data buffer
/// \param btr    Number of bytes to receive (even number)
///////////////////////////////////////////////////////////////////////////
static void rcvr_spi_multi(BYTE *buff, UINT btr)
{
  do
  {
    *buff++ = xchg_spi(0xFF);
    *buff++ = xchg_spi(0xFF);
  }
  while(btr -= 2);
}


///////////////////////////////////////////////////////////////////////////
/// Send multiple byte 
///
/// \param buff    Pointer to the data
/// \param btx    Number of bytes to send (even number)
///////////////////////////////////////////////////////////////////////////
#if _USE_WRITE
static void xmit_spi_multi(const BYTE *buff, UINT btx)
{
  do
  {
    (void)xchg_spi(*buff++);
    (void)xchg_spi(*buff++);
  }
  while(btx -= 2);
}
#endif

Gruss
Patrick

[Küsel (Gast)]

Es sieht so aus, dass einmal der MBR und einmal der VBR  gelesen wird.

Wie sehen die Routinen zum Mounten der SD-Card aus?

Tipp: Für das Formatieren nehme ich den "SD-Card Formatter".

https://www.sdcard.org/downloads/formatter_4/

[Jim M. (turboj)]

Patrick B. schrieb:
> Nun wirds richtig schräg: Der MBR sieht auf dem PC komplett anders aus.
> SPI-Buffer und Bus-Aktionen stimmen überein.

Nö, sieht er nicht. Er ist nur unter Windoof verdammt kompliziert 
einzulesen: Nur als Admin und nur vom physischen Device und nicht vom 
Laufwerksbuchstaben!

Was für Dich wie der 0. Sektor aussieht ist in Wirklichkeit der 1. 
Sektor der Partition.

Schau mal nach ob FatFS den PartitionsTypeCode 0x0C korrekt versteht. 
Die LBA Einträge sehen für eine 8GB Karte gesund aus.

Wieso greifst Du in xchg_spi() nicht direkt aus SPI2->DR zu? Die ganzen 
Pointer casts machen mir Kopfweh.

[M.K. B. (mkbit)]

Versuch doch mal disk_initialize und disk_read direkt zu verwenden, um 
einzelne Sektoren zu lesen. Wenn das funktioniert, dann müsstest du ja 
die Daten aus deinem Windows Dump wiederfinden.

Nur weil disk_read ein OK zurückgibt, heißt das ja nicht, dass es auch 
das richtige gelesen hat. Vielleicht kannst du in disk_read dann mal mit 
dem Debugger reinschauen, ob man da was sieht. Ansonsten wäre noch zu 
prüfen, ob die Befehle für die Karte korrekt sind.

[Patrick B. (p51d)]

Jim M. schrieb:
> Wieso greifst Du in xchg_spi() nicht direkt aus SPI2->DR zu? Die ganzen
> Pointer casts machen mir Kopfweh.

8-Bit zugriff auf ein 16Bit Register, und da ich nur 8 Bit senden möchte 
muss ich den Umweg gehen.

M.K. B. schrieb:
> ersuch doch mal disk_initialize und disk_read direkt zu verwenden, um
> einzelne Sektoren zu lesen. Wenn das funktioniert, dann müsstest du ja
> die Daten aus deinem Windows Dump wiederfinden.

Habe ich auch gemacht. Das Resultat sd_mbr_over_spi ist über disk_read 
gelesen.


Küsel schrieb:
> Es sieht so aus, dass einmal der MBR und einmal der VBR  gelesen wird.

Ich vermute nun stark, dass du recht hast.

Ich konnte die Karte in Zwischenzeit mounten und sogar schreiben/lesen.. 
juhu!

Aber erst, nachdem ich diese auf einem Win10 Gerät neu formatiert habe.
Dann habe ich die transmitt und receive multi-Byte Funktionen 
umgeschrieben, das sie die xmit_byte 2 mahl aufrufen. Im Beispiel ist 
sowieso etwas komisch. Das kann von mir aus gesehen nicht richtig 
funktionieren, da die Anzahl Bytes nicht stimmt.

Direkt aus der Sample-Datei von Chan (mmc_stm32f1_spi.c), ohne 
Änderungen

void rcvr_spi_multi (
  BYTE *buff,    /* Pointer to data buffer */
  UINT btr    /* Number of bytes to receive (even number) */
)
{
  WORD d;


  SPIx_CR1 &= ~_BV(6);
  SPIx_CR1 |= (_BV(6) | _BV(11));  /* Put SPI into 16-bit mode */

  SPIx_DR = 0xFFFF;    /* Start the first SPI transaction */
  btr -= 2;
  do {          /* Receive the data block into buffer */
    while ((SPIx_SR & 0x83) != 0x03) ;  /* Wait for end of the SPI transaction */
    d = SPIx_DR;            /* Get received word */
    SPIx_DR = 0xFFFF;          /* Start next transaction */
    buff[1] = d; buff[0] = d >> 8;     /* Store received data */
    buff += 2;
  } while (btr -= 2);
  while ((SPIx_SR & 0x83) != 0x03) ;    /* Wait for end of the SPI transaction */
  d = SPIx_DR;              /* Get last word received */
  buff[1] = d; buff[0] = d >> 8;      /* Store it */

  SPIx_CR1 &= ~(_BV(6) | _BV(11));  /* Put SPI into 8-bit mode */
  SPIx_CR1 |= _BV(6);
}

Ich habe den Code nun etwas genauer angeschaut und analysiert:
wenn hier btr=2 ist und buf 2 gross (also 2 Byte empfangen), wird das 
Datenregister 2 mal mit 16 Bit gelesen und in den Buffer geschrieben. 
Somit würde im schlimmsten Fall nicht nur falsche Daten eingelesen, 
sondern auch gleich unbekannter Speicher überschrieben!
Das Lesen nach der do-while Schlaufe ist zu viel. Oder sehe ich das 
falsch?

Kombiniert mit rcrv_datablock kann man nichtmal sagen, dass die CRC 
nebenbei noch eingelesen wird, da dies noch nachträglich "manuell" 
gemacht wird.

int rcvr_datablock (  /* 1:OK, 0:Error */
  BYTE *buff,      /* Data buffer */
  UINT btr      /* Data block length (byte) */
)
{
  BYTE token;


  Timer1 = 200;
  do {              /* Wait for DataStart token in timeout of 200ms */
    token = xchg_spi(0xFF);
    /* This loop will take a time. Insert rot_rdq() here for multitask envilonment. */
  } while ((token == 0xFF) && Timer1);
  if(token != 0xFE) return 0;    /* Function fails if invalid DataStart token or timeout */

  rcvr_spi_multi(buff, btr);    /* Store trailing data to the buffer */
  xchg_spi(0xFF); xchg_spi(0xFF);      /* Discard CRC */

  return 1;            /* Function succeeded */
}

Ich werde da wohl wieder ein paar Schritte zurückgehen und schauen, was 
wo genau den Fehler verursacht.