/*
Copyright (c) 2016, Texas Instruments Incorporated - http://www.ti.com/
All rights reserved.

* Redistribution and use in source and binary forms, with or without 
* modification, are permitted provided that the following conditions
* are met:
*
* Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the
* distribution.
*
* Neither the name of Texas Instruments Incorporated nor the names of
* its contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/

/**
 * \file      audio_dc_config.c
 *
 * \brief     Configures Audio daughter card HW modules
 *
 */

#include "audio_dc_cfg.h"
#include "vproccmds_a.h"
#include <stdarg.h>
#include "string.h"

Platform_STATUS audioHDMIConfig(void);

#define HSR4_I2C_ADDR 0x5D
#define	HSR4_I2C_PORT_NUM I2C_PORT_1

/* ------------------------------------------------------------------------ *
 *  Prototypes                                                              *
 * ------------------------------------------------------------------------ */

/**
 *  \brief    Initializes ADC module
 *
 *  This function initializes and configures the ADC modules
 *  on audio daughter card
 *
 *  \param     devId  [IN]  ADC Device Id
 *  \param     config [IN]  ADC configuration parameters
 *
 *  \return    Platform_EOK on Success or error code
 */
Platform_STATUS audioAdcConfig(AdcDevId  devId, AdcConfig *config)
{
	Platform_STATUS status;

	if(config == NULL)
	{
		IFPRINT(platform_write("Invalid Inputs\n"));
		return (Platform_EINVALID);
	}

	/* Initialize all the HW instances of ADC */
	status = platformAudioAdcInit(devId);
	if(status != Platform_EOK)
	{
		IFPRINT(platform_write("audioAdcConfig : platformaudioAdcConfig Failed\n"));
		return (status);
	}

	/* Set ADC channel gain */
	status = platformAudioAdcSetGain(devId, ADC_CH_ALL, config->gain);
	if(status != Platform_EOK)
	{
		IFPRINT(platform_write("audioAdcConfig : platformAudioAdcSetGain Failed\n"));
		return (status);
	}

	/* Configure Left input mux for ADC1L */
	status = platformAudioAdcSetLeftInputMux(devId, ADC_CH1_LEFT,
	                                         config->adc1LMux);
	if(status != Platform_EOK)
	{
		IFPRINT(platform_write("audioAdcConfig : platformAudioAdcSetLeftInputMux Failed\n"));
		return (status);
	}

	/* Configure Left input mux for ADC2L*/
	status = platformAudioAdcSetLeftInputMux(devId, ADC_CH2_LEFT,
	                                         config->adc2LMux);
	if(status != Platform_EOK)
	{
		IFPRINT(platform_write("audioAdcConfig : platformAudioAdcSetLeftInputMux Failed\n"));
		return (status);
	}

	/* Configure Right input mux for ADC1R */
	status = platformAudioAdcSetRightInputMux(devId, ADC_CH1_RIGHT,
	                                          config->adc1RMux);
	if(status != Platform_EOK)
	{
		IFPRINT(platform_write("audioAdcConfig : platformAudioAdcSetRightInputMux Failed\n"));
		return (status);
	}

	/* Configure Right input mux for ADC2R */
	status = platformAudioAdcSetRightInputMux(devId, ADC_CH2_RIGHT,
	                                          config->adc2RMux);
	if(status != Platform_EOK)
	{
		IFPRINT(platform_write("audioAdcConfig : platformAudioAdcSetRightInputMux Failed\n"));
		return (status);
	}

	/* Configure audio data format */
	status = platformAudioAdcDataConfig(devId, config->wlen, config->format);
	if(status != Platform_EOK)
	{
		IFPRINT(platform_write("audioAdcConfig : platformAudioAdcDataConfig Failed\n"));
		return (status);
	}

	/* Configure all the interrupts */
	status = platformAudioAdcConfigIntr(devId, ADC_INTR_ALL,
	                                    config->intEnable);
	if(status != Platform_EOK)
	{
		IFPRINT(platform_write("audioAdcConfig : platformAudioAdcConfigIntr Failed\n"));
		return (status);
	}

	return (status);
}

/**
 *  \brief    Initializes DAC module
 *
 *  This function initializes and configures the DAC modules
 *  on audio daughter card
 *
 *  \param     devId  [IN]  DAC Device Id
 *  \param     config [IN]  DAC configuration parameters
 *
 *  \return    Platform_EOK on Success or error code
 */
Platform_STATUS audioDacConfig(DacDevId devId, DacConfig *config)
{
	Platform_STATUS status;

	if(config == NULL)
	{
		IFPRINT(platform_write("Invalid Inputs\n"));
		return (Platform_EINVALID);
	}

	/* Initialize Audio DAC */
	status = platformAudioDacInit(devId);
	if(status != Platform_EOK)
	{
		IFPRINT(platform_write("audioDacConfig : platformaudioDacConfig Failed\n"));
		return (status);
	}

	/* Configure AMUTE control event */
	status = platformAudioDacAmuteCtrl(devId, config->amuteCtrl,
	                                   config->amuteEnable);
	if(status != Platform_EOK)
	{
		IFPRINT(platform_write("audioDacConfig : platformAudioDacAmuteCtrl Failed\n"));
		return (status);
	}

	/* Set sampling mode */
	status = platformAudioDacSetSamplingMode(devId, config->samplingMode);
	if(status != Platform_EOK)
	{
		IFPRINT(platform_write("audioDacConfig : platformAudioDacSetSamplingMode Failed\n"));
		return (status);
	}

	/* Set data format */
	status = platformAudioDacSetDataFormat(devId, config->dataFormat);
	if(status != Platform_EOK)
	{
		IFPRINT(platform_write("audioDacConfig : platformAudioDacSetDataFormat Failed\n"));
		return (status);
	}

	/* Enable soft mute control */
	status = platformAudioDacSoftMuteCtrl(devId, DAC_CHAN_ALL,
	                                      config->softMuteEnable);
	if(status != Platform_EOK)
	{
		IFPRINT(platform_write("audioDacConfig : platformAudioDacSoftMuteCtrl Failed\n"));
		return (status);
	}

	/* Set attenuation mode */
	status = platformAudioDacSetAttnMode(devId, config->attnMode);
	if(status != Platform_EOK)
	{
		IFPRINT(platform_write("audioDacConfig : platformAudioDacSetAttnMode Failed\n"));
		return (status);
	}

	/* Set De-emphasis control */
	status = platformAudioDacDeempCtrl(devId, config->deempCtrl);
	if(status != Platform_EOK)
	{
		IFPRINT(platform_write("audioDacConfig : platformAudioDacDeempCtrl Failed\n"));
		return (status);
	}

	/* Set DAC volume */
	status = platformAudioDacSetVolume(devId, DAC_CHAN_ALL, config->volume);
	if(status != Platform_EOK)
	{
		IFPRINT(platform_write("audioDacConfig : platformAudioDacSetVolume Failed\n"));
		return (status);
	}

	return (status);
}

/**
 *  \brief    Initializes DIR module
 *
 *  This function initializes and configures the DIR modules
 *  on audio daughter card
 *
 *  \return    Platform_EOK on Success or error code
 */
Platform_STATUS audioDirConfig(void)
{
	Platform_STATUS status;
	int8_t          fsout;
#ifdef CHECK_ERROR_STATUS
	uint32_t        timeout;
#endif

	status = platformAudioDirInit();
	if(status != Platform_EOK)
	{
		IFPRINT(platform_write("audioDirConfig : Audio DIR Configuration Failed!\n"));
		return (status);
	}

#ifdef CHECK_ERROR_STATUS
	/* DIR should be in PLL mode.
	   Wait for ERROR signal to be low as DIR is configured for
	   AUTO mode */
	timeout = ERROR_STATUS_WAIT_TIMEOUT;
	while (timeout)
	{
		if(!platformAudioDirGetErrStatus())
		{
			IFPRINT(platform_write("audioDirConfig : DIR in PLL Mode\n"));
			break;
		}

		IFPRINT(platform_write("audioDirConfig : Waiting for DIR to Enter PLL Mode...\n"));
		platform_delay(1000);
		timeout--;
	}

	if(!timeout)
	{
		IFPRINT(platform_write("audioDirConfig : DIR is not in PLL Mode!!\n"));
		return (Platform_EFAIL);
	}
#endif

	fsout = platformAudioDirGetFsOut();
	if(fsout == 2)
	{
		IFPRINT(platform_write("audioDirConfig : Out of Range Sampling Frequency\n"));
	}
	else if(fsout == 0)
	{
		IFPRINT(platform_write("audioDirConfig : Calculated Sampling Frequency Output is 43 kHz–45.2 kHz\n"));
	}
	else if(fsout == 1)
	{
		IFPRINT(platform_write("audioDirConfig : Calculated Sampling Frequency Output is 46.8 kHz–49.2 kHz\n"));
	}
	else if(fsout == 3)
	{
		IFPRINT(platform_write("audioDirConfig : Calculated Sampling Frequency Output is 31.2 kHz–32.8 kHz\n"));
	}
	else
	{
		IFPRINT(platform_write("audioDirConfig : Error in Reading FSOUT status \n"));
		status = Platform_EFAIL;
	}

 	return (status);
}

int alpha_i2c_write(unsigned short, ...);
void set_audio_desc(unsigned char ,unsigned char ,unsigned char ,unsigned char ,unsigned char );
void hrptredid();
void  hdmi128();


int gret_val=0;
int alpha_i2c_write(unsigned short var1, ...)
{
	unsigned short alpha_type,length,temp_var;
	int i,offset,ret_val;
	unsigned char cmd[50];
	char *s;
	va_list argp;
	va_start(argp, var1);

	alpha_type = var1>> 8;
	switch(alpha_type)
	{
		case 0xca:
		case 0xc2:
		case 0xc3:
		case 0xc4:
			length = 4;
			break;
		case 0xcb:
			length = 6;
			break;
		case 0xcc:
			length = 8;
			break;
		case 0xcd:
		case 0xc5:
			length= 8; // temporary - data starts after 8 bytes
			break;
	}

	cmd[0]=length;
	temp_var=var1;
	for(i=0;i<length-2;i+=2) // convert to bytes as per protocol
	{
		cmd[i+1]= temp_var & 0xff;
		cmd[i+2]= temp_var >> 8;
		temp_var=va_arg(argp, short);
	}
	cmd[i+1]= temp_var & 0xff;
	cmd[i+2]= temp_var >> 8;


	if(alpha_type == 0xcd) // special processing for variable length
	{
		offset=9;
		s = va_arg(argp, char *); // remaining data is in form of string
		length = temp_var; // last short indicates data length
		cmd[0]+=length;
		for(i=offset;i<offset+length;i++)
			cmd[i]=s[i-offset];
	}
va_end(argp);


ret_val = i2cWrite(HSR4_I2C_PORT_NUM, HSR4_I2C_ADDR, cmd, cmd[0]+1, I2C_RELEASE_BUS);
if(ret_val !=I2C_RET_OK)
		gret_val++;


return ret_val;
}

void set_audio_desc(unsigned char var1,unsigned char var2,unsigned char var3,unsigned char var4,unsigned char var5)
{
	int ret_val=I2C_RET_OK;
	do{ret_val=alpha_i2c_write(HSDIO_EDID_AUDIO_DESC_FORMAT(var1, var2));}while (ret_val !=I2C_RET_OK);
	platform_delay(1000);
	do{ret_val=alpha_i2c_write(HSDIO_EDID_AUDIO_DESC_NUM_CHANNELS(var1, var3));}while (ret_val !=I2C_RET_OK);
	platform_delay(1000);
	do{ret_val=alpha_i2c_write(HSDIO_EDID_AUDIO_DESC_SAMPLE_RATES(var1, var4));}while (ret_val !=I2C_RET_OK);
	platform_delay(1000);
	do{ret_val=alpha_i2c_write(HSDIO_EDID_AUDIO_DESC_MISC(var1, var5));}while (ret_val !=I2C_RET_OK);
	platform_delay(1000);
	do{ret_val=alpha_i2c_write(HSDIO_ALERT(HSDIO_ALERT_INPUT_AUDIO_CHANGE_msk));}while (ret_val !=I2C_RET_OK);
	platform_delay(1000);
	do{ret_val=alpha_i2c_write(HSDIO_ALERT(HSDIO_ALERT_INPUT_AUDIO_MUTE_msk));}while (ret_val !=I2C_RET_OK);
	platform_delay(1000);
}

void hrptredid()
{
	int ret_val=I2C_RET_OK;

	do{
		platform_delay(1000);
		ret_val=alpha_i2c_write(HSDIO_EDID_SPEAKER_ALLOCATION_BLOCK(0xFF));
        if (ret_val !=I2C_RET_OK)
            i2cConfig(HSR4_I2C_PORT_NUM);        
            
	}while (ret_val !=I2C_RET_OK);

	platform_delay(1000);
	do{ret_val=alpha_i2c_write(HSDIO_EDID_SPEAKER_ALLOCATION_BLOCK_2(0x7));}while (ret_val !=I2C_RET_OK);

	set_audio_desc(0,1,2,0x7f,7);	// Stero PCM
	set_audio_desc(1,1,8,0x7f,7);	// Multi Ch PCM
	set_audio_desc(2,2,6,0x7,80);	//AC3
	set_audio_desc(3,10,8,0x07,0);	// EAC3	//DTS (3,7,6,0x1e,192)
	set_audio_desc(4,12,8,0x7F,0);	// MLP (THD) //DTS (4,7,8,0x6,192)
	// Empty descriptors to be programmed to 0s
	set_audio_desc(5,0,0,0,0);	//AAC LC (5,6,6,0x1f,192);
	set_audio_desc(6,0,0,0,0);
	set_audio_desc(7,0,0,0,0);
	set_audio_desc(8,0,0,0,0);	// DTS-HD (8,11,8,0x7F,1)
	set_audio_desc(9,0,0,0,0);
	set_audio_desc(10,0,0,0,0);
	set_audio_desc(11,0,0,0,0);
	set_audio_desc(12,0,0,0,0);
	set_audio_desc(13,0,0,0,0);
	set_audio_desc(14,0,0,0,0);
	set_audio_desc(15,0,0,0,0);
	set_audio_desc(16,0,0,0,0);
	set_audio_desc(17,0,0,0,0);
	set_audio_desc(18,0,0,0,0);
	set_audio_desc(19,0,0,0,0);
	platform_delay(1000);
	do{ret_val=alpha_i2c_write(HSDIO_EDID_GO);}while (ret_val !=0);
	//fclose(fp1);
}

void  hdmi128()
{
		int ret_val=0;
	platform_delay(1000);
	do{ret_val=alpha_i2c_write(HSDIO_AUDIO_MCLK_TO_HOST(HSDIO_AudioMClk_128X));}while (ret_val !=0);
	platform_delay(1000);
	do{ret_val=alpha_i2c_write(HSDIO_AUDIO_FORMAT_TO_HOST(HSDIO_AudioFmt_I2S));}while (ret_val !=0);
	platform_delay(1000);
	do{ret_val=alpha_i2c_write(HSDIO_IMPLEMENT_AUDIO_TO_HOST_CMDS);}while (ret_val !=0);
	platform_delay(1000);
	do{ret_val=alpha_i2c_write(HSDIO_AUDIO_OUTPUT_PRESENT(HSDIO_AudioPresent_HAS_NO_AUDIO));}while (ret_val !=0);
	platform_delay(1000);
	do{ret_val=alpha_i2c_write(HSDIO_AUDIO_OUTPUT_FORMAT(HSDIO_AudioFmt_I2S));}while (ret_val !=0);
	platform_delay(1000);
	do{ret_val=alpha_i2c_write(HSDIO_AUDIO_OUTPUT_SAMPLE_SIZE(HSDIO_AudioSampleSize_32));}while (ret_val !=0);
	platform_delay(1000);
	do{ret_val=alpha_i2c_write(HSDIO_AUDIO_OUTPUT_FREQ(HSDIO_AudioFreq_48K));}while (ret_val !=0);
	platform_delay(1000);
	do{ret_val=alpha_i2c_write(HSDIO_AUDIO_OUTPUT_LAYOUT(HSDIO_AudioLayout_2));}while (ret_val !=0);
	platform_delay(1000);
	do{ret_val=alpha_i2c_write(HSDIO_AUDIO_OUTPUT_MCLK(HSDIO_AudioMClk_AUTO));}while (ret_val !=0);
	platform_delay(1000);
	do{ret_val=alpha_i2c_write(HSDIO_AUDIO_OUTPUT_AUX_CHANNEL_CNT(1));}while (ret_val !=0);
	platform_delay(1000);
	do{ret_val=alpha_i2c_write(HSDIO_AUDIO_OUTPUT_AUX_SPEAKER_MAPPING(0));}while (ret_val !=0);
	platform_delay(1000);
	do{ret_val=alpha_i2c_write(HSDIO_AUDIO_OUTPUT_CHSTS_PCM_PREEMPHASIS(HSDIO_CSFormatInfo_PCM_NO_PRE));}while (ret_val !=0);
	platform_delay(1000);
	do{ret_val=alpha_i2c_write(HSDIO_AUDIO_OUTPUT_CHSTS_COPYRIGHT(HSDIO_CSCopyright_PROTECTED));}while (ret_val !=0);
	platform_delay(1000);
	do{ret_val=alpha_i2c_write(HSDIO_AUDIO_OUTPUT_CHSTS_WORD_LENGTH(HSDIO_CSWordLength_24));}while (ret_val !=0);
	platform_delay(1000);
	do{ret_val=alpha_i2c_write(HSDIO_AUDIO_OUTPUT_GO);}while (ret_val !=0);
	platform_delay(1000);
	do{ret_val=alpha_i2c_write(HSDIO_AUDIO_ROUTING(HSDIO_AudioRouting_HSDIOIN_HOSTOUT));}while (ret_val !=0);
	platform_delay(1000);
	do{ret_val=alpha_i2c_write(HSDIO_SYS_CFG_GO);}while (ret_val !=0);
}

Platform_STATUS audioHDMIConfig(void)
{
	Platform_STATUS status = 0;

	hrptredid();

	hdmi128();

	return (status);
}

unsigned int read_hdmi_samprate()
{
	unsigned char data[50];
	Uint8 length;
	int ret_val=7;
	//int ret_val2=0;
	int clear_to_read=5;

	clear_to_read=alpha_i2c_write(HSDIO_ALERT_STS); //clear the interrupt on ~HMINT by reading the Alert Status register

	ret_val=alpha_i2c_write(HSDIO_AUDIO_INPUT_FREQ_STS);

	if(!ret_val) i2cRead(HSR4_I2C_PORT_NUM, HSR4_I2C_ADDR,&length,0,1,1);
	if(!ret_val) i2cRead(HSR4_I2C_PORT_NUM, HSR4_I2C_ADDR,&data[0],0,1,length);
	if(!ret_val) ret_val= data[3]; // indicates sample rate
	else
	ret_val = 0;

	return ret_val;
}

/* Nothing past this point */