//----------------------------------------------------------------------------
// STAUDIO.C
//----------------------------------------------------------------------------
// Description : small description of the goal of the module
//----------------------------------------------------------------------------
// Copyright SGS Thomson Microelectronics  !  Version alpha  !  Jan 1st, 1995
//----------------------------------------------------------------------------

//----------------------------------------------------------------------------
//                             Include files
//----------------------------------------------------------------------------
#include "stdefs.h"
#include "common.h"
#include "staudio.h"
#include "debug.h"
#include "error.h"
#ifdef STi3520A
	#include "sti3520A.h"
#else
	#include "sti3520.h"
#endif

//----------------------------------------------------------------------------
//                   GLOBAL Variables (avoid as possible)
//----------------------------------------------------------------------------

//----------------------------------------------------------------------------
//                            Private Constants
//----------------------------------------------------------------------------
#define SLOW_MODE	0
#define PLAY_MODE	1
#define FAST_MODE	2

#define IT_A        0 // interrupt detected

//----------------------------------------------------------------------------
//                              Private Types
//----------------------------------------------------------------------------

//----------------------------------------------------------------------------
//                     Private GLOBAL Variables (static)
//----------------------------------------------------------------------------

//----------------------------------------------------------------------------
//                    Functions (statics one are private)
//----------------------------------------------------------------------------

//----------------------------------------------------------------------------
// Constructor: Initializes Audio's variables
//----------------------------------------------------------------------------
VOID AudioOpen(PAUDIO pAudio)
{
	pAudio->AudioState = AUDIO_POWER_UP;
	pAudio->IntAudio = NO_IT_A;
	pAudio->MaskItAudio = 0;
	pAudio->EnWrite = TRUE;
	pAudio->ErrorMsg = NO_ERROR;
	pAudio->icd[0] = 0x6FD4EL;		   // 44.1 KHz
	pAudio->icd[1] = 0xBAD58L;		   // 48.0 KHz
	pAudio->icd[2] = 0x17EDC6L;		   // 32.0 KHz
	pAudio->icd[3] = 0x787DAL;		   // 90.0 KHz
	pAudio->FirstPTS = FALSE;			   // First PTS not reached yet
	pAudio->mute = FALSE;
	pAudio->Stepped = FALSE;
	pAudio->FrameCount = 0;
}

//----------------------------------------------------------------------------
// Destructor : Frees space allocated to Audio Class
//----------------------------------------------------------------------------
VOID AudioClose(PAUDIO FAR *pAudio)
{
//	*pAudio = NULL;
}

//----------------------------------------------------------------------------
// Initialize Audio Decoder
//----------------------------------------------------------------------------
VOID AudioInitDecoder(PAUDIO pAudio, U16 StreamType)
{
//	DEBUG_PRINT ((DebugLevelInfo, " Inotializing Audio Decoder...\n" ));
	pAudio->StrType = StreamType;
	switch(pAudio->AudioState) {
	case AUDIO_POWER_UP:
		AudioWrite(RESET, 0x1);	// reset the decoder
		AudioWrite(INTR_EN, 0x0);	// disable all interupts
		AudioWrite(INTR_EN + LSB, 0x0);	// disable all interupts
		AudioWrite(PLAY, 0x0);	// disable play output
		AudioWrite(MUTE, 0x0);	// do not mute output.
		AudioWrite(INVERT_SCLK, 0x0);	// standard
		AudioWrite(INVERT_LRCLK, 0x0);	// standard
		AudioWrite(PCM_DIV, 0x3);	// SCLK=PCMCLK/8 -> PCM_DIV= 3
		AudioWrite(PCM_ORD, 0x0);	// MSB first
		AudioWrite(PCM_18, 0x0);	// 16 bits of PCM data
		AudioWrite(FORMAT, 0x0);	// I2S output format
		AudioWrite(DIF, 0x0);	// Optionnal in 16 bit output
		AudioWrite(STR_SEL, StreamType);	// Select Input Stream Type
		AudioWrite(CRC_ECM, 0x1);	// mute on CRC error correction
		AudioWrite(SYNC_ECM, 0x01);	// mute if Sync lost
		AudioWrite(SYNCHRO_CONFIRM, 0x1);	// synchro confirmation mode
		AudioWrite(SYNC_REG, 0x3F);	// layer, bitrate, fs fields not used
		AudioWrite(PACKET_SYNC_CHOICE, 0x0);	// multiplexed stream
		AudioWrite(SKIP, 0x0);	// don't skip pAudio frame
		AudioWrite(REPEAT, 0x0);	// don't repeat pAudio frame
		AudioWrite(RESTART, 0x0);	// do not perform a restart
		AudioWrite(LATENCY, 0x01);	// high latency (DRAM present)
		AudioWrite(SYNC_LCK, 0x0);	// locked after 2 good Sync
		AudioWrite(SIN_EN, 0x0);	// parrallel data input
		AudioWrite(ATTEN_L, 0x00);  // No attenuation of the left channel
		AudioWrite(ATTEN_R, 0x00);  // No attenuation of the right channel
		AudioWrite(AUDIO_ID_EN, 0x0);	// ignore audio stream ID
		AudioWrite(AUDIO_ID, 0x0);	// audio stream ID ignored
		AudioWrite(FREE_FORM_H, 0x0);	// not free format
		AudioWrite(FREE_FORM_L, 0x0);	// not free format
		AudioWrite(STC_INC, 0x1);	// Count by steps of 1
		AudioWrite(STC_DIVH, 0x0);	// No division on STC (90kHz is input)
		AudioWrite(STC_DIVL, 0x0);	// No division on STC (90kHz is input)
		AudioWrite(STC_CTL, 0x40);	// Load STC_VID on rising edge of VSYNC
		AudioWrite(BALF_LIM_H, 120);	// Buffer almost full limit
		AudioWrite(BALE_LIM_H, 100);	// Buffer almost empty limit

		AudioSetSamplingFrequency(44100UL);
		pAudio->EnWrite = TRUE;
		pAudio->FrameCount = 0;	   // Reset Frame Count.
		pAudio->AudioState = AUDIO_INIT;
		break;

	default:
		break;
	}
}

//----------------------------------------------------------------------------
// Tests if STi4500 registers are correctly accessed
//----------------------------------------------------------------------------
U16 AudioTestReg(VOID)
{
	U16 err = NO_ERROR,val;

	AudioWrite(ATTEN_L, 0x55);
	AudioWrite(ATTEN_R, 0xAA);
	val = AudioRead(ATTEN_L);
	val = val & 0x3F;
	if (val != 0x15)
		err = BAD_REG_A;
	val = AudioRead(ATTEN_R);
	val = val & 0x3F;
	if (val != 0x2A)
		err = BAD_REG_A;
	return ( err);
}

//----------------------------------------------------------------------------
// Test of STi4500 registers and interrupts
//----------------------------------------------------------------------------
U16 AudioTest(PAUDIO pAudio)
{
	U16 TestResult;

	TestResult = AudioTestReg();
	if (TestResult != NO_ERROR)
		return TestResult;
	else {
/*
		if (AudioTestInt(pAudio) == NO_IT_A)
			return NO_IT_A;
		else
*/
			return NO_ERROR;
	}
}

//----------------------------------------------------------------------------
//  Tests Audio interrupts
//----------------------------------------------------------------------------
U16 AudioTestInt(PAUDIO pAudio)
{
	U16 err = NO_ERROR;
	U8  balfsv;
	U16 mask;
	U16 a = 0;

	balfsv = (U8)(AudioRead(BALF_LIM_H));
	mask = AudioRead(INTR_EN);
	mask = (mask << 8) || (AudioRead(INTR_EN + LSB) & 0xFF);

	pAudio->MaskItAudio = BALF;
	AudioWrite(INTR_EN, pAudio->MaskItAudio);	// 0x10
	AudioWrite(BALF_LIM_H, 0);
	// Write 1 byte to DATA_IN in order to produce an INT
	AudioWrite(DATA_IN, 0);

	// wait for occurrence of first audio interrupt
	while (pAudio->IntAudio == NO_IT_A) {
		WaitMicroseconds(1000);
		a++;						  /* incremented every 1 ms */
		if (a >= 1000) {
			SetErrorCode(ERR_NO_AUDIO_INTR);
			err = NO_IT_A; 	/* No interrupt */
			break;
		}
	}

	// Restore Interrupt mask
	pAudio->MaskItAudio = mask;
	AudioWrite(INTR_EN, (U16)(mask & 0xFF));
	AudioWrite(INTR_EN + LSB, (U16)(mask >> 8));
	// Restore BALF_LIM_H value
	AudioWrite(BALF_LIM_H, balfsv);
	AudioRead(INTR);		   /* to clear audio interrupts flags */
	pAudio->EnWrite = TRUE;
	return ( err);
}

//----------------------------------------------------------------------------
// Set the decoding mode and parameters
//----------------------------------------------------------------------------
VOID AudioSetMode(PAUDIO pAudio, U16 Mode, U16 param)
{
	pAudio->DecodeMode = Mode;
	switch (pAudio->DecodeMode) {
	case PLAY_MODE:
		AudioWrite(MUTE, 0);
		pAudio->fastForward = 0;
		pAudio->decSlowDown = 0;
		break;
	case FAST_MODE:
		pAudio->fastForward = 1;
		pAudio->decSlowDown = 0;
		break;
	case SLOW_MODE:
		pAudio->fastForward = 0;
		pAudio->decSlowDown = param;
		break;
	}
}

//----------------------------------------------------------------------------
// Decode
//----------------------------------------------------------------------------
VOID AudioDecode(PAUDIO pAudio)
{
	switch (pAudio->AudioState)	{
	case AUDIO_POWER_UP:
		break;
	case AUDIO_INIT:
		// Change in synchro + buffer over BALF +PTS
		pAudio->MaskItAudio = SYNC | BALF | PTS | BOF;
		AudioWrite(INTR_EN, (U16)(pAudio->MaskItAudio & 0xFF));
		AudioWrite(INTR_EN + LSB, (U16)(pAudio->MaskItAudio >> 8 ));
		AudioWrite(MUTE, 1);	// This Starts SClk and LRClk outputs
		AudioWrite(PLAY, 1);	// Start decoding Output is Mute
		pAudio->AudioState = AUDIO_STC_INIT;
		break;
	case AUDIO_STC_INIT:
		pAudio->AudioState = AUDIO_DECODE;
		AudioWrite(PLAY, 1);	// Restart decoding (decoding had been stopped when first audio PTS detected)
		AudioWrite(MUTE, 0);	// Stop Muting output
		break;
	case AUDIO_DECODE:
		break;
	case AUDIO_PAUSE:
	case AUDIO_STEP:
		AudioWrite(PLAY, 1);
		AudioWrite(MUTE, 0);
		pAudio->AudioState = AUDIO_DECODE;
		break;
	}
}

//----------------------------------------------------------------------------
// Step
//----------------------------------------------------------------------------
VOID AudioStep(PAUDIO pAudio)
{
	AudioWrite(MUTE, 0);
	AudioWrite(PLAY, 1);
	pAudio->AudioState = AUDIO_STEP;
	pAudio->Stepped = FALSE;
}

//----------------------------------------------------------------------------
// Stop
//----------------------------------------------------------------------------
VOID AudioStop(PAUDIO pAudio)
{
	switch(pAudio->AudioState) {
	case AUDIO_POWER_UP:
		break;
	case AUDIO_INIT:
		break;
	case AUDIO_STC_INIT:
	case AUDIO_DECODE:
		pAudio->AudioState = AUDIO_POWER_UP;
		AudioInitDecoder(pAudio, pAudio->StrType);
		break;
	}
}

//----------------------------------------------------------------------------
// Pause
//----------------------------------------------------------------------------
VOID AudioPause(PAUDIO pAudio)
{
	switch(pAudio->AudioState) {
	case AUDIO_POWER_UP: /* After reset */
	case AUDIO_INIT:		 /* Initialisation + test of the decoders */
	case AUDIO_STC_INIT: /* STC of audio decoder initialized */
	case AUDIO_DECODE:	 /* Normal decode */
		AudioWrite(MUTE, 1);
		AudioWrite(PLAY, 0);
		pAudio->AudioState = AUDIO_PAUSE;
		break;
	}
}

//----------------------------------------------------------------------------
// Get Audio State
//----------------------------------------------------------------------------
U16 AudioGetState(PAUDIO pAudio)
{
	return ( pAudio->AudioState);
}

//----------------------------------------------------------------------------
// Get Current STC value
//----------------------------------------------------------------------------
U32 AudioGetSTC(VOID)
{
	U32  stc;
	U16	 j;

	AudioWrite(STC_CTL, 0x44);	// load current STC value to STC
	for ( j = 0; j < 0xF; j++);
	stc = ( AudioRead(STC_3 ) & 0xFFL ) << 24;
	stc = stc | ( ( AudioRead(STC_2 ) & 0xFFL ) << 16);
	stc = stc | ( ( AudioRead(STC_1 ) & 0xFFL ) << 8);
	stc = stc | ( AudioRead(STC_0 ) & 0xFFL);
	return ( stc);
}

//----------------------------------------------------------------------------
// Get STC value latched on VSYNC
//----------------------------------------------------------------------------
U32 AudioGetVideoSTC(VOID)
{
	U32 stc;
	U16	j;

	AudioWrite(STC_CTL, 0x48);	// load STC_VID to STC, Mode 0 mapping
	for ( j = 0; j < 0xF; j++)
		;
	stc = ( AudioRead(STC_3 ) & 0xFFL ) << 24;
	stc = stc | ((AudioRead(STC_2) & 0xFFL ) << 16);
	stc = stc | ((AudioRead(STC_1) & 0xFFL ) << 8);
	stc = stc | ((AudioRead(STC_0) & 0xFFL ));
	return stc;
}

//----------------------------------------------------------------------------
// Initialize STC
//----------------------------------------------------------------------------
VOID AudioInitSTC(U32 stc)
{
	AudioWrite(STC_0, (U8)(stc & 0xFFL));
	stc >>= 8;
	AudioWrite(STC_1, (U8)(stc & 0xFFL));
	stc >>= 8;
	AudioWrite(STC_2, (U8)(stc & 0xFFL));
	stc >>= 8;
	AudioWrite(STC_3, (U8)(stc & 0xFFL));
	AudioWrite(STC_CTL, 0x41);	// load STC to accumulator,
}

//----------------------------------------------------------------------------
// Get Current Audio PTS
//----------------------------------------------------------------------------
U32 AudioGetPTS(PAUDIO pAudio)
{
	return pAudio->PtsAudio;
}

//----------------------------------------------------------------------------
// Get Error Message
//----------------------------------------------------------------------------
U16 AudioGetErrorMsg(PAUDIO pAudio)
{
	return pAudio->ErrorMsg;
}

//----------------------------------------------------------------------------
// Set Right Volume
//----------------------------------------------------------------------------
VOID AudioSetRightVolume(U16 volume)
{
	AudioWrite(ATTEN_R, volume);
}

//----------------------------------------------------------------------------
// Set Left Volume
//----------------------------------------------------------------------------
VOID AudioSetLeftVolume(U16 volume)
{
	AudioWrite(ATTEN_L, volume);
}

//----------------------------------------------------------------------------
// Mute audio output
//----------------------------------------------------------------------------
VOID AudioMute(PAUDIO pAudio)
{
	if (pAudio->mute) {
		AudioWrite(MUTE, 0);
		pAudio->mute = FALSE;
	}
	else {
		AudioWrite(MUTE, 1);
		pAudio->mute = TRUE;
	}
}

//----------------------------------------------------------------------------
//
//----------------------------------------------------------------------------
BOOLEAN AudioIsFirstPTS(PAUDIO pAudio)
{
	return pAudio->FirstPTS;
}

//----------------------------------------------------------------------------
// Sets Input Stream Type 0:Audio only, 1:Audio Packet
//----------------------------------------------------------------------------
VOID AudioSetStreamType(U16 StrType)
{
	AudioWrite(STR_SEL, StrType);
}

//----------------------------------------------------------------------------
// Mask Audio interrupt
//----------------------------------------------------------------------------
VOID AudioMaskInt(VOID)
{
	AudioWrite(INTR_EN, 0);
	AudioWrite(INTR_EN + LSB, 0);
}

//----------------------------------------------------------------------------
// Restore Audio interrupt Mask
//----------------------------------------------------------------------------
VOID AudioRestoreInt(PAUDIO pAudio)
{
	AudioWrite(INTR_EN, (U16)(pAudio->MaskItAudio & 0xFF));
	AudioWrite(INTR_EN + LSB, (U16)(pAudio->MaskItAudio >> 8));
}

//----------------------------------------------------------------------------
// Audio interrupt routine
//----------------------------------------------------------------------------
BOOLEAN AudioAudioInt(PAUDIO pAudio)
{
	U16     int_stat_reg, i;
	BOOLEAN	bAudioIntr = FALSE;

	// Read the interrupt status register
	int_stat_reg = AudioRead(INTR);
	i = AudioRead(INTR + LSB);
	i = i << 8;
	int_stat_reg = ( int_stat_reg & 0xFF ) | i;
	int_stat_reg = int_stat_reg & pAudio->MaskItAudio;	/* Mask the IT not used */

	if(int_stat_reg)
		bAudioIntr = TRUE;

	/******************************************************/
	/**                   CHANGE SYNCHRO                 **/
	/******************************************************/
	if (int_stat_reg & SYNC) {
		i = AudioRead(SYNC_ST);	// Synchronization status
		if ((i & 0x3) == 3)	{	   // Locked
			// Disable Change in synchro
			pAudio->MaskItAudio = pAudio->MaskItAudio & NSYNC;
			// Next Interrupt should be change in sampling freq
			pAudio->MaskItAudio = pAudio->MaskItAudio | SAMP;
		}
	}

	/******************************************************/
	/**             CHANGE IN SAMPLING FREQUENCY         **/
	/******************************************************/
	if (int_stat_reg & SAMP) {
		i = AudioRead(PCM_FS ) & 0x3;	// Get Sampling frequency
		switch(i) {
		case 0 :
			AudioSetSamplingFrequency(44100UL); break;
		case 1 :
			AudioSetSamplingFrequency(48000UL); break;
		case 2 :
			AudioSetSamplingFrequency(32000UL); break;
		default :
			DebugPrint((DebugLevelFatal, "Unknown case !"));
		}
		// Disable change in sampling frequency
		pAudio->MaskItAudio = pAudio->MaskItAudio & NSAMP;
	}

	/******************************************************/
	/**                   OVER BALF LIMIT                **/
	/******************************************************/
	if (int_stat_reg & BALF) {
		pAudio->IntAudio = IT_A;		   // Audio Interrupt detected.
		pAudio->MaskItAudio = pAudio->MaskItAudio | BALE;	// Enable BALE
		pAudio->EnWrite = FALSE;
	}

	/******************************************************/
	/**                   BELOW BALE LIMIT               **/
	/******************************************************/
	if (int_stat_reg & BALE) {
		pAudio->EnWrite = TRUE;
	}

	/******************************************************/
	/**                   CRC error                      **/
	/******************************************************/
	if (int_stat_reg & CRC)	{
		pAudio->EnWrite = TRUE;
	}

	/******************************************************/
	/**                   PCM Underflow                  **/
	/******************************************************/
	if (int_stat_reg & PCMU) {
		pAudio->EnWrite = TRUE;
	}

	/******************************************************/
	/**                  Begining of Frame               **/
	/******************************************************/
	if (int_stat_reg & BOF)	{
		// Check if stepping
		if ((pAudio->AudioState == AUDIO_STEP) && (pAudio->Stepped == FALSE)) {
			AudioWrite(MUTE, 1);
			AudioWrite(PLAY, 0);
			pAudio->Stepped = TRUE;
		}
		// If Slow motion or Fast forward, Mute Audio
		if ( pAudio->DecodeMode != PLAY_MODE ) {
			AudioWrite(MUTE, 1);
			pAudio->mute = TRUE;
			if ((pAudio->FrameCount % 4) && (pAudio->fastForward))
				AudioWrite(SKIP, 1);
			else if ((pAudio->DecodeMode == SLOW_MODE ) &&
							 ((pAudio->FrameCount % (pAudio->decSlowDown + 1)) != 0))
				AudioWrite(REPEAT, 1);
		}

		pAudio->FrameCount++;			   // Increment Frame Count
	}

	/******************************************************/
	/**                   PTS detected                   **/
	/******************************************************/
	if ( int_stat_reg & PTS )	{
		U32 pts;

		AudioRead(PTS_4);	   // To clear pts interrupt
		pts = (AudioRead(PTS_3) & 0xFFL) << 24;
		pts = pts | ((AudioRead(PTS_2 ) & 0xFFL) << 16);
		pts = pts | ((AudioRead(PTS_1 ) & 0xFFL) << 8);
		pts = pts | ( AudioRead(PTS_0 ) & 0xFFL);

		pAudio->PtsAudio = pts;
		if (pAudio->AudioState == AUDIO_STC_INIT) {
			pAudio->FirstPTS = TRUE;
			AudioWrite(PLAY, 0);
		}
		if (pAudio->AudioState == AUDIO_DECODE)	{
			AudioInitSTC ( pts);
		}
	}

	return bAudioIntr;
}

//------------------------------- End of File --------------------------------