//us级延时时,关闭任务调度(防止打断us级延迟)
void delay_osschedlock(void)
{
#ifdef CPU_CFG_CRITICAL_METHOD   				//使用UCOSIII
	OS_ERR err; 
	OSSchedLock(&err);							//UCOSIII的方式,禁止调度，防止打断us延时
#else											//否则UCOSII
	OSSchedLock();								//UCOSII的方式,禁止调度，防止打断us延时
#endif
}

INT32U get_usb_logger_data(void)
{
	INT32U ret = 0;
	
	/* read operation */
#if _OPERATING_SYSTEM != _OS_NONE	// Soft Protect for critical section
	OSSchedLock();
#endif	
	ret = (INT32U)logger_read_ptr;
	//memcpy((CHAR*)dataptr, usb_read_ptr, USB_LOGGER_BUF_SIZE);

	if(logger_read_ptr == logger_write_ptr)
	{
		logger_read_ptr[0] = 0;
	}
	else
	{
		if(logger_read_ptr < (usb_logger_buf + USB_LOGGER_BUF_TOTAL_SIZE - USB_LOGGER_BUF_SIZE))
	    	logger_read_ptr += USB_LOGGER_BUF_SIZE;
	    else
	    	logger_read_ptr = usb_logger_buf;
    }
	
	//loggerwritecnt = (logger_write_ptr - usb_logger_buf) >> 9;
    //loggerreadcnt = (logger_read_ptr - usb_logger_buf) >> 9;
	    	
#if _OPERATING_SYSTEM != _OS_NONE	//exit critical section
	OSSchedUnlock();
#endif
  
    return ret;	
}

/*********************************************************************************************************
** Function name:           zyThreadDel
** Descriptions:            删除线程
** input parameters:        ulThreadId: 线程ID
** output parameters:       none
** Returned value:          zy_OK: 成功
**                          负数:  错误,绝对值参考zy_if.h
** Created by:              Chenmingji
** Created Date:            2009-07-23
**--------------------------------------------------------------------------------------------------------
** Modified by:
** Modified date:
*********************************************************************************************************/
INT32S zyThreadDel (unsigned long ulThreadId)
{
    OS_TCB *ptcbTask;                                                   /*  任务TCB                     */
    void   *pvTmp1;

    ptcbTask = (OS_TCB *)ulThreadId;

    if (zyThreadGetCurId() == ulThreadId) {
        zyIrqDisable();
        pvTmp1 = (void *)(ptcbTask->OSTCBStkPtr);
        zyHeapFree(pvTmp1);
        OSTaskDel(ptcbTask->OSTCBPrio);
        zyIrqEnable();
        return ZY_OK;
    }

    OSSchedLock();

    pvTmp1 = (void *)(ptcbTask->OSTCBStkPtr);
    zyHeapFree(pvTmp1);
    OSTaskDel(ptcbTask->OSTCBPrio);

    OSSchedUnlock();
    return ZY_OK;
}

/*********************************************************************************************************
** Function name:           zyThreadCreate
** Descriptions:            建立线程
** input parameters:        pvThreedMain: 线程主程序
**                          pvArg:        给线程的参数
**                          uiPrio:       线程优先级
**                          ulSize:       堆栈大小
** output parameters:       none
** Returned value:          线程ID,0为不成功
** Created by:              Chenmingji
** Created Date:            2009-07-23
**--------------------------------------------------------------------------------------------------------
** Modified by:
** Modified date:
*********************************************************************************************************/
unsigned long zyThreadCreate (void *pvThreedMain, void *pvArg, unsigned int uiPrio, INT32U ulSize)
{
    OS_STK       *pstpTmp1;
    OS_TCB      **pptcpTmp2;
    unsigned long ulRt;
    
    pstpTmp1 = (OS_STK *)zyHeapMalloc(ulSize * sizeof(OS_STK));
    if (pstpTmp1 == NULL) {
        return 0;
    }

    OSSchedLock();
    
    if (OSTaskCreate((void (*) (void *))pvThreedMain,
                     pvArg,
#if OS_STK_GROWTH == 1
                     pstpTmp1 + ulSize - 1,
#else
                     pstpTmp1,
#endif                                                                  /*  OS_STK_GROWTH               */
                     (INT8U)uiPrio) != OS_NO_ERR) {
        OSSchedUnlock();
        return 0;
    }    

    pptcpTmp2 = OSTCBPrioTbl;
    ulRt      = (unsigned long)pptcpTmp2[uiPrio];
    
    OSSchedUnlock();
    
    return ulRt;
}

/*FUNCTION**********************************************************************
 *
 * Function Name : OSA_MemFree
 * Description   : This function is used to free the memory previously allocated.
 *
 *END**************************************************************************/
osa_status_t OSA_MemFree(void *ptr)
{
    OSSchedLock();
    free(ptr);
    OSSchedUnlock();
    return kStatus_OSA_Success;
}

/*
 * This function sets the system clock time.  
 */
int setclock(alt_u32 seconds)
{
  struct timeval time = {0, 0};
  struct timezone zone = {0, 0};
  
  /* 
   * NTP Time is seconds since 1900 
   * Convert to Unix time which is seconds since 1970
   */
  seconds -= NTP_TO_UNIX_TIME;
  
  time.tv_sec = seconds;

  printf("Setting System Clock time to: %s\n",ctime(&time.tv_sec));
  //settimeofday() can not be called at the same time as gettimeofday()
  OSSchedLock();  
  //settimeofday(&time, &zone);
  if(settimeofday(&time, &zone) < 0)
  {
    printf("Error set the time of day %s\n", strerror(errno));
    exit(0);
  }
  OSSchedUnlock();

  return 0;
}

INT8U  CTask::Create(bool bRunNow)
{
	INT32U nStackSize = StackSize();
										
	m_nId = s_nNextId ++;

	OSSchedLock();	
	INT8U  errno = OSTaskCreateExt(_callbackFunc, (void*)this, 
					&m_pTaskStack[nStackSize-1],
					m_nPrio,
					m_nId,
					m_pTaskStack,
					nStackSize,
					(void*)NULL,
					OS_TASK_OPT_STK_CHK|OS_TASK_OPT_STK_CLR);
	if (!errno){
		OSTaskNameSet(m_nPrio, (INT8U*)m_aTaskName, &errno);
	}
	
	if (!bRunNow){
		OSTaskSuspend(m_nPrio);
	}
	OSSchedUnlock();

	return errno;
}

void Function(void)
{
	OSSchedLock();
	/*
	you can access shared data in here (interrupts are still recoginizeds)
	*/
	OSSchedUnlock();
}

void   adi_osal_SchedulerLock( void )
{
    OSSchedLock();

#ifdef OSAL_DEBUG
    _adi_osal_gnSchedulerLockCnt++;
#endif /* OSAL_DEBUG */
    return;
}

INT8U msgQQuery(MSG_Q_ID msgQId, OS_Q_DATA *pdata)
{
    INT8U ret;

	OSSchedLock();
    ret = OSQQuery(msgQId->pEvent, pdata);
	OSSchedUnlock();
    return ret;
}

void alt_ucosii_check_return_code(INT8U return_code)
{
  if(return_code != OS_NO_ERR)
  {
    OSSchedLock();  /* Disable Task Switching but still service other IRQs */
    alt_ucosii_simple_error_handler(return_code);
    OSSchedUnlock(); /* Enable Task Switching */
  }
}

void  OS_TmrTask (void  *p_arg)
{
    OS_ERR               err;
    OS_TMR_CALLBACK_PTR  p_fnct;
    OS_TMR              *p_tmr;
    OS_TMR              *p_tmr_next;
    CPU_TS               ts;
    CPU_TS               ts_start;
    CPU_TS               ts_delta;



    (void)&p_arg;                                                /* Not using 'p_arg', prevent compiler warning       */
    while (DEF_ON) {
        (void)OSTaskSemPend((OS_TICK )0,                         /* Wait for signal indicating time to update tmrs    */
                            (OS_OPT  )OS_OPT_PEND_BLOCKING,
                            (CPU_TS *)&ts,
                            (OS_ERR *)&err);


        OS_TmrLock();
        ts_start = OS_TS_GET();
        OSTmrTickCtr++;                                          /* Increment the current time                        */
        p_tmr    = OSTmrListPtr;
        while (p_tmr != (OS_TMR *)0) {                           /* Update all the timers in the list                 */
            OSSchedLock(&err);
            (void)&err;
            p_tmr_next = p_tmr->NextPtr;
            p_tmr->Remain--;
            if (p_tmr->Remain == 0) {
                if (p_tmr->Opt == OS_OPT_TMR_PERIODIC) {
                    p_tmr->Remain = p_tmr->Period;               /* Reload the time remaining                         */
                } else {
                    OS_TmrUnlink(p_tmr);                         /* Remove from list                                  */
                    p_tmr->State = OS_TMR_STATE_COMPLETED;       /* Indicate that the timer has completed             */
                }
                p_fnct = p_tmr->CallbackPtr;                     /* Execute callback function if available            */
                if (p_fnct != (OS_TMR_CALLBACK_PTR)0) {
                    (*p_fnct)((void *)p_tmr,
                              p_tmr->CallbackPtrArg);
                }
            }
            p_tmr = p_tmr_next;
            OSSchedUnlock(&err);
            (void)&err;
        }

        ts_delta = OS_TS_GET() - ts_start;                      /* Measure execution time of timer task              */

        if (OSTmrTaskTimeMax < ts_delta) {
            OSTmrTaskTimeMax = ts_delta;
        }

        OS_TmrUnlock();
    }
}

/*FUNCTION**********************************************************************
 *
 * Function Name : OSA_MemAllocZero
 * Description   : This function is used to allocate amount of memory in bytes
 * and initializes it to 0.
 * Return the pointer to the memory if success, otherwise return NULL;
 *
 *END**************************************************************************/
void * OSA_MemAllocZero(size_t size)
{
    void *pMem;

    OSSchedLock();
    pMem = calloc(1, size);
    OSSchedUnlock();

    return pMem;
}

/*FUNCTION**********************************************************************
 *
 * Function Name : OSA_MemAlloc
 * Description   : This function is used to allocate amount of memory in bytes.
 * Return the pointer to the memory if success, otherwise return NULL;
 *
 *END**************************************************************************/
void * OSA_MemAlloc(size_t size)
{
    void *pMem;

    OSSchedLock();
    pMem = malloc(size);
    OSSchedUnlock();

    return pMem;
}

/*FUNCTION**********************************************************************
 *
 * Function Name : OSA_EnterCritical
 * Description   : This function is used to ensure some code will not be preempted.
 *
 *END**************************************************************************/
void OSA_EnterCritical(osa_critical_section_mode_t mode)
{
    if (kCriticalDisableInt == mode)
    {
        OS_ENTER_CRITICAL();
    }
    else
    {
        OSSchedLock();
    }
}

static  void  OSTmr_Task (void *p_arg)
{
    INT8U            err;
    OS_TMR          *ptmr;
    OS_TMR          *ptmr_next;
    OS_TMR_CALLBACK  pfnct;
    OS_TMR_WHEEL    *pspoke;
    INT16U           spoke;


    p_arg = p_arg;                                               /* Prevent compiler warning for not using 'p_arg'    */
    for (;;) {
		/* 等待OSTmrSignal()发送的定时器更新的信号，在OSTimeTickHook()中调用，发送频率100HZ */
        OSSemPend(OSTmrSemSignal, 0u, &err);                     /* Wait for signal indicating time to update timers  */
		/* 关调度 */
        OSSchedLock();
        OSTmrTime++;                                             /* Increment the current time                        */
		/* 获得当前要处理的分组编号 */
        spoke  = (INT16U)(OSTmrTime % OS_TMR_CFG_WHEEL_SIZE);    /* Position on current timer wheel entry             */
		/* 获得当前要处理分组链表头 */
        pspoke = &OSTmrWheelTbl[spoke];
		/* 获得当前分组中第一个定时器控制块指针 */
        ptmr   = pspoke->OSTmrFirst;
        while (ptmr != (OS_TMR *)0) {
			/* 获得该组中下一个定时器控制块指针 */
            ptmr_next = (OS_TMR *)ptmr->OSTmrNext;               /* Point to next timer to update because current ... */
                                                                 /* ... timer could get unlinked from the wheel.      */
			/* 定时器时间到 */
            if (OSTmrTime == ptmr->OSTmrMatch) {                 /* Process each timer that expires                   */
				/* 把定时器从当前分组移除，并设置定时器状态为OS_TMR_STATE_STOPPED
				 * 虽然定时器已经不在该定时器分组中了，但是该定时器仍然有效，可以通过定时器控制块访问
				 */
                OSTmr_Unlink(ptmr);                              /* Remove from current wheel spoke                   */
				/* 如果是周期定时器,则更新定时器到时时间后，把定时器重新链接到新的分组 */
                if (ptmr->OSTmrOpt == OS_TMR_OPT_PERIODIC) {
                    OSTmr_Link(ptmr, OS_TMR_LINK_PERIODIC);      /* Recalculate new position of timer in wheel        */
                }
				/* 如果是单次定时器，则在定时器控制块中标示定时器已经完成 */
				else {
                    ptmr->OSTmrState = OS_TMR_STATE_COMPLETED;   /* Indicate that the timer has completed             */
                }
				/* 调用定时器到时回调函数 */
                pfnct = ptmr->OSTmrCallback;                     /* Execute callback function if available            */
                if (pfnct != (OS_TMR_CALLBACK)0) {
                    (*pfnct)((void *)ptmr, ptmr->OSTmrCallbackArg);
                }
            }
			/* 处理该分组中的下一个元素 */
            ptmr = ptmr_next;
        }
		/* 允许调度 */
        OSSchedUnlock();
    }
}

/*FUNCTION**********************************************************************
 *
 * Function Name : OSA_MemAllocZero
 * Description   : This function is used to allocate amount of memory in bytes
 * and initializes it to 0.
 * Return the pointer to the memory if success, otherwise return NULL;
 *
 *END**************************************************************************/
void * OSA_MemAllocZero(size_t size)
{
    OS_ERR err;
    void *pMem;

    OSSchedLock(&err);
    pMem = calloc(1, size);
    OSSchedUnlock(&err);

    return pMem;
}

INT8U  OSTmrNameGet (OS_TMR   *ptmr,
                     INT8U   **pdest,
                     INT8U    *perr)
{
    INT8U  len;


#ifdef OS_SAFETY_CRITICAL
    if (perr == (INT8U *)0) {
        OS_SAFETY_CRITICAL_EXCEPTION();
        return (0u);
    }
#endif

#if OS_ARG_CHK_EN > 0u
    if (pdest == (INT8U **)0) {
        *perr = OS_ERR_TMR_INVALID_DEST;
        return (0u);
    }
    if (ptmr == (OS_TMR *)0) {
        *perr = OS_ERR_TMR_INVALID;
        return (0u);
    }
#endif
    if (ptmr->OSTmrType != OS_TMR_TYPE) {              /* Validate timer structure                                    */
        *perr = OS_ERR_TMR_INVALID_TYPE;
        return (0u);
    }
    if (OSIntNesting > 0u) {                           /* See if trying to call from an ISR                           */
        *perr = OS_ERR_NAME_GET_ISR;
        return (0u);
    }
    OSSchedLock();
    switch (ptmr->OSTmrState) {
        case OS_TMR_STATE_RUNNING:
        case OS_TMR_STATE_STOPPED:
        case OS_TMR_STATE_COMPLETED:
             *pdest = ptmr->OSTmrName;
             len    = OS_StrLen(*pdest);
             OSSchedUnlock();
             *perr = OS_ERR_NONE;
             return (len);

        case OS_TMR_STATE_UNUSED:                      /* Timer is not allocated                                      */
             OSSchedUnlock();
             *perr = OS_ERR_TMR_INACTIVE;
             return (0u);

        default:
             OSSchedUnlock();
             *perr = OS_ERR_TMR_INVALID_STATE;
             return (0u);
    }
}

void osSuspendAllTasks(void)
{
   OS_ERR err;

   //Make sure the operating system is running
   if(OSRunning == OS_STATE_OS_RUNNING)
   {
      //Suspend scheduler activity
      OSSchedLock(&err);
   }
}

void   adi_osal_SchedulerLock( void )
{
    PAUSE_PROFILING();
    OSSchedLock();
    RESUME_PROFILING();

#ifdef OSAL_DEBUG
    _adi_osal_gnSchedulerLockCnt++;
#endif /* OSAL_DEBUG */
    return;
}