/*
* initEdma() - Initialize the DMA controller. Use linked transfers to
* automatically transition from ping to pong and visa-versa.
*/
void initEdma(void)
{
/* Configure transmit channel */
hEdmaXmt = EDMA_open(EDMA_CHA_XEVT1, EDMA_OPEN_RESET); // get hEdmaXmt handle and reset channel
hEdmaReloadXmtPing = EDMA_allocTable(-1); // get hEdmaReloadXmtPing handle
hEdmaReloadXmtPong = EDMA_allocTable(-1); // get hEdmaReloadXmtPong handle
gEdmaConfigXmt.dst = MCBSP_getXmtAddr(hMcbsp1); // set the desination address to McBSP1 DXR
gXmtChan = EDMA_intAlloc(-1); // get an open TCC
gEdmaConfigXmt.opt |= EDMA_FMK(OPT,TCC,gXmtChan); // set TCC to gXmtChan
EDMA_config(hEdmaXmt, &gEdmaConfigXmt); // then configure the registers
EDMA_config(hEdmaReloadXmtPing, &gEdmaConfigXmt); // and the reload for Ping
gEdmaConfigXmt.src = EDMA_SRC_OF(gBufferXmtPong); // change the structure to have a source of Pong
EDMA_config(hEdmaReloadXmtPong, &gEdmaConfigXmt); // and configure the reload for Pong
EDMA_link(hEdmaXmt,hEdmaReloadXmtPong); // link the regs to Pong
EDMA_link(hEdmaReloadXmtPong,hEdmaReloadXmtPing); // link Pong to Ping
EDMA_link(hEdmaReloadXmtPing,hEdmaReloadXmtPong); // and link Ping to Pong
/* Configure receive channel */
hEdmaRcv = EDMA_open(EDMA_CHA_REVT1, EDMA_OPEN_RESET); // get hEdmaRcv handle and reset channel
hEdmaReloadRcvPing = EDMA_allocTable(-1); // get hEdmaReloadRcvPing handle
hEdmaReloadRcvPong = EDMA_allocTable(-1); // get hEdmaReloadRcvPong handle
gEdmaConfigRcv.src = MCBSP_getRcvAddr(hMcbsp1); // and the desination address to McBSP1 DXR
gRcvChan = EDMA_intAlloc(-1); // get an open TCC
gEdmaConfigRcv.opt |= EDMA_FMK(OPT,TCC,gRcvChan); // set TCC to gRcvChan
EDMA_config(hEdmaRcv, &gEdmaConfigRcv); // then configure the registers
EDMA_config(hEdmaReloadRcvPing, &gEdmaConfigRcv); // and the reload for Ping
gEdmaConfigRcv.dst = EDMA_DST_OF(gBufferRcvPong); // change the structure to have a destination of Pong
EDMA_config(hEdmaReloadRcvPong, &gEdmaConfigRcv); // and configure the reload for Pong
EDMA_link(hEdmaRcv,hEdmaReloadRcvPong); // link the regs to Pong
EDMA_link(hEdmaReloadRcvPong,hEdmaReloadRcvPing); // link Pong to Ping
EDMA_link(hEdmaReloadRcvPing,hEdmaReloadRcvPong); // and link Ping to Pong
/* Enable interrupts in the EDMA controller */
EDMA_intClear(gXmtChan);
EDMA_intClear(gRcvChan); // clear any possible spurious interrupts
EDMA_intEnable(gXmtChan); // enable EDMA interrupts (CIER)
EDMA_intEnable(gRcvChan); // enable EDMA interrupts (CIER)
EDMA_enableChannel(hEdmaXmt); // enable EDMA channel
EDMA_enableChannel(hEdmaRcv); // enable EDMA channel
/* Do a dummy write to generate the first McBSP transmit event */
MCBSP_write(hMcbsp1, 0);
}
int main(void) {
/* Initialize the CSL and the CPLD */
CSL_init();
DSK6713_init();
DSK6713_LED_init();
/* Turn on one LED so we can see it executed at least the main function */
DSK6713_LED_on(0);
/* Initialize the DIP switches to be able to read them */
DSK6713_DIP_init();
/* Configure the codec according to the definitions in config_AIC23.c
* via the McBSP0 interface
*/
conf_AIC23();
/* Configure the McBSP to transfer the data from and to the codec */
conf_MCBSP();
/* Start the MCBSP */
start_MCBSP();
/* Configure EDMA */
conf_EDMA();
/* Time to initialize the buffer and zerofill it */
for(i = 0; i < 10; i++) FIFO_I[i] = 0;
for(i = 0; i < 10; i++) FIFO_Q[i] = 0;
/* Config Interrupts */
IRQ_enable(IRQ_EVT_EDMAINT);
IRQ_map(IRQ_EVT_EDMAINT, 8);
IRQ_globalEnable();
/* Enable the EDMA channels */
EDMA_enableChannel(hEDMATrx);
/******************************************************/
/* We should be done here by now. The McBSP generates an
* Interrupt (called "event" in this case) each time
* there's a new word ready to be written or ready to
* be transferred from the serial port to the
* input buffer. We use it for the golden wire config
* and will disable the input when we throw in the
* QPSK modulation algorithm as it is not needed by then.
*/
/******************************************************/
/* End main - RTOS takes over */
}
Int ppuEnableChannel(PPU_DevHandle device, Int channelnum )
{
Bool res;
PPU_ChannelHandle chan;
const PPU_PictureChannelHAL * hal;
chan = &device->Channels[channelnum];
hal = &(ppuHal.PictureChannel[channelnum]);
// Check if the channel is realy open and not enabled.
if ( ! chan->Open)
return SYS_EBADIO;
if ( chan->Enabled )
return SYS_OK;
// Get a buffer for the picture.
res = bfqAllocBuffer( &(chan->Queue), (Ptr*)&(chan->Buffer), 0);
assertLog(res != 0);
// Configure the DMA and enable it.
ppuConfigEDMA( device, channelnum );
EDMA_clearChannel( chan->DMA1 );
EDMA_enableChannel( chan->DMA1 );
// Enable the interrupt in the PPU -> Set the appropriate bit in the interrupt mask register.
ppuMemory[ hal->RegIntEnable_addr ] |= hal->RegIntEnable_mask;
// Select the camera as source for this channel
ppuMemory[ hal->RegSourceSelect_addr ] |= hal->RegSourceSelect_mask;
// Enable the channel in the PPU -> Set the appropriate bit in the control register.
// DEBUG::: don't yet do this, since this triggers a new image.
ppuMemory[ hal->RegChannelEnable_addr ] |= hal->RegChannelEnable_mask;
chan->Enabled = TRUE;
return SYS_OK;
}
void config_EDMA(void)
{
LOG_printf(&myLog, "config EDMA begin");
// EIGEN!!!: Konfiguration Recieve Ping
/* Konfiguration der EDMA zum Lesen*/
hEdmaRcv = EDMA_open(EDMA_CHA_REVT1, EDMA_OPEN_RESET); // EDMA Channel for REVT1
hEdmaReloadRcvPing = EDMA_allocTable(-1); // Reload-Parameters Ping
hEdmaReloadRcvPong = EDMA_allocTable(-1); // Reload-Parameters Pong 2 Param Sets needed (Ping & Pong) -> Pong write on my own
hEdmaReloadRcvPeng = EDMA_allocTable(-1); // Reload-Parameters Peng
configEDMARcv.src = MCBSP_getRcvAddr(hMcbsp); // source addr
//Recieve Ping
tccRcvPing = EDMA_intAlloc(-1); // next available TCC
configEDMARcv.opt |= EDMA_FMK(OPT,TCC,tccRcvPing); // Grundkonfiguration EDMA-channel
configEDMARcv.dst = ((int)Buffer_in_ping)/* & 0xFFFF*/; // Zieladresse
//configEDMARcv.dst = ((short)Buffer_in_ping)/* & 0xFFFF*/; // Zieladresse
/* Erster Transfer und Reload-Ping */
EDMA_config(hEdmaRcv, &configEDMARcv);
EDMA_config(hEdmaReloadRcvPing, &configEDMARcv);
//Recieve Pong
tccRcvPong = EDMA_intAlloc(-1); // next available TCC
configEDMARcv.opt |= EDMA_FMK(OPT,TCC,tccRcvPong); // Grundkonfiguration EDMA-channel
configEDMARcv.dst = ((int)Buffer_in_pong)/* & 0xFFFF*/; // Zieladresse
//configEDMARcv.dst = ((short)Buffer_in_pong)/* & 0xFFFF*/; // Zieladresse
/* Erster Transfer und Reload-Ping */
EDMA_config(hEdmaReloadRcvPong, &configEDMARcv);
//Recieve Peng
tccRcvPeng = EDMA_intAlloc(-1); // next available TCC
configEDMARcv.opt |= EDMA_FMK(OPT,TCC,tccRcvPeng); // Grundkonfiguration EDMA-channel
configEDMARcv.dst = ((int)Buffer_in_peng)/* & 0xFFFF*/; // Zieladresse
//configEDMARcv.dst = ((short)Buffer_in_peng)/* & 0xFFFF*/; // Zieladresse
/* Erster Transfer und Reload-Ping */
EDMA_config(hEdmaReloadRcvPeng, &configEDMARcv);
/* link transfers ping -> pong -> peng -> ping */
EDMA_link(hEdmaRcv,hEdmaReloadRcvPong);
EDMA_link(hEdmaReloadRcvPong,hEdmaReloadRcvPeng);
EDMA_link(hEdmaReloadRcvPeng,hEdmaReloadRcvPing);
EDMA_link(hEdmaReloadRcvPing,hEdmaReloadRcvPong);
/* do you want to hear music? */
// Gleiche Konfiguration wie oben für Lesen muss nun für Schreiben angewendet werden
hEdmaXmt = EDMA_open(EDMA_CHA_XEVT1, EDMA_OPEN_RESET); // EDMA Channel for REVT1
hEdmaReloadXmtPing = EDMA_allocTable(-1); // Reload-Parameters Ping
hEdmaReloadXmtPong = EDMA_allocTable(-1); // Reload-Parameters Pong 2 Param Sets needed (Ping & Pong) -> Pong write on my own
hEdmaReloadXmtPeng = EDMA_allocTable(-1); // Reload-Parameters Peng
configEDMAXmt.dst = MCBSP_getXmtAddr(hMcbsp); // destination addr
//Transmit Ping
tccXmtPing = EDMA_intAlloc(-1); // next available TCC
configEDMAXmt.opt |= EDMA_FMK(OPT,TCC,tccXmtPing); // Grundkonfiguration EDMA-channel
configEDMAXmt.src = ((int)Buffer_out_ping)/* & 0xFFFF*/; // Quelladresse
//configEDMAXmt.src = ((short)Buffer_out_ping)/* & 0xFFFF*/; // Quelladresse
/* Erster Transfer und Reload-Ping */
EDMA_config(hEdmaXmt, &configEDMAXmt);
EDMA_config(hEdmaReloadXmtPing, &configEDMAXmt);
//Transmit Pong
tccXmtPong = EDMA_intAlloc(-1); // next available TCC
configEDMAXmt.opt |= EDMA_FMK(OPT,TCC,tccXmtPong); // Grundkonfiguration EDMA-channel
configEDMAXmt.src = ((int)Buffer_out_pong)/* & 0xFFFF*/; // Quelladresse
//configEDMAXmt.src = ((short)Buffer_out_pong)/* & 0xFFFF*/; // Quelladresse
/* Erster Transfer und Reload-Ping */
EDMA_config(hEdmaReloadXmtPong, &configEDMAXmt);
//Transmit Peng
tccXmtPeng = EDMA_intAlloc(-1); // next available TCC
configEDMAXmt.opt |= EDMA_FMK(OPT,TCC,tccXmtPeng); // Grundkonfiguration EDMA-channel
configEDMAXmt.src = ((int)Buffer_out_peng)/* & 0xFFFF*/; // Quelladresse
//configEDMAXmt.src = ((short)Buffer_out_peng)/* & 0xFFFF*/; // Quelladresse
/* Erster Transfer und Reload-Ping */
EDMA_config(hEdmaReloadXmtPeng, &configEDMAXmt);
/* link transfers ping -> pong -> ping */
EDMA_link(hEdmaXmt,hEdmaReloadXmtPong);
EDMA_link(hEdmaReloadXmtPong,hEdmaReloadXmtPeng);
EDMA_link(hEdmaReloadXmtPeng,hEdmaReloadXmtPing);
EDMA_link(hEdmaReloadXmtPing,hEdmaReloadXmtPong);
/* enable EDMA TCC */
//recieve ping
EDMA_intClear(tccRcvPing);
EDMA_intEnable(tccRcvPing);
//recieve pong
EDMA_intClear(tccRcvPong);
EDMA_intEnable(tccRcvPong);
//recieve peng
EDMA_intClear(tccRcvPeng);
EDMA_intEnable(tccRcvPeng);
//transmit ping
EDMA_intClear(tccXmtPing);
EDMA_intEnable(tccXmtPing);
//transmit pong
EDMA_intClear(tccXmtPong);
EDMA_intEnable(tccXmtPong);
//transmit peng
EDMA_intClear(tccXmtPeng);
EDMA_intEnable(tccXmtPeng);
/* which EDMAs do we have to enable? */
EDMA_enableChannel(hEdmaRcv);
EDMA_enableChannel(hEdmaXmt);
LOG_printf(&myLog, "config EDMA end");
}
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
hEdmaRcvRelPing = EDMA_allocTable(-1); // einen Reload-Parametersatz für Ping
hEdmaRcvRelPong = EDMA_allocTable(-1); // einen Reload-Parametersatz für Pong
configEDMARcv.src = MCBSP_getRcvAddr(hMcbsp); // Quell-Adresse zum Lesen
tccRcvPing = EDMA_intAlloc(-1); // nächsten freien Transfer-Complete-Code Ping
tccRcvPong = EDMA_intAlloc(-1); // nächsten freien Transfer-Complete-Code Pong
configEDMARcv.opt |= EDMA_FMK(OPT,TCC,tccRcvPing); // dann der Grundkonfiguration des EDMA Empfangskanals zuweisen
/* ersten Transfer und Reload-Ping mit ConfigPing konfigurieren */
EDMA_config(hEdmaRcv, &configEDMARcv);
EDMA_config(hEdmaRcvRelPing, &configEDMARcv);
/* braucht man auch noch andere EDMA-Konfigurationen fuer das Lesen? ja -> pong */
configEDMARcv.opt |= EDMA_FMK(OPT,TCC,tccRcvPong);
configEDMARcv.dst = (Uint32)Buffer_in_pong ;
EDMA_config(hEdmaRcvRelPong, &configEDMARcv);
/* Transfers verlinken ping -> pong -> ping */
EDMA_link(hEdmaRcv, hEdmaRcvRelPong); /* noch mehr verlinken? */
EDMA_link(hEdmaRcvRelPong, hEdmaRcvRelPing);
EDMA_link(hEdmaRcvRelPing, hEdmaRcvRelPong);
/* muss man mittels EDMA auch schreiben? */
/* Konfiguration der EDMA zum Schreiben */
hEdmaXmt = EDMA_open(EDMA_CHA_XEVT1, EDMA_OPEN_RESET); // EDMA Kanal für das Event REVT1
hEdmaXmtRelPing = EDMA_allocTable(-1); // einen Reload-Parametersatz für Ping
hEdmaXmtRelPong = EDMA_allocTable(-1); // einen Reload-Parametersatz für Pong
configEDMAXmt.dst = MCBSP_getXmtAddr(hMcbsp); // Ziel-Adresse zum Schreiben
tccXmtPing = EDMA_intAlloc(-1); // nächsten freien Transfer-Complete-Code Ping
tccXmtPong = EDMA_intAlloc(-1); // nächsten freien Transfer-Complete-Code Pong
configEDMAXmt.opt |= EDMA_FMK(OPT,TCC,tccXmtPing); // dann der Grundkonfiguration des EDMA Sendekanal zuweisen
/* ersten Transfer und Reload-Ping mit ConfigPing konfigurieren */
EDMA_config(hEdmaXmt, &configEDMAXmt);
EDMA_config(hEdmaXmtRelPing, &configEDMAXmt);
/* braucht man auch noch andere EDMA-Konfigurationen fuer das Schreiben? ja -> pong */
configEDMAXmt.opt |= EDMA_FMK(OPT,TCC,tccXmtPong);
configEDMAXmt.src = (Uint32)Buffer_out_pong ;
EDMA_config(hEdmaXmtRelPong, &configEDMAXmt);
/* Transfers verlinken ping -> pong -> ping */
EDMA_link(hEdmaXmt, hEdmaXmtRelPong); /* noch mehr verlinken? */
EDMA_link(hEdmaXmtRelPong, hEdmaXmtRelPing);
EDMA_link(hEdmaXmtRelPing, hEdmaXmtRelPong);
/* EDMA TCC-Interrupts freigeben */
EDMA_intClear(tccRcvPing);
EDMA_intEnable(tccRcvPing);
EDMA_intClear(tccRcvPong);
EDMA_intEnable(tccRcvPong);
/* sind das alle? nein -> pong und alle für Sendeseite */
EDMA_intClear(tccXmtPing);
EDMA_intEnable(tccXmtPing);
EDMA_intClear(tccXmtPong);
EDMA_intEnable(tccXmtPong);
/* EDMA starten, wen alles? */
EDMA_enableChannel(hEdmaRcv);
EDMA_enableChannel(hEdmaXmt);
}
void DSK6713_configure_AIC23() {
/* Configure McBSP0 as control interface for aic23 */
MCBSP_Handle MCBSP0_handle;
MCBSP0_handle = MCBSP_open(MCBSP_DEV0, MCBSP_OPEN_RESET);
MCBSP_config(MCBSP0_handle, &MCBSP0_config);
MCBSP_start(MCBSP0_handle, MCBSP_XMIT_START | MCBSP_SRGR_START | MCBSP_SRGR_START, 220);
set_aic23_register(MCBSP0_handle, RESET_REGISTER, 0x0000);
set_aic23_register(MCBSP0_handle, POWER_DOWN_CONTROL, 0x0000);
set_aic23_register(MCBSP0_handle, LEFT_LINE_INPUT_CHANNEL_VOLUME, 0x0017);
set_aic23_register(MCBSP0_handle, RIGHT_LINE_INPUT_CHANNEL_VOLUME, 0x0017);
set_aic23_register(MCBSP0_handle, LEFT_CHANNEL_HEADPHONE_VOLUME, 0x00f9);
set_aic23_register(MCBSP0_handle, RIGHT_CHANNEL_HEADPHONE_VOLUME, 0x00f9);
set_aic23_register(MCBSP0_handle, ANALOG_AUDIO_PATH, 0x0011); // 00001 0010
set_aic23_register(MCBSP0_handle, DIGITAL_AUDIO_PATH, 0x0000); // 000000000
set_aic23_register(MCBSP0_handle, DIGITAL_AUDIO_INTERFACE_FORMAT, 0x0043); //0 0100 0001
set_aic23_register(MCBSP0_handle, SAMPLE_RATE_CONTROL, 0x000d); // 01100
set_aic23_register(MCBSP0_handle, DIGITAL_INTERFACE_ACTIVATION, 0x0001);
/* Configure McBSP1 as data interface for aic23 */
MCBSP_Handle MCBSP1_handle;
MCBSP1_handle = MCBSP_open(MCBSP_DEV1, MCBSP_OPEN_RESET);
MCBSP_config(MCBSP1_handle, &MCBSP1_config);
MCBSP_start(MCBSP1_handle, MCBSP_XMIT_START|MCBSP_RCV_START|MCBSP_SRGR_FRAMESYNC|MCBSP_SRGR_START, 220);
/* Configure receive EDMA */
EDMA_Handle hEdmaRcv;
EDMA_Handle hEdmaRcvA;
EDMA_Handle hEdmaRcvB;
hEdmaRcv = EDMA_open(EDMA_CHA_REVT1, EDMA_OPEN_RESET);
hEdmaRcvA = EDMA_allocTable(-1);
hEdmaRcvB = EDMA_allocTable(-1);
gEdmaRcvConfig.src = MCBSP_getRcvAddr(MCBSP1_handle); // Get address of DRR
gTccRcvChan = EDMA_intAlloc(-1); // get next free transfer complete code
gEdmaRcvConfig.opt |= EDMA_FMK(OPT, TCC, gTccRcvChan);
EDMA_config(hEdmaRcv, &gEdmaRcvConfig);
EDMA_config(hEdmaRcvA, &gEdmaRcvConfig);
gEdmaRcvConfig.dst = EDMA_DST_OF(gRcvBufferB);
EDMA_config(hEdmaRcvB, &gEdmaRcvConfig);
EDMA_link(hEdmaRcv, hEdmaRcvB);
EDMA_link(hEdmaRcvB, hEdmaRcvA);
EDMA_link(hEdmaRcvA, hEdmaRcvB);
/* Configure transmit EDMA */
EDMA_Handle hEdmaXmt;
EDMA_Handle hEdmaXmtA;
EDMA_Handle hEdmaXmtB;
hEdmaXmt = EDMA_open(EDMA_CHA_XEVT1, EDMA_OPEN_RESET);
hEdmaXmtA = EDMA_allocTable(-1);
hEdmaXmtB = EDMA_allocTable(-1);
gEdmaXmtConfig.dst = MCBSP_getXmtAddr(MCBSP1_handle); // Get address of DXR
gTccXmtChan = EDMA_intAlloc(-1); // get next free transfer complete code
gEdmaXmtConfig.opt |= EDMA_FMK(OPT, TCC, gTccXmtChan);
EDMA_config(hEdmaXmt, &gEdmaXmtConfig);
EDMA_config(hEdmaXmtA, &gEdmaXmtConfig);
gEdmaXmtConfig.src = EDMA_DST_OF(gXmtBufferB); // set source to buffer B
EDMA_config(hEdmaXmtB, &gEdmaXmtConfig);
EDMA_link(hEdmaXmt, hEdmaXmtB);
EDMA_link(hEdmaXmtB, hEdmaXmtA);
EDMA_link(hEdmaXmtA, hEdmaXmtB);
EDMA_intClear(gTccRcvChan);
EDMA_intClear(gTccXmtChan);
EDMA_intEnable(gTccRcvChan);
EDMA_intEnable(gTccXmtChan);
gBufferState.cpuBufferState = StateB; // inittial cpu buffer state
EDMA_enableChannel(hEdmaRcv);
EDMA_enableChannel(hEdmaXmt);
IRQ_clear(IRQ_EVT_EDMAINT);
IRQ_enable(IRQ_EVT_EDMAINT);
MCBSP_write(MCBSP1_handle, 0x00);
}
