Problem mit dem STM32F205 SPI RX DMA

[Mw E. (Firma: fritzler-avr.de) (fritzler)]

Hallöchen,
hier zickt der SPI RX DMA rum.

Ich lese über den SPI einen externen 24Bit ADC mit 6 Kanälen aus.
Das sind dann 18 Bytes.
Den ADC betreibe ich im "Loopmode", der ADC bekam einmal das Steuerbyte 
und dann kann man den CS auf low lassen.
Bei jedem anlegen von CLK bekommt man dann alle 18 Bytes zugesendet.

IRQ getrieben und per Polling kommen auch immer die passenden 18 Bytes 
im Speicher an.

Dann das Ganze auf DMA umgebaut.
Nur ab und zu ließt dieser falsche Bytes vom SPI.
Also die Bytes sind nicht verschoben, sondern völlig anders, aber auch 
nicht alle Bytes sind blödsinn.
Das falsch Auslesen kommt auch unregelmäßig.

Jetzt könnt das ja nen Timingproblem sein und der ADC sendet murks.
Also eine Erkennung in die SW gebaut welche mein Oszi triggert bei 
diesem Fehler.
Und siehe da, am SPI RX Pin liegen valide Daten an! Aber nicht im 
Speicher!

Der DMA wirft keine Errorflags und der DMA funktioniert wunderbar beim 
auslesen des internen ADC.
Weiterhin läuft der DMA beim UART TX bestens.
Also hab ichs wohl nicht komplett vergeigt den DMA zu initialisieren.

Kann mir einer erklären was hier abgeht?

Code kann ich gerne nachliefern, habs nur erstmal nicht angehangen, weil 
alles selbergeschrieben ist ohne CMSIS/HAL.

[Curby23523 N. (Gast)]

Mw E. schrieb:
> Code kann ich gerne nachliefern, habs nur erstmal nicht angehangen, weil
> alles selbergeschrieben ist ohne CMSIS/HAL.

Dann zeig doch mal, wie du DMA, SPI initialisierst und wie du sonst mit 
dem DMA / SPI umgehst. Also die relevanten Codestellen.

[Mw E. (Firma: fritzler-avr.de) (fritzler)]

Hier, kannste haben ;)

Sämtliche DMA Transfers stellen den DMA über die dma.c ein.
"enum dma_periph peri" enthält dabei codiert DMA1 o. 2, den kanal und 
den Stream.

Per Timer wird der Auslesevorgang 1000mal/s angestoßen:

static void callb_tim4_cc4_triggered(unsigned int statreg, void *callb_userdata){
  
  (void)callb_userdata;
  
  if (statreg & SR_CC4IF){
    //weiteres Auslesen circulär ohne weiteres Controlbyte
    if (spi_is_transfering){
      return;
    }
    spi_is_transfering = 1;
    int dma_res = spi_dmamode(
      SPI1,             //Welcher SPI
      (uint8_t*)&extadc_tx[1],   //SPI Sendebuffer
      (uint8_t*)&extadc_rx[1],  //SPI Empfangsbuffer
      DMA_SPI1TX_V1,        //DMA Sendestream
      DMA_SPI1RX_V2,        //DMA Empfangsstream
      18,              //Anzahl der zu übertragenden Daten
      callb_dma_adcext,       //IRQ Handler DMA
      NULL,             //IRQ Handler DMA Daten
      callb_adc_ext_irq,       //IRQ Handler SPI Err
      NULL);            //IRQ Handler SPI Err Daten
    if (dma_res){
      dprintf("SPI DMA REERR: %i\n", dma_res);
      asm("udf");
    }
  }
}

Im SPI Treiber wird das dann durchgereicht und noch mir Prioritäten 
versehen.
Um ein SPI CLK zu erzeugen müssen ja Nullbytes gesendet werden.

int spi_dmamode(
  unsigned int spi_base,               //Welcher SPI
  uint8_t *tx,                   //SPI Sendebuffer
  uint8_t *rx,                  //SPI Empfangsbuffer
  enum dma_periph stream_tx,            //DMA Sendestream
  enum dma_periph stream_rx,            //DMA Empfangsstream
  uint16_t buflen,                //Anzahl der zu übertragenden Daten
  void (*callb_dma)(unsigned int, void*),     //IRQ Handler DMA
  void *callb_data_dma,               //IRQ Handler DMA Daten
  void (*callb)(unsigned int, void*),       //IRQ Handler SPI Err
  void *callb_data){                //IRQ Handler SPI Err Daten

  volatile struct spi * const spi = (struct spi *)spi_bases[spi_base];
  
  spi->CR2 &= ~(CR2_TXDMAEN | CR2_RXDMAEN);
  asm("DSB");

  int dma_arr;
  
  //RX DMA zuerst einstellen, falls DMA Bits noch gesetzt sind
  dma_arr = dma_periph(
    stream_rx,      //Angabe der Peripherie
    (unsigned int)rx,
    (unsigned int)&(spi->DR),
    buflen,        //Anzahl der zu übertragenden Elemente
    DMA_SIZE_BYTE,    //Größe der zu Übertragenden Daten
    0,          //nicht circular
    DMA_PERIPH_TO_MEM,  //in welche Richtung geht der DMA (mem to mem ist verboten)
    DMA_PRIO_HIGH,    //Priorität des DMA
    callb_dma,      //Callback bei auftretendem IRQ
    callb_data_dma    //Daten für den Callback
    );
  if (dma_arr){
    return -1;
  }
  
  //TX DMA
  dma_arr = dma_periph(
    stream_tx,      //Angabe der Peripherie
    (unsigned int)tx,
    (unsigned int)&(spi->DR),
    buflen,        //Anzahl der zu übertragenden Elemente
    DMA_SIZE_BYTE,    //Größe der zu Übertragenden Daten
    0,          //nicht circular
    DMA_MEM_TO_PERIPH,  //in welche Richtung geht der DMA (mem to mem ist verboten)
    DMA_PRIO_LOW,    //Priorität des DMA
    callb_dma,      //Callback bei auftretendem IRQ
    callb_data_dma    //Daten für den Callback
    );
  if (dma_arr){
    return -1;
  }
  
  callb_irq[spi_base] = callb;
  callb_irq_data[spi_base] = callb_data;
  
  spi->CR2 |= CR2_ERRIE | CR2_TXDMAEN | CR2_RXDMAEN;
  
  //IRQ aktivieren
  nvic_enable_irq(spi_irq_nbrs[spi_base], 0xF, 0xF);
  
  return 0;
}

Der interne ADC wird so angestoßen:

dma_res = adc_int_dmamode(
    ADC1,         //Welcher ADC
    (uint16_t*)adc_werte,     //ADC Daten wohin
    callb_dma,       //IRQ Handler DMA
    NULL,         //IRQ Handler DMA Daten
    callb_adc_int_irq,   //IRQ Handler ADc Err
    NULL,         //IRQ Handler ADc Err Daten
    ADCM_SCANCONT);
  if (dma_res){
    dprintf("ADC DMA ERR: %i\n", dma_res);
    asm("udf");
  }

Der Treiber des internen ADC:

int adc_int_dmamode(
  unsigned int adc_base,               //Welcher ADC
  uint16_t *mem_buf,                 //ADC Daten wohin
  void (*callb_dma)(unsigned int, void*),     //IRQ Handler DMA
  void *callb_data_dma,               //IRQ Handler DMA Daten
  void (*callb)(unsigned int, uint16_t, void*),   //IRQ Handler ADc Err
  void *callb_data,                 //IRQ Handler ADc Err Daten
  enum adc_mode amode){              //ADC Mode

  volatile struct adc * const adc = (struct adc *)adc_addrs[adc_base];
  
  //Modus setzen
  adc_int_xmode(adc, amode);
  unsigned int circular = 0;
  if (ADCM_SCANCONT == amode){
    circular = 1;
  }
  unsigned int sequ_len = adc->SQR1 >> SQR1_SLEN_SHIFT;
  sequ_len &= 0b1111;
  sequ_len += 1;
  //dprintf("DMA_ADC scanlen: %u\n", sequ_len);
  int i, dma_arr;
  
  //es gibt 2 Versuche, denn jede Periph ist in 2 DMA Vetreten
  //beide belegt -> dammnit
  for (i = 0; i < 2; i++){
    dma_arr = dma_periph(
      dma_streamchan[adc_base][i],    //Angabe der Peripherie
      (unsigned int)mem_buf,
      (unsigned int)&(adc->DR),
      sequ_len,      //Anzahl der zu übertragenden Elemente
      DMA_SIZE_HWORD,    //Größe der zu Übertragenden Daten
      circular,      //mem wird circulär befüllt = DMA geht nie zuende
      DMA_PERIPH_TO_MEM,  //in welche Richtung geht der DMA (mem to mem ist verboten)
      DMA_PRIO_MED,    //Priorität des DMA
      callb_dma,      //Callback be auftretendem IRQ
      callb_data_dma    //Daten für den Callback
      );
    if (0 == dma_arr){
      break;
    }
  }
  if (dma_arr){
    return -1;
  }
  
  callb_irq[adc_base] = callb;
  callb_irq_data[adc_base] = callb_data;
  
  //IRQ aktivieren
  nvic_enable_irq(IRQ_NBR_ADC, 0xF, 0xF);
  adc->CR1 |= CR1_OVRIE;
  
  //Leinen los!
  adc->CR1 &= ~CR1_EOCIE;
  adc->CR2 &= ~CR2_EOCS;
  adc->CR2 |= CR2_DMA | CR2_DDS; //Damit bei SCANCONT nach einem SCAN der DMAREQ weiterhin ausgelöst wird
  
  return 0;
}