/*==========================================================================
 * Copyright (c) 2005 Digital Stream Technologies Inc.  All Rights Reserved.
 *
 * Module:      sta323w.c
 * Author: 		Arzhna, arzhna@dstreamtech.com
 * Description: STA323W, Audio Sound Controller
 *
 ==========================================================================*/
 
#include "dsthalcommon.h"
#include "STA323W_reg.h"
#include "STA323W.h"

#ifndef USE_12288_MCLK
#define USE_12288_MCLK 0
#endif

#define STA_DEBUG	1

#define	I2C_STA323W_WRITE		0x34
#define	I2C_STA323W_READ		0x35


extern DS_U32 gdhlExtDbgLvl;

void STA323W_ReadConfig(void);

DS_U8 DEFAULT_CH_VOL = DEFAULT_CH_DTV_VOL_9W_12V_REG;
DS_U8 DEFAULT_CH_DTV_VOL = DEFAULT_CH_DTV_VOL_9W_12V_REG;
DS_U8 DEFAULT_CH_CAP_VOL = DEFAULT_CH_CAP_VOL_9W_12V_REG;
DS_U8	I2C_STA_WRITE 	= I2C_STA323W_WRITE;
DS_U8	I2C_STA_READ	= I2C_STA323W_READ;

int SRS_COMP = SRS_COMP_9W_12V;
int AVL_COMP = AVL_COMP_9W_12V;

/*=====================================================================
	Register Write Function
 =====================================================================*/
int STA323W_SetAddress( DS_U8 read, DS_U8 write) // 323W 와 333W,333BW가 ADDRESS가 다르기 때문에 기존 DEFINE으로 처리되던 부분을 변수로
{
	int retVal = 0;
	I2C_STA_WRITE  	= write;
	I2C_STA_READ	= read;
	return retVal;
}

int STA323W_RegWrite( DS_U8 regNum, DS_U8 data )
{
	int retVal = 0;

	if ( regNum > STA323W_COEF_WRT_CTRL ) {
		DHL_DbgPrintf(0,DHLDBG_EXT, "|%s| failed, line = %d\n", __FUNCTION__, __LINE__);
		retVal = -1;
		return retVal;
	}

	retVal = DHL_SYS_I2cWrite( I2C_STA_WRITE, TRUE, regNum, &data, 1 );
	
	if ( retVal != 0 )
		DHL_DbgPrintf(0,DHLDBG_EXT, "|%s| failed.\n", __FUNCTION__);
		
	return retVal;
}

int STA323W_RegWriteMultiple( DS_U8 regNum, DS_U8 *data, DS_U8 Len )
{
	int retVal = 0;

	if ( regNum > STA323W_COEF_WRT_CTRL ) {
		DHL_DbgPrintf(0,DHLDBG_EXT, "|%s| failed, line = %d\n", __FUNCTION__, __LINE__);
		retVal = -1;
		return retVal;
	}

	retVal = DHL_SYS_I2cWrite( I2C_STA_WRITE, TRUE, regNum, data, Len );
	
	if ( retVal != 0 )
		DHL_DbgPrintf(0,DHLDBG_EXT, "|%s| failed.\n", __FUNCTION__);
		
	return retVal;
}

/*=====================================================================
	Register Write Function
 =====================================================================*/

int STA323W_RegRead( DS_U8 regNum, DS_U8 *data )
{
	int retVal = 0;

	if ( regNum > STA323W_COEF_WRT_CTRL ) {
		DHL_DbgPrintf(0,DHLDBG_EXT, "|%s| failed, line = %d\n", __FUNCTION__, __LINE__);
		retVal = -1;
		return retVal;
	}
#if 0
	retVal = DHL_SYS_I2cWrite( I2C_STA323W_READ, TRUE, regNum, 0, 0 );
	if ( retVal != 0 )
		DHL_DbgPrintf(0,DHLDBG_EXT, "|%s| failed.\n", __FUNCTION__);
#endif

	retVal = DHL_SYS_I2cWriteAndRead( I2C_STA_READ, TRUE, regNum, data, 1 );
	if ( retVal != 0 )
		DHL_DbgPrintf(0,DHLDBG_EXT, "|%s| failed.\n", __FUNCTION__);
		
	return retVal;
}

int STA323W_RegReadMultiple( DS_U8 regNum, DS_U8 *data, DS_U8 Len )
{
	int retVal = 0;

	if ( regNum > STA323W_COEF_WRT_CTRL ) {
		DHL_DbgPrintf(0,DHLDBG_EXT, "|%s| failed, line = %d\n", __FUNCTION__, __LINE__);
		retVal = -1;
		return retVal;
	}

	retVal = DHL_SYS_I2cRead( I2C_STA_READ, TRUE, regNum, data, Len );
	
	if ( retVal != 0 )
		DHL_DbgPrintf(0,DHLDBG_EXT, "|%s| failed.\n", __FUNCTION__);
		
	return retVal;
}


#if STA_DEBUG//BK
void sta_r(int reg)
{
	DS_U8 data;
	STA323W_RegRead(reg, &data);
	DHL_DbgPrintf(0,DHLDBG_EXT, "STA read: [0x%x]=0x%x\n",reg, (int)data);
}
void sta_w(int reg, DS_U8 data)
{
	DS_U8 data1;
	STA323W_RegRead(reg, &data1);
	DHL_DbgPrintf(0,DHLDBG_EXT, "STA befor: [0x%x]=0x%x\n", reg, (int)data1);
	STA323W_RegWrite(reg,data);
	STA323W_RegRead(reg, &data1);
	DHL_DbgPrintf(0,DHLDBG_EXT, "STA after: [0x%x]=0x%x\n", reg, (int)data1);
}
#endif


/*=====================================================================
	Chip Control Function
 =====================================================================*/
static int g_STA323W_Intialized = 0;
int STA323W_Init(void)
{
	int err = 0;

	if ( g_STA323W_Intialized == 1 )
		return err;

#if USE_12288_MCLK
	err |= STA323W_RegWrite(STA323W_CONFIG_A, 0x63);	
#else
	err |= STA323W_RegWrite(STA323W_CONFIG_A, 0x61);	
#endif
	err |= STA323W_RegWrite(STA323W_CONFIG_B, 0x82);	
	err |= STA323W_RegWrite(STA323W_CONFIG_D, 0x70);				// drc mode enable
	err |= STA323W_RegWrite(STA323W_CONFIG_E, 0xC0);// Soft volume update, Zero-Crossing Volume Update 사용
	err |= STA323W_RegWrite(STA323W_CONFIG_F, 0xdc);	
	err |= STA323W_RegWrite(STA323W_AUTO_MODE1, 0x80);
	err |= STA323W_RegWrite(STA323W_MVOL, DEFAULT_MASTER_VOL);		// default 값은 조정이 필요
	err |= STA323W_RegWrite(STA323W_CH1_VOL, DEFAULT_CH_VOL);		// default : 0x42
	err |= STA323W_RegWrite(STA323W_CH2_VOL, DEFAULT_CH_VOL);		// default : 0x42
	err |= STA323W_RegWrite(STA323W_CH3_VOL, DEFAULT_CH_VOL);		// default : 0x42
	err |= STA323W_RegWrite(STA323W_MMUTE, 0);

        //
        // hwatk/20061025
        // AVL Function enable시 사용되는 Limiter값을 0x70 --> 0x57로 변경.
        // 이는 Reference TV Graph를 따르며, AVL Enable시에만 적용되므로 Dolby/SRS 등에는 무관.
        //
	err |= STA323W_RegWrite(STA323W_LMT1_ATRT, 0x57);
	err |= STA323W_RegWrite(STA323W_LMT2_ATRT, 0x57);
	
	if(err){
		DHL_DbgPrintf(0,DHLDBG_EXT, "%s| STA323W Volume Initialize Failed!, lines = %d\n",__FUNCTION__,__LINE__);
		return err;
	}		
	
	//printf("%s| STA323W Configuration Success!\n",__FUNCTION__);

#if 0//STA_DEBUG//BK TEST
		ZMon_AddCommand( "sta_r","sta_r","sta_r reg", "i", sta_r);
		ZMon_AddCommand( "sta_w","sta_w","sta_w", "ii", sta_w);
		ZMon_AddCommand( "sta_dump","sta_dump","sta_dump", "", STA323W_ReadConfig);
#endif

	g_STA323W_Intialized = 1;
	
	return err;
}

int STA323W_SetMVolume(DS_U16 Vol)
{
	int err = 0;
	
	if ( g_STA323W_Intialized == 0 )
		STA323W_Init();
		
	err = STA323W_RegWrite(STA323W_MVOL, Vol);
	if(err)
		DHL_DbgPrintf(0,DHLDBG_EXT, "|%s| STA323W_RegWrite failed.\n", __FUNCTION__);
	
	return err;
}

int STA323W_GetMVolume(DS_U16 *Vol)
{
	int err = 0;

	if ( g_STA323W_Intialized == 0 )
		err = STA323W_Init();
		
	err = STA323W_RegRead(STA323W_MVOL, (DS_U8*)Vol);	//org

	if(err)
		DHL_DbgPrintf(0,DHLDBG_EXT, "|%s| STA323W_RegRead failed.\n", __FUNCTION__);

	return err;	
}

int STA323W_SetMMute(DS_BOOL bMute)
{
	int err = 0;	

	if ( g_STA323W_Intialized == 0 )
		err = STA323W_Init();
			
	if(bMute)
		err = STA323W_RegWrite(STA323W_MMUTE, 1);
	else
		err = STA323W_RegWrite(STA323W_MMUTE, 0);
	
	if(err)
		DHL_DbgPrintf(0,DHLDBG_EXT, "|%s| STA323W_RegWrite failed.\n", __FUNCTION__);
	
	return err;	
}

int STA323W_GetMMute(DS_BOOL *bMute)
{
	int err = 0;	
	DS_U8 data;
	
	if ( g_STA323W_Intialized == 0 )
		err = STA323W_Init();

	err = STA323W_RegRead(STA323W_MMUTE, &data);	
	if(err)
		DHL_DbgPrintf(0,DHLDBG_EXT, "|%s| STA323W_RegRead failed.\n", __FUNCTION__);	
	
	if(data) 
		*bMute = TRUE;
	else	
		*bMute = FALSE;
		
		
	return err;	
}

int STA323W_SetTone(INT16 Treble, INT16 Bass)
{
	int err = 0;
	DS_U8 Tone;	
	
	Tone = (DS_U8)((Treble<<4)|Bass);

	if ( g_STA323W_Intialized == 0 )
		err = STA323W_Init();
	
	err = STA323W_RegWrite(STA323W_TONE_CONTROL, Tone);
	if(err)
		DHL_DbgPrintf(0,DHLDBG_EXT, "|%s| STA323W_RegWrite failed.\n", __FUNCTION__);
		
	return err;	
}

int STA323W_GetTone(INT16* Treble, INT16 *Bass)
{
	int err = 0;
	DS_U8 Tone;	

	if ( g_STA323W_Intialized == 0 )
		err = STA323W_Init();
	
	err = STA323W_RegRead(STA323W_TONE_CONTROL, &Tone);
	if(err)
		DHL_DbgPrintf(0,DHLDBG_EXT, "|%s| STA323W_RegRead failed.\n", __FUNCTION__);
					
	*Treble = (INT16)(Tone>>4);
	*Bass 	= (INT16)(Tone&0x0f);
	
	return err;	
}

int STA323W_SetAVLMode(/*STA323W_AMGC*/int avlMode)
{
	int err = 0;
	DS_U8 data1, data2;

	if ( g_STA323W_Intialized == 0 )
		err = STA323W_Init();

	if(avlMode){
		data1=0x10;
		data2=0x50;
	}else{
		data1=0x00;
		data2=0x40;
	}

	err = STA323W_RegWrite(STA323W_CH1_CONFIG, data1);
	if(err)
		DHL_DbgPrintf(0,DHLDBG_EXT, "|%s:%d| STA323W_RegWrite failed.\n",__FUNCTION__, __LINE__);	

	err = STA323W_RegWrite(STA323W_CH2_CONFIG, data2);
	if(err)
		DHL_DbgPrintf(0,DHLDBG_EXT, "|%s:%d| STA323W_RegWrite failed.\n",__FUNCTION__, __LINE__);	
	
	return err;
}

int STA323W_GetAVLMode(/*STA323W_AMGC*/int *avlMode)
{
	int err = 0;
	DS_U8 data;
	DS_U8 mode;

	if ( g_STA323W_Intialized == 0 )
		err = STA323W_Init();
	
	err = STA323W_RegRead(STA323W_AUTO_MODE1, &data);
	if(err)
		DHL_DbgPrintf(0,DHLDBG_EXT, "|%s| STA323W_RegRead failed.\n",__FUNCTION__);
	
	mode = ((data>>4) & 0x3);
	
	switch(mode){
		case 0:
			*avlMode = STA323W_AMGC_USER;
			break;
		case 1:
			*avlMode = STA323W_AMGC_ACNC;
			break;
		case 2:
			*avlMode = STA323W_AMGC_ACLC;
			break;
		case 3:
			*avlMode = STA323W_AMGC_DRC;
			break;
	}
	
	return err;
}

int STA323W_SetChannelVol(DS_U8 Ch1, DS_U8 Ch2)
{
	int err=0;

	if ( g_STA323W_Intialized == 0 )
		err = STA323W_Init();
	
	err |= STA323W_RegWrite(STA323W_CH1_VOL, Ch2);		// L
	err |= STA323W_RegWrite(STA323W_CH2_VOL, Ch1);		// R
	
	//DHL_DbgPrintf(0,DHLDBG_EXT, "%s| L: 0x%lx, R: 0x%lx, line=%d\n",__FUNCTION__,(DS_U32)Ch1,(DS_U32)Ch2,__LINE__);
	
	return err;
}

int STA323W_GetChannelVol(DS_U8 *Ch1, DS_U8 *Ch2)
{
	int err=0;

	if ( g_STA323W_Intialized == 0 )
		err = STA323W_Init();
	
	err |= STA323W_RegRead(STA323W_CH1_VOL, Ch1);		// L
	err |= STA323W_RegRead(STA323W_CH2_VOL, Ch2);		// R
	
	return err;	
}

void STA323W_ReadConfig(void)
{
	int err = 0;
	DS_U8 data;	
	int i;
	
	for(i=0;i<0x26;i++){
		if(i!=0 && i%4==0)
			printf("\n");
		err = STA323W_RegRead(i, &data );
		printf("Reg[0x%2xl]:0x%2lx  ",i,(DS_U32)data);
	}
}