ac97.c

samsung 最新芯片2450 的测试程序.

/*======================================================================

 Project Name : S3C2443

 Copyright 2006 by Samsung Electronics, Inc.
 All rights reserved.

 Project Description :
 This software is only for verifying functions of the S3C2443. 
 Anybody can use this code without our permission.

 File Name    : AC97.c
 Description  : S3C2443 AC97 module code
 Author       : Junon Jeon
 Dept         : AP
 Created Date : 2006.06.02
 Version      : 0.0
 History
   R0.0 (2006.06.02): Junon draft
		- This code is derived from S3C2460A AC97 test code.
   	    - This S3C2443 AC97 test code works with WM9710 AC97 CODEC on the SMDK2443. 
	    - AC97 PCM-In in DMA or interrupt mode is supported.
        - AC97 PCM-Out in DMA or interrupt mode is supported.
	    - Volume up/down is available, when codec plays PCM data.
        - AC97 power down mode test is supported.	
        - AC97 reset timing check is supported.
        - Variable ADC/DAC operation is supported. 
		
=======================================================================*/

#include "system.h"
#include "ac97.h"
#include "SfrReadWriten.h"
#include "audiolibrary.h"
#include "audiolibraryexterns.h"
#include "tada.h"

#define AC97_REC_LEN 0xfffff*4	//Max value of DMA Transfer Counter (20bit) = 0xfffff, Date Size=Word (4bytes)
//#define AC97_REC_LEN 0xfffff

#define AC97_LINE_LEN (20)	
#define AC97_MIC_REC_LEN (20)	//Max value of DMA Transfer Counter (20bit) = 0xfffff, Date Size=Word (4bytes)
// sec = sampling rate
//       * 2byte (16bit mono) , 10seconds

#define DOWN_BUF _NONCACHE_STARTADDRESS
#define PCM_OUT_TRIGGER 8
#define PCM_IN_TRIGGER 8

#define AC97_CODECREADY_INT (1<<22)

#define AC97_PCM_OUT_UNDERRUN (1<<21)
#define AC97_PCM_IN_OVERRUN (1<<20)
#define AC97_MIC_IN_OVERRUN (1<<19)

#define AC97_PCM_OUT_THRESHOLD (1<<18)
#define AC97_PCM_IN_THRESHOLD (1<<17)
#define AC97_MIC_IN_THRESHOLD (1<<16)

#define AC97_PCM_OUT_MODE_OFF (0<<12)
#define AC97_PCM_OUT_MODE_PIO (1<<12)
#define AC97_PCM_OUT_MODE_DMA (2<<12)
#define AC97_PCM_OUT_MODE_MASK (3<<12)

#define AC97_PCM_IN_MODE_OFF (0<<10)
#define AC97_PCM_IN_MODE_PIO (1<<10)
#define AC97_PCM_IN_MODE_DMA (2<<10)

#define AC97_MIC_IN_MODE_OFF (0<<8)
#define AC97_MIC_IN_MODE_PIO (1<<8)
#define AC97_MIC_IN_MODE_DMA (2<<8)

#define AC97_ACLINK_ON			(1<<2)
#define AC97_TRANSFERDATA_EN	(1<<3)

// Global variables
unsigned int AC97_size, AC97_fs;
unsigned int Output_Volume,Input_Volume;
unsigned int *Rec_AC97_BUF, *End_Rec_AC97_BUF, *Play_AC97_BUF, *End_AC97_BUF;
volatile static int	timer_exit=0;

volatile short AC97_Out_INT_Exit = 0;
volatile short AC97_In_INT_Exit =0;

unsigned char *AC97_BUF,*AC97_temp;
unsigned char Volume_Control;

char AC97_Rec_Done = 0;
char Codec_Ready_Irq;
char AC97_mute = 1;
char Codec_Ready = 1;

int g_test=0;

//SFR test	
REGINFOn		sRegInfoAC97[] = 
{ 
    //01234567890123 ..63     			  address             reset        uPrivateBitMask(1:do check)
    //														  value       
	{"AC_GLBCTRL                    ",	0x5B000000,  2-1, RW, 0x0  , DPDB, 0			,0},//reset
	{"AC_GLBCTRL                    ",	0x5B000000, 23-2, RW, 0x0  , DPPB, 0x7f3f0e		,0},		
	{"AC_GLBSTAT                    ",	0x5B000004, 23-1, RO, 0x1  , DPDB, 0			,0},	
	{"AC_CODEC_CMD                  ",	0x5B000008, 24-1, RW, 0x0  , DPDB, 0			,0},	
	{"AC_CODEC_STAT                 ",	0x5B00000C, 23-1, RO, 0x0  , DPDB, 0			,0},	
	{"AC_PCMADDR                    ",	0x5B000010, 28-1, RO, 0x0  , DPPB, 0xf0f0f0f	,0},	
	{"AC_MICADDR                    ",	0x5B000014, 20-1, RO, 0x0  , DPPB, 0xf000f		,0},	
	{"AC_PCMDATA(FIFO read/write)   ",	0x5B000018, 32-1, RO, 0x0  , DPDB, 0			,0},//fifo read / write should check from ac link	
	{"AC_MICDATA(fifo read)         ",	0x5B00001C, 16-1, RO, 0x0  , DPDB, 0			,0},//fifo	read should check from ac link
};


//Externs
extern bool TestSFRn(const REGINFOn* psRegInfo, int count);//sfrreadwriten.c
extern void AC97_Port_Init(void);//codec.c
extern void AC97_Port_Return(void);
extern unsigned short AC97_Codec_Cmd(unsigned char CMD_Read, unsigned char CMD_Offset, unsigned short CMD_Data);

// Functions
bool AC97_SFR_test();
void AC97_Interrupt_Test();

// AC97 Controller configuration
void AC97_Controller_State(void);
bool AC97_Init(void);
// AC97 CODEC control
unsigned short AC97_Codec_Cmd(unsigned char CMD_Read, unsigned char CMD_Offset, unsigned short CMD_Data);
void AC97_CodecInit_PCMOut(unsigned short AC97_fs);
void AC97_CodecInit_PCMIn(unsigned short AC97_fs);
void AC97_CodecInit_MICIn(unsigned short AC97_fs);
void AC97_CodecInit_PD(void);
void AC97_CodecExit_PCMOut(void);
void AC97_CodecExit_PCMIn(unsigned short DACs_off);
void AC97_CodecExit_MICIn(unsigned short DACs_off);
void PCM_In_Volume( unsigned char Up_Down_Volume);
void PCM_Out_Volume( unsigned char Up_Down_Volume);
void Download_PCM_File(void);
// AC97 data in/out function
void AC97_PCMout_DMA1(unsigned int Addr, unsigned int PCM_Size);
void AC97_PCMin_DMA2(unsigned int PCM_Size);
void AC97_MICin_DMA3(unsigned int MIC_Size);

void AC97_PCMout_INT(unsigned int PCM_Size);
void AC97_PCMin_INT(unsigned int PCM_Size);
void AC97_MICin_INT(unsigned int PCM_Size);

void AC97_PCMout_Polling(unsigned int PCM_Size);
void AC97_PCMin_Polling(unsigned int PCM_Size);
void AC97_MICin_Polling(unsigned int PCM_Size);

void AC97_PCMout_PollingInterruptTest();
void AC97_PCMin_PollingInterruptTest(unsigned int PCM_Size);
void AC97_MICin_PollingInterruptTest(unsigned int PCM_Size);

void AC97_Demo();

char AC97_FifoEmptyCntPCMOUT(bool bprint);
char AC97_FifoEmptyCntPCMIN(bool bprint);
char AC97_FifoEmptyCntMICIN(bool bprint);
char AC97_FifoCntMICIN(bool bprint);

static void __irq DMA1_Play_Done(void);
static void __irq DMA2_Rec_Done(void);
static void __irq DMA3_Rec_Done(void);

void __irq AC97_Codec_Ready(void);
void __irq Irq_AC97_PCMout(void);
void __irq Irq_AC97_PCMin(void);
void __irq Irq_AC97_MICin(void);

void __irq Irq_AC97_PCMoutIntTest(void);
void __irq Irq_AC97_PCMinIntTest(void);
void __irq Irq_AC97_MICinIntTest(void);

static void __irq IsrWatchdog(void);
void __irq RxInt(void);

// other library
unsigned short AC97_Select_SamplingRate(void);
float delay_func(unsigned short num_delay); 
 

void * func_ac97_test[][2]=
{	
	//AC97 Function Test Item
	(void *)AC97_SFR_test, 			"AC97 SFR reset value, r/w test",
	(void *)Powerdown_Test_AC97,	"AC97 Power Down   ",  
	(void *)AC97_Demo,			"playing sample wav  \n\n",  	

	(void *)PCM_Out_Test_AC97,		"Play Wave file",   
	(void *)PCM_In_Out_Test_AC97,	"Record Sound via LineIn and Play it  ",   
	(void *)MICin_Test_AC97,		"Record Voice via MIC and Play it      ",    

	
	(void *)Reset_Test_AC97,		"AC97 Reset Timing Check ",	
	(void *)AC97_Interrupt_Test,	"AC97 Interrupt test",
	0,0
};


void Test_AC97(void)
{
	int i;

	AC97_Port_Init();
	
	while(1)
	{
		i=0;
		printf("\n\n==================== AC97 Function Test ====================\n\n");
		while(1)
		{   //display menu
			printf("%2d:%s",i,func_ac97_test[i][1]);
			i++;
			if((int)(func_ac97_test[i][0])==0)
			{
				printf("\n");
				break;
			}
			if((i%2)==0)
			printf("\n");
		}
		printf("\n============================================================");
		printf("\nSelect #Item or Press enter key to exit:");
		i = GetIntNum();
			
		
		if(i==-1) break;		// return.	
		if(i>=0 && (i<(sizeof(func_ac97_test)/8)) )	// select and execute...
			( (void (*)(void)) (func_ac97_test[i][0]) )();
	}
	
	rAC_GLBCTRL = 0;
}



//should execute at first
bool AC97_SFR_test()
{
	bool bret;
	bret=TestSFRn(sRegInfoAC97, sizeof(sRegInfoAC97)/sizeof(REGINFOn));
	return bret;
}

//============================== [ AC97 Drivers ] ===============================



void AC97_Controller_State(void)
{
	unsigned char state;
    
    	state=(unsigned char)(rAC_GLBSTAT);

     	switch(state)
    	{
		case 0:
		printf("AC97 Controller State: Idle\n"); 
		break;
	
		case 1:
			printf("AC97 Controller State: Init\n"); 
		break;

		case 2:
		       printf("AC97 Controller State: Ready\n"); 
		break;
		
		case 3:
			printf("AC97 Controller State: Active\n"); 
		break;

		case 4:
			printf("AC97 Controller State: LP\n"); 
		break;

		case 5:
			printf("AC97 Controller State: Warm\n"); 
		break;

		default:
		break;
     	}
}

void AC97_ColdReset(void)
{
 	//Cold Reset 
	rAC_GLBCTRL = 0x1;	// controller and codec cold reset
	Delay(1000);		// delay for controller safety reset
	rAC_GLBCTRL = 0x0;	// controller and codec normal mode
	Delay(1000);		
	
	//for secure cold reset following are needed
	rAC_GLBCTRL = 0x1;							
	Delay(1000);									
	rAC_GLBCTRL = 0x0;						
	Delay(1000);
	//
	
	printf("AC97 Codec Powerdown Ctrl/Stat Reg. Value (at 0x26): 0x%x\n", AC97_Codec_Cmd(1,0x26,0x0000));		
}

void AC97_WarmReset(void)
{
 	//Warm Reset
 	printf("\n=>Warm Reset\n");
 	rAC_GLBCTRL = (1<<1);
 	AC97_Controller_State();
 	rAC_GLBCTRL &= ~(1<<1);
 	/*
 	rAC_GLBCTRL |= (1<<2);
 	AC97_Controller_State();
 	rAC_GLBCTRL |= (1<<3);
 	printf("AC97 Codec Powerdown Ctrl/Stat Reg. Value (at 0x26): 0x%x\n", AC97_Codec_Cmd(1,0x26,0x0000));	
 	*/
}

bool AC97_Init(void)
{
	int i=0;

	printf("\nAC97 Initialization...\n");	

	AC97_ColdReset();

#if (AC97_CODEC_NAME== AC97WM9713)

	AC97_WarmReset();	

#endif
	
	//AC-link On
	rAC_GLBCTRL = (1<<2);
	Delay(1000);	
	AC97_Controller_State();

	//Transfer data enable using AC-link
	rAC_GLBCTRL |= (1<<3);	// AC97 Data transfer active 
	Delay(1000);	
	AC97_Controller_State();
	
	printf("\nAC97-Link On...\n");
       
	//Codec Ready Check using Codec Ready Interrupt
	Codec_Ready_Irq =0;	
	pISR_WDT_AC97 = (unsigned)AC97_Codec_Ready;	

	ClearPending(BIT_WDT_AC97);	
	rSUBSRCPND=(BIT_SUB_AC97);

   	rINTMSK=~(BIT_WDT_AC97);			
   	rINTSUBMSK=~(BIT_SUB_AC97);

   	rAC_GLBCTRL |= AC97_CODECREADY_INT;
   	
	while(!Codec_Ready_Irq)
	{

	 	printf(".");
         	Delay(3000);
         	i++;
         	
         	if(i==20)
		break;
	 }

	printf("\n");

	if(i==20)
	{
		printf("\nAC97 codec is not ready.");
		printf("\nCheck on connection between S3C2460 and AC97 CODEC.\n");
		printf("\nBye. ");
		Codec_Ready = 0;
		return 0;
	}
	
	return 1;
}



void AC97_CodecInit_PD(void)
{
#if (AC97_CODEC_NAME== STAC9767)

	printf("\nAC97 Codec Soft Reset\n");
	AC97_Codec_Cmd(0,0x00,0x683F);		//Codec Soft Reset : 16bit In/Out  (stac9766/67) 	
	printf("AC97 Codec 0x26 Reg.: 0x%x\n\n", AC97_Codec_Cmd(1,0x26,0x0000));		
	
#endif	
}


//input : cmdoffset  ADC-linein, micin (0x32), DAC-out(0x2c), 
//input : sample freq
//when VRA is off, setting to this register is meaningless, it will play/record at 48KHz.
void AC97_CodecSampleFreq(unsigned char cmdoffset, unsigned short samplefreq)
{
		if(samplefreq==48000){
		//ADC Sampling frequency 48kHz
		AC97_Codec_Cmd(0,cmdoffset,0xbb80);	
		}
		else if(AC97_fs==24000){
		//ADC Sampling frequency 24kHz
		AC97_Codec_Cmd(0,cmdoffset,0x5dc0);	 	
		}				
		else if(AC97_fs==12000){
		//ADC Sampling frequency 12kHz
		AC97_Codec_Cmd(0,cmdoffset,0x2ee0);	 	
		}
				
		else if(AC97_fs==44100){
		//ADC Sampling frequency 44.1kHz
		AC97_Codec_Cmd(0,cmdoffset,0xac44);
		}
		else if(AC97_fs==22050){
		//ADC Sampling frequency 22.05kHz
		AC97_Codec_Cmd(0,cmdoffset,0x5622);	 			
		}
		else if(AC97_fs==11025){
		//ADC Sampling frequency 11.025kHz
		AC97_Codec_Cmd(0,cmdoffset,0x2b11);	 	
		}
						
		else if(AC97_fs==32000){
		//ADC Sampling frequency 32kHz
		AC97_Codec_Cmd(0,cmdoffset,0x7d00);	 	
		}
		else if(AC97_fs==16000){
		//ADC Sampling frequency 16kHz
		AC97_Codec_Cmd(0,cmdoffset,0x3e80);	
		}
		else if(AC97_fs==8000){
		//ADC Sampling frequency 8kHz
		AC97_Codec_Cmd(0,cmdoffset,0x1f40);	
		}	
}

void AC97_CodecInit_PCMIn( unsigned short AC97_fs)
{
	int i;
	#if (AC97_CODEC_NAME== STAC9767)	
		AC97_Codec_Cmd(0,0x00,0x683F);		//codec soft reset 	

		AC97_Codec_Cmd(0,0x26,(1<<9));		//all power on except DAC Block
		printf("\nAC97 Codec 0x26 Reg.: 0x%x\n\n", AC97_Codec_Cmd(1,0x26,0x0000));
		
		AC97_Codec_Cmd(0,0x2A,0x0001);		//variable rate enable	
		//printf("\nVRA Enable(1)/Disable(0): 0x%x\n", (0x1&AC97_Codec_Cmd(1,0x2A,0x0001)));
		
		if(AC97_fs==48000){
		//ADC Sampling frequency 48kHz
		AC97_Codec_Cmd(0,0x32,0xbb80);	
		}
		else if(AC97_fs==44100){
		//ADC Sampling frequency 44.1kHz
		AC97_Codec_Cmd(0,0x32,0xac44);
		}
		else if(AC97_fs==22050){
		//ADC Sampling frequency 22.05kHz
		AC97_Codec_Cmd(0,0x32,0x5622);	 	
		}
		else if(AC97_fs==8000){
		//ADC Sampling frequency 8kHz
		AC97_Codec_Cmd(0,0x32,0x1F40);	 	
		}

		AC97_Codec_Cmd(0,0x10,0x1010);		//line in volume on
		//* khs.050504
		//*	removed because seem that this is not necessary
		//AC97_Codec_Cmd(0,0x6e,0x0000);		//All Analog Mode, ADC Input select => left slot3, right slot4
		AC97_Codec_Cmd(0,0x1a,0x0505);		//record source select => Stereo Mix
		AC97_Codec_Cmd(0,0x1c,0x0909);		//record gain is initial
		//* khs.050504
		//*	removed because seem that this is not necessary
		//AC97_Codec_Cmd(0,0x78,0x0001);		//ADC HPF Bypass
		AC97_Codec_Cmd(0,0x20,0x0000);		//General Reg.
		
		Input_Volume = 	AC97_Codec_Cmd(1,0x10,0x0000);	      //Line In volume	
		printf("Current Line-In Volume level : 0x%04x\n",Input_Volume);	
	
	#elif (AC97_CODEC_NAME== AC97WM9713)	

	 	AC97_Codec_Cmd(0,0x26, 0x4f00);		// Enable PR5(Internal Clock, AC-link I/F)
		AC97_Codec_Cmd(0,0x26, 0x4700);		// Enable PR3(VREF, I/P PGA's, DAC's, ADC's, Mixer, O/P's)