#include "os_config.h"

#include "c_def.h"
#include "debug.h"
#include "oem.h"

#include "regmap.h"

#include "hw_dma.h"


#ifdef USB_DEV_ENABLE

#include "mem_reloc.h"
#include "fifo.h"

#include "message.h"

#include "stdDespt.h"
//#include "AOAproto.h"

#include "IRP.h"
#include "usbmsc.h"
#include "usbd.h"

#include "usbdev.h"

#include "denumAudio.h"
#include "Audio_dec.h"
#include "optek_link.h"

U32 usbTransLen = 0;
U8 usbErr = 0;

static void usbirpCompleteCallback(U8 iprResult, U32 iprActualLen )
{
	usbErr = iprResult;
	usbTransLen = iprActualLen;

	usbmsg_IRPcompleteFunc();
}


//===========================================================================
//	USB device
//===========================================================================

U8 usbdev_start_flag = FALSE;

//FIMXE: same as usb_host_start, attr
int usb_devStart(enum_USB_DEVICE_STACK_ATTR attr)
{
	IRP	irp;

	if (usbdev_start_flag == FALSE)
	{
		DBG_USBDev_Printf ("usbSlave open\n\r");

		//tx_mutex_get( &mutex_usb, TX_WAIT_FOREVER );
		USB_MUTEX_LOCK;
		FILL_NORMAL_IRP( &irp, enIRPT_DEV_STACK, enIRP_TYPE_DEV_START,	0,
			attr,	0,	0,	enIRPR_SUBMIT, usbirpCompleteCallback );    //(PIRP)->param = attr !!!

		usbmsg_sendIRP( &irp );
		usbmsg_waitIRPcomplete();
		DBG_assert( usbErr == enIRPR_SUCCESS );
		usbdev_start_flag = TRUE;

		//tx_mutex_put( &mutex_usb );
		USB_MUTEX_UNLOCK;
		//DBG_USBDev_Printf ("usb_devStart::enIRP_TYPE_DEV_START is sent!\n\r");
		return ( usbErr == enIRPR_SUCCESS );
	}
	else
	{
		DBG_USBDev_Printf ("usbSlave is open\n\r");
	}
}

int usb_devStop(void)
{
	IRP	irp;

	if (usbdev_start_flag == TRUE)
	{
		DBG_USBDev_Printf ("usbSlave close\n\r");

		//tx_mutex_get( &mutex_usb, TX_WAIT_FOREVER );
		USB_MUTEX_LOCK;
		FILL_NORMAL_IRP( &irp, enIRPT_DEV_STACK, enIRP_TYPE_DEV_STOP,	0,
			0,	0,	0,	enIRPR_SUBMIT, usbirpCompleteCallback );

		usbmsg_sendIRP( &irp );
		usbmsg_waitIRPcomplete();
		DBG_assert( usbErr == enIRPR_SUCCESS );
		usbdev_start_flag = FALSE;

		//tx_mutex_put( &mutex_usb );
		USB_MUTEX_UNLOCK;
		return ( usbErr == enIRPR_SUCCESS );
	}
	else
	{
		DBG_USBDev_Printf ("usbSlave is close\n\r");
	}
}


int usb_devID_get(U16 *pVendorID, U16 *pProductID)
{
	*pVendorID = VENDOR_ID;
	*pProductID = PRODUCT_ID;
	
	return TRUE;
}

#if 0
int usb_devAudioSampleRate_get(U32 *pSampleRate)
{
	*pSampleRate = USB_AUDIO_SAMPLE_FREQ;
	
	return TRUE;
}
#endif


#ifdef USB_DEV_ENABLE
//#define STR_MANUFACTURE_LENGTH    (2 + 5*2)
//static const U8 usbAudioStringManufactureDescriptor[STR_MANUFACTURE_LENGTH] __USB_DEV_BSS = {
const U8 usbAudioStringManufactureDescriptor[STR_MANUFACTURE_LENGTH] = {
	STR_MANUFACTURE_LENGTH,
	DESCRIPTOR_TYPE_STRING,
		'O',0,
		'p',0,
		't',0,
		'e',0,
		'k',0
};

//#define STR_PRODUCT_LENGTH    (2 + 11*2)
//static const U8 usbAudioStringProductDescriptor[STR_PRODUCT_LENGTH] __USB_DEV_BSS = {
#if 0
const U8 usbAudioStringProductDescriptor[STR_PRODUCT_LENGTH] = {
	STR_PRODUCT_LENGTH,
		DESCRIPTOR_TYPE_STRING,
		'U',0,
		'S',0,
		'B',0,
		' ',0,
		's',0,
		'p',0,
		'e',0,
		'a',0,
		'k',0,
		'e',0,
		'r',0
};
#endif
const U8 usbAudioStringProductDescriptor[STR_PRODUCT_LENGTH] = {
	STR_PRODUCT_LENGTH-8,
	DESCRIPTOR_TYPE_STRING,
		'U',0,
		'S',0,
		'B',0,
		' ',0,
		's',0,
		'p',0,
		'k',0,
		'-',0,
		'm',0,
		'i',0,
		'c',0,
		'M',0,
		'i',0,
		'x',0
};

//#define STR_SERIAL_NUM_MIN_LENGTH    (2 + 12*2)
//static const U8 usbAudioStringSerialNoDescriptor[STR_SERIAL_NUM_MIN_LENGTH] __USB_DEV_BSS = {
const U8 usbAudioStringSerialNoDescriptor[STR_SERIAL_NUM_MIN_LENGTH] = {
	STR_SERIAL_NUM_MIN_LENGTH,
	DESCRIPTOR_TYPE_STRING,
		'0',0,
		'1',0,
		'2',0,
		'7',0,
		'8',0,
		'9',0,
		'A',0,
		'B',0,
		'C',0,
		'D',0,
		'E',0,
		'F',0
};

#ifdef USB_SPEAKER

extern FIFO AdcInFifo;
void app_timer_usbdev_upstream_timeout_time_set (U16 time);
//Normal case: AUX data (from DMA2) send to USB In.
U16 adc_pcm_data_read(short *pdata) __INTERNAL_RAM_TEXT; 
U8 change_to_game_mode_cnt;
U16 adc_pcm_data_read(short *pdata)
{
#if 0//#ifndef OPTEK_DSP_MX1
	U32 *pADCDest;
	U32 wlen, dlen, len;

	len = 192;
	
	pADCDest = DMA_2_DEST;			//current fifo write address
	fifo_put_data_by_dma (&AdcInFifo, pADCDest);

	wlen = fifo_get_fifo_data_wlen(&AdcInFifo);
	dlen = fifo_get_fifo_data_len(&AdcInFifo);
DBG_iPrintf ("getADC %d)%d,%d\n\r", len, wlen, dlen);

#ifdef AUDIO_ADC_24BIT	//jj for ADC in 24 bit

#ifdef AudioData24BIT	//!!! ONLY consider 16bit for Audio IN !!!
	len = len*2;	//24 bit data occupying 32 bit space!
#else
	len = len;	//16 bit data occupying 32 bit space! Force MIC audio to 16bits !!! AUDIOIN_SUB_FRAME_SIZE, AUDIOIN_BIT_RESOLUTION
#endif

#endif

	if ( (AUDIO_SAMPLE_FREQ==48000) && (AUDIOIN_SAMPLE_FREQ==16000) )   //Downsamlpe 48KHz to 16KHz
	{
		len = len*3;	//Be to extract 1 every 3 pairs of channel data.
	}
	
	if (wlen < 0x4000)
	{
		//discard some data for pop noise and fix the latency
		if (dlen > 512)
		{
			fifo_discard_data(&AdcInFifo, (dlen - 512));
		}
		
		memset(pdata,0,len);
	}
	else
	{
		if (dlen < len )
		{
			DBG_iPrintf ("Mic Underflow1 %d,%d<%d\n\r", wlen, dlen, len);
			memset(pdata,0,len);
		}
		else
		{
			if (dlen >= len*4)
			{
				fifo_discard_data(&AdcInFifo, (dlen - len*2));
				DBG_iPrintf("Mic Overflow1 %d>=%d\n\r", dlen, len*4);
			}
			
			fifo_get_data (&AdcInFifo, pdata, len);
			
			//DBG_iPrintf ("Mic %d-%x-%x-%x-%x-%x-%x\n\r", len, (U8)*(pdata+0), (U8)*(pdata+1), (U8)*(pdata+2), (U8)*(pdata+3), (U8)*(pdata+4), (U8)*(pdata+5));

			U8 *pIn = pdata, *pOut = pdata; 
			U16 i;

			if ( (AUDIO_SAMPLE_FREQ==48000) && (AUDIOIN_SAMPLE_FREQ==16000) )   //Downsamlpe 48KHz to 16KHz
			{
				for (i=0;i<len;i+=24)		//get 4 bytes data every 24 bytes
				{
					pIn++;	//skip 1 byte --- L channel
					pIn++;	//skip 1 byte
					*pOut = *pIn;			pIn++; pOut++;
					*pOut = *pIn;			pIn++; pOut++;

					pIn++;	//skip 1 byte --- R channel
					pIn++;	//skip 1 byte
					*pOut = *pIn;			pIn++; pOut++;
					*pOut = *pIn;			pIn++; pOut++;

					pIn+=4;	//skip 4 byte --- L channel

					pIn+=4;	//skip 4 byte --- R channel

					pIn+=4;	//skip 4 byte --- L channel

					pIn+=4;	//skip 4 byte --- R channel
				}
			}
			else
			{
#ifdef AUDIO_ADC_24BIT
				for (i=0;i<len;i+=4)
				{
					pIn++;	//skip 1 byte --- L channel
					pIn++;	//skip 1 byte
					*pOut = *pIn;			pIn++; pOut++;
					*pOut = *pIn;			pIn++; pOut++;
				}
#endif
				//ADC in 16bit just use pdata from AdcInFifo!
			}
		}
	}

	return 192;

#else //OPTEK_DSP_MX1

/************************************************************************
For 44100 Sample Frequency:
	if ( (counter%10) == 0)	//for 44.1kHz sample rate, 44100 x 2 Channel x 2 Bytes /(1000) [125us] = 176.4 Bytes
	{
		counter = 0;
		len = 180;
	}
	else
	{
		len = 176;
	}

For 48000 Sample Frequency:
	len = 192;				//for 48kHz sample rate, 48000 x 2 Channel x 2 Bytes /(1000) [125us] = 192 Bytes
*************************************************************************/

	U32 *pADCDest;
	short *pIn, *pOut;
	U16 i;
	U32 wlen, dlen,inlen;

	//len = 192;	// Due to App to set len to specifc value !
	//len = AUDIO_SAMPLE_FREQ/1000 * AUDIO_CHANNELS * AUDIO_SUB_FRAME_SIZE;
	inlen = AUDIOIN_SAMPLE_FREQ/1000 * AUDIOIN_CHANNELS * AUDIOIN_SUB_FRAME_SIZE;
	
#if 0//( (SHARE_LINK_MODE == SL_DISABLE) && (!(defined OPTEK_DSP_MX1)) ) /*jj+ for standalone ADC input*/
	pADCDest = DMA_2_DEST;			//current fifo write address
	fifo_put_data_by_dma (&AdcInFifo, pADCDest);
#else
	#if  defined OPL_MODE_TWO_WAY
	if (optek_link_mode == BC_SF48K_PT5MS || optek_link_mode == BC_SF48K_PT7P5MS)
	{
		if (change_to_game_mode_cnt++ > 2)
		{
			app_timer_usbdev_upstream_timeout_time_set(1000);			
			change_to_game_mode_cnt = 0;
			if (optek_link_mode == BC_SF48K_PT5MS)
				app_change_mode_req(GAME_HEADPHONE_PT_5MS_LP,100,50);
			else// if (optek_link_mode == BC_SF48K_PT7P5MS)
				app_change_mode_req(GAME_HEADPHONE_PT7P5MS_T7R3E,150,75);
		}
		memset(pdata, 0, inlen);
		return inlen;		
	}
	app_timer_usbdev_upstream_timeout_time_set(1000);	
	#endif
#endif

	wlen = fifo_get_fifo_data_wlen(&AdcInFifo);
	dlen = fifo_get_fifo_data_len(&AdcInFifo);
	//DBG_iPrintf ("getADC %d,%d,%d\n\r", len, wlen, dlen);

	
	if (wlen < 0x4000)
	{
		//discard some data for pop noise and fix the latency
		if (dlen > 512)
		{
			fifo_discard_data(&AdcInFifo, (dlen - 512));
		}
//		DBG_iPrintf("wlen < 0x4000\n\r");
		memset(pdata, 0, inlen);
	}
	else
	{
		if (dlen < inlen )
		{
			//DBG_iPrintf ("upstream  Underflow %d<%d\n\r", dlen, inlen);
			memset(pdata, 0, inlen);
		}
		else
		{
			if (dlen >= (480*4))
			{
				fifo_discard_data(&AdcInFifo, (dlen - 480*2));
				DBG_iPrintf("upstream Overflow\n\r");
			}

			fifo_get_data (&AdcInFifo, pdata, inlen);		

		#if 0 //only for 48KHz data downsample to 16KHz, then USB In!
			if ( (AUDIO_SAMPLE_FREQ==48000) && (AUDIOIN_SAMPLE_FREQ==16000) )   //Downsamlpe 48KHz to 16KHz
			{
				pIn = pdata; pOut = pdata;
			#if (AUDIOIN_CHANNELS==2)
				for (i=0; i<(len/2); i+=6)	//len/2 samples
				{
					*pOut++ = *(pIn+i);		//L sample
					*pOut++ = *(pIn+i+1);	//R sample
				}
			#else
				for (i=0; i<(len/2); i+=6)	//len/2 samples
				{
					*pOut++ = *(pIn+i);		//L sample
				}
			#endif
			}
		#endif
		}
	}
	//len = inlen;

	//DBG_iPrintf ("len=%d\n", len);
	return inlen;
#endif
}
void app_change_mode_req(u8 mode, u8 max_master_tx_len, u8 max_master_rx_len);
void usbdev_upstream_timeout_handle(void)
{
	if (GAME_HEADPHONE_PT_5MS_LP == optek_link_mode)
	{
		app_change_mode_req(BC_SF48K_PT5MS,100,6);
	}
	else if (GAME_HEADPHONE_PT7P5MS_T7R3E == optek_link_mode)
	{
		app_change_mode_req(BC_SF48K_PT7P5MS,150,6);
	}
}

#ifdef HIDFUNC
int dhid_submitIntIn(U8* pU8data);	//USB HID API in lib.

//HID data send to USB HID In.
U16 usb_hid_data_in(short *pdata) __INTERNAL_RAM_TEXT; 

U16 usb_hid_data_in(short *pdata)
{
	if (usbdev_featureconf.HIDFuncEnable)
	{
		return dhid_submitIntIn(pdata);
	}
	else
	{
		return 0;
	}
}

extern FIFO HIDOutFifo;

//Get HID data from USB HID Out pipe.
int usb_hid_hid_data_out() __INTERNAL_RAM_TEXT; 

int usb_hid_hid_data_out()
{
/*
	U8 pBuf[1024];
	
	if (usbdev_featureconf.HIDFuncEnable)
	{
		fifo_get_data(&HIDOutFifo, pBuf, 64);
	}
*/	
}
#endif //HIDFUNC


int Samplerate_offset;
void daudio_SetFBSamplerateCorrection(int sample_rate_offset)
{
	Samplerate_offset = sample_rate_offset;
}

//return the delta value applied to USB device feedback Sample rate on theoretical value
void daudio_GetFBSamplerateCorrection(int *value)
{
	*value = Samplerate_offset;
}

#endif //(defined USB_SPEAKER)

#endif //USB_DEV_ENABLE


#ifdef USB_DEV_MICROPHONE
//===========================================================================
//	for usb microphone
//===========================================================================

#define	STR_MANUFACTURE_LENGTH    (2 + 5*2)
const U8 StringManufactureDescriptor[STR_MANUFACTURE_LENGTH] = {
	STR_MANUFACTURE_LENGTH,
	DESCRIPTOR_TYPE_STRING,
	'o',0,
	'p',0,
	't',0,
	'e',0,
	'k',0
};

#define	STR_PRODUCT_LENGTH        (2 + 14*2)
const U8 StringProductDescriptor[STR_PRODUCT_LENGTH] = {
	STR_PRODUCT_LENGTH,
	DESCRIPTOR_TYPE_STRING,
	'U',0,
	'S',0,
	'B',0,
	' ',0,
	'm',0,
	'i',0,
	'c',0,
	'r',0,
	'o',0,
	'p',0,
	'h',0,
	'o',0,
	'n',0,
	'e',0
};

#define	STR_SERIAL_NUM_LENGTH     (2 + 11*2)
const U8 StringSerialNoDescriptor[STR_SERIAL_NUM_LENGTH] = {
	STR_SERIAL_NUM_LENGTH,
	DESCRIPTOR_TYPE_STRING,
	'0',0,
	'1',0,
	'2',0,
	'3',0,
	'4',0,
	'A',0,
	'B',0,
	'C',0,
	'D',0,
	'E',0,
	'F',0
};
#endif

#endif //USB_DEV_ENABLE