uda1341ts.c

os arm os arm os arm os arm os arm os arm os arm os arm os arm os arm os arm os arm os arm os arm

/*
 *	ApOS (Another Project software for s3c2410)
 *	
 *	This program is free software; you can redistribute it and/or modify
 *	it under the terms of the GNU General Public License version 2 as
 *	published by the Free Software Foundation.
 *			
 *						Copyright caiyuqing
 *
 */
#include "../include/s3c2410/s3c2410.h"
#include "../include/s3c2410/UDA1341TS.h" 
#include "../include/s3c2410/io.h" 

extern struct io_control_obj io_control_obj;

/*
 *	L3MODE,L3DATA,L3ClOCK是L3接口的三个管脚，它们连接于CPU的GPB2,GPB3,GB4
 *
 */
#define L3MODE(n) (n)?(*io_control_obj.gpb_data|=(1<<L3M)):(*io_control_obj.gpb_data&=~(1<<L3M))
#define L3DATA(n) (n)?(*io_control_obj.gpb_data|=(1<<L3D)):(*io_control_obj.gpb_data&=~(1<<L3D))
#define L3ClOCK(n) (n)?(*io_control_obj.gpb_data|=(1<<L3C)):(*io_control_obj.gpb_data&=~(1<<L3C))

#define UP 	1
#define DOWN 	0

unsigned char UDA1341TS_STATUS_BYTE0;
unsigned char UDA1341TS_STATUS_BYTE1;
unsigned char UDA1341TS_DATA0_BYTE0;
unsigned char UDA1341TS_DATA0_BYTE1;
unsigned char UDA1341TS_DATA0_BYTE2;
unsigned char UDA1341TS_DATA0_BYTE3;
unsigned char UDA1341TS_DATA0_BYTE4;
unsigned char UDA1341TS_DATA1_BYTE0;

//----------------------------------UDA1341TS Base Function----------------------------------------

/*
 *
 *
 */
void UDA1341TS_WrL3Addr(unsigned char addr)
{
	int i,j;

	L3ClOCK(UP);
	L3MODE(DOWN);
	for(j=0;j<4;j++);

	for(i=0;i<8;i++)
	{
		if((addr>>i)&0x01)
		{
			L3ClOCK(DOWN);
			L3DATA(1);
			for(j=0;j<4;j++);

			L3ClOCK(UP);
			L3DATA(1);
			for(j=0;j<4;j++);
		}
		else
		{
			L3ClOCK(DOWN);
			L3DATA(0);
			for(j=0;j<4;j++);

			L3ClOCK(UP);
			L3DATA(0);
			for(j=0;j<4;j++);
		}
	}

	L3ClOCK(UP);
	L3MODE(UP);
	for(j=0;j<4;j++);
}

/*
 *
 *
 */
void UDA1341TS_WrL3Data(unsigned char data)
{
	int i,j;

	L3ClOCK(UP);
	L3MODE(UP);
	for(j=0;j<4;j++);

	for(i=0;i<8;i++)
	{
		if((data>>i)&0x01)
		{
			L3ClOCK(DOWN);
			L3DATA(1);
			for(j=0;j<4;j++);

			L3ClOCK(UP);
			L3DATA(1);
			for(j=0;j<4;j++);
		}
		else
		{
			L3ClOCK(DOWN);
			L3DATA(0);
			for(j=0;j<4;j++);

			L3ClOCK(UP);
			L3DATA(0);
			for(j=0;j<4;j++);
		}
	}

	L3ClOCK(UP);
	L3MODE(UP);
	for(j=0;j<4;j++);
}

void UDA1341TS_select_data_transfer_mode(unsigned char selection)
{
	switch(selection)
	{
		case DATA0:
			UDA1341TS_WrL3Addr(UDA1341TS_ADDR|DATA0);
			break;
			
		case DATA1:
			UDA1341TS_WrL3Addr(UDA1341TS_ADDR|DATA1);
			break;
			
		case STATUS:
			UDA1341TS_WrL3Addr(UDA1341TS_ADDR|STATUS);
			break;
	}
}

void UDA1341TS_set_status()
{
	UDA1341TS_WrL3Data(UDA1341TS_STATUS_BYTE0);
	UDA1341TS_WrL3Data(UDA1341TS_STATUS_BYTE1);
}

void UDA1341TS_set_data0()
{
	UDA1341TS_WrL3Data(UDA1341TS_DATA0_BYTE0);
	UDA1341TS_WrL3Data(UDA1341TS_DATA0_BYTE1);
	UDA1341TS_WrL3Data(UDA1341TS_DATA0_BYTE2);
	UDA1341TS_WrL3Data(UDA1341TS_DATA0_BYTE3);
	UDA1341TS_WrL3Data(UDA1341TS_DATA0_BYTE4);
}

void UDA1341TS_set_data1()
{
	UDA1341TS_WrL3Data(UDA1341TS_DATA1_BYTE0);
}

//----------------------------------UDA1341TS Feature Function----------------------------------------

/*
 *
 */
void UDA1341TS_reset()
{
	UDA1341TS_STATUS_BYTE0|=(1<<RST);

}
void UDA1341TS_no_reset()
{
	UDA1341TS_STATUS_BYTE0&=~(1<<RST);

}
/*
 *
 */
void UDA1341TS_set_sysclock(unsigned char clock)
{
	
	UDA1341TS_STATUS_BYTE0&=~(0x3<<CS0);
	switch(clock)
	{
		case _512FS:
			UDA1341TS_STATUS_BYTE0|=(0<<CS1|0<<CS0);
			break;
		case _384FS:
			UDA1341TS_STATUS_BYTE0|=(0<<CS1|1<<CS0);
			break;
		case _256FS:
			UDA1341TS_STATUS_BYTE0|=(1<<CS1|0<<CS0);
			break;
	}
}


/*
 *
 */
void UDA1341TS_set_dc_filter(unsigned char type)
{
	UDA1341TS_STATUS_BYTE0&=~(0x1<<DC);
	
	switch(type)
	{
		case NO_DC_FILTER:
			UDA1341TS_STATUS_BYTE0|=(0<<DC);
			break;
			
		case DC_FILTER:
			UDA1341TS_STATUS_BYTE0|=(1<<DC);
			break;
	}

}


/*
 *
 */
void UDA1341TS_set_input_format(unsigned char type)
{
	UDA1341TS_STATUS_BYTE0&=~(0x7<<IF0);
	
	switch(type)
	{
		case IIS_BUS:
			UDA1341TS_STATUS_BYTE0|=(0<<IF2|0<<IF1|0<<IF0);
			break;
			
		case LSB_JUSTIFIED16:
			UDA1341TS_STATUS_BYTE0|=(0<<IF2|0<<IF1|1<<IF0);
			break;
			
		case LSB_JUSTIFIED18:
			UDA1341TS_STATUS_BYTE0|=(0<<IF2|1<<IF1|0<<IF0);
			break;
			
		case LSB_JUSTIFIED20:
			UDA1341TS_STATUS_BYTE0|=(0<<IF2|1<<IF1|1<<IF0);
			break;
			
		case MSB_JUSTIFIED:
			UDA1341TS_STATUS_BYTE0|= (1<<IF2|0<<IF1|0<<IF0);
			break;
			
		case LSB_JUSTIFIED16_IN_MSB_JUSTIFIED_OUT:
			UDA1341TS_STATUS_BYTE0|=(1<<IF2|0<<IF1|1<<IF0);
			break;
			
		case LSB_JUSTIFIED18_IN_MSB_JUSTIFIED_OUT:
			UDA1341TS_STATUS_BYTE0|=(1<<IF2|1<<IF1|0<<IF0);
			break;
			
		case LSB_JUSTIFIED20_IN_MSB_JUSTIFIED_OUT:
			UDA1341TS_STATUS_BYTE0|=(1<<IF2|1<<IF1|1<<IF0);
			break;
			
		
	}

}


/*
 *
 */
void UDA1341TS_gain_switch_dac(unsigned char type)
{
	
	UDA1341TS_STATUS_BYTE1&=~(0x1<<OGS);
	
	switch(type)
	{
		case _0DB:
			UDA1341TS_STATUS_BYTE1|=(0<<OGS);
			break;
			
		case _6DB:
			UDA1341TS_STATUS_BYTE1|=(1<<OGS);
			break;
	}

}



/*
 *
 */
void UDA1341TS_gain_switch_adc(unsigned char type)
{
	UDA1341TS_STATUS_BYTE1&=~(0x1<<IGS);
	
	switch(type)
	{
		case _0DB:
			UDA1341TS_STATUS_BYTE1|=(0<<IGS);
			break;
			
		case _6DB:
			UDA1341TS_STATUS_BYTE1|=(1<<IGS);
			break;
	}

}


/*
 *
 */
void UDA1341TS_polarity_adc(unsigned char type)
{
	UDA1341TS_STATUS_BYTE1&=~(0x1<<PAD);
	
	switch(type)
	{
		case NON_INVERTING:
			UDA1341TS_STATUS_BYTE1|=(0<<PAD);
			break;
			
		case INVERTINTG:
			UDA1341TS_STATUS_BYTE1|=(1<<PAD);
			break;
	}

}


/*
 *
 */
void UDA1341TS_polarity_dac(unsigned char type)
{
	UDA1341TS_STATUS_BYTE1&=~(0x1<<PDA);
	
	switch(type)
	{
		case NON_INVERTING:
			UDA1341TS_STATUS_BYTE1|=(0<<PDA);
			break;
			
		case INVERTINTG:
			UDA1341TS_STATUS_BYTE1|=(1<<PDA);
			break;
	}

}


/*
 *
 */
void UDA1341TS_double_speed(unsigned char type)
{
	UDA1341TS_STATUS_BYTE1&=~(0x1<<DS);
	
	switch(type)
	{
		case SINGLE_SPEED_PLAYBACK:
			UDA1341TS_STATUS_BYTE1|=(0<<DS);
			break;

		case DOUBLE_SPEED_PLAYBACK:
			UDA1341TS_STATUS_BYTE1|=(1<<DS);
			break;
	}

}


/*
 *
 */
void UDA1341TS_power_control(unsigned char type)
{

	UDA1341TS_STATUS_BYTE1&=~(0x3<<PC0);
	
	switch(type)
	{
		case ADC_OFF_DAC_OFF:
			UDA1341TS_STATUS_BYTE1|=(0<<PC1|0<<PC0);
			break;

		case ADC_OFF_DAC_ON:
			UDA1341TS_STATUS_BYTE1|=(0<<PC1|1<<PC0);
			break;
		case ADC_ON_DAC_OFF:
			UDA1341TS_STATUS_BYTE1|=(1<<PC1|0<<PC0);
			break;

		case ADC_ON_DAC_ON:
			UDA1341TS_STATUS_BYTE1|=(1<<PC1|1<<PC0);
			break;
	}

}

//----------------------------------UDA1341TS init Function-------------------------------------------
void UDA1341TS_param_init()
{
	UDA1341TS_STATUS_BYTE0=0x00;
	UDA1341TS_STATUS_BYTE1=1<<7;
	
	UDA1341TS_DATA0_BYTE0=0x00;
	UDA1341TS_DATA0_BYTE1=1<<6;
	UDA1341TS_DATA0_BYTE2=1<<7;
	UDA1341TS_DATA0_BYTE3=3<<6;
	UDA1341TS_DATA0_BYTE3=5<<5;	
	
	UDA1341TS_DATA1_BYTE0=0x00;
}

void UDA1341TS_init()
{
	UDA1341TS_param_init();
	
	UDA1341TS_select_data_transfer_mode(STATUS);
	
	UDA1341TS_reset();
	
	UDA1341TS_set_status();
	
	UDA1341TS_no_reset();
	UDA1341TS_set_sysclock(_256FS);
	UDA1341TS_set_dc_filter(NO_DC_FILTER);
	UDA1341TS_set_input_format(IIS_BUS);
	UDA1341TS_gain_switch_dac(_0DB);  
	UDA1341TS_gain_switch_adc(_0DB);
	UDA1341TS_polarity_adc(NON_INVERTING);
	UDA1341TS_polarity_dac(NON_INVERTING);
	UDA1341TS_double_speed(SINGLE_SPEED_PLAYBACK);
	UDA1341TS_power_control(ADC_OFF_DAC_ON);

	UDA1341TS_set_status();
}