535_ezkit_talkthrough.asm

基于visual dsp++开发环境

/*****************************************************************************************************************

(C) Copyright 2001 - Analog Devices, Inc.  All rights reserved.

File Name:		21535_EZKIT_TALKTHROUGH

Date Modified:	10/10/01		JB		Rev 0.1

Purpose:	  	ADSP-21535 EZ-Kit Lite Initialization and Main Program Shell                 
		       	Developed using the ADSP-21535 EZ-KIT Lite Evaluation Platform                
										  
				This routine contains function calls and routines to initialize the 	  
				state of the 21535, program the DMA controller, initialize the AD1885   
				
				This project contains an audio Talkthru example for the ADSP21535 EZ-KIT Lite evaluation system.
				The main code module is used to configure the AC'97 interface and AC'97 CODEC (AD1885)
				in a talkthrough fashion.  The analog front end of CODEC receives the analog audio data, and 
				converts it using the A/D converter.  It is then sent to the ADSP21535 via SPORT0, configured
	   			for slot 16 mode AC'97 link.  
			   	On the DSP side, the data is received and placed into a buffer in memory.  The DSP transmits 
				data from this same buffer to the codec via the SPORT0 - AC'97 link.  The CODEC receives this digital 
			   	data, converts it back to an analog representation and sends the data out of the head phone 
			   	interface.

************************************************************************************************/

#include <defBF535.h>
#include <btc.h>

/************************************************************************************************/
/*			   GLOBAL & EXTERNAL DECLARATIONS													*/	
/************************************************************************************************/    
.SECTION	data1;
.GLOBAL		_main;
.EXTERN 	Codec_Reset;
.EXTERN		Program_SPORT0_Registers;
.EXTERN		Program_DMA_Controller;
.EXTERN		AD1885_Codec_Initialization;
.EXTERN		Process_AD1885_Audio_Samples;
.EXTERN 	RX_Status;
.EXTERN		rx_buf;

.extern ldf_stack_end;


////////////////////
// BTC Definitions
////////////////////
#define MAXBTCBUF  12000
.align 2;
.byte2 _BTCLeft[MAXBTCBUF];		// a 16-bit array
.global _BTCLeft;

.byte2 _BTCRight[MAXBTCBUF];		// a 16-bit array
.global _BTCRight;

.byte2 _BTCLeftVolume;
.global _BTCLeftVolume;
 
.byte2 _BTCRightVolume;
.global _BTCRightVolume;

BTC_MAP_BEGIN
//             Channel Name, Starting Address, Length (bytes)
BTC_MAP_ENTRY('Audio Left Channel', _BTCLeft, MAXBTCBUF*2)
BTC_MAP_ENTRY('Audio Right Channel', _BTCRight, MAXBTCBUF*2)
BTC_MAP_ENTRY('Left Volume', _BTCLeftVolume, 2)
BTC_MAP_ENTRY('Right Volume', _BTCRightVolume, 2)
BTC_MAP_END


/************************************************************************************************/  
/* 				Program             															*/
/************************************************************************************************/ 
.SECTION program;

SETUP:

// Setup Event Vectors and Handlers
	R0 = 0;
	p0.l = EVT0 & 0xffff;
	p0.h = EVT0 >> 16;
	r1 = _EHANDLER (Z);
	r1.h = _EHANDLER;  	// Emulation Handler (Int0)
      [ P0 ++ ] = R1;

    R0 = _RHANDLER (Z);
    R0.H = _RHANDLER;  	// Reset Handler (Int1)
      [ P0 ++ ] = R0;

    R0 = _NHANDLER (Z);
	R0.H = _NHANDLER;  	// NMI Handler (Int2)
      [ P0 ++ ] = R0;

    R0.L = _XHANDLER;
  	R0.H = _XHANDLER;  	// Exception Handler (Int3)
      [ P0 ++ ] = R0;
	
	[ P0 ++ ] = R0; 	// IVT4 isn't used

      R0 = _HWHANDLER (Z);
	R0.H = _HWHANDLER; 	// HW Error Handler (Int5)
      [ P0 ++ ] = R0;
	
      R0 = _THANDLER (Z);
	R0.H = _THANDLER;  	// Timer Handler (Int6)
      [ P0 ++ ] = R0;
	
      R0 = _RTCHANDLER (Z);
	R0.H = _RTCHANDLER; 	// IVG7 Handler
      [ P0 ++ ] = R0;

      R0 = _I8HANDLER (Z);
	R0.H = _I8HANDLER; 	// IVG8 Handler
      [ P0 ++ ] = R0;

      R0 = _I9HANDLER (Z);
	R0.H = _I9HANDLER; 	// IVG9 Handler
      [ P0 ++ ] = R0;

      R0 = _I10HANDLER (Z);
	R0.H = _I10HANDLER;// IVG10 Handler
      [ P0 ++ ] = R0;

      R0 = _I11HANDLER (Z);
	R0.H = _I11HANDLER;// IVG11 Handler
      [ P0 ++ ] = R0;

      R0 = _I12HANDLER (Z);
	R0.H = _I12HANDLER;// IVG12 Handler
      [ P0 ++ ] = R0;

      R0 = _I13HANDLER (Z);
	R0.H = _I13HANDLER;// IVG13 Handler
      [ P0 ++ ] = R0;

      R0 = _I14HANDLER (Z);
	R0.H = _I14HANDLER;// IVG14 Handler
      [ P0 ++ ] = R0;

      R0 = _I15HANDLER (Z);
	R0.H = _I15HANDLER;// IVG15 Handler
      [ P0 ++ ] = R0;

//	P0.L = EVT_OVERRIDE & 0xffff;  // added in to address anomaly 20 for rev 0.1 ADSP-21535 silicon
//	P0.H = EVT_OVERRIDE >> 16;
// 	R0 = 0;
// 	[ P0  ] = R0;

	SP.H = ldf_stack_end;					//Set up supervisor stack
	SP.L = ldf_stack_end;
	
	P0.L = EVT15 & 0xFFFF;		//Point to IVG15 in Event Vector Table		
	P0.H = (EVT15 >> 16) & 0xFFFF;
	P1.L = START;					//Point to start of  code	
	P1.H = START;
	[P0] = P1;						//Place the address of start code in IVG15 of EVT
	P0.L = IMASK & 0xFFFF;
	R0 = W[P0];
	R1.L = EVT_IVG15 & 0xFFFF;
	R0 = R0 | R1;
	W[P0] = R0;						//Set(enable) IVG15 bit in FCIC Interrupt Mask Register
	RAISE 15;						//Invoke IVG15 interrupt
	P0.L = WAIT_HERE;
	P0.H = WAIT_HERE;
	RETI = P0;
	nop;
	nop;
	nop;
	nop;
	RTI;							//Return from Reset Interrupt

	WAIT_HERE:						//Wait here till IVG15 interrupt is processed
		JUMP WAIT_HERE;
/********************************************************************************************/

START:
	[--SP] = RETI;					//RETI must be pushed to enable interrupts.  Boot code in supervisor mode starts here.

_main:	

	//BTC 
	call _btc_init;
	
	call Codec_Reset;	
	call Program_SPORT0_Registers;		/* Initialize SPORT0 for codec communications */
	call Program_DMA_Controller;		/* Start Serial Port 0 tx and rx DMA Transfers */
	call AD1885_Codec_Initialization;	/* Initialize & program AD1885 */
	
	/* Clear RX_Status flag indicating incoming RX data is audio data and can be processed  according */
	p0.l = RX_Status;
	p0.h = RX_Status;
	r0 = 0x0000 (z);
	[p0] = r0;

wait_forever:
	nop;
	nop;
	nop;
	call _btc_poll;
	nop;
	nop;
	nop;
	jump wait_forever;
	
_main.end:

_EHANDLER:            // Emulation Handler 0
    RTE;

_RHANDLER:            // Reset Handler 1
    RTI;

_NHANDLER:            // NMI Handler 2
	RTN;

_XHANDLER:            // Exception Handler 3
    RTX;

_HWHANDLER:           // HW Error Handler 5
    RTI;

_THANDLER:            // Timer Handler 6
	RTI;

_RTCHANDLER:           // IVG 7 Handler  (RTC)
	RTI;

_I8HANDLER:           // IVG 8 Handler
	[--SP] = (r7:0);
	[--SP] = (p5:0);
	[--sp] = a0.w;
	[--sp] = a0.x;
	[--sp] = a1.w;
	[--sp] = a1.x;
	[--SP] = i0;
	[--SP] = l0;
	[--SP] = lc0;
	[--SP] = lt0;
	[--SP] = lb0;
	[--SP] = lc1;
	[--SP] = lt1;
	[--SP] = lb1;
	[--SP] = astat;
	[--SP] = rets;
	
//R0 = LENGTH(rx_buf);
r0 = 16;
	p0.l = SPORT0_COUNT_RX & 0xFFFF;
	p0.h = (SPORT0_COUNT_RX >> 16) & 0xFFFF;
	R1 = W[p0];
	R0 = R0 - R1;
	CC = AZ;
IF !CC jump Roll_Over;

	R0.l = 0x8000;
	p0.l = RX_Status;
	p0.h = RX_Status;
	r1 = w[p0];
	R0 = R0 & R1;
	CC = AZ;
	IF !CC jump Roll_Over;
	call Process_AD1885_Audio_Samples;


Roll_Over:
	R0 = 0x0007;			// Clear RX Interrupts
	P0.L = SPORT0_IRQSTAT_RX & 0xFFFF;
	P0.H = (SPORT0_IRQSTAT_RX >> 16) & 0xFFFF;
	W[p0] = R0;
	
	// Restore Regs
	rets = [sp++];
	astat = [sp++];
	lb1 = [SP++];
	lt1 = [SP++];
	lc1 = [SP++];
	lb0 = [SP++];
	lt0 = [SP++];
	lc0 = [SP++];
	l0 = [SP++];
	i0 = [SP++];
	a1.x = [sp++];
	a1.w = [sp++];
	a0.x = [sp++];
	a0.w = [sp++];
	(p5:0) = [SP++];  		
	(r7:0) = [SP++];
	RTI;

_I9HANDLER:           // IVG 9 Handler
    RTI;

_I10HANDLER:          // IVG 10 Handler
    RTI;

_I11HANDLER:          // IVG 11 Handler
    RTI;

_I12HANDLER:          // IVG 12 Handler
    RTI;

_I13HANDLER:		// IVG 13 Handler
    RTI;

_I14HANDLER:
    RTI;

_I15HANDLER:
    RTI;