xmega DMA Interupts

[xmega dma (Gast)]

Wenn ich das Manual zum xmega32a4 bzw. die application note zu DMA 
richtig interpretiere, dann sollte der DMA-Controller erst ein Interrupt 
auslösen wenn eine Transaction abgeschlossen ist, im Repeat-Mode also 
alle Wiederholungen durchgeführt wurden:

"When a transaction on the DMA channel has been completed, the TRNIF 
flag will be set and the optional interrupt is
generated." (AVR Manual)

Trotzdem wird bei mir offenbar bei jedem Triggersignal vom ADC (oder 
nach jedem Block) ein Interrupt ausgelöst, ich komm aber nicht dahinter 
weshalb. Kann mir da jemand weiterhelfen?

#define NSAMPLE = 12

void adc_dma_init()
{
    // Resset DMA and Enable
    DMA_CTRL = DMA_RESET_bm;
    while( (DMA_CTRL & DMA_RESET_bm) != 0);
    DMA_CTRL = DMA_ENABLE_bm | DMA_DBUFMODE_CH01_gc;

    adc_dma1_init();
    adc_dma0_init();

    ADC_DMA0.CTRLA |= (1 << 7);

}


void adc_dma0_init()
{
    ADC_DMA0.CTRLA  = (DMA_CH_BURSTLEN_2BYTE_gc | DMA_CH_REPEAT_bm);
    ADC_DMA0.CTRLB  = DMA_CH_TRNINTLVL_LO_gc | DMA_CH_ERRINTLVL_LO_gc;
    ADC_DMA0.ADDRCTRL = ( DMA_CH_SRCRELOAD_BLOCK_gc | DMA_CH_SRCDIR_INC_gc | DMA_CH_DESTRELOAD_TRANSACTION_gc | DMA_CH_DESTDIR_INC_gc );

    ADC_DMA0.TRIGSRC = DMA_CH_TRIGSRC_ADCA_CH2_gc;
    ADC_DMA0.TRFCNTL = 0x06;
    ADC_DMA0.TRFCNTH = 0x00;
    ADC_DMA0.REPCNT = NSAMPLE;

    ADC_DMA0.SRCADDR0 = 0x10; // CH0RESLOW
    ADC_DMA0.SRCADDR1 = 0x02; // ADCA
    ADC_DMA0.SRCADDR2 = 0x00;

    ADC_DMA0.DESTADDR0 = ((uint16_t)&dma0_buff) >> 0;
    ADC_DMA0.DESTADDR1 = ((uint16_t)&dma0_buff) >> 8;
    ADC_DMA0.DESTADDR2 = 0x00;

    //ADC_DMA0.CTRLA |= DMA_CH_ENABLE_bm;
}

void adc_dma1_init()
{
    ADC_DMA1.CTRLA  = (DMA_CH_BURSTLEN_2BYTE_gc | DMA_CH_REPEAT_bm);
    ADC_DMA1.CTRLB = DMA_CH_TRNINTLVL_LO_gc | DMA_CH_ERRINTLVL_LO_gc;
    ADC_DMA1.ADDRCTRL = ( DMA_CH_SRCRELOAD_BLOCK_gc |DMA_CH_SRCDIR_INC_gc | DMA_CH_DESTRELOAD_TRANSACTION_gc | DMA_CH_DESTDIR_INC_gc );

    ADC_DMA1.TRIGSRC = DMA_CH_TRIGSRC_ADCA_CH2_gc;
    ADC_DMA1.TRFCNTL = 0x06;
    ADC_DMA1.TRFCNTH = 0x00;
    ADC_DMA1.REPCNT = NSAMPLE;

    ADC_DMA1.SRCADDR0 = 0x10; // CH0RESLOW
    ADC_DMA1.SRCADDR1 = 0x02; // ADCA
    ADC_DMA1.SRCADDR2 = 0x00;

    ADC_DMA1.DESTADDR0 = ((uint16_t)&dma1_buff) >> 0;
    ADC_DMA1.DESTADDR1 = ((uint16_t)&dma1_buff) >> 8;
    ADC_DMA1.DESTADDR2 = 0x00;

    //ADC_DMA1.CTRLA |= DMA_CH_ENABLE_bm;
}

ISR(DMA_CH0_vect)
{
    
    if (DMA_INTFLAGS & DMA_CH0TRNIF_bm) 
    {
        DMA.INTFLAGS = DMA_CH0TRNIF_bm;
        ADC_DMA0.REPCNT = NSAMPLE;
        ADC_DMA0.CTRLA |= DMA_CH_REPEAT_bm;
        adc_process(dma0_buff);
    }
    else // DMA Error
    {
        DMA.INTFLAGS = DMA_CH0ERRIF_bm;
        // TODO: Error handling
    }

}

ISR(DMA_CH1_vect)
{
    
    if (DMA_INTFLAGS & DMA_CH1TRNIF_bm) 
    {
        DMA.INTFLAGS = DMA_CH1TRNIF_bm;
        ADC_DMA1.REPCNT = NSAMPLE;
        ADC_DMA1.CTRLA |= DMA_CH_REPEAT_bm;
        adc_process(dma1_buff);
    }
    else // DMA Error
    {
        DMA.INTFLAGS = DMA_CH1ERRIF_bm;
        // TODO: Error handling
    }

}

Hier sollte dma0 dma0_buff mit NSAMPLES von ADCA CH0-2 füllen, dann 
einen interrupt generieren während dma1 übernimmt und dma1_buff füllt 
usw.

Was passiert ist (soweit ich das bisher beobachten konnte), dass dma0 
einen Block (nach einem Trigger des ADCs) kopiert, einen interrupt 
auslöst, dann dma1 einen block kopiert und einen Interrupt auslöst usw.
Im Grund Verhält es sich so, als wäre der Repeat Mode nicht aktiv.

[xmega dma (Gast)]

Hab meinen Denkfehler gefunden, im Repeat Modus wird nicht ein Block 
transfer getriggert sondern die komplette Transaction.