/*
************************************************************************************************************************
*                                    Post an event to active object  
*
* Description: This function is called to post an event to active object (Implemented as FIFO way)
*
* Arguments  :me is the address of this active object
*                    ---------
*                    event is the address of sending event               
*				         
* Returns			
*						
* Note(s)    	
*
*             
************************************************************************************************************************
*/
void active_event_post_end(ACTIVE_OBJECT_STRUCT *me, STATE_EVENT *event)
{
	RAW_OS_ERROR err;

	RAW_SR_ALLOC();
	

	RAW_CPU_DISABLE();

	if (event->which_pool) {          
		event->ref_count++;          
	}

	RAW_CPU_ENABLE();

	err = raw_queue_end_post(&me->active_queue, (void *)event);

	if (err != RAW_SUCCESS) {

		RAW_ASSERT(0);

	}

	

	
	
}

/*
************************************************************************************************************************
*                                    Post an event to active object  
*
* Description: This function is called to post an event to active object (Implemented as LIFO way)
*
* Arguments  :me is the address of this active object
*                    ---------
*                    event is the address of sending event               
*				         
* Returns			
*						
* Note(s)    	
*
*             
************************************************************************************************************************
*/
void active_event_post_front(ACTIVE_OBJECT_STRUCT *me, STATE_EVENT *event)
{

	RAW_U16 ret;

	RAW_SR_ALLOC();

	RAW_CPU_DISABLE();

	if (event->which_pool) {          
		event->ref_count++;          
	}

	RAW_CPU_ENABLE();

	ret = raw_queue_front_post(&me->active_queue, (void *)event);

	if (ret != RAW_SUCCESS) {

		RAW_ASSERT(0);

	}

	
	
}

/*
************************************************************************************************************************
*                                   Post an event  to a defered queue
*
* Description: This function is called to post an event  to a defered queue.
*
* Arguments  :q is the address of the defered queue
*                    ---------
*                   me is the active object  to post       
*				         
* Returns			
*						
* Note(s)    	
*
*             
************************************************************************************************************************
*/
RAW_U16 active_event_recall(ACTIVE_OBJECT_STRUCT *me, RAW_QUEUE *q) 
{
	STATE_EVENT *event;
	RAW_U16 recalled;
	RAW_U16 err;
	RAW_SR_ALLOC();

	err = raw_queue_receive (q, RAW_NO_WAIT, (RAW_VOID  **)&event);

	if (err == RAW_SUCCESS) {
		
		RAW_CPU_DISABLE();

		if (event->which_pool) {  
			
			event->ref_count++;
		}

		RAW_CPU_ENABLE();

		active_event_post_front(me, event);

		recalled = 1;
	}

	else {

		recalled = 0;
	}


	return recalled;
}

/*
************************************************************************************************************************
*                                    Register notify function to semaphore
*
* Description: This function is called to Register notify function to semphore.
*
* Arguments  :semaphore_ptr is the address of the semphore object
*                 -----
*                   notify_function is the function to be called whennever put semphore.
*                 
*                 
*				         
* Returns			
*			RAW_SUCCESS: raw os return success
*					
* Note(s)  This function is normally used to implement pending on multi object function.
*
*             
************************************************************************************************************************
*/
RAW_OS_ERROR raw_semphore_send_notify(RAW_SEMAPHORE *semaphore_ptr, SEMPHORE_SEND_NOTIFY notify_function)
{
	RAW_SR_ALLOC();
	
	#if (RAW_SEMA_FUNCTION_CHECK > 0)

	if (semaphore_ptr == 0) {

		return RAW_NULL_OBJECT;
	}

	if (raw_int_nesting) {

		return RAW_NOT_CALLED_BY_ISR;
	}

	#endif
	
	RAW_CRITICAL_ENTER();

	if (semaphore_ptr->common_block_obj.object_type != RAW_SEM_OBJ_TYPE) {

		RAW_CRITICAL_EXIT();
		return RAW_ERROR_OBJECT_TYPE;
	}
	
	semaphore_ptr->semphore_send_notify = notify_function;
	RAW_CRITICAL_EXIT();
	
	return RAW_SUCCESS;
}

/*this function can be used in interrupt*/
int
process_post(struct process *p, process_event_t ev, process_data_t data)
{
  static process_num_events_t snum;
  RAW_SR_ALLOC();
  
  if(nevents == PROCESS_CONF_NUMEVENTS) {

    RAW_ASSERT(0);
  }

  RAW_CRITICAL_ENTER();
  
  snum = (process_num_events_t)(fevent + nevents) & (PROCESS_CONF_NUMEVENTS - 1);
  ++nevents;
  
  RAW_CRITICAL_EXIT();
  
  events[snum].ev = ev;
  events[snum].data = data;
  events[snum].p = p;
  
  if(nevents > process_maxevents) {
    process_maxevents = nevents;
  }

  
  return PROCESS_ERR_OK;
}

void raw_sched(void)
{
	RAW_SR_ALLOC();

	/*if it is in interrupt or system is locked, just return*/ 
	if (raw_int_nesting || raw_sched_lock) {              
		return;                                             
	}

	USER_CPU_INT_DISABLE();
	         
	get_ready_task(&raw_ready_queue);

	/*if highest task is currently task, then no need to do switch and just return*/
	if (high_ready_obj == raw_task_active) {                 
		USER_CPU_INT_ENABLE();                                     
		return;
	}

	TRACE_TASK_SWITCH(raw_task_active, high_ready_obj);

	CONTEXT_SWITCH(); 

	USER_CPU_INT_ENABLE();  

}

static void work_queue_task(void *pa)
{
	RAW_OS_ERROR  ret;
	OBJECT_WORK_QUEUE_MSG *msg_recv;
	WORK_QUEUE_STRUCT *wq;

	RAW_SR_ALLOC();
	
	wq = pa;

	while (1) {

		ret = raw_queue_receive (&wq->queue, RAW_WAIT_FOREVER, (void **)(&msg_recv));

		if (ret != RAW_SUCCESS) {
			
			RAW_ASSERT(0);

		}

		msg_recv->handler(msg_recv->arg, msg_recv->msg);

		RAW_CPU_DISABLE();

		msg_recv->next = free_work_queue_msg;
		free_work_queue_msg = msg_recv;

		RAW_CPU_ENABLE();


	}

}

/*
************************************************************************************************************************
*                                    Register notify function to queue
*
* Description: This function is called to Register notify function to queue.
*
* Arguments  :p_q is the address of the queue object
*                 -----
*                   notify_function is the function to be called whennever send queue data to it.
*                 -----
*                 
*				         
* Returns			
*			RAW_SUCCESS: raw os return success
*					
* Note(s)       This function is normally used to implement pending on multi object function.	
*
*             
************************************************************************************************************************
*/
RAW_U16 raw_queue_send_notify(RAW_QUEUE *p_q, QUEUE_SEND_NOTIFY notify_function)
{

	RAW_SR_ALLOC();
	

	#if (RAW_QUEUE_FUNCTION_CHECK > 0)

	if (p_q == 0) {
		
		return RAW_NULL_OBJECT;
	}

	if (raw_int_nesting) {
		
		return RAW_NOT_CALLED_BY_ISR;
		
	}
	
	#endif
	
	RAW_CRITICAL_ENTER();

	if (p_q->common_block_obj.object_type != RAW_QUEUE_OBJ_TYPE) {
		
		RAW_CRITICAL_EXIT();
		return RAW_ERROR_OBJECT_TYPE;
	}
	
	p_q->queue_send_notify = notify_function;
	RAW_CRITICAL_EXIT();
	
	return RAW_SUCCESS;
}

/*
************************************************************************************************************************
*                                       Get a semaphore
*
* Description: This function is called to get a semaphore.
*
* Arguments  :semaphore_ptr is the address of semphore object want to be initialized 
*                  -----
*                 wait_option: 0 means return immediately if not get semphore
*
*				       RAW_NO_WAIT (0x00000000)
*						RAW_WAIT_FOREVER (0xFFFFFFFF)
*						timeout value (0x00000001
*							  					through
*												0xFFFFFFFE)   
* Returns		
*					RAW_SUCCESS : Get semphore success.
*               RAW_BLOCK_ABORT: semphore is aborted by other task or ISR.
*               RAW_NO_PEND_WAIT: semphore is not got and option is RAW_NO_WAIT.
*               RAW_SCHED_DISABLE: semphore is locked ant task is not allowed block.
*               RAW_BLOCK_DEL: if this mutex is deleted
*						
* Note(s)    	
*
*             
************************************************************************************************************************
*/
RAW_OS_ERROR raw_semaphore_get(RAW_SEMAPHORE *semaphore_ptr, RAW_TICK_TYPE wait_option)
{

	RAW_OS_ERROR error_status;

	RAW_SR_ALLOC();

	#if (RAW_SEMA_FUNCTION_CHECK > 0)

	if (semaphore_ptr == 0) {
		
		return RAW_NULL_OBJECT;
	}

	
	
	if (raw_int_nesting) {

		return RAW_NOT_CALLED_BY_ISR;
	}

	#endif
	
	RAW_CRITICAL_ENTER();

	if (semaphore_ptr->common_block_obj.object_type != RAW_SEM_OBJ_TYPE) {

		RAW_CRITICAL_EXIT();
		return RAW_ERROR_OBJECT_TYPE;
	}
	
	if (semaphore_ptr->count) {                      
		semaphore_ptr->count--;                                       

		RAW_CRITICAL_EXIT();
		TRACE_SEMAPHORE_GET_SUCCESS(raw_task_active, semaphore_ptr);		
		return RAW_SUCCESS;
	}
	
	/*Cann't get semphore, and return immediately if wait_option is  RAW_NO_WAIT*/
	if (wait_option == RAW_NO_WAIT) { 

		RAW_CRITICAL_EXIT();
		return RAW_NO_PEND_WAIT;
	}      
	
	SYSTEM_LOCK_PROCESS();

	raw_pend_object((RAW_COMMON_BLOCK_OBJECT  *)semaphore_ptr, raw_task_active, wait_option);
	RAW_CRITICAL_EXIT();

	TRACE_SEMAPHORE_GET_BLOCK(raw_task_active, semaphore_ptr, wait_option);
	
	raw_sched(); 
	
	error_status = block_state_post_process(raw_task_active, 0);
	return error_status;

}

RAW_U16 raw_queue_get_information(RAW_QUEUE *p_q, RAW_MSG_INFO *msg_information)
{
	LIST *block_list_head;
	
	RAW_SR_ALLOC();
	
	#if (RAW_QUEUE_FUNCTION_CHECK > 0)

	if (p_q == 0)  {
		
		return RAW_NULL_OBJECT;
	}

	
	if (msg_information == 0) {
		
		return RAW_NULL_POINTER;
	}
	
	#endif

	#if (CONFIG_RAW_ZERO_INTERRUPT > 0)

	if (raw_int_nesting) {
		
		return RAW_NOT_CALLED_BY_ISR;
		
	}
	
	#endif
	
	RAW_CRITICAL_ENTER();

	if (p_q->common_block_obj.object_type !=  RAW_QUEUE_OBJ_TYPE) {
		
		RAW_CRITICAL_EXIT();
		return RAW_ERROR_OBJECT_TYPE;
	}

	block_list_head = &p_q->common_block_obj.block_list;
	
	msg_information->msg_q.peak_numbers =  p_q->msg_q.peak_numbers;
	msg_information->msg_q.current_numbers = p_q->msg_q.current_numbers;
	msg_information->msg_q.queue_start =  p_q->msg_q.queue_start;
	msg_information->msg_q.queue_end = p_q->msg_q.queue_end;
	msg_information->msg_q.read = p_q->msg_q.read;
	msg_information->msg_q.write = p_q->msg_q.write;
	msg_information->msg_q.size = p_q->msg_q.size;
	msg_information->suspend_entry = block_list_head->next;
	
	RAW_CRITICAL_EXIT();

	return RAW_SUCCESS;

}

void calculate_time_slice(RAW_U8 task_prio)
{
	RAW_TASK_OBJ   *task_ptr;
	LIST *head;

	RAW_SR_ALLOC();

	head = &raw_ready_queue.task_ready_list[task_prio];
	 
	RAW_CRITICAL_ENTER();
	
	/*if ready list is empty then just return because nothing is to be caculated*/                       
	if (is_list_empty(head)) {

		RAW_CRITICAL_EXIT();
		return;
	}

	/*Always look at the first task on the ready list*/
	task_ptr = list_entry(head->next, RAW_TASK_OBJ, task_list);

	/*SCHED_FIFO does not has timeslice, just return*/
	if (task_ptr->sched_way == SCHED_FIFO) {
		
		RAW_CRITICAL_EXIT();
		return;
	}

	/*there is only one task on this ready list, so do not need to caculate time slice*/
	/*idle task must satisfy this condition*/
	if (head->next->next == head)  {
		
		RAW_CRITICAL_EXIT();
		return;
		
	}

	if (task_ptr->time_slice) {
		task_ptr->time_slice--;
	}

	/*if current active task has time_slice, just return*/
	if (task_ptr->time_slice) {               
		RAW_CRITICAL_EXIT();
		return;
	}

	/*Move current active task to the end of ready list for the same priority*/
	move_to_ready_list_end(&raw_ready_queue, task_ptr);

	/*restore the task time slice*/ 
	task_ptr->time_slice = task_ptr->time_total;  
	
	RAW_CRITICAL_EXIT();
}

RAW_OS_ERROR raw_semaphore_set(RAW_SEMAPHORE *semaphore_ptr,  RAW_U32 sem_count)
{
	LIST *block_list_head;
	
	RAW_SR_ALLOC();

	block_list_head = &semaphore_ptr->common_block_obj.block_list;

	#if (RAW_SEMA_FUNCTION_CHECK > 0)

	if (semaphore_ptr == 0) {

		return RAW_NULL_OBJECT;
	}

	if (raw_int_nesting) {

		return RAW_NOT_CALLED_BY_ISR;
	}

	#endif

	RAW_CRITICAL_ENTER();

	if (semaphore_ptr->common_block_obj.object_type != RAW_SEM_OBJ_TYPE) {

		RAW_CRITICAL_EXIT();
		return RAW_ERROR_OBJECT_TYPE;
	}
	
	if (semaphore_ptr->count) { 
		
		semaphore_ptr->count = sem_count;                                   
	} 

	else {

		if (is_list_empty(block_list_head)) {

			semaphore_ptr->count = sem_count; 
		}

		else {

			RAW_CRITICAL_EXIT();
			return RAW_SEMAPHORE_TASK_WAITING;
		}

	}

	RAW_CRITICAL_EXIT();

	return RAW_SUCCESS;

}

RAW_OS_ERROR raw_queue_size_get_information(RAW_QUEUE_SIZE *p_q, MSG_SIZE_TYPE *queue_free_msg_size, MSG_SIZE_TYPE *queue_peak_msg_size, MSG_SIZE_TYPE *queue_current_msg)
{

	RAW_SR_ALLOC();
	
	#if (RAW_QUEUE_SIZE_FUNCTION_CHECK > 0)

	if (p_q == 0)  {
		
		return RAW_NULL_OBJECT;
	}
	
	if (queue_free_msg_size == 0) {
		
		return RAW_NULL_POINTER;
	}

	if (queue_current_msg == 0) {
		
		return RAW_NULL_POINTER;
	}

	
	#endif

	#if (CONFIG_RAW_ZERO_INTERRUPT > 0)

	if (raw_int_nesting) {
		
		return RAW_NOT_CALLED_BY_ISR;
		
	}
	
	#endif

	RAW_CRITICAL_ENTER();

	if (p_q->common_block_obj.object_type != RAW_QUEUE_SIZE_OBJ_TYPE) {

		RAW_CRITICAL_EXIT();
		return RAW_ERROR_OBJECT_TYPE;
	}
	
	*queue_free_msg_size = p_q->queue_msg_size - p_q->queue_current_msg;
	*queue_current_msg = p_q->queue_current_msg;
	*queue_peak_msg_size = p_q->peak_numbers;
	
	RAW_CRITICAL_EXIT();

	return RAW_SUCCESS;

}

RAW_U16 raw_queue_buffer_get_information(RAW_QUEUE_BUFFER  *q_b, RAW_U32 *queue_buffer_free_size, RAW_U32 *queue_buffer_size)
{
	RAW_SR_ALLOC();
	
	#if (RAW_QUEUE_BUFFER_FUNCTION_CHECK > 0)

	if (q_b == 0) {
		
		return RAW_NULL_OBJECT;
	}

	if (queue_buffer_free_size == 0) {
		
		return RAW_NULL_OBJECT;
	}

	if (queue_buffer_size == 0) {
		
		return RAW_NULL_OBJECT;
	}

	#endif

	#if (CONFIG_RAW_ZERO_INTERRUPT > 0)

	if (raw_int_nesting) {
		
		return RAW_NOT_CALLED_BY_ISR;
		
	}
	
	#endif

	RAW_CRITICAL_ENTER();
	
	if (q_b->common_block_obj.object_type != RAW_QUEUE_BUFFER_OBJ_TYPE) {

		RAW_CRITICAL_EXIT();
		return RAW_ERROR_OBJECT_TYPE;
	}

	*queue_buffer_free_size = q_b->frbufsz;
	
	*queue_buffer_size = q_b->bufsz;

	RAW_CRITICAL_EXIT();
	
	return RAW_SUCCESS;

}

/*
************************************************************************************************************************
*                                       Release byte memory from pool
*
* Description: This function is called to allocate memory from pool
*
* Arguments  : block_ptr is the address want to return to memory pool.          
*                   ---------------------
*				         
* Returns		
*						RAW_SUCCESS: raw os return success
* Note(s)     This methods will not cause fragmention. 
*
*             
************************************************************************************************************************
*/
RAW_OS_ERROR raw_byte_release(RAW_BYTE_POOL_STRUCT *pool_ptr, void *memory_ptr)
{
	RAW_U8  *work_ptr;           /* Working block pointer      */

	RAW_SR_ALLOC();


	#if (RAW_BYTE_FUNCTION_CHECK > 0)

	if (pool_ptr == 0) {

		return RAW_NULL_POINTER;
	}

	if (memory_ptr == 0) {

		return RAW_NULL_POINTER;
	}
		
	#endif

	if (pool_ptr ->common_block_obj.object_type != RAW_BYTE_OBJ_TYPE) {

		return RAW_ERROR_OBJECT_TYPE;
	}
	
	/* Back off the memory pointer to pickup its header.  */
	work_ptr = (RAW_U8 *)memory_ptr - sizeof(RAW_U8 *) - sizeof(RAW_U32);

	/* Disable interrupts.  */
	RAW_CPU_DISABLE();

	/* Indicate that this thread is the current owner.  */
	pool_ptr->raw_byte_pool_owner = raw_task_active;

	/* Release the memory.*/
	*((RAW_U32 *)(work_ptr + sizeof(RAW_U8 *))) = RAW_BYTE_BLOCK_FREE;

	/* Update the number of available bytes in the pool. */
	pool_ptr->raw_byte_pool_available =  
	pool_ptr->raw_byte_pool_available + (*((RAW_U8 * *)(work_ptr)) - work_ptr);

	/* Set the pool search value appropriately. */
	pool_ptr->raw_byte_pool_search = work_ptr;

	RAW_CPU_ENABLE();

	return RAW_SUCCESS;
		
}

/*
************************************************************************************************************************
*                                    Check whether queue size obj is full or not
*
* Description: This function is called to Check whether queue size obj is full or not.
*
* Arguments  :p_q is the address of the queue object
*                 -----
*
*
* Returns			
*		1: queue_size obj is full
*		0: queue_size obj is not full
* 
*Note(s)   
*
*             
************************************************************************************************************************
*/
RAW_U16 raw_queue_size_full_check(RAW_QUEUE_SIZE *p_q)
{
	RAW_SR_ALLOC();

	RAW_U16 full_check_ret;
	
	#if (RAW_QUEUE_FUNCTION_CHECK > 0)

	if (p_q == 0) {

		return RAW_NULL_OBJECT;
	}

	#endif


	#if (CONFIG_RAW_ZERO_INTERRUPT > 0)

	if (raw_int_nesting) {
		
		return RAW_NOT_CALLED_BY_ISR;
		
	}
	
	#endif

	RAW_CRITICAL_ENTER();

	if (p_q->common_block_obj.object_type != RAW_QUEUE_SIZE_OBJ_TYPE) {

		RAW_CRITICAL_EXIT();
		return RAW_ERROR_OBJECT_TYPE;
	}

	if (p_q->queue_current_msg >= p_q->queue_msg_size) {   

		full_check_ret = 1u;
	}

	else {

		full_check_ret = 0u;

	}

	RAW_CRITICAL_EXIT();

	return full_check_ret;

}

RAW_OS_ERROR raw_queue_size_flush(RAW_QUEUE_SIZE  *p_q)
{
	RAW_MSG_SIZE  *p_msg;

	RAW_SR_ALLOC();
	
	
	#if (RAW_QUEUE_SIZE_FUNCTION_CHECK > 0)

	if (p_q == 0) {
		
		return RAW_NULL_OBJECT;
	}

	if (raw_int_nesting) {
		
		return RAW_NOT_CALLED_BY_ISR;
		
	}
	
	#endif
	
	RAW_CRITICAL_ENTER();

	if (p_q->common_block_obj.object_type != RAW_QUEUE_SIZE_OBJ_TYPE) {

		RAW_CRITICAL_EXIT();
		return RAW_ERROR_OBJECT_TYPE;
	}

	if (p_q->queue_current_msg) {
		
        p_msg               	= p_q->write;           
        p_msg->next         	= p_q->free_msg;

		/*free msg reset to queue read*/
        p_q->free_msg       	= p_q->read;         
        
       	p_q->queue_current_msg  = 0;           
        p_q->read          		= 0;
        p_q->write         		= 0;
    }
	
	RAW_CRITICAL_EXIT();

	TRACE_QUEUE_SIZE_FLUSH(raw_task_active, p_q);
	
	return RAW_SUCCESS;
}

RAW_OS_ERROR raw_queue_size_full_register(RAW_QUEUE_SIZE *p_q, QUEUE_SIZE_FULL_CALLBACK callback_full)
{
	RAW_SR_ALLOC();

	if (raw_int_nesting) {

		return RAW_NOT_CALLED_BY_ISR;	
	}
	
	RAW_CPU_DISABLE();
	p_q->queue_size_full_callback = callback_full;
	RAW_CPU_ENABLE();

	return RAW_SUCCESS;
}

RAW_U16 raw_event_delete(RAW_EVENT *event_ptr)
{
	LIST *block_list_head;

	RAW_SR_ALLOC();

	#if (RAW_EVENT_FUNCTION_CHECK > 0)

	if (event_ptr == 0) {
		return RAW_NULL_OBJECT;
	}

	if (raw_int_nesting) {
		
		return RAW_NOT_CALLED_BY_ISR;
		
	}

	#endif

	RAW_CRITICAL_ENTER();

	if (event_ptr->common_block_obj.object_type != RAW_EVENT_OBJ_TYPE) {

		RAW_CRITICAL_EXIT();
		
		return RAW_ERROR_OBJECT_TYPE;
	}

	block_list_head = &event_ptr->common_block_obj.block_list;
	
	event_ptr->common_block_obj.object_type = 0u;
	/*All task blocked on this queue is waken up until list is empty*/
	while (!is_list_empty(block_list_head)) {
		
		delete_pend_obj(list_entry(block_list_head->next, RAW_TASK_OBJ, task_list));	
	}    

	event_ptr->flags = 0u;

	RAW_CRITICAL_EXIT();

	TRACE_EVENT_DELETE(raw_task_active, event_ptr);

	raw_sched();  

	return RAW_SUCCESS;
}

void process_poll(struct process *p)
{
	RAW_SR_ALLOC();
	
	if (p) {
		
		if(p->state == PROCESS_STATE_RUNNING ||
			p->state == PROCESS_STATE_CALLED) {
			
			RAW_CRITICAL_ENTER();
			p->needspoll = 1;
			poll_requested++;
			RAW_CRITICAL_EXIT();
		}
	}
}