AXI DMA Loopback - Wohin schreibt MM2S?

[Alex441 (Gast)]

Hallo MC,

angenommen, wir haben folgende Architektur:

             +-----------+
     AXI LITE|           |  AXI LITE
     +-------+   PS      +------+
     |       |           |      |
     |       +-----------+      |
     |                          |
     |                          |
     v                          v
+----+------+             +-----+-----+              +------------+
|           |    MM2S     |           |     MM2S     |            |
| DDR Mem   +------------>+  AXI DMA  +------------->+    FIFO    |
| Controller|             |  Engine   |              |            |
|           |   S2MM      |           |     S2MM     |            |
|           +<------------+           +<-------------+            |
+-----------+             +-----------+              +------------+

Hier kann ich nun die AXI DMA Engine dazu veranlassen, aus dem 
DDR-Speicher Daten zu lesen und über MM2S in die FIFO zu schreiben. Dort 
liegen die Daten dann.

Irgendwann später kann ich die AXI DMA Engine dazu veranlassen, über 
S2MM die Daten aus der FIFO zu lesen und in den DDR-Speicher zu 
schreiben.

Es sind sozusagen zwei unabhängige Vorgänge.

DAS PROBLEM:

Angenommen, wir lassen die FIFO wegfallen, also Loopback:

             +-----------+
     AXI LITE|           |  AXI LITE
     +-------+   PS      +------+
     |       |           |      |
     |       +-----------+      |
     |                          |
     |                          |
     v                          v
+----+------+             +-----+-----+
|           |    MM2S     |           |     MM2S
| DDR Mem   +------------>+  AXI DMA  +--------------|
| Controller|             |  Engine   |              |
|           |   S2MM      |           |     S2MM     |
|           +<------------+           +<-------------|
+-----------+             +-----------+

1) Die FIFO ist weg. Wenn ich jetzt aus dem DDR-Speicher über MM2S einen 
Sendevorgang veranlasse, wohin werden die Daten dann geschrieben? Es 
gibt ohne FIFO keinen Zielbuffer.

2) Ist es eventuell so, dass in diesem Fall ein Sendevorgang OHNE 
GLEICHZEITIGEN Empfangsvorgang über S2MM gar keinen Sinn macht, weil die 
Daten sonst nirgends hingeschrieben werden können?

Der S2MM-Port der DMA Engine muss sozusagen über "TREADY" seine 
Bereitschaft erklären, die Daten zu empfangen, ansonsten wird der 
Sendevorgang sogar garnicht ausgelöst?

Verstehe ich das richtig?

[Samuel C. (neoexacun)]

Ich würde davon ausgehen, dass der DMA sowohl ausgangs- als auch 
eingangsseitig über kleinere Buffer verfügt. Schon alleine um 
ordentliche Bursts auf dem Speicher ausführen zu können.

Daher denke ich, dass der Loopback ebenfalls funktionieren sollte. Das 
Datenblatt macht dazu bestimmt hilfreiche Aussagen.

Auch hier stellt sich jedoch die Frage, weshalb man das tun sollte.

[Klakx (Gast)]

sicherlich wird das gehen.
Wie schon in der Antwort zuvor gesagt, sind da Register-Slices und 
wahrscheinlich ist sogar auch ein Mini-FIFO drin. Laut AXI-Stream sollte 
eine Senke auch immer befähigt sein mind. ein Datum entgegenzunehmen 
(d.h. tready=1 ohne anliegendes tvalid).

Ansonsten geht bei Bedarf automatisch einfach das tready runter und 
verursacht einen Backpressure zur DMA. Langsam, aber funktional :)

[Alex441 (Gast)]

Samuel C. schrieb:
> Ich würde davon ausgehen, dass der DMA sowohl ausgangs- als auch
> eingangsseitig über kleinere Buffer verfügt. Schon alleine um
> ordentliche Bursts auf dem Speicher ausführen zu können.
>
> Daher denke ich, dass der Loopback ebenfalls funktionieren sollte. Das
> Datenblatt macht dazu bestimmt hilfreiche Aussagen.

Okay, dann ginge es. Was passiert aber, wenn die internen Buffer 
deutlich kleiner sind als die Gesamtmenge der Daten, die gesendet werden 
soll.

Samuel C. schrieb:
> Auch hier stellt sich jedoch die Frage, weshalb man das tun sollte.

Was mich so verwirrt, ist der C-Code, denn ich dazu teilweise gelesen 
habe. Hier ist ein runterladbares Beispiel für DMA aus Linux heraus:

https://xilinx-wiki.atlassian.net/wiki/spaces/A/pages/18842418/Linux+DMA+From+User+Space

In Pseudocode sieht der so aus:

start_DMA_tx(&source_buffer[0])
start_DMA_rx(&dest_buffer[0])

Es wird also ERST der Sendevorgang initiert, und DANN der 
Empfangsvorgang. Wohin soll aber der Sender schreiben, wenn beim 
Loopback der Empfänger erst danach aufgerufen wird?

Ich kann mir das nur so erklären, dass bei Loopback der Sendevorgang 
erst gestartet wird, wenn der Empfänger Empfangsbereitschaft 
signalisiert.

[Alex441 (Gast)]

Klakx schrieb:
> Ansonsten geht bei Bedarf automatisch einfach das tready runter und
> verursacht einen Backpressure zur DMA. Langsam, aber funktional :)

Okay, das macht auch Sinn. Ein Teil, wenn auch nur ein sehr kleiner, 
wird gestreamt, der Rest bleibt stecken bis der Empfänger seine 
Schleusen öffnet.

[S. R. (svenska)]

Alex441 schrieb:
> Was passiert aber, wenn die internen Buffer deutlich kleiner
> sind als die Gesamtmenge der Daten, die gesendet werden soll.

Was passiert, wenn das Zielsystem (alte Festplatte) langsamer ist als 
das Quellsystem (DMA-Engine aus dem RAM)? Die Daten werden gebremst.

Die Gesamtmenge der Daten spielt keine Rolle, sondern nur die Größe 
eines einzelnen Datums (z.B. 32 Bit). Die einzelnen Teilnehmer haben 
eingangsseitig mindestens ein Flipflop (können also ein Datum 
verlustfrei annehmen) und der Rest stallt.

[Duke Scarring (Gast)]

Alex441 schrieb:
> In Pseudocode sieht der so aus:
> start_DMA_tx(&source_buffer[0])
> start_DMA_rx(&dest_buffer[0])
>
> Es wird also ERST der Sendevorgang initiert, und DANN der
> Empfangsvorgang.
Ja.

> Wohin soll aber der Sender schreiben, wenn beim
> Loopback der Empfänger erst danach aufgerufen wird?
In der DMA-Engine sind kleine FIFOs verbaut, schon weil die Datenbreiten 
i.d.R. unterschiedlich sind.

Man kann die Wege auch unabhängig voneinander nutzen, z.B. um Daten zu 
einem DAC zu schicken, oder welche von einem ADC einzusammeln. Über 
TREADY bzw. TVALID lässt sich der jeweilige Datenfluss steuern.