Daten empfangen und senden mit DMA

[Amal N. (Firma: fraunhofer) (amal2010)]

Hallo,

ich bin dabei eine USB device Funktionalität am Beispiel des LPC3250 
microcontroller zuerstellen. Mein Usb Device muss Daten empfangen (auf 
bulk endpunkt 4)und senden (von bulk endpunkt 5)können.

Die Datenübertragung vom endpunkt4 zum USB RAM (beim Empfangen) und vom 
USB RAM zum Endpunkt5 (beim senden) macht mir die DMA . was die Software 
machen soll ist zwei buffer in USB RAM anzulegen: ein Dma_Receive_buffer 
(zum Empfangen) und einen Dma_Transmit_buffer (zum empfangen). Dann 
müssen noch die DMA Descriptoren (DD) initialisiert werden. diese DD 
werden von DMA gelesen bevor sie mit dem Transfer anfängt.

Mein ziel ist der Dma_Receive_buffer in 64 byte buffers zuzerlegen. wenn 
die DMA daten in diesem buffer schreiben will, liest sie den ersten 
descriptor, dieser descriptor beschreibt wie die Datenübertragung für 
die ersten 64 byte aussehen soll( die Adresse wo die Daten geschrieben 
werden sollen und wie viel max da geschrieben werden können (64 
byte)...) dann schreibt sie Daten im ersten Stück vom buffer. und 
schreibt sie neue status im descriptor. Danach liest sie den nächsten 
descriptor und schreibt wieder im 2. Stück vom buffer unsoweiter.

fgolgendes ist das Stückprogramm was ich geschrieben habe. Damit 
Schreibt die DMA die ersten 64 byte im ersten 64 byte größ stückbuffer. 
Aber dann schreibt nix mehr. Ich gehe davon aus dass die DMA den zweiten 
Dekriptor von EP4 nicht lesen kann. Was ich da falsch mache ? keien 
Ahnung

Ich würde mich sehr freuen, wenn jemanden von euch mir helfen kann.

// USB DMA Descriptor

typedef struct _attribute_ ((packed)) USB_DMA_DESCRIPTOR {
  int   next_dd_addr ;                // next DD address
  short max_packet_size;              // the maximum packet size of
                                      // the endpoint
  short dma_buffer_length;            // the depth of the DMA buffer
                                      //allocated for transferring the 
data
  int   dma_buffer_addr;              // the address from where the
                                      //data has to be picked up or
                                       //to be stored
  int   status;                        // the status of the DMA transfer
  } USB_DMA_DESCRIPTOR;


 int DmaReceivebuffer [DD_BUFFER_LEN /4 ] ; // receivebuffer for 
endpoint 4
 int DmaTransmitbuffer [DD_BUFFER_LEN /4 ]; //transmitbuffer for 
endpoint 5

 USB_DMA_DESCRIPTOR *DmaUdcaList[USB_EP_NUM] ;
 USB_DMA_DESCRIPTOR DDListEp4[DD_COUNT]
 USB_DMA_DESCRIPTOR DDListEp5[DD_COUNT]

int Usb_Dma_Init()
  {
  int error, n;

  memset(DmaUdcaList, 0, sizeof(DmaUdcaList));
  memset(DDListEp4, 0, sizeof(DDListEp4));
  memset(DDListEp5, 0, sizeof(DDListEp5));
  memset(DmaTransmitbuffer, 0, sizeof(DmaTransmitbuffer));
  memset(DmaReceivebuffer, 0, sizeof(DmaReceivebuffer));

  USB_UDCA_H = &DmaUdcaList[0];
  DmaUdcaList[4] = &DDListEp4[0];
  DmaUdcaList[5] = &DDListEp5[0];

  // Initialize dma descriptor for EP4
    for (n=0; n < DD_COUNT; n++)
     {
    DDListEp4[n].next_dd_addr = (n * USB_DD_SIZE);
    DDListEp4[n].max_packet_size = MAX_PACKET_SIZE << 5;
    DDListEp4[n].dma_buffer_length = (sizeof(DmaReceivebuffer)) / 
DD_COUNT;
    DDListEp4[n].dma_buffer_addr = &(DmaReceivebuffer[n]) ;
    DDListEp4[n].status = 0;
     }

  // Initialize dma descriptor for EP5
    for (n=0; n < DD_COUNT; n++)
     {
    DDListEp5[n].next_dd_addr = (n * USB_DD_SIZE);
    DDListEp5[n].max_packet_size = MAX_PACKET_SIZE << 5;
    DDListEp5[n].dma_buffer_length = (sizeof(DmaTransmitbuffer)) / 
DD_COUNT;
    DDListEp5[n].dma_buffer_addr = &(DmaTransmitbuffer[n]);
    DDListEp5[n].status = 0;
   }

  return error;


#define USB_DD_SIZE               sizeof (USB_DMA_DESCRIPTOR)
#define DD_BUFFER_LEN             640
#define DD_COUNT                  10


ich bedanke mich,
amal