Left/Right Channel Separation using EDMA

#include "header.h"

void main(void)
{
	CSL_init();  /* init CSL */
	

	/* Konfiguration des AIC23 �ber McBSP0 */
	Config_DSK6713_AIC23();
	
	/* Konfiguration des McBSP1 - Datenschnittstelle */
	hMcbsp = MCBSP_open(MCBSP_DEV1, MCBSP_OPEN_RESET);
    MCBSP_config(hMcbsp, &datainterface_config);
    
    config_EDMA();

    /* interrupts immer zuletzt */
    config_interrupts();

    MCBSP_start(hMcbsp, MCBSP_RCV_START | MCBSP_XMIT_START, 0xffffffff);
    MCBSP_write(hMcbsp, 0x0); /* einmal schie�en */
} /* und fertig */


void config_EDMA(void)
{
	/* Konfiguration der EDMA zum Lesen*/
	hEdmaRcv = EDMA_open(EDMA_CHA_REVT1, EDMA_OPEN_RESET);  // EDMA Kanal f�r das Event REVT1
	hEdmaRcvPing = EDMA_allocTable(-1);                     // Reload-Parametersatz Ping
	hEdmaRcvPong = EDMA_allocTable(-1);                     // Reload-Parametersatz Pong


	configEDMARcv.src = MCBSP_getRcvAddr(hMcbsp);          //  Quell-Adresse zum Lesen

	// receive ping (default)
	tccRcvPing = EDMA_intAlloc(-1);                        // n�chsten freien Transfer-Complete-Code
	configEDMARcv.opt |= EDMA_FMK(OPT,TCC,tccRcvPing);     // dann der Grundkonfiguration des EDMA Empfangskanals zuweisen
	configEDMARcv.dst = (short)Buffer_in_pingLEFT;			   // Ziel Adresse

	/* ersten Transfer und Reload-Ping mit Config Ping konfigurieren */
	EDMA_config(hEdmaRcv, &configEDMARcv);
	EDMA_config(hEdmaRcvPing, &configEDMARcv);

	//receive pong
	tccRcvPong = EDMA_intAlloc(-1);                        // n�chsten freien Transfer-Complete-Code
	configEDMARcv.opt |= EDMA_FMK(OPT,TCC,tccRcvPong);     // dann der Grundkonfiguration des EDMA Empfangskanals zuweisen
	configEDMARcv.dst =(short)Buffer_in_pongLEFT;

	/* ersten Transfer und Reload-Ping mit ConfigPing konfigurieren */
	EDMA_config(hEdmaRcvPong, &configEDMARcv);
	
	/* Transfers verlinken ping -> pong -> ping */
	EDMA_link(hEdmaRcv,hEdmaRcvPong);
	EDMA_link(hEdmaRcvPong,hEdmaRcvPing);
	EDMA_link(hEdmaRcvPing,hEdmaRcvPong);

	/* Konfiguration der EDMA zum Schreiben*/
	hEdmaXmt = EDMA_open(EDMA_CHA_XEVT1, EDMA_OPEN_RESET);  // EDMA Kanal f�r das Event XEVT1
	hEdmaXmtPing = EDMA_allocTable(-1);                     // Reload-Parametersatz Ping
	hEdmaXmtPong = EDMA_allocTable(-1);                     // Reload-Parametersatz Pong

	configEDMAXmt.dst = MCBSP_getXmtAddr(hMcbsp);		//Ziel Adresse zum Schreiben


	//transmit ping (default)
	configEDMAXmt.src =(short)Buffer_out_pingLEFT;		//  Quell-Adresse zum Schreiben
	tccXmtPing = EDMA_intAlloc(-1);							// n�chsten freien Transfer-Complete-Code
	configEDMAXmt.opt |= EDMA_FMK(OPT,TCC,tccXmtPing);

	/* ersten Transfer und Reload-Ping mit ConfigPing konfigurieren */
	EDMA_config(hEdmaXmt, &configEDMAXmt);
	EDMA_config(hEdmaXmtPing, &configEDMAXmt);

	//transmit pong
	configEDMAXmt.src =(short)Buffer_out_pongLEFT;		//  Quell-Adresse zum Schreiben
	tccXmtPong = EDMA_intAlloc(-1);							// n�chsten freien Transfer-Complete-Code
	configEDMAXmt.opt |=EDMA_FMK(OPT,TCC,tccXmtPong);

	/* ersten Transfer und Reload-Ping mit ConfigPing konfigurieren */
	EDMA_config(hEdmaXmtPong, &configEDMAXmt);

	/* Transfers verlinken ping -> pong -> ping */
	EDMA_link(hEdmaXmt,hEdmaXmtPong);
	EDMA_link(hEdmaXmtPong,hEdmaXmtPing);
	EDMA_link(hEdmaXmtPing,hEdmaXmtPong);

	/* EDMA TCC-Interrupts freigeben */
	// receive ping
	EDMA_intClear(tccRcvPing);
	EDMA_intEnable(tccRcvPing);
	// receive pong
	EDMA_intClear(tccRcvPong);
	EDMA_intEnable(tccRcvPong);
	// transmit ping
	EDMA_intClear(tccXmtPing);
	EDMA_intEnable(tccXmtPing);
	// transmit ping
	EDMA_intClear(tccXmtPong);
	EDMA_intEnable(tccXmtPong);
	/* EDMA starten, wen alles? */
	EDMA_enableChannel(hEdmaRcv);
	EDMA_enableChannel(hEdmaXmt);
}

void config_interrupts(void)
{
	IRQ_globalDisable();				//Disable all Interrupts for init of serial data port
	IRQ_map(IRQ_EVT_EDMAINT, 8);
	IRQ_clear(IRQ_EVT_EDMAINT);
	IRQ_enable(IRQ_EVT_EDMAINT);
	IRQ_globalEnable();

}

void EDMA_interrupt_service(void)
{
	static volatile int rcvPingDone=0;
	static volatile int rcvPongDone=0;
	static volatile int xmtPingDone=0;
	static volatile int xmtPongDone=0;
	
	if(EDMA_intTest(tccRcvPing)) {
		EDMA_intClear(tccRcvPing); /* ohne clear geht es NICHT */
		rcvPingDone=1;
	}
	else if(EDMA_intTest(tccRcvPong)) {
		EDMA_intClear(tccRcvPong);
		rcvPongDone=1;
	}
	
	if(EDMA_intTest(tccXmtPing)) {
		EDMA_intClear(tccXmtPing);
		xmtPingDone=1;
	}
	else if(EDMA_intTest(tccXmtPong)) {
		EDMA_intClear(tccXmtPong);
		xmtPongDone=1;
	}	
	
	if(rcvPingDone && xmtPingDone) {
		rcvPingDone=0;
		xmtPingDone=0;
		// SW-Interrupt mit Verarbeitung
		SWI_post(&swi_ping);
	}
	else if(rcvPongDone && xmtPongDone) {
		rcvPongDone=0;
		xmtPongDone=0;
		// SW-Interrupt mit Verarbeitung
		SWI_post(&swi_pong);
	}
}

void process_ping_SWI(void)
{
	int i;
	for(i=0; i<BUFFER_LEN; i++)
		{ *(Buffer_out_pingLEFT+i) = *(Buffer_in_pingLEFT+i);
		  *(Buffer_out_pingRIGHT+i) = *(Buffer_in_pingRIGHT+i);
		}

}

void process_pong_SWI(void)
{
	int i;
	for(i=0; i<BUFFER_LEN; i++)
		{ *(Buffer_out_pongLEFT+i) = *(Buffer_in_pongLEFT+i);
		  *(Buffer_out_pongRIGHT+i) = *(Buffer_in_pongRIGHT+i);
		}
}