Macht ein FAT Filesystem mit DMA überhaupt Sinn ohne RTOS

[Thomas B. (escamoteur)]

Hallo,

ich bin gerade dabei Elm Chans FAT Filesystem für eine SD-Karte in einem 
neuen Projekt einzubinden.
Es gibt ja einige Beispielportierungen, die für das Lesen der Blöcke SPI 
mit DMA verwenden.

DMA hört sich ja erst mal gut an, der µC kann in der Zwischenzeit sich 
um andere Sachen kümmern. ABER in den Beispielen habe ich nur gesehen, 
dass nach Starten des DMAs auf dessen Ende gepollt wird. Wo ist da der 
Gewinn?

Wenn ich ein RTOS mit mehreren Threads habe, dann könnte der µC ja 
wirklich andere Dinge machen bis der DMA fertig ist. Aber ohne RTOS läßt 
sich ein Kontextswitch nicht so einfah in die FAT-Funktionen 
integrieren.

Daher die Frage: Macht DMA hier überhaupt Sinn? Das einzige was ich mir 
vorstellen könnte, dass mit DMA eine bereits gestartete Übertragung 
nicht durch auftretende IRQs unterbrochen/verzögert wird. Wobei sich die 
Frage ergibt, ob die DMA durch IRQs beeinflusst wird.

Wie seht Ihr das?

Gruß
Thomas

[Timmo H. (masterfx)]

Wieso pollen? Es gibt doch auch "DMA Transfer Complete"-Interrupts. Wenn 
dieser eintritt kann man irgendein Flag setzen und "irgendwann" mal 
danach schauen wenn man gerade Zeit hat, oder direkt den nächsten 
Transfer starten. Wobei man im Gewissen Sinne natürlich dann auf das 
"Flag" pollen würde. Aber das lässt sich ja implementieren wie man will 
(zumindest wenn man nicht an ein OS gebunden ist)

[Μαtthias W. (matthias)]

Hi

Oft ist ein DMA schneller als ein Transfer über die CPU.

Matthias

[Thomas B. (escamoteur)]

@Timmo:

Schon klar. Aber leider wird die entsprechende Funktion nicht direkt vo 
meinem Programm sondern in den tiefen der FAT Bibliothek aufgerufen 
wird, hab ich keine Idee was mir da der IRQ helfen soll.

static
void stm32_dma_transfer(
  BOOL receive,    /* FALSE for buff->SPI, TRUE for SPI->buff               */
  const BYTE *buff,  /* receive TRUE  : 512 byte data block to be transmitted
               receive FALSE : Data buffer to store received data    */
  UINT btr       /* receive TRUE  : Byte count (must be multiple of 2)
               receive FALSE : Byte count (must be 512)              */
)
{
  DMA_InitTypeDef DMA_InitStructure;
  WORD rw_workbyte[] = { 0xffff };

  /* shared DMA configuration values */
  DMA_InitStructure.DMA_PeripheralBaseAddr = (DWORD)(&(SPI_SD->DR));
  DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
  DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;
  DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
  DMA_InitStructure.DMA_BufferSize = btr;
  DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;
  DMA_InitStructure.DMA_Priority = DMA_Priority_VeryHigh;
  DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;

  DMA_DeInit(DMA_Channel_SPI_SD_RX);
  DMA_DeInit(DMA_Channel_SPI_SD_TX);

  if ( receive ) {

    /* DMA1 channel2 configuration SPI1 RX ---------------------------------------------*/
    /* DMA1 channel4 configuration SPI2 RX ---------------------------------------------*/
    DMA_InitStructure.DMA_MemoryBaseAddr = (DWORD)buff;
    DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;
    DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
    DMA_Init(DMA_Channel_SPI_SD_RX, &DMA_InitStructure);

    /* DMA1 channel3 configuration SPI1 TX ---------------------------------------------*/
    /* DMA1 channel5 configuration SPI2 TX ---------------------------------------------*/
    DMA_InitStructure.DMA_MemoryBaseAddr = (DWORD)rw_workbyte;
    DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralDST;
    DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Disable;
    DMA_Init(DMA_Channel_SPI_SD_TX, &DMA_InitStructure);

  } else {

#if _FS_READONLY == 0
    /* DMA1 channel2 configuration SPI1 RX ---------------------------------------------*/
    /* DMA1 channel4 configuration SPI2 RX ---------------------------------------------*/
    DMA_InitStructure.DMA_MemoryBaseAddr = (DWORD)rw_workbyte;
    DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;
    DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Disable;
    DMA_Init(DMA_Channel_SPI_SD_RX, &DMA_InitStructure);

    /* DMA1 channel3 configuration SPI1 TX ---------------------------------------------*/
    /* DMA1 channel5 configuration SPI2 TX ---------------------------------------------*/
    DMA_InitStructure.DMA_MemoryBaseAddr = (DWORD)buff;
    DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralDST;
    DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
    DMA_Init(DMA_Channel_SPI_SD_TX, &DMA_InitStructure);
#endif

  }

  /* Enable DMA RX Channel */
  DMA_Cmd(DMA_Channel_SPI_SD_RX, ENABLE);
  /* Enable DMA TX Channel */
  DMA_Cmd(DMA_Channel_SPI_SD_TX, ENABLE);

  /* Enable SPI TX/RX request */
  SPI_I2S_DMACmd(SPI_SD, SPI_I2S_DMAReq_Rx | SPI_I2S_DMAReq_Tx, ENABLE);

  /* Wait until DMA1_Channel 3 Transfer Complete */
  /// not needed: while (DMA_GetFlagStatus(DMA_FLAG_SPI_SD_TC_TX) == RESET) { ; }
  /* Wait until DMA1_Channel 2 Receive Complete */
  while (DMA_GetFlagStatus(DMA_FLAG_SPI_SD_TC_RX) == RESET) { ; }
  // same w/o function-call:
  // while ( ( ( DMA1->ISR ) & DMA_FLAG_SPI_SD_TC_RX ) == RESET ) { ; }

  /* Disable DMA RX Channel */
  DMA_Cmd(DMA_Channel_SPI_SD_RX, DISABLE);
  /* Disable DMA TX Channel */
  DMA_Cmd(DMA_Channel_SPI_SD_TX, DISABLE);

  /* Disable SPI RX/TX request */
  SPI_I2S_DMACmd(SPI_SD, SPI_I2S_DMAReq_Rx | SPI_I2S_DMAReq_Tx, DISABLE);
}

wird hier aufgerufen

static
BOOL rcvr_datablock (
  BYTE *buff,      /* Data buffer to store received data */
  UINT btr      /* Byte count (must be multiple of 4) */
)
{
  BYTE token;


  Timer1 = 10;
  do {              /* Wait for data packet in timeout of 100ms */
    token = rcvr_spi();
  } while ((token == 0xFF) && Timer1);
  if(token != 0xFE) return FALSE;  /* If not valid data token, return with error */

#ifdef STM32_SD_USE_DMA
  stm32_dma_transfer( TRUE, buff, btr );
#else
  do {              /* Receive the data block into buffer */
    rcvr_spi_m(buff++);
    rcvr_spi_m(buff++);
    rcvr_spi_m(buff++);
    rcvr_spi_m(buff++);
  } while (btr -= 4);
#endif /* STM32_SD_USE_DMA */

  rcvr_spi();            /* Discard CRC */
  rcvr_spi();

  return TRUE;          /* Return with success */
}

[W.S. (Gast)]

Thomas Burkhart schrieb:
> Wo ist da der Gewinn?

Ich hab mit diese Frage auch schon mal gestellt und bin zu dem Schluß 
gekommen, daß es mit der DMA nur dann einen Sinn macht, wenn der 
restliche Controller zwecks Stromsparen deftig heruntergetaktet wird und 
dann mit der Übertragungsrate der SDIO Schnittstelle nicht mehr 
mithalten kann oder wenn man mit nem externen Speicher arbeitet, wo auch 
noch der Bildschirm-Refresh drüberläuft und man während der 
Blockübertragung die CPU stoppt, damit die Bandbreite des Busses nicht 
zum Flaschenhals wird oder wenn du heftigen Interruptverkehr hast, der 
für das Grundprogramm nur noch 20% Cpu-Zeit oder weniger übrig läßt.

Aber für gewöhnliche Anwendungen, wo die jetzt üblichen uC mit 72 MHz 
oder mehr laufen, ist simples Polling genauso gut wie DMA, bloß 
einfacher und mit weniger Overhead. Immerhin kann man bei den STM's mit 
32 Bit pollen, das ist schnell genug für Byteraten von 13 MHz. Für ein 
Filesystem wie ChaN's oder EFSL mußt du ja sowieso auf das Ende der 
Übertragung warten.

W.S.

[holger (Gast)]

>Aber für gewöhnliche Anwendungen, wo die jetzt üblichen uC mit 72 MHz
>oder mehr laufen, ist simples Polling genauso gut wie DMA, bloß
>einfacher und mit weniger Overhead.

Dem würde ich jetzt so pauschal nicht zustimmen.
Wenn die CPU mit vielen Interrupts beschäftigt ist
ist DMA auf jeden Fall besser als Polling.

>Immerhin kann man bei den STM's mit
>32 Bit pollen, das ist schnell genug für Byteraten von 13 MHz.

Das hab ich jetzt nicht verstanden.

>Für ein Filesystem wie ChaN's oder EFSL mußt du ja sowieso
>auf das Ende der Übertragung warten.

Bei einem UART musst du auch warten bis mal wieder
Platz ist um zu senden. Die Frage ist nur wie man
das am besten in die Programmstruktur einbindet.
Ein RTOS bietet da durchaus Lösungen an. Task für eine
bestimmte Zeit schlafen legen und das DMA arbeiten lassen.
Den Rest der Rechenzeit kann man dann für andere Arbeiten
nutzen. Wenn nix zu tun ist musst du aber trotzdem auf das Ende
des DMA Transfers warten bevor du neue Daten senden kannst.

[TTL (Gast)]

Einfach mal mit dem Scope auf den SPI schauen! Du erhältst mit DMA einen 
lückenlosen Transfer. Ohne DMA musst du ja die Datenbytes immer 
nachladen. DMA bringt bei 19MHz Bustakt ca. 30% mehr Geschwindigkeit

[Albert B. (Gast)]

Hallo zusammen,

DMA macht natürlich bei der Verwendung eines Schedulers als Teil des 
Betriebssystems (in solch einem Fall) IMMER Sinn. Denn 
CPU-Unterbrechungen durch DMA-Zugriffe können für andere 
Tasks/Prozesse/... verwendet werden.

Aber: Bei solch einer Frage darf auf keinen Fall die hardwaremäßige 
Architekturfrage vergessen werden. Multi-Master Architekturen, wie es 
solche mit DMA-Zugriffen vermutlich sind, vermindern Buszugriffszeiten 
enorm.

Ihr wisst bestimmt was ich meine:
Sind viele Teilnehmer an einem Bus, so müssen ohne DMA die Daten 
zunächst vom SRAM an die CPU - und von dort aus an andere Medien 
verteilt werden.
Ohne CPU-interaction kann die Zugriffszeit deutlich verringert werden. 
Daten werden vom SRAM direkt an den DMA-Controller übertragen (ohne 
CPU)...
Dies ist die ursprüngliche Idee hinter DMA-Zugriffen.


Beste Grüße
Albert B.