//
// Copyright (c) 2008 Optek.
//
//! \file os_entry.c
//! \brief creates threads for your project.
//! \date 08/09
//!
//! Example for creating threads, stack size
//! used here is simply for example purposes, set based on your needs.
//!

#include "os_config.h"

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

#include "app_timer.h"

#include "FreeRTOS.h"
#include "task.h"
#include "semphr.h"


#define TASK_UI_ENABLE
#define TASK_KEYFUNC_ENABLE


//TX_MINIMUM_STACK_BASIC(416 bytes defined in freeRTOS)

#ifndef TX_MINIMUM_STACK
#define TX_MINIMUM_STACK               (XT_STK_FRMSZ + 0x20)
#endif
#ifdef  TX_ENABLE_STACK_CHECKING
#define TX_STACK_CHECK_PREMIUM         0x50
#else
#define TX_STACK_CHECK_PREMIUM         0
#endif
#ifndef TX_MINIMUM_STACK_BASIC
#define TX_MINIMUM_STACK_BASIC         (XT_STK_FRMSZ + 0x100 + TX_STACK_CHECK_PREMIUM)
#endif



#if 0
#define TASK_STREAM_RCV_STACK_SIZE  (TX_MINIMUM_STACK_BASIC + 1024)
#define	TASK_DEC_STACK_SIZE         (TX_MINIMUM_STACK_BASIC + 4096)
#define TASK_KEYSCAN_STACK_SIZE     (TX_MINIMUM_STACK_BASIC + 2048)
#define TASK_CDSC_STACK_SIZE        (TX_MINIMUM_STACK_BASIC + 2048)
#define TASK_UI_STACK_SIZE          (TX_MINIMUM_STACK_BASIC + 2048)
#define TASK_KEYFUNC_STACK_SIZE     (TX_MINIMUM_STACK_BASIC + 2048)
#define TASK_HDD_STACK_SIZE         (TX_MINIMUM_STACK_BASIC + 2048)
#define TASK_USB_STACK_SIZE         (TX_MINIMUM_STACK_BASIC + 2048)
#define TASK_USBOTG_STACK_SIZE      (TX_MINIMUM_STACK_BASIC + 2048)
#define TASK_IDLE_STACK_SIZE        (TX_MINIMUM_STACK_BASIC + 1024)
#else
#define TASK_STREAM_RCV_STACK_SIZE  (1024)
//#define TASK_STREAM_RCV_STACK_SIZE  (1024+512)
//#define TASK_STREAM_RCV_STACK_SIZE  (1024+1024)

#if (defined CD_RIPPING || defined MP3_DECODE_ENABLE)
#define TASK_DEC_STACK_SIZE         (1024*4)	//
//#define TASK_DEC_STACK_SIZE         (1024*3+512)		//
//#define TASK_DEC_STACK_SIZE         (1024*3)		//
#else
#define TASK_DEC_STACK_SIZE         (1536)    //0x600
//#define TASK_DEC_STACK_SIZE         (1024*2)    //for AAC
#endif

#define TASK_KEYSCAN_STACK_SIZE     (1024+512)
#define TASK_CDSC_STACK_SIZE        (1024+512)

#if 1
//#define TASK_UI_STACK_SIZE          (2048)
#define TASK_UI_STACK_SIZE          (1024+256)
//#define TASK_UI_STACK_SIZE          ((1024+256)*2)
#else
//#define TASK_UI_STACK_SIZE          (2048)
#define TASK_UI_STACK_SIZE          (1024+256+256)
//#define TASK_UI_STACK_SIZE          ((1024+256)*2)
#endif

#if 1
//#define TASK_KEYFUNC_STACK_SIZE     (1024+512)
#define TASK_KEYFUNC_STACK_SIZE     (2048+512)
//#define TASK_KEYFUNC_STACK_SIZE     ((1024+512)*2)
#else
//#define TASK_KEYFUNC_STACK_SIZE     (1024+512)
#define TASK_KEYFUNC_STACK_SIZE     (2048+512+256)
//#define TASK_KEYFUNC_STACK_SIZE     ((1024+512)*2)
#endif

//#define TASK_HDD_STACK_SIZE       (1024+512)
#define TASK_HDD_STACK_SIZE         (2048)

//#define TASK_USB_STACK_SIZE       (2048)

#if 0//(defined CD_RIPPING || defined ADC_RECORD)
#define TASK_USBOTG_STACK_SIZE      (2048+512)
#else
#define TASK_USBOTG_STACK_SIZE      (1024+512)
//#define TASK_USBOTG_STACK_SIZE      (2048)
#endif

//#define TASK_BtHCI_STACK_SIZE       (2048)
//#define TASK_BtHCI_STACK_SIZE       (2048*2)
//#define TASK_BtHCI_STACK_SIZE       (1024+256+64+64)
//#define TASK_BtHCI_STACK_SIZE       (1024+256+256)
#define TASK_BtHCI_STACK_SIZE         (1024+256+256+512)

//#define TASK_BTDM_CONTROLL_STACK_SIZE    (1024)
//#define TASK_BTDM_CONTROLL_STACK_SIZE    (1024*2)
//#define TASK_BTDM_CONTROLL_STACK_SIZE    (1024+512+256+64)
//#define TASK_BTDM_CONTROLL_STACK_SIZE    (1024+512+256+128)
//#define TASK_BTDM_CONTROLL_STACK_SIZE    (1024+512+256+128+32)
//#define TASK_BTDM_CONTROLL_STACK_SIZE    (1024+512+256+128+64)
#define TASK_BTDM_CONTROLL_STACK_SIZE    (1024+512+256+128+128)

#define TASK_IDLE_STACK_SIZE        (512)
#endif



/* This has impact on speed of search for highest priority */
#ifdef SMALL_TEST
//#define configMAX_PRIORITIES      (7)
#else
//#define configMAX_PRIORITIES      (25)
#endif



/* This has impact on speed of search for highest priority */
#ifdef SMALL_TEST
//#define configMAX_PRIORITIES      (7)
#else
//#define configMAX_PRIORITIES      (25)
#endif

#define TASK_STREAM_RCV_PRIORITY	(14)
#define TASK_DEC_PRIORITY           (13)
#define TASK_BtController_PRIORITY  (12)
#define TASK_BtHCI_PRIORITY         (11)
//#define TASK_STREAM_RCV_PRIORITY	(10)
//#define TASK_DEC_PRIORITY           (9)

#define TASK_USB_PRIORITY           (8)//6

#define TASK_HDD_PRIORITY_HI        (7)//7

#define TASK_UI_PRIORITY            (6)//8
#define TASK_KEYFUNC_PRIORITY       (5)//9
//#define TASK_KEYFUNC_PRIORITY       (4)
#define TASK_HDD_PRIORITY           (3)//11:15-10

#define TASK_IDLE_PRIORITY          (0)


//#define TASK_EXAMPLE1_PRIORITY      (12)
//#define TASK_EXAMPLE2_PRIORITY      (11)



//Event
void *event_grop;
//void *gSDdmaEvent;
void *gUartSemphrBinnary;



//Mutexes:
void *mutex_qspi;

#if 1 //def MP3CD
void *mutex_i2c0;
void *mutex_i2c2;
#endif

#if 1//def UART0_ENABLE
void  *mutex_uart0_tx;
#if 1//def UART0_RX_ENABLE
void *mutex_uart0_rx;
#endif
#endif

#if 1//def UART1_ENABLE
void *mutex_uart1_tx;
#if 1//def UART1_RX_ENABLE
void * mutex_uart1_rx;
#endif
#endif

#if 1//def UART2_ENABLE
void *mutex_uart2_tx;
#if (defined UART_RX_ENABLE && defined UART_SCANF_ENABLE)
void *mutex_uart2_rx;
#endif
#endif


void *mutex_stream;

#ifdef BT_HCI_ENABLE
//void *mutex_malloc;
#endif

void *mutex_fs;
void *mutex_usb;

#ifdef SD_ENABLE
#ifdef SD_DMA_TRANSFER
void* gSDdmaEvent;
#endif
#endif

#ifdef SD_ENABLE
void* gSDqueue;
#endif

#ifdef SD_ENABLE
void *gSDmutex;
#endif

#if 0
void *mutex_lcd_refresh;
#endif


//TX_TIMER timer_CD_INPUT;
void *timer_CD_FIT;
void *timer_5ms;

#if 0//def MP3CD
void *timer_CD_PROCESS;
#endif

#ifdef REMOTE_ENABLE
void *timer_CD_BASE;
#endif

#if 1//def APPS_UPGRADE_ENABLE
void *mutex_spi;
#endif



//Queue
void *qDEC;

void * qStream_Rcv;

#ifdef TASK_UI_ENABLE
void *qUI;
#endif

#ifdef TASK_KEYFUNC_ENABLE
void *qKFUNC;
#endif

void *qHDD;
void *gUsbQueue;

#if 1//def BT_HCI_ENABLE
void *qBtHCI; //for bt hci
#endif

//void *gSDqueue;
void *taskHDD_thread;

void taskBtHCI(void *pvParameters);

void taskUi(void *pvParameters);
void taskKeyFunc(void *pvParameters);

void taskIdle(void *pvParameters);

void taskDec(void *pvParameters);

void taskStream_Rcv(void *pvParameters);
void task_usbotg(void *pvParameters);
void taskHdd(void *pvParameters);

#define mainREG_TEST_1_PARAMETER    (NULL)
#define mainREG_TEST_2_PARAMETER    (NULL)
#define mainREG_TEST_3_PARAMETER    (NULL)

void os_entry(void *param)
{
	U32 ret;
	long stack_size;

	DBG_Printf("free rtos ver:%s,build time:%s %s\r\n",free_rtos_lib_version_get(),free_rtos_lib_time_get(),free_rtos_lib_data_get());
	

	//Event creating
	event_grop = xEventGroupCreate();

	qBtHCI = xQueueGenericCreate( DEPTH_OF_BtHCI_QUEUE, (WIDTH_OF_BtHCI_QUEUE*4), queueQUEUE_TYPE_SET );

	qKFUNC = xQueueGenericCreate( DEPTH_OF_KFUNC_QUEUE, (WIDTH_OF_KFUNC_QUEUE*4), queueQUEUE_TYPE_SET );


#if 1
	stack_size = TASK_BtHCI_STACK_SIZE;
	ret = xTaskCreate(taskBtHCI, 
    			"btdm host", 
    			stack_size, 
    			mainREG_TEST_1_PARAMETER, 
     			TASK_BtHCI_PRIORITY,
    			NULL);

    if (ret != TRUE)
    {
		DBG_Assert(FALSE);
	}
#endif


#if 1
	void task_bt_controller(void *pvParameters);
	stack_size = TASK_BTDM_CONTROLL_STACK_SIZE;
	ret = xTaskCreate(task_bt_controller, 
    			"btdm controller", 
    			stack_size, 
    			mainREG_TEST_2_PARAMETER, 
    			TASK_BtController_PRIORITY,
    			NULL);

    if (ret != TRUE)
    {
		DBG_Assert(FALSE);
    }
#endif


#if 1
	stack_size = TASK_DEC_STACK_SIZE;
	ret = xTaskCreate(taskDec, 
    			"dec", 
    			stack_size, 
    			mainREG_TEST_2_PARAMETER, 
    			TASK_DEC_PRIORITY,
    			NULL);

    if (ret != TRUE)
    {
		DBG_Assert(FALSE);
    }
#endif


#if 1//def TASK_UI_ENABLE

#if 1
	stack_size = TASK_UI_STACK_SIZE;
	//stack_size = TASK_UI_STACK_SIZE+1024;
#else
	//if we defined UART_TX_FIFO_ENABLE,please use the code below.
	stack_size = 1024*2;
	//stack_size = 4096;
#endif

	ret = xTaskCreate(taskUi, 
    			"Rreg5", 
    			stack_size, 
    			mainREG_TEST_1_PARAMETER, 
     			TASK_UI_PRIORITY,
    			NULL);
#endif //TASK_UI_ENABLE


#ifdef TASK_KEYFUNC_ENABLE
	stack_size = TASK_KEYFUNC_STACK_SIZE;

	ret = xTaskCreate(taskKeyFunc, 
    			"keyFunc", 
    			stack_size, 
    			mainREG_TEST_1_PARAMETER, 
     			TASK_KEYFUNC_PRIORITY,
    			NULL);
	
    if (ret != TRUE)
    {
		DBG_Assert(FALSE);
	}
#endif


#ifdef USB_HOST_ENABLE
 	//stack_size = configMINIMAL_STACK_SIZE; /* 4096 */
	//stack_size = XT_STACK_MIN_SIZE;        /* 1348 */

#if 1
	stack_size = TASK_USBOTG_STACK_SIZE;
	//stack_size = TASK_USBOTG_STACK_SIZE+256;
	//stack_size = TASK_USBOTG_STACK_SIZE+512;
#else
	//if we defined UART_TX_FIFO_ENABLE,please use the code below.
	stack_size = 1024*2;
	//stack_size = 4096;
#endif

	ret = xTaskCreate(task_usbotg, 
    			"Rreg7", 
    			stack_size, 
    			mainREG_TEST_1_PARAMETER, 
     			TASK_USB_PRIORITY,
    			NULL);

    if (ret != TRUE)
    {
		DBG_Assert(FALSE);
	}
#endif

#ifdef SPDIF_ENABLE
	qStream_Rcv = xQueueGenericCreate( DEPTH_OF_STREAM_RCV_QUEUE, (WIDTH_OF_STREAM_RCV_QUEUE*4), queueQUEUE_TYPE_SET );
	stack_size = TASK_STREAM_RCV_STACK_SIZE;
	ret = xTaskCreate(taskStream_Rcv, 
    			"Rreg7", 
    			stack_size, 
    			mainREG_TEST_1_PARAMETER, 
     			TASK_STREAM_RCV_PRIORITY,
    			NULL);

    if (ret != TRUE)
    {
		DBG_Assert(FALSE);
	}
#endif


#if ((defined SD_ENABLE) || (defined USB_HOST_ENABLE) )		
 
#if 1//((defined SD_ENABLE) || (defined USB_HOST_ENABLE) )
	//stack_size = configMINIMAL_STACK_SIZE; /* 4096 */
	//stack_size = XT_STACK_MIN_SIZE;        /* 1348 */

#if 1
	stack_size = TASK_HDD_STACK_SIZE;
	//stack_size = TASK_HDD_STACK_SIZE+1024;
#else
	//if we defined UART_TX_FIFO_ENABLE,please use the code below.
	stack_size = 1024*2;
	//stack_size = 4096;
#endif

#if 0
	ret = xTaskCreate(taskHdd, 
    			"Rreg9", 
    			stack_size, 
    			mainREG_TEST_1_PARAMETER, 
     			TASK_HDD_PRIORITY,
    			NULL);
#else
	ret = xTaskCreate(taskHdd, 
    			"Rreg9", 
    			stack_size, 
    			mainREG_TEST_1_PARAMETER, 
     			TASK_HDD_PRIORITY,
    			taskHDD_thread);
#endif
	
#endif

#endif


	//stack_size = TASK_IDLE_STACK_SIZE*2; //If you add to print the information of "taskIdel" in taskIdle, it can print the information of "Stack overflow. Stopping."
	stack_size = TASK_IDLE_STACK_SIZE*2; //If you add to print the information of "taskIdel" in taskIdle, it can print the information of "Stack overflow. Stopping."
	//stack_size = TASK_IDLE_STACK_SIZE*6; //If you add to print the information of "taskIdel" in taskIdle, it can print the information of "Stack overflow. Stopping."

	ret = xTaskCreate(taskIdle, 
    			"idle", 
    			stack_size, 
    			mainREG_TEST_3_PARAMETER, 
    			TASK_IDLE_PRIORITY, 
    			NULL);

    if (ret != TRUE)
	{
		DBG_Assert(FALSE);
	}


	//Queue creating
#if 1//def MP3CD
	qDEC = xQueueGenericCreate( DEPTH_OF_DEC_QUEUE, (WIDTH_OF_DEC_QUEUE), queueQUEUE_TYPE_SET );
#endif


#ifdef TASK_UI_ENABLE
	qUI = xQueueGenericCreate( DEPTH_OF_UI_QUEUE, (WIDTH_OF_UI_QUEUE*4), queueQUEUE_TYPE_SET );
#endif


#ifdef TASK_KEYFUNC_ENABLE
	qKFUNC = xQueueGenericCreate( DEPTH_OF_KFUNC_QUEUE, (WIDTH_OF_KFUNC_QUEUE*4), queueQUEUE_TYPE_SET );
#endif

	qHDD = xQueueGenericCreate( DEPTH_OF_HDD_QUEUE, (WIDTH_OF_HDD_QUEUE*4), queueQUEUE_TYPE_SET );


#ifdef USB_HOST_ENABLE
	gUsbQueue = xQueueGenericCreate( DEPTH_OF_USBMSG_QUEUE, (WIDTH_OF_USBMSG_QUEUE*4), queueQUEUE_TYPE_SET );
#endif

#ifdef SD_ENABLE

	gSDqueue = xQueueGenericCreate( DEPTH_OF_SD_QUEUE, (WIDTH_OF_SD_QUEUE*4), queueQUEUE_TYPE_SET );

#ifdef SD_DMA_TRANSFER
	gSDdmaEvent  = xEventGroupCreate();
#endif

#endif


	mutex_fs  =       xSemaphoreCreateMutex();
	mutex_usb =       xSemaphoreCreateMutex();

	mutex_qspi =      xSemaphoreCreateMutex();
    mutex_spi      =  xSemaphoreCreateMutex();

	mutex_uart0_tx =  xSemaphoreCreateMutex();

	mutex_uart1_tx =  xSemaphoreCreateMutex();

	mutex_uart2_tx =  xSemaphoreCreateMutex();

    mutex_i2c0     =  xSemaphoreCreateMutex();
    mutex_i2c2     =  xSemaphoreCreateMutex();

	mutex_stream  =   xSemaphoreCreateMutex();

#ifdef SD_ENABLE
	gSDmutex =        xSemaphoreCreateMutex();
#endif

	app_key_lock(TRUE);

#if 1 //ndef LOW_CONSUMPTION_MODE
	app_timer_init();
#endif

	/* Finally start the scheduler. */
	vTaskStartScheduler();



	/* Will only reach here if there is insufficient heap available to start
	the scheduler. */
	//DBG_Printf("Error: scheduler did not start!");
	while ( 1)
	{
		asm("nop");
	}
}


#if	1//def IPOD_USB_AUDIO
int osentry_HddTaskPriority( void )
{
#ifndef TASK_EXAMPLE_TEST
	vTaskPrioritySet(taskHDD_thread, TASK_HDD_PRIORITY_HI );
#endif
}

int osentry_restoreHdd_TaskPriority( void )
{
#ifndef TASK_EXAMPLE_TEST
	vTaskPrioritySet(taskHDD_thread, TASK_HDD_PRIORITY );
#endif
}
#endif

////////////////////////////////////////////////////////////////////////////////
// End of file
////////////////////////////////////////////////////////////////////////////////
//! @}