Atmel SAM - USB iso Endpoint Funktionsweise

[Markus G. (usound)]

Hallo zusammen,

ich befasse mich gerade näher mit der USB-Implementierung auf einem 
Atmel SAM D21 uC. Die Lib aus dem ASF funktioniert problemlos. Mir fehlt 
es nur etwas am Verständnis der Funktionsweise. Konkret geht es um einen 
isochronen Transfer.
Im Beispiel wird ein simpler Loopback in Verbindung mit einer 
Testsoftware auf dem PC implementiert. Hier mal ein Code-Ausschnitt der 
hauptsächlich wichtigen Funktionen:

bool udi_vendor_iso_out_run(uint8_t * buf, iram_size_t buf_size,
    udd_callback_trans_t callback)
{
  return udd_ep_run(UDI_VENDOR_EP_ISO_OUT,
      false,
      buf,
      buf_size,
      callback);
}

void main_vendor_iso_out_received(udd_ep_status_t status,
    iram_size_t nb_transfered, udd_ep_id_t ep)
{
  uint8_t *buf_ptr;
  UNUSED(ep);

  if (UDD_EP_TRANSFER_OK != status) {
    return; // Transfer aborted, then stop loopback
  }

  if (nb_transfered) {
    ui_loop_back_state(true);
    // Send on IN endpoint the data received on endpoint OUT
    buf_ptr = &main_buf_loopback[ main_buf_iso_sel
        *(sizeof(main_buf_loopback)/2) ];
    udi_vendor_iso_in_run(
        buf_ptr,
        nb_transfered,
        main_vendor_iso_in_received);
  }

  // Switch of buffer
  main_buf_iso_sel = main_buf_iso_sel? 0:1;

  buf_ptr = &main_buf_loopback[ main_buf_iso_sel
      *(sizeof(main_buf_loopback)/2) ];

  // Send on IN endpoint the data received on endpoint OUT
  udi_vendor_iso_out_run(
      buf_ptr,
      udd_is_high_speed()?
      UDI_VENDOR_EPS_SIZE_ISO_FS,
      main_vendor_iso_out_received);
}

Es wird also zunächst die Funktion aufgerufen, um den Endpoint zu 
bedienen (Daten empfangen)
--> "udd_ep_run".
Wenn die Daten empfangen wurden, wird eine Callback-Funktion aufgerufen
--> "main_vendor_iso_out_received"
In der Callback-Funktion wird wieder die ursprüngliche Funktion 
udd_ep_run aufgerufen.
Da das nun ja beliebig lange so weiterlaufen würde und sich im Grunde 
unendlich rekursiv selbst aufruft, müsste doch irgendwann der Stack 
überlaufen, wenn nicht irgendwann wieder zurückgesprungen wird?

Ich habe diverse Tests durchgeführt. Das scheint so aber zu laufen.

Rein von der Logik hatte ich eigentlich folgenden Ansatz:
- nach erfolgreicher Beendigung der USB-Enumeration bekomme ich bei 
jedem erkannten Start-of-Frame (SOF) einen Interrupt
- theoretisch müsste ich nun einfach hergehen und in jedem SOF-Interrupt 
1x udd_ep_run aufrufen, um die Daten im zugehörigen Frame zu 
transferieren.

Somit wäre die Funktion sauber terminiert bzw es wird wieder 
zurückgesprungen.
Ich habe nun diverse Tests gemacht. Es scheint, dass dabei Daten 
verloren gehen.
In der Programmierung rund um die USB-Schnittstelle bin ich noch recht 
neu, deshalb die Frage, ob mir da jemand etwas auf die Sprünge helfen 
kann.

Beste Grüße,
Markus

[Jim M. (turboj)]

Markus G. schrieb:
> Da das nun ja beliebig lange so weiterlaufen würde und sich im Grunde
> unendlich rekursiv selbst aufruft, müsste doch irgendwann der Stack
> überlaufen, wenn nicht irgendwann wieder zurückgesprungen wird?

Es wird zurück gesprungen - der callback wird nämlich erst vom USB 
Interrupt Handler aufgerufen.

Lass Dir mal im Callback den Stack Trace komplett bis zum Usrsprung 
anzeigen - das sollte im USB Interrupt landen.

[Markus G. (usound)]

Jim M. schrieb:
> Es wird zurück gesprungen - der callback wird nämlich erst vom USB
> Interrupt Handler aufgerufen.
>
> Lass Dir mal im Callback den Stack Trace komplett bis zum Usrsprung
> anzeigen - das sollte im USB Interrupt landen.

Danke für den Hinweis!
Habe den Call-Stack geprüft (auf die Idee bin ich warum auch immer noch 
nicht selbst gekommen) und das von dir geschilderte Verhalten 
entsprechend verifizieren können.
Der Callback wird vom USB Interrupt Handler aufgerufen.

Das heißt, im Grunde funktioniert das Ganze so:
udd_ep_run wird aufgerufen, das sagt dem USB-Modul eigentlich nur, dass 
zum nächst möglichen Zeitpunkt Daten empfangen werden sollen und die 
zugehörigen Register werden entsprechend gesetzt. Der Callback wird dann 
praktisch "hinterlegt". Die Funktion udd_ep_run wird dann beendet. Ist 
nun die Datenübertragung abgeschlossen, ruft der USB-Handler den 
Callback auf. Dann wird die nächste Übertragung vorbereitet.