#include "os_config.h"

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

#include "mem_reloc.h"

#include "message.h"
#include "printf.h"
#include "audio_dec.h"

#if 1//ndef FREE_RTOS_DEBUG
/* FreeRTOS includes. */
#include "FreeRTOS.h"
#include "task.h"
#include "timers.h"
#include "event_groups.h"
#endif


volatile U16 keysInQueue = 0;

#if 0
void ukMsgSend (FUNCTION key_func) __INTERNAL_RAM_TEXT;
void ukParmSend (FUNCTION key_func, U32 parm1) __INTERNAL_RAM_TEXT;
void ukiParmSend (FUNCTION key_func, U32 parm1) __INTERNAL_RAM_TEXT;
void ukParmSendExt (FUNCTION key_func, U32 parm1, U32 parm2) __INTERNAL_RAM_TEXT;

void uiStreamSend (U16 msg, void *parm1, U16 parm2) __INTERNAL_RAM_TEXT;

int os_event_iset(unsigned long event_mask) __INTERNAL_RAM_TEXT;
int os_event_get(unsigned long event_mask) __INTERNAL_RAM_TEXT;

int os_queue_isend(void *queueID, unsigned long *msg_buf) __INTERNAL_RAM_TEXT;
//int os_queue_receive_for_wait_xms(void *queueID, unsigned long *data, unsigned long wait_xms) __INTERNAL_RAM_TEXT;
//int os_mutex_lock_for_timeout(unsigned long *mutexID, unsigned long wait_xms) __INTERNAL_RAM_TEXT;

void uiDecSend (U16 msg, U16 parm) __INTERNAL_RAM_TEXT;
void uDecSend (U16 msg, U16 parm) __INTERNAL_RAM_TEXT;

void usbmsg_isendIRP( void * irp ) __INTERNAL_RAM_TEXT;

void usbmsg_setHTDevent( void ) __INTERNAL_RAM_TEXT;
#else
int os_queue_isend(void *queueID, unsigned long *msg_buf) __INTERNAL_RAM_TEXT;
void uiDecSend (U16 msg, U16 parm) __INTERNAL_RAM_TEXT;
#endif

#ifdef MP3_ENCODE_ENABLE
void usbmsg_sendIRP( void * irp ) __INTERNAL_RAM_TEXT;
void usbmsg_isendIRP( void * irp ) __INTERNAL_RAM_TEXT;
void usbmsg_IRPcompleteFunc( void ) __INTERNAL_RAM_TEXT;
void usbmsg_waitIRPcomplete(void) __INTERNAL_RAM_TEXT;
void usbmsg_setHTDevent( void ) __INTERNAL_RAM_TEXT;
void usbmsg_clearHTDevent(void ) __INTERNAL_RAM_TEXT;
int usbmsg_waitHTDevent( void ) __INTERNAL_RAM_TEXT;

int fs_thread_lock(void) __INTERNAL_RAM_TEXT;
int fs_thread_unlock(void) __INTERNAL_RAM_TEXT;

#endif

void uDecSend (U16 msg, U16 parm)
{
	U32 ret;
	DEC_MSG uMsg;
	unsigned long *data = (unsigned long *)&uMsg;
	
	uMsg.msg = msg;
	uMsg.parm = parm;

/*	if ( (wCodecBusy == TRUE) && (msg == DECODE_FRAME) )
	{
		return;
	}
*/
#if 0
	if (msg == DECODE_INIT)
	{
		asm("nop");
	}
#endif

	QUEUE_DEC_SEND;
	//DBG_Assert(ret);
}

void uiDecSend (U16 msg, U16 parm)
{
	U32 ret;
	DEC_MSG uMsg;
	unsigned long *data = (unsigned long *)&uMsg;
	
	uMsg.msg = msg;
	uMsg.parm = parm;

/*	if ( (wCodecBusy == TRUE) && (msg == DECODE_FRAME) )
	{
		return;
	}
*/
	//ret = xQueueSendToBackFromISR( qDEC, (void *)&uMsg, 0 );
	QUEUE_DEC_iSEND;
	//DBG_Assert(ret);
}

void uDecSendWaitForever (U16 msg, U16 parm)
{
	U32 ret;
	DEC_MSG uMsg;
	unsigned long *data = (unsigned long *)&uMsg;
	
	uMsg.msg = msg;
	uMsg.parm = parm;

/*	if ( (wCodecBusy == TRUE) && (msg == DECODE_FRAME) )
	{
		return;
	}
*/
#if 0
	if (msg == DECODE_INIT)
	{
		asm("nop");
	}
#endif

	QUEUE_DEC_SEND_WAIT_FOREVER;
	//DBG_Assert(ret);
}

void ukMsgSend (FUNCTION key_func)
{
	U32 data[WIDTH_OF_KFUNC_QUEUE];

	data[0] = (U32)key_func;
	data[1] = enKEY_FUNC_VOID;

	QUEUE_KEYFUNC_SEND;
}

void ukiMsgSend (FUNCTION key_func)
{
	U32 data[WIDTH_OF_KFUNC_QUEUE];

	data[0] = (U32)key_func;
	data[1] = enKEY_FUNC_VOID;

	QUEUE_KEYFUNC_iSEND;
}

void ukParmSend (FUNCTION key_func, U32 parm1)
{
	U32 data[WIDTH_OF_KFUNC_QUEUE];

	data[0] = (U32)key_func;
	data[1] = enKEY_FUNC_1PARAM;
	data[2] = (U32)parm1;

	QUEUE_KEYFUNC_SEND;
}

void ukiParmSend (FUNCTION key_func, U32 parm1)
{
	U32 data[WIDTH_OF_KFUNC_QUEUE];

	data[0] = (U32)key_func;
	data[1] = enKEY_FUNC_1PARAM;
	data[2] = (U32)parm1;

	QUEUE_KEYFUNC_iSEND;
}

void ukParmSendExt (FUNCTION key_func, U32 parm1, U32 parm2)
{
	U32 data[WIDTH_OF_KFUNC_QUEUE];

	data[0] = (U32)key_func;
	data[1] = enKEY_FUNC_2PARAM;
	data[2] = (U32)parm1;
	data[3] = (U32)parm2;

	QUEUE_KEYFUNC_SEND;
}

void ukiParmSendExt (FUNCTION key_func, U32 parm1, U32 parm2)
{
	U32 data[WIDTH_OF_KFUNC_QUEUE];

	data[0] = (U32)key_func;
	data[1] = enKEY_FUNC_2PARAM;
	data[2] = (U32)parm1;
	data[3] = (U32)parm2;

	keysInQueue++;

	QUEUE_KEYFUNC_SEND;
}


//The code below for qUI message senging
void uMsgSend (U16 uiSource, U16 parm1, U32 parm2) __INTERNAL_RAM_TEXT;
void uiMsgSend (U16 uiSource, U16 parm1, U32 parm2) __INTERNAL_RAM_TEXT;

void uMsgSend (U16 uiSource, U16 parm1, U32 parm2)
{
	UI_MSG uMsg;
	U32 *data = (U32 *)&uMsg;

	uMsg.source = uiSource;
	uMsg.parm1 = parm1;
	uMsg.parm2 = parm2;

	//if (uMsg.source == UI_CODEC)
	//{
	//	asm("nop");
	//}

	//if (uMsg.parm1 == UI_DECODE_SKIP_F)
	//{
	//	asm("nop");
	//}

	QUEUE_UI_SEND;
}

void uiMsgSend (U16 uiSource, U16 parm1, U32 parm2)
{
	UI_MSG uMsg;
	U32 *data = (U32 *)&uMsg;

	uMsg.source = uiSource;
	uMsg.parm1 = parm1;
	uMsg.parm2 = parm2;

	//if (uMsg.source == UI_CODEC)
	//{
	//	asm("nop");
	//}

	QUEUE_UI_iSEND;
}

#ifdef SPDIF_ENABLE
void uiStreamSend (U16 msg, void *parm1, U16 parm2)
{
	STREAM_MSG uMsg;
	U32 *data = (U32 *)&uMsg;

	uMsg.source = msg;
	uMsg.buffer = (void *)(ULONG)parm1;
	uMsg.length = parm2;

	QUEUE_STREAM_RCV_iSEND;
}
#endif

void uHddMsgSend (U16 msg, U32 parm1, U16 parm2)
{
#if (defined USB_HOST_ENABLE || defined SD_ENABLE)
	HDD_MSG uMsg;
	U32 *data = (U32 *)&uMsg;

	uMsg.msg = msg;
	uMsg.parm1 = parm1;
	uMsg.parm2 = parm2;

	QUEUE_HDD_SEND;
#endif
}


#ifdef USB_HOST_ENABLE

#define	USB_WAIT_IRP_EVENT_MAX_TIME	(3000 / OS_MSEC_PER_TICK + 1)	//3s
#define	USB_WAIT_HTD_EVENT_MAX_TIME	(1000)			//FIXME


void usbmsg_sendIRP( void * irp )
{
	//U32 data[WIDTH_OF_HDD_QUEUE];
	U32 *data = (U32 *)irp;

	USB_IRP_EVENT_CLR;
	QUEUE_USB_SEND;
}

void usbmsg_isendIRP( void * irp )
{
	U32 *data = (U32 *)irp;

	//USB_IRP_EVENT_iCLR; //don't use it
	QUEUE_USB_iSEND;
}


void usbmsg_IRPcompleteFunc( void )
{
	USB_IRP_EVENT_SET;
}

void usbmsg_waitIRPcomplete(void)
{
	USB_IRP_EVENT_GET;
}

void usbmsg_setHTDevent( void )
{
	USB_HTD_EVENT_iSET;
}

void usbmsg_clearHTDevent(void )
{
#if 1
	USB_HTD_EVENT_CLR;

#else

#if 1//defined FREE_RTOS
	{
	    unsigned long ret;
	    ret = xEventGroupClearBits(event_grop, USB_HTD_EVNET);
	    if ( (ret & USB_HTD_EVNET) != USB_HTD_EVNET)
	    {
	        DBG_Assert(FALSE);
	    }
	}
#endif

#endif
}

int usbmsg_waitHTDevent( void )
{
	int temp;

#if 0
	USB_HTD_EVENT_GET;
#else
	temp = USB_HTD_EVENT_GET; //if USB_HTD_EVENT_GET called a funtion
	return temp;
#endif

#if 0

#if 0
	unsigned int flag;

	unsigned int ret = tx_event_flags_get( &event_grop, USB_HTD_EVNET,
			TX_OR_CLEAR, &flag, USB_WAIT_HTD_EVENT_MAX_TIME );

	if( ret == TX_SUCCESS )
	{
		return TRUE;
	}
	else
	{
		DBG_assert ( ret == TX_NO_EVENTS );
		return FALSE;
	}
#else
    unsigned long ret;
    ret = xEventGroupWaitBits(event_grop, USB_HTD_EVNET, pdFALSE, pdTRUE, portMAX_DELAY);
    if ( (ret & USB_HTD_EVNET) != USB_HTD_EVNET)
    {
        DBG_Assert(FALSE);
		return FALSE;
    }
    ret = xEventGroupClearBits(event_grop, USB_HTD_EVNET);
    if ( (ret & USB_HTD_EVNET) != USB_HTD_EVNET)
    {
        DBG_Assert(FALSE);
		return FALSE;
    }

	return TRUE;
#endif

#endif
}

int fs_thread_lock(void)
{
	unsigned int ret;
	
	ret = os_mutex_lock(&mutex_fs);
	return ret;
}

int fs_thread_unlock(void)
{
	unsigned int ret;
	
	ret = os_mutex_unlock(&mutex_fs);
	return ret;
}

#endif //USB_HOST_ENABLE


int os_mutex_lock(unsigned long *mutexID)
{
	if (mutexID == NULL)
		return FALSE;

	if (xSemaphoreTake( mutexID, portMAX_DELAY) != TRUE)
	{
		DBG_Assert(FALSE);
		return FALSE;
	}

	return TRUE;
}

//jj+
int os_mutex_ilock(unsigned long *mutexID)
{
	if (mutexID == NULL)
		return FALSE;	
	if (xSemaphoreTakeFromISR( mutexID, NULL) != TRUE)
	{
		DBG_Assert(FALSE);
		return FALSE;
	}

	return TRUE;
}

int os_mutex_lock_for_timeout(unsigned long *mutexID, unsigned long wait_xms)
{
	int wait_time_ticks;


	if (mutexID == NULL)
		return FALSE;

#ifdef RTOS_ENABLE

	wait_time_ticks = ( (wait_xms + OS_MSEC_PER_TICK - 1) / OS_MSEC_PER_TICK );

#if defined THREAD_RTOS
	if (tx_mutex_get( (TX_MUTEX *)mutexID, wait_time_ticks) != TX_SUCCESS)
	{
		DBG_Assert(FALSE);
		return FALSE;
	}
	
	return TRUE;
#elif defined FREE_RTOS
	if (xSemaphoreTake( mutexID, wait_time_ticks) != TRUE)
	{
		DBG_Assert(FALSE);
		return FALSE;
	}

	return TRUE;
#else
	return FALSE;
#endif

#else
	return FALSE;
#endif
}

int os_mutex_unlock(unsigned long *mutexID)
{

	if (mutexID == NULL)
		return FALSE;

	if( xSemaphoreGive( mutexID ) != TRUE )
	{
		DBG_Assert(FALSE);
		return FALSE;
	}

	return TRUE;
}

//jj+
int os_mutex_iunlock(unsigned long *mutexID)
{

	if (mutexID == NULL)
		return FALSE;
		
	if( xSemaphoreGiveFromISR( mutexID, NULL ) != TRUE )
	{
		DBG_Assert(FALSE);
		return FALSE;
	}

	return TRUE;
}

//The event's functions is used for the variable of "event_grop" .
int os_event_set(unsigned long event_mask)
{
	unsigned long ret;
	ret = xEventGroupSetBits(event_grop, event_mask);
	if ( (ret & event_mask) != event_mask)
	{
	    //DBG_Assert(FALSE);
		return FALSE;
	}

	return TRUE;
}

int os_event_iset(unsigned long event_mask)
{
	unsigned long ret;

	ret = xEventGroupSetBitsFromISR( event_grop, event_mask, NULL); 
	if( ret == pdTRUE)
	{
		//INCLUDE_xEventGroupSetBitFromISR
		portYIELD_FROM_ISR();
	}

	if (ret != TRUE)
	{
	    DBG_Assert(FALSE); //sometimes comes here.
		return FALSE;
	}


	return TRUE;
}

int os_event_clr(unsigned long event_mask)
{
	unsigned long ret;
	ret = xEventGroupClearBits(event_grop, event_mask);
	if ( (ret & event_mask) != event_mask)
	{
		DBG_Assert(FALSE);
		return FALSE;
	}

	return TRUE;
}

int os_event_iclr(unsigned long event_mask)
{
	unsigned long ret;
	ret = xEventGroupClearBitsFromISR(event_grop, event_mask);
	if ( (ret & event_mask) != event_mask)
	{
		DBG_Assert(FALSE);
		return FALSE;
	}

	return TRUE;
}

int os_event_get(unsigned long event_mask)
{
	unsigned long ret;

#if 1
	ret = xEventGroupWaitBits(event_grop, event_mask, pdTRUE, pdFALSE, portMAX_DELAY);
	if ( (ret & event_mask) != event_mask)
	{
		DBG_Assert(FALSE);
	}

	return ret;
#else
	ret = xEventGroupWaitBits(event_grop, event_mask, pdFALSE, pdFALSE, portMAX_DELAY);
	if ( (ret & event_mask) != event_mask)
	{
		DBG_Assert(FALSE);
	}
	ret = xEventGroupClearBits(event_grop, event_mask);
	if ( (ret & event_mask) != event_mask)
	{
		DBG_Assert(FALSE);
	}

	return ret;
#endif
}


int os_event_get_for_wait_xms(unsigned long event_mask, unsigned long wait_xms)
{
	unsigned long ret;
	unsigned long wait_time_ms;

	wait_time_ms = ( (wait_xms + OS_MSEC_PER_TICK - 1) / OS_MSEC_PER_TICK );

#if 1
	ret = xEventGroupWaitBits(event_grop, event_mask, pdTRUE, pdFALSE, wait_time_ms);
	if ( (ret & event_mask) != event_mask)
	{
		DBG_Assert(FALSE);
	}

	return ret;
#else
	ret = xEventGroupWaitBits(event_grop, event_mask, pdFALSE, pdFALSE, wait_time_ms);
	if ( (ret & event_mask) != event_mask)
	{
		DBG_Assert(FALSE);
	}
	ret = xEventGroupClearBits(event_grop, event_mask);
	if ( (ret & event_mask) != event_mask)
	{
		DBG_Assert(FALSE);
	}

	return ret;
#endif
}


int os_queue_send(void *queueID, unsigned long *msg_buf)
{
	U32 ret;
	ret = xQueueSend( queueID, (void *)msg_buf, 0 );
	if (ret != TRUE)
	{
		DBG_Assert(FALSE);
		return FALSE;
	}

	return TRUE;
}

int os_queue_isend(void *queueID, unsigned long *msg_buf)
{
	U32 ret;

	ret = xQueueSendToBackFromISR( queueID, (void *)msg_buf, NULL );
	if( ret == pdTRUE)
	{
		//INCLUDE_xEventGroupSetBitFromISR
		portYIELD_FROM_ISR();
	}
	
	if (ret != TRUE)
	{
		DBG_Assert(FALSE);
	}

	return TRUE;
}

int os_queue_send_wait_forever(void *queueID, unsigned long *msg_buf)
{
	U32 ret;
	ret = xQueueSend( queueID, (void *)msg_buf, portMAX_DELAY);
	if (ret != TRUE)
	{
		DBG_Assert(FALSE);
		return FALSE;
	}

	return TRUE;
}

int os_queue_receive(void *queueID, unsigned long *msg_buf)
{
	U32 ret;
	ret = xQueueReceive( queueID, (void *)msg_buf, portMAX_DELAY );
	if (ret != TRUE)
	{
		DBG_Assert(FALSE);
		return FALSE;
	}

	return TRUE;
}

int os_queue_receive_for_wait_xms(void *queueID, unsigned long *data, unsigned long wait_xms)
{
	unsigned long ret;
	unsigned long wait_time_ms;

	wait_time_ms = ( (wait_xms + OS_MSEC_PER_TICK - 1) / OS_MSEC_PER_TICK );

	ret = xQueueReceive( queueID, (void *)data, wait_time_ms );
	if (ret != TRUE)
	{
		//DBG_Assert(FALSE); //if using TX_NO_WAIT, it can be here.
		return FALSE;
	}

	return TRUE;
}

int os_queue_ireceive(void *queueID, unsigned long *msg_buf)
{
	return FALSE;
}

int os_queue_clear(void *queueID)
{
	unsigned long ret;

	ret = xQueueReset(queueID);
	if (ret)
	{
		ret = TRUE; //flush queue successfully
	}
	else
	{
		ret = FALSE; //flush queue failed
	}

	return ret;	
}


int os_queue_delete(void *queueID)
{
	unsigned long ret;

	vQueueDelete(queueID);
	return TRUE;
}


int os_int_level_disable(char int_level)
{
#if 1
	register int interrupt_save;
	//XTOS_SET_INTLEVEL(int_level);
	interrupt_save = _xtos_set_intlevel(int_level)
	portbenchmarkINTERRUPT_DISABLE();
	return interrupt_save;
#else
	register int interrupt_save;
	_xtos_set_intlevel(int_level)
	portbenchmarkINTERRUPT_DISABLE();
	return XCHAL_EXCM_LEVEL;
#endif
}

void os_int_level_restore(int int_level)
{
#if 0
	portEXIT_CRITICAL_NESTED(int_level);
#else
	_interrupt_control(int_level);
#endif
}


void int1_disable(void)
{
	register int interrupt_save;
    interrupt_save = _interrupt_control(3);
	
	DBG_Printf("int dis %d\n\r",interrupt_save);
//	TX_DISABLE;
	delayms(10000);
//	DBG_Printf("int dis %d\n\r",XCHAL_EXCM_LEVEL);
	os_int_level_restore(interrupt_save);
	delayms(30000);
}

void int1_restore(void)
{
	os_int_level_restore(1);
//	DBG_Printf("int restore%d\n\r",os_int_level_restore(1));
}

void freeRTOS_xTaskIncrementTick_callback(void) __INTERNAL_RAM_TEXT;
void freeRTOS_xTaskIncrementTick_callback(void)
{

}