/*****************************************************************************
 函 数 名  : FC_CCORE_RcvTimerExpireMsg
 功能描述  : 接收定时器消息的分发处理
 输入参数  : REL_TIMER_MSG *pTimerMsg
 输出参数  : 无
 返 回 值  : 无
 被调函数  :

 修改历史      :
  1.日    期   : 2013年10月21日
    作    者   : caikai
    修改内容   : 新生成函数

*****************************************************************************/
VOS_VOID FC_CCORE_RcvTimerExpireMsg(REL_TIMER_MSG *pTimerMsg)
{
    VOS_UINT32                          ulResult;


    switch (pTimerMsg->ulName)
    {
        case TIMER_FC_CCPU_TRACE_CPULOAD:
            /*====================================*//* 输出可维可测 */
            FC_MNTN_TraceCpuLoad(ID_FC_MNTN_CPU_C_CPULOAD, g_stFcTraceCpuLoad.ulCpuLoadRecord);

            /* 重启定时器 */
            ulResult = VOS_StartRelTimer(&g_stFcTraceCpuLoad.pstTraceCpuLoadTHandle, UEPS_PID_FLOWCTRL_C,
                                          g_stFcTraceCpuLoad.ulTraceCpuLoadTimerLen,
                                          TIMER_FC_CCPU_TRACE_CPULOAD, 0,
                                          VOS_RELTIMER_NOLOOP, VOS_TIMER_NO_PRECISION);
            if (VOS_OK != ulResult)
            {
                FC_LOG2(PS_PRINT_ERROR, "FC_Init, ERROR, Fail to Start Timer! ulResult = %d, ulTraceCpuLoadTimerLen = %d\n", (VOS_INT32)ulResult, (VOS_INT32)g_stFcTraceCpuLoad.ulTraceCpuLoadTimerLen);
                return;
            }

            break;

        default:
            break;
    }

    return;
}
VOS_UINT32  FC_CPUC_Init( VOS_VOID )
{
    VOS_UINT32                          ulResult;


    ulResult = FC_UL_InitFcPoints(FC_POLICY_ID_CPU_C, &(g_stFcCfg.stFcCfgUmUlRateForCpu));

    if ( VOS_OK != ulResult )
    {
        FC_LOG(PS_PRINT_ERROR, "FC_Init, ERROR, Fail to init FC Points for CPU!\n");
        return VOS_ERR;
    }

    VOS_MemSet(&g_stFcCpuCCtrl, 0, sizeof(g_stFcCpuCCtrl));

    ulResult = VOS_StartRelTimer(&g_stFcTraceCpuLoad.pstTraceCpuLoadTHandle, UEPS_PID_FLOWCTRL_C,
                                  g_stFcTraceCpuLoad.ulTraceCpuLoadTimerLen,
                                  TIMER_FC_CCPU_TRACE_CPULOAD, 0,
                                  VOS_RELTIMER_NOLOOP, VOS_TIMER_NO_PRECISION);
    if (VOS_OK != ulResult)
    {
        FC_LOG(PS_PRINT_ERROR, "FC_Init, ERROR, Fail to Start Timer!\n");
        return VOS_ERR;
    }

    return VOS_OK;
}
VOS_VOID  ADS_StartTimer(
    VOS_UINT32                          ulPid,
    ADS_TIMER_ID_ENUM_UINT32            enTimerId,
    VOS_UINT32                          ulLen
)
{
    VOS_UINT32                          ulRet;
    ADS_TIMER_CTX_STRU                 *pstTiCtx;
    VOS_TIMER_PRECISION_ENUM_UINT32     enTmrPrecision;

    /* 输入参数检查 */
    if (0 == ulLen)
    {
        ADS_ERROR_LOG1(ACPU_PID_ADS_UL, "ADS_StartTimer:ulLen is",ulLen);
        return;
    }

    if (ulLen >= VOS_TIMER_MAX_LENGTH)
    {
        ulLen = VOS_TIMER_MAX_LENGTH - 1;
    }

    /* 不在使用的定时器范围内 */
    if (enTimerId >= ADS_MAX_TIMER_NUM)
    {
        return;
    }

    pstTiCtx = ADS_GetTiCtx();

    if (ADS_TIMER_STATUS_RUNNING == pstTiCtx[enTimerId].enTimerStatus)
    {
        return;
    }

    enTmrPrecision = ADS_GetTimerPrecision(enTimerId);

    ulRet = VOS_StartRelTimer(&(pstTiCtx[enTimerId].hTimer),
                              ulPid,
                              ulLen,
                              enTimerId,
                              0,
                              VOS_RELTIMER_NOLOOP,
                              enTmrPrecision);

    if (VOS_OK != ulRet)
    {
        ADS_ERROR_LOG(ulPid, "ADS_StartTimer:timer is fail start!");
        return;
    }

    pstTiCtx[enTimerId].enTimerStatus = ADS_TIMER_STATUS_RUNNING;

    /*勾包ADS_TIMER_INFO_STRU*/
    ADS_MNTN_TraceTimerOperation(ulPid, enTimerId, ulLen, ADS_TIMER_OPERATION_START, ADS_TIMER_STOP_CAUSE_ENUM_BUTT);

    return;
}
VOS_UINT32 RRM_StartTimer
(
    RRM_RFID_ENUM_UINT16                enRFIDTimerId
)
{
    RRM_RFID_TIMER_CTRL_STRU           *pstRFIDTimerAddr;
    VOS_UINT32                          ulRslt;


    /*获取该状态定时器控制块地址*/
    pstRFIDTimerAddr       = RRM_GetRFIDTimerAddr(enRFIDTimerId);

    /*无法获取该定时器控制块地址,说明定时器ID非法*/
    if( VOS_NULL_PTR == pstRFIDTimerAddr)
    {
        /* 打印错误信息 */
        RRM_WARNING_LOG1(UEPS_PID_RRM, "TimerId is Error!", enRFIDTimerId);
        return VOS_ERR;
    }

    /*检查该状态定时器是否在运行,如果正在运行,先停止该定时器。
      停止定时器时,VOS会直接将该定时器句柄清除为VOS_NULL_PTR*/
    if(VOS_NULL_PTR != pstRFIDTimerAddr->pstStaTHandle)
    {
        VOS_StopRelTimer(&(pstRFIDTimerAddr->pstStaTHandle));
    }

    /* 定时器ID设置 */
    pstRFIDTimerAddr->enRFIDTimerId = enRFIDTimerId;

    /* 定时器无参数信息,启动定时器时将定时器参数设置为0
      非循环定时器,定时器模式为VOS_RELTIMER_NOLOOP*/
    ulRslt        = VOS_StartRelTimer( &(pstRFIDTimerAddr->pstStaTHandle),
                                        UEPS_PID_RRM,
                                        RRM_TMR_DEF_LEN,
                                        pstRFIDTimerAddr->enRFIDTimerId,
                                        0,
                                        VOS_RELTIMER_NOLOOP,
                                        VOS_TIMER_PRECISION_0);

    /*这里调用的是VOS的接口函数,因此需要使用VOS的返回值进行检查*/
    if( VOS_OK != ulRslt)
    {
        /* 启动失败,打印失败信息 */
        RRM_ERROR_LOG1(UEPS_PID_RRM, "Start TimerId Failure!", enRFIDTimerId);
        return VOS_ERR;
    }

    return VOS_OK;
}
/*****************************************************************************
 Function Name   : diag_FsOpenProc
 Description     : 打开或创建文件
 Input           :VOS_UINT8* pstReq
                VOS_UINT32 ulCmdId
 Output          : None
 Return          : VOS_UINT32

 History         :
    1.w00182550      2013-1-29  Draft Enact

*****************************************************************************/
VOS_UINT32 diag_FsOpenProc(VOS_UINT8* pstReq,VOS_UINT32 ulCmdId)
{
    DIAG_CMD_FS_OPEN_REQ* pstFsReq = NULL;
    DIAG_CMD_FS_OPEN_CNF stFsCnf = {0};
    VOS_UINT32 ret = ERR_MSP_SUCCESS;

    pstFsReq = (DIAG_CMD_FS_OPEN_REQ*)(DIAG_OFFSET_HEAD_GET_DATA(pstReq));

    /*不支持操作文件的重入操作*/
    if (DIAG_FILE_NULL != g_stDiagFileInfo.lFile)
    {
        diag_printf("warning: last File import not finished\n");
        diag_FsClose();
    }
    /*lint -save -e539*/
	diag_fs_log();
    /*lint -restore*/
    g_stDiagFileInfo.lFile = diag_FsOpen(pstFsReq->szDirectory, (VOS_INT)(pstFsReq->ulMode));

    if (g_stDiagFileInfo.lFile < 0)
    {
    	g_stDiagFileInfo.lFile = DIAG_FILE_NULL;
        ret = VOS_ERR;
    }
	else
	{
	    /*启动定时器*/
	    g_stDiagFileInfo.hTimer = VOS_NULL_PTR;

	    ret = VOS_StartRelTimer(&g_stDiagFileInfo.hTimer, diag_GetAgentPid(), DIAG_CMD_FILE_OPS_TIME_OUT_LEN, 0, DIAG_TMR_FILE_OP_TIMEOUT_PARAM,VOS_RELTIMER_NOLOOP, VOS_TIMER_NO_PRECISION);
        if(ret != ERR_MSP_SUCCESS)
        {
            /*lint -save -e717*/
            diag_printf("VOS_StartRelTimer fail [%s]\n",__func__);
            /*lint -restore*/
        }
        diag_fs_log();
	}
    stFsCnf.ulRet = ret;

    /*打包回复给FW*/
    ret = diag_AgentCnfFun((VOS_UINT8*)&stFsCnf,ulCmdId,sizeof(DIAG_CMD_FS_OPEN_CNF));
	diag_fs_log();

    return ret;

}
示例#6
0
/*****************************************************************************
 函 数 名  : AT_StartRelTimer
 功能描述  : AT启动REL定时器函数
 输入参数  : HTIMER *phTm
             VOS_PID Pid
             VOS_UINT32 ulLength
             VOS_UINT32 ulName
             VOS_UINT32 ulParam
             VOS_UINT8 ucMode
 输出参数  : 无
 返 回 值  : VOS_UINT32
 调用函数  :
 被调函数  :

 修改历史      :
  1.日    期   : 2011年10月5日
    修改内容   : 新生成函数

*****************************************************************************/
VOS_UINT32 AT_StartRelTimer(
    HTIMER                             *phTm,
    VOS_UINT32                          ulLength,
    VOS_UINT32                          ulName,
    VOS_UINT32                          ulParam,
    VOS_UINT8                           ucMode
)
{
    VOS_UINT32                          ulRet;
    AT_TIMER_OPERATION_STRU             stTimer;

    if (0 == ulLength)
    {
        AT_ERR_LOG("AT_StartRelTimer: Start Rel Timer Length is 0!");
        return VOS_ERR;
    }

    if ( ulLength >= VOS_TIMER_MAX_LENGTH )
    {
        ulLength = VOS_TIMER_MAX_LENGTH - 1;
    }

    ulRet = VOS_StartRelTimer(phTm, WUEPS_PID_AT, ulLength, ulName, ulParam, ucMode, VOS_TIMER_PRECISION_5);

    if (VOS_ERR == ulRet)
    {
        AT_ERR_LOG("AT_StartRelTimer: Start Rel Timer Fail!");
    }

    stTimer.ulSenderCpuId   = VOS_LOCAL_CPUID;
    stTimer.ulSenderPid     = WUEPS_PID_AT;
    stTimer.ulReceiverCpuId = VOS_LOCAL_CPUID;
    stTimer.ulReceiverPid   = VOS_PID_TIMER;
    stTimer.ulLength        = sizeof(AT_TIMER_OPERATION_STRU) - VOS_MSG_HEAD_LENGTH;
    stTimer.ulMsgName       = ulName;
    stTimer.enTimeAction    = AT_TIMER_OPERATION_START;
    stTimer.ulTimeLen       = ulLength;

    OM_AcpuTraceMsgHook(&stTimer);

    return ulRet;
}
VOS_UINT32 diag_FsImportProc(VOS_UINT8* pstReq,VOS_UINT32 ulCmdId)
{
    DIAG_CMD_FS_IMPORT_REQ* pstFsReq = NULL;
    DIAG_CMD_FS_IMPORT_CNF stFsCnf = {0};
    VOS_UINT32 ret = ERR_MSP_SUCCESS;
    VOS_INT32 lResult =0;
#if(VOS_OS_VER == VOS_LINUX)
    mm_segment_t old_fs;
#endif

    pstFsReq = (DIAG_CMD_FS_IMPORT_REQ*)(DIAG_OFFSET_HEAD_GET_DATA(pstReq));

    if (DIAG_FILE_NULL == g_stDiagFileInfo.lFile)
    {
        return ERR_MSP_FAILURE;
    }
    diag_fs_log();

    /*停止定时器*/
    VOS_StopRelTimer(&g_stDiagFileInfo.hTimer);

    /*写文件完毕,关闭文件*/
    if (0 == pstFsReq->ulSize)
    {

		diag_fs_log();
        diag_FsClose();
        /*打包回复给FW*/
        stFsCnf.ulRet = ERR_MSP_SUCCESS;
        ret = diag_AgentCnfFun((VOS_UINT8*)&stFsCnf,ulCmdId,sizeof(DIAG_CMD_FS_IMPORT_CNF));
        return ret;
    }

#if(VOS_OS_VER == VOS_LINUX)
    old_fs = get_fs();
    set_fs(KERNEL_DS);
#endif

#if(VOS_OS_VER == VOS_LINUX)
    lResult = DIAG_FS_WRITE(g_stDiagFileInfo.lFile, pstFsReq->acContent, pstFsReq->ulSize);
#else
    lResult = DIAG_FS_WRITE((FILE *)g_stDiagFileInfo.lFile, pstFsReq->acContent, pstFsReq->ulSize);
#endif

	diag_fs_log();

#if(VOS_OS_VER == VOS_LINUX)
    set_fs(old_fs);
#endif

    /*写文件操作失败或者写入长度不正确*/
    if ((DIAG_FS_ERROR == lResult)||(lResult != (VOS_INT32)(pstFsReq->ulSize)))
    {
		diag_fs_log();
		diag_printf("[%s]!,lResult=%d\n",__FUNCTION__,lResult);
		diag_FsClose();
        return VOS_ERR;
    }

    /*启动定时器*/
    ret = VOS_StartRelTimer(&g_stDiagFileInfo.hTimer, diag_GetAgentPid(),DIAG_CMD_FILE_OPS_TIME_OUT_LEN,0,DIAG_TMR_FILE_OP_TIMEOUT_PARAM,VOS_RELTIMER_NOLOOP, VOS_TIMER_NO_PRECISION);
    if(ret != ERR_MSP_SUCCESS)
    {
        diag_printf("VOS_StartRelTimer fail [%s]\n",__func__);
    }

    stFsCnf.ulRet = ret;

    /*打包回复给FW*/
    ret = diag_AgentCnfFun((VOS_UINT8*)&stFsCnf,ulCmdId,sizeof(DIAG_CMD_FS_IMPORT_CNF));
    return ret;

}
VOS_UINT32 l4a_StartTimer(HTIMER *phTimerId, L4A_RX_INFO_STRU* pNewNode, VOS_UINT32 ulms)
{
    return VOS_StartRelTimer(phTimerId, MSP_L4_L4A_PID,ulms, 0,(VOS_UINT32)pNewNode,VOS_RELTIMER_NOLOOP, VOS_TIMER_NO_PRECISION);
}
示例#9
0
/*****************************************************************************
 Prototype      : Ppp_ReleasePppReq
 Description    : 为AT模块"释放PPP链路"提供对应的API函数。

 Input          : ---要释放的PPP链路对应的PPP ID
 Output         : ---
 Return Value   : ---VOS_UINT32
 Calls          : ---
 Called By      : ---

 History        : ---
  1.Date        : 2005-11-18
    Author      : ---
    Modification: Created function
*****************************************************************************/
VOS_UINT32 Ppp_ReleasePppReq ( PPP_ID usPppId)
{
    VOS_UINT32                          ulRet;


    /* 可维可测信息上报*/
    Ppp_EventMntnInfo(usPppId, AT_PPP_RELEASE_PPP_REQ);

    if(VOS_OK != PppIsIdValid(usPppId))
    {
        return VOS_ERR;
    }

    /* 如果当前PPP在PHASE_NETWORK阶段,属于网侧主动去激活
       此时PPP等待和PC间PPP协议结束后通知AT拉管脚信号,并起定时器保护*/
    if (PHASE_NETWORK == (PPP_LINK(usPppId)->phase))
    {
        if (VOS_NULL_PTR != (PPP_LINK(usPppId)->lcp.hLcpCloseTimer))
        {
            PS_STOP_REL_TIMER(&(PPP_LINK(usPppId)->lcp.hLcpCloseTimer));
            PPP_LINK(usPppId)->lcp.hLcpCloseTimer= VOS_NULL_PTR;
        }

        /*起定时器,确保通知拉AT管脚信号*/
        ulRet = VOS_StartRelTimer(&(PPP_LINK(usPppId)->lcp.hLcpCloseTimer),  PS_PID_APP_PPP,
            1000,  usPppId,  PHASE_TERMINATE_PENDING,  VOS_RELTIMER_NOLOOP,  VOS_TIMER_PRECISION_5 );

        if (VOS_OK != ulRet)
        {
            PPP_LINK(usPppId)->lcp.hLcpCloseTimer = VOS_NULL_PTR;
            PPP_ProcPppDisconnEvent(usPppId);
        }
    }

    /*首先调用PPP模块对应的函数*/
    fsm_Close(&(PPP_LINK(usPppId)->ipcp.fsm));
    fsm_Close(&(PPP_LINK(usPppId)->lcp.fsm));

    /*停止IPCP状态机定时器:*/
    if( VOS_NULL_PTR !=((PPP_LINK(usPppId))->ipcp.fsm.timer) )
    {
        VOS_StopRelTimer(&((PPP_LINK(usPppId))->ipcp.fsm.timer));
        (PPP_LINK(usPppId))->ipcp.fsm.timer = VOS_NULL_PTR;
    }

    /*停止CHAP状态机定时器:*/
    if( VOS_NULL_PTR !=((PPP_LINK(usPppId))->chap.auth.hAuthTimer) )
    {
        VOS_StopRelTimer(&((PPP_LINK(usPppId))->chap.auth.hAuthTimer));
        (PPP_LINK(usPppId))->chap.auth.hAuthTimer = VOS_NULL_PTR;
    }

    /*停止LCP状态机定时器:*/
    if( VOS_NULL_PTR !=((PPP_LINK(usPppId))->lcp.fsm.timer) )
    {
        VOS_StopRelTimer(&((PPP_LINK(usPppId))->lcp.fsm.timer));
        (PPP_LINK(usPppId))->lcp.fsm.timer = VOS_NULL_PTR;
    }

    /*释放待PDP激活定时器*/
    if (VOS_NULL_PTR != (PPP_LINK(usPppId)->ipcp.hIpcpPendTimer))
    {
        PS_STOP_REL_TIMER(&(PPP_LINK(usPppId)->ipcp.hIpcpPendTimer));
        PPP_LINK(usPppId)->ipcp.hIpcpPendTimer = VOS_NULL_PTR;
    }

    /*释放待处理IPCP帧*/
    if (VOS_NULL_PTR != (PPP_LINK(usPppId)->ipcp.pstIpcpPendFrame))
    {
        ppp_m_freem(PPP_LINK(usPppId)->ipcp.pstIpcpPendFrame);
        PPP_LINK(usPppId)->ipcp.pstIpcpPendFrame = VOS_NULL_PTR;
    }

    PppFreeId(usPppId);

    /* 不用释放PPP数据队列,因为只要队列里面有数据,PPP任务就会被调度起来处理,
       如果HDLC处理完成而PPP实体已经释放,那么封装或解封装出来的数据自然会被丢弃。
       这个API会在AT任务里被调用,如果这里把数据放掉,PPP任务有可能正在使用 */
    /* PPP_ClearDataQ(); */

    /*返回正确*/
    return VOS_OK;
}
VOS_UINT32  TAF_SSA_StartTimer(
    TAF_SSA_TIMER_ID_ENUM_UINT8         enTimerId,
    VOS_UINT32                          ulLen,
    VOS_UINT8                           ucTi
)
{
    TAF_SSA_TIMER_CXT_STRU             *pstSsaTimerCtx = VOS_NULL_PTR;
    VOS_UINT32                          i;
    VOS_UINT32                          ulRet;
    VOS_TIMER_PRECISION_ENUM_UINT32     ulPrecision;
    NAS_TIMER_OPERATION_STRU            stTimer;

    /*TI有效范围是0-6,8-14*/
    if (VOS_FALSE == TAF_SSA_IsTiValid(ucTi))
    {
        SSA_LOG(WARNING_PRINT, "TAF_SSA_StopTimer: Ti invalid!");
        return VOS_FALSE;
    }

    pstSsaTimerCtx   =  gastSsaStatetable[ucTi].astSsaTimerCtx;

    if (0 == ulLen)
    {
        SSA_LOG(WARNING_PRINT, "TAF_SSA_StartTimer: timer len is zero!");
        return VOS_FALSE;
    }

    /* 如果该定时器已经启动则直接返回 */
    for ( i = 0 ; i < TAF_SSA_MAX_TIMER_NUM ; i++ )
    {
        if ( ( TAF_SSA_TIMER_STATUS_RUNING == pstSsaTimerCtx[i].enTimerStatus )
          && ( enTimerId                   == pstSsaTimerCtx[i].enTimerId))
        {
            SSA_LOG1(WARNING_PRINT, "TAF_SSA_StartTimer:timer is running", enTimerId);
            return VOS_FALSE;
        }
    }

    for ( i = 0 ; i < TAF_SSA_MAX_TIMER_NUM ; i++ )
    {
        if ( TAF_SSA_TIMER_STATUS_STOP == pstSsaTimerCtx[i].enTimerStatus )
        {
            break;
        }
    }

    if ( i >= TAF_SSA_MAX_TIMER_NUM)
    {
        SSA_LOG1(WARNING_PRINT, "TAF_SSA_StartTimer:too many timer", enTimerId);

        return VOS_FALSE;
    }

    if ( ulLen >= VOS_TIMER_MAX_LENGTH )
    {
        ulLen = VOS_TIMER_MAX_LENGTH - 1;
    }

    ulPrecision = NAS_GetTimerPrecision(WUEPS_PID_SS, enTimerId);

    ulRet = VOS_StartRelTimer(&(pstSsaTimerCtx[i].hTimer),
                              WUEPS_PID_SS,
                              ulLen,
                              enTimerId,
                              ucTi,
                              VOS_RELTIMER_NOLOOP,
                              ulPrecision);

    if ( VOS_OK != ulRet)
    {
        SSA_LOG(WARNING_PRINT, "TAF_SSA_StartTimer: start timer failed!");

        return VOS_FALSE;
    }

    pstSsaTimerCtx[i].enTimerId     = enTimerId;
    pstSsaTimerCtx[i].enTimerStatus = TAF_SSA_TIMER_STATUS_RUNING;


    /* 定时器状态勾包出来 */
    stTimer.MsgHeader.ulSenderCpuId    = VOS_LOCAL_CPUID;
    stTimer.MsgHeader.ulSenderPid      = WUEPS_PID_SS;
    stTimer.MsgHeader.ulReceiverCpuId  = VOS_LOCAL_CPUID;
    stTimer.MsgHeader.ulReceiverPid    = VOS_PID_TIMER;
    stTimer.MsgHeader.ulLength         = sizeof(NAS_TIMER_OPERATION_STRU) - VOS_MSG_HEAD_LENGTH;
    stTimer.MsgHeader.ulMsgName        = enTimerId;
    stTimer.ulTimeAction               = NAS_TIMER_OPERATION_START;
    stTimer.ulTimeLen                  = ulLen;

    DIAG_TraceReport(&stTimer);

    NAS_TIMER_EventReport(stTimer.MsgHeader.ulMsgName, WUEPS_PID_SS, NAS_OM_EVENT_TIMER_OPERATION_START);

    return VOS_TRUE;
}
示例#11
0
VOS_VOID  TAF_MMA_StartTimer(
    TAF_MMA_TIMER_ID_ENUM_UINT32        enTimerId,
    VOS_UINT32                          ulLen
)
{
    TAF_MMA_TIMER_CTX_STRU             *pstMmaTimerCtx = VOS_NULL_PTR;
    VOS_UINT32                          i;
    VOS_UINT32                          ulRet;

    if (0 == ulLen)
    {
        TAF_WARNING_LOG1(WUEPS_PID_MMA,"TAF_MMA_StartTimer:timer len is zero!", (VOS_INT32)enTimerId);
        return;
    }

    if (ulLen >= VOS_TIMER_MAX_LENGTH)
    {
       ulLen = VOS_TIMER_MAX_LENGTH - 1;
    }

    pstMmaTimerCtx   =  TAF_MMA_GetTimerCtxAddr();

    /* 如果缓存队列中该定时器已经启动则直接返回 */
    for (i = 0 ; i < TAF_MMA_MAX_TIMER_NUM ; i++)
    {
        if ((TAF_MMA_TIMER_STATUS_RUNING == pstMmaTimerCtx[i].enTimerStatus)
         && (enTimerId                   == pstMmaTimerCtx[i].enTimerId))
        {
            TAF_WARNING_LOG1(WUEPS_PID_MMA,"TAF_MMA_StartTimer:timer is running!", (VOS_INT32)enTimerId);
            return;
        }
    }

    for (i = 0 ; i < TAF_MMA_MAX_TIMER_NUM ; i++)
    {
        if (TAF_MMA_TIMER_STATUS_STOP == pstMmaTimerCtx[i].enTimerStatus )
        {
            break;
        }
    }

    if (i >= TAF_MMA_MAX_TIMER_NUM)
    {
       TAF_WARNING_LOG1(WUEPS_PID_MMA, "TAF_MMA_StartTimer:too many timer", (VOS_INT32)enTimerId);

       return;
    }

    /* 启动定时器 */
    ulRet = VOS_StartRelTimer(&(pstMmaTimerCtx[i].hTimer),
                              WUEPS_PID_MMA,
                              ulLen,
                              enTimerId,
                              0,
                              VOS_RELTIMER_NOLOOP,                              
                              VOS_TIMER_PRECISION_5);                              
    
    if (VOS_OK != ulRet)
    {
        TAF_WARNING_LOG(WUEPS_PID_MMA,"TAF_MMA_StartTimer:VOS_StartRelTimer failed");
        return;
    }

    pstMmaTimerCtx[i].enTimerId             = enTimerId;
    pstMmaTimerCtx[i].enTimerStatus         = TAF_MMA_TIMER_STATUS_RUNING;

    TAF_MMA_SndOmTimerStatus(TAF_MMA_TIMER_STATUS_RUNING, enTimerId, ulLen);

    return;
}
示例#12
0
VOS_VOID  RNIC_StartTimer(
    RNIC_TIMER_ID_ENUM_UINT16           enTimerId,
    VOS_UINT32                          ulLen
)
{
    VOS_UINT32                          ulRet;
    RNIC_TIMER_CTX_STRU                *pstRnicTimerCtx;
    VOS_UINT32                          i;
    RNIC_UL_CTX_STRU                   *pstUlCtx;
    VOS_TIMER_PRECISION_ENUM_UINT32     enTimerPrecision;

    /* 目前按需拨号的功能只在网卡0上有 */
    pstUlCtx            = RNIC_GetUlCtxAddr(RNIC_RM_NET_ID_0);

    pstRnicTimerCtx     = RNIC_GetTimerAddr();
    enTimerPrecision    = VOS_TIMER_PRECISION_5;

    /* 如果缓存队列中该定时器已经启动则直接返回 */
    for (i = 0 ; i < RNIC_MAX_TIMER_NUM ; i++)
    {
        if ((RNIC_TIMER_STATUS_RUNING == pstRnicTimerCtx[i].enTimerStatus)
         && (enTimerId                == pstRnicTimerCtx[i].enTimerId))
        {
            RNIC_INFO_LOG1(ACPU_PID_RNIC, "RNIC_StartTimer:timer is running", enTimerId);
            return;
        }
    }

    for (i = 0 ; i < RNIC_MAX_TIMER_NUM ; i++)
    {
        if ( RNIC_TIMER_STATUS_STOP == pstRnicTimerCtx[i].enTimerStatus )
        {
            break;
        }
    }

    if (i >= RNIC_MAX_TIMER_NUM)
    {
        RNIC_WARNING_LOG1(ACPU_PID_RNIC, "RNIC_StartTimer:too many timer", enTimerId);
        return;
    }

    if (ulLen >= VOS_TIMER_MAX_LENGTH)
    {
        ulLen = VOS_TIMER_MAX_LENGTH - 1;
    }

#if (FEATURE_ON == FEATURE_LTE)
    /* 如果还未设置唤醒源标志,并且是按需断开定时器,则设置该标志,并且设置32K时钟为唤醒源 */
    if ((VOS_FALSE == RNIC_GetTimer4WakeFlg())
      && (TI_RNIC_DEMAND_DIAL_DISCONNECT == enTimerId))
    {
        BSP_PWC_SetTimer4WakeSrc();

        RNIC_SetTimer4WakeFlg(VOS_TRUE);
    }

#endif

     /* 如果是流量上报定时器,则挂在26M时钟上,以降低功耗 */
    if (RNIC_IS_DSFLOW_TIMER_ID(enTimerId))
    {
        enTimerPrecision = VOS_TIMER_NO_PRECISION;
    }


    /* VOS_StartRelTimer 启动定时器 */
    ulRet = VOS_StartRelTimer(&(pstRnicTimerCtx[i].hTimer),
                              ACPU_PID_RNIC,
                              ulLen,
                              enTimerId,
                              0,
                              VOS_RELTIMER_NOLOOP,
                              enTimerPrecision);
    if (VOS_OK != ulRet)
    {
        RNIC_WARNING_LOG(ACPU_PID_RNIC, "NAS_MMC_StartTimer:NAS_StartRelTimer failed");
        return;
    }

    if (TI_RNIC_DEMAND_DIAL_DISCONNECT == enTimerId)
    {
        /* 按需拨号统计清零 */
        pstUlCtx->stULDataStats.ulULPeriodSndPkts = 0;
    }

    pstRnicTimerCtx[i].enTimerId     = enTimerId;
    pstRnicTimerCtx[i].enTimerStatus = RNIC_TIMER_STATUS_RUNING;


    /* 定时器状态勾包出来 */

}
VOS_UINT32 Aging_TestInit(VOS_VOID)
{
    NAS_MMA_NVIM_RF_AUTO_TEST_FLAG_STRU stRfAutoTestFlg;
    MODEM_ID_ENUM_UINT16                enModemID;
    VOS_UINT32                          aulReceiverPid[] = {I0_DSP_PID_GPHY, I1_DSP_PID_GPHY};

    VOS_MemSet(g_apstGAgingTestMsg, VOS_NULL_PTR, sizeof(g_apstGAgingTestMsg));

    g_pstOmAgingTestNV = (OM_AGING_TEST_NV_STRU*)VOS_MemAlloc(
                  WUEPS_PID_AGING, STATIC_MEM_PT, sizeof(OM_AGING_TEST_NV_STRU));

    if (VOS_NULL_PTR == g_pstOmAgingTestNV)
    {
        PS_LOG(WUEPS_PID_AGING, 0, PS_PRINT_WARNING, "Aging_TestInit: VOS_MemAlloc fail.\n");
        return VOS_ERR;
    }

    /*读取老化测试需要的NV项*/
    if(NV_OK != NV_Read(en_NV_Item_AGING_TEST_TABLE,
                        g_pstOmAgingTestNV,
                        sizeof(OM_AGING_TEST_NV_STRU)))
    {
        PS_LOG(WUEPS_PID_AGING, 0, PS_PRINT_WARNING, "Aging_TestInit: NV_Read fail.\n");
        return VOS_ERR;
    }
    /*判断老化测试是否开启*/
    if (VOS_NO == g_pstOmAgingTestNV->ulIsEnable)
    {
        return VOS_ERR;
    }

    /*读取自动开机使能位*/
    if(NV_OK != NV_Read(en_NV_Item_RF_Auto_Test_Flag,
                        &stRfAutoTestFlg,
                        sizeof(NAS_MMA_NVIM_RF_AUTO_TEST_FLAG_STRU)))
    {
        PS_LOG(WUEPS_PID_AGING, 0, PS_PRINT_WARNING, "Aging_TestInit: RF NV_Read fail.\n");
        return VOS_ERR;
    }

    if(VOS_YES == stRfAutoTestFlg.usRfAutoTestFlg)
    {
        PS_LOG(WUEPS_PID_AGING, 0, PS_PRINT_WARNING, "Aging_TestInit: Auto test enabled!\n");
        return VOS_ERR;
    }

    /*参数检测*/
    if ((0 == g_pstOmAgingTestNV->ulNumber)
        || (OM_AGING_TEST_NUM < g_pstOmAgingTestNV->ulNumber)
        || (0 == g_pstOmAgingTestNV->ulTimerLen))
    {
        return VOS_ERR;
    }

    PS_LOG(WUEPS_PID_AGING, 0, PS_PRINT_INFO, "Aging_TestInit: Aging test is launched.\n");

    DRV_PWRCTRL_SLEEPVOTE_LOCK(PWRCTRL_SLEEP_FTM);

    for (enModemID = MODEM_ID_0; enModemID < MODEM_ID_BUTT; enModemID++)
    {
        /*初始化发送给G物理层的配置数据包*/
        g_apstGAgingTestMsg[enModemID] = (GPHY_OAM_RF_AGING_TEST_REQ_STRU*)VOS_AllocMsg(
                        WUEPS_PID_AGING, sizeof(GPHY_OAM_RF_AGING_TEST_REQ_STRU) - VOS_MSG_HEAD_LENGTH);

        if (VOS_NULL_PTR == g_apstGAgingTestMsg[enModemID])
        {
            PS_LOG(WUEPS_PID_AGING, 0, PS_PRINT_WARNING, "Aging_TestInit: VOS_AllocMsg fail.\n");
            return VOS_ERR;
        }

        VOS_ReserveMsg(WUEPS_PID_AGING, (MsgBlock *)g_apstGAgingTestMsg[enModemID]);

        g_apstGAgingTestMsg[enModemID]->ulReceiverPid = aulReceiverPid[enModemID];
        g_apstGAgingTestMsg[enModemID]->enMsgId = ID_OAM_GPHY_RF_AGING_TEST_REQ;
    }

    /*初始化发送给W物理层的配置数据包*/
    g_pstWAgingTestMsg = (WPHY_OAM_RF_AGING_TEST_REQ_STRU*)VOS_AllocMsg(
                    WUEPS_PID_AGING, sizeof(WPHY_OAM_RF_AGING_TEST_REQ_STRU) - VOS_MSG_HEAD_LENGTH);

    if (VOS_NULL_PTR == g_pstWAgingTestMsg)
    {
        PS_LOG(WUEPS_PID_AGING, 0, PS_PRINT_WARNING, "Aging_TestInit: VOS_AllocMsg fail.\n");
        return VOS_ERR;
    }

    VOS_ReserveMsg(WUEPS_PID_AGING, (MsgBlock *)g_pstWAgingTestMsg);

    g_pstWAgingTestMsg->ulReceiverPid = DSP_PID_WPHY;
    g_pstWAgingTestMsg->enMsgID = ID_OAM_WPHY_RF_AGING_TEST_REQ;

    /*启动老化测试定时器*/
    if (VOS_OK != VOS_StartRelTimer(&g_hAgingTestTimer,
                      WUEPS_PID_AGING, 10000, OM_AGING_START_TIMER, 0,
                      VOS_RELTIMER_NOLOOP, VOS_TIMER_NO_PRECISION))
    {
        PS_LOG(WUEPS_PID_AGING, 0, PS_PRINT_ERROR, "Aging_TestInit:VOS_StartRelTimer fail!");
        return VOS_ERR;
    }

    return VOS_OK;
}
VOS_VOID  CMMCA_StartTimer(
    VOS_UINT32                          ulPid,
    CMMCA_TIMER_ID_ENUM_UINT32          enTimerId,
    VOS_UINT32                          ulLen,
    VOS_UINT32                          ulParam
)
{
    VOS_UINT32                          i;
    VOS_UINT32                          ulRet;
    CMMCA_TIMER_CTX_STRU               *pstTiCtx;
    VOS_TIMER_PRECISION_ENUM_UINT32     enTmrPrecision;

    /* 输入参数检查 */
    if (0 == ulLen)
    {
        CMMCA_ERROR1_LOG("CMMCA_StartTimer:ulLen is", ulLen);
        return;
    }

    if (ulLen >= VOS_TIMER_MAX_LENGTH)
    {
        ulLen = VOS_TIMER_MAX_LENGTH - 1;
    }

    pstTiCtx = CMMCA_GetTiCtx();

    /* 如果该定时器已经启动则直接返回 */
    for (i = 0; i < CMMCA_MAX_TIMER_NUM; i++)
    {
        if ((CMMCA_TIMER_STATUS_RUNNING == pstTiCtx[i].enTimerStatus)
         && (enTimerId               == pstTiCtx[i].enTimerId))
        {
            return;
        }
    }

    /* 找到一个空闲位置 */
    for (i = 0; i < CMMCA_MAX_TIMER_NUM; i++)
    {
        if (CMMCA_TIMER_STATUS_STOP == pstTiCtx[i].enTimerStatus )
        {
            break;
        }
    }

    /* 未找到空闲位置,无法保存该定时器信息,直接返回 */
    if (i >= CMMCA_MAX_TIMER_NUM)
    {
        CMMCA_ERROR1_LOG("CMMCA_StartTimer:i is",i);
        return;
    }

    enTmrPrecision = CMMCA_GetTimerPrecision(enTimerId);

    ulRet = VOS_StartRelTimer(&(pstTiCtx[i].hTimer),
                              ulPid,
                              ulLen,
                              enTimerId,
                              ulParam,
                              VOS_RELTIMER_NOLOOP,
                              enTmrPrecision);

    if (VOS_OK != ulRet)
    {
        CMMCA_ERROR_LOG("CMMCA_StartTimer:timer is fail start!");
        return;
    }

    pstTiCtx[i].enTimerId     = enTimerId;
    pstTiCtx[i].enTimerStatus = CMMCA_TIMER_STATUS_RUNNING;

    /* 勾包CMMCA_TIMER_INFO_STRU */
    CMMCA_MNTN_TraceTimerOperation(ulPid, enTimerId, ulLen, CMMCA_TIMER_OPERATION_START);

    return;
}
VOS_VOID Monitor_QueryTask( VOS_VOID )
{
#if 0
    VOS_UINT32       ulRet;
#endif

    for(;;)
    {
        /* 等待信号量 */
        VOS_SmP(g_ulMonitorCtrlSem, 0);

#if 0

        switch ( g_ulMonitorConnectState )
        {
            case MONITOR_IDLE_STATE:

                if (ID_PHY_MONITOR_QUERY_IND == g_ulMonitorIndType )   /* IDLE态收到环境查询中断 */
                {
                    Moniter_SendReq(WUEPS_PID_MONITOR,ID_MONITOR_TEMP_QUERY_REQ);
                }
                else                                        /* IDLE态收到进入NORMAL态中断 */
                {
                    if (VOS_NULL_PTR == g_hQueryTimer)
                    {
                       ulRet = VOS_StartRelTimer( &g_hQueryTimer,
                                                   WUEPS_PID_MONITOR,
                                                   2000,
                                                   MONITOR_TIMER_NAME_QUERY,
                                                   0,
                                                   VOS_RELTIMER_LOOP );

                        if(VOS_OK != ulRet)
                        {
                            g_ulMonitorErrCode |= MONITOR_ERR_CODE_TIMER;
                        }
                    }

                    g_ulMonitorConnectState = MONITOR_CONNECT_STATE;
                }

                break;

            case MONITOR_CONNECT_STATE:      /* 进入CONN态 */

                if (ID_PHY_MONITOR_QUERY_IND == g_ulMonitorIndType )   /* IDLE态收到环境查询中断 */
                {
                    if( VOS_NULL_PTR != g_hQueryTimer )
                    {
                        VOS_StopRelTimer( &g_hQueryTimer );
                    }

                    g_hQueryTimer = VOS_NULL_PTR;

                    Moniter_SendReq(WUEPS_PID_MONITOR, ID_MONITOR_TEMP_QUERY_REQ);

                    g_ulMonitorConnectState = MONITOR_IDLE_STATE;
                }
                else
                {
                    g_ulMonitorErrCode |= MONITOR_ERR_CODE_INT;
                }

                break;

            default:
                break;
        }
#endif
    }
}
VOS_UINT32 diag_FsExportProc(VOS_UINT8* pstReq,VOS_UINT32 ulCmdId)
{
    //DIAG_CMD_FS_EXPORT_REQ* pstFsReq = NULL;
    DIAG_CMD_FS_EXPORT_CNF *pstFsCnf = NULL;
    VOS_UINT32 ret = ERR_MSP_SUCCESS;
    VOS_UINT32 ulReadSize = 0;
#if(VOS_OS_VER == VOS_LINUX)
    mm_segment_t old_fs;
#endif


    if (DIAG_FILE_NULL == g_stDiagFileInfo.lFile)
    {

		diag_fs_log();
         return ERR_MSP_FAILURE;
    }

    /*停止定时器*/
    VOS_StopRelTimer(&g_stDiagFileInfo.hTimer);
	diag_fs_log();

    pstFsCnf = (DIAG_CMD_FS_EXPORT_CNF*)VOS_MemAlloc(diag_GetAgentPid(), DYNAMIC_MEM_PT, sizeof(DIAG_CMD_FS_EXPORT_CNF)+DIAG_TRANSFER_BLOCK_MAX_SIZE);
    if (VOS_NULL_PTR == pstFsCnf)
    {

		diag_fs_log();
        diag_FsClose();
        return ERR_MSP_FAILURE;

    }

#if(VOS_OS_VER == VOS_LINUX)
    old_fs = get_fs();
    set_fs(KERNEL_DS);
#endif

#if(VOS_OS_VER == VOS_LINUX)
    ulReadSize = (VOS_UINT32)DIAG_FS_READ(g_stDiagFileInfo.lFile,(VOS_CHAR*)pstFsCnf + sizeof(DIAG_CMD_FS_EXPORT_CNF), DIAG_TRANSFER_BLOCK_MAX_SIZE);
#else
    ulReadSize = (VOS_UINT32)DIAG_FS_READ((FILE *)g_stDiagFileInfo.lFile,(VOS_CHAR*)pstFsCnf + sizeof(DIAG_CMD_FS_EXPORT_CNF), DIAG_TRANSFER_BLOCK_MAX_SIZE);
#endif

	diag_fs_log();

#if(VOS_OS_VER == VOS_LINUX)
    set_fs(old_fs);
#endif

    /*读取文件出现错误*/
    if (DIAG_FS_ERROR == (VOS_INT32)ulReadSize)
    {

		diag_fs_log();
        VOS_MemFree(diag_GetAgentPid(),pstFsCnf);
        diag_FsClose();
        return ERR_MSP_FAILURE;

    }

    /*表明已经没有内容可以读取,文件内容全部读完*/
    if (0 == ulReadSize)
    {

		diag_fs_log();
        diag_FsClose();
    }
    else
    {

		diag_fs_log();
        /*启动定时器*/
        g_stDiagFileInfo.hTimer = VOS_NULL_PTR;
        ret = VOS_StartRelTimer(&g_stDiagFileInfo.hTimer, diag_GetAgentPid(), DIAG_CMD_FILE_OPS_TIME_OUT_LEN, 0, DIAG_TMR_FILE_OP_TIMEOUT_PARAM, VOS_RELTIMER_NOLOOP, VOS_TIMER_NO_PRECISION);
        if(ret != ERR_MSP_SUCCESS)
        {
            diag_printf("VOS_StartRelTimer fail [%s]\n", __func__);
        }

	}

    pstFsCnf->ulRet = ret;
    pstFsCnf->ulSize = ulReadSize;

    /*打包回复给FW*/
    ret = diag_AgentCnfFun((VOS_UINT8*)pstFsCnf,ulCmdId,sizeof(DIAG_CMD_FS_EXPORT_CNF)+ulReadSize);
    VOS_MemFree(diag_GetAgentPid(),pstFsCnf);

	diag_fs_log();
    return ret;

}
VOS_UINT32  NAS_MMC_StartTimer(
    NAS_MMC_TIMER_ID_ENUM_UINT16        enTimerId,
    VOS_UINT32                          ulLen
)
{
    NAS_MMC_TIMER_CTX_STRU             *pstMmcTimerCtx;
    VOS_UINT32                          i;
    VOS_UINT32                          ulRet;
    VOS_TIMER_PRECISION_ENUM_UINT32     ulPrecision;

    pstMmcTimerCtx   =  NAS_MMC_GetTimerAddr();

    if (0 == ulLen)
    {
        NAS_INFO_LOG1(WUEPS_PID_MMC,"NAS_MMC_StartTimer:timer len is zero!", (VOS_INT32)enTimerId);
        return VOS_FALSE;
    }

    /* 如果缓存队列中该定时器已经启动则直接返回 */
    for ( i = 0 ; i < NAS_MMC_MAX_TIMER_NUM ; i++ )
    {
        if ( ( NAS_MMC_TIMER_STATUS_RUNING == pstMmcTimerCtx[i].enTimerStatus )
          && ( enTimerId                   == pstMmcTimerCtx[i].enTimerId))
        {
            NAS_INFO_LOG1(WUEPS_PID_MMC, "NAS_MMC_StartTimer:timer is running", enTimerId);

            return VOS_FALSE;
        }
    }

    for ( i = 0 ; i < NAS_MMC_MAX_TIMER_NUM ; i++ )
    {
        if ( NAS_MMC_TIMER_STATUS_STOP == pstMmcTimerCtx[i].enTimerStatus )
        {
            break;
        }
    }

    if ( i >= NAS_MMC_MAX_TIMER_NUM)
    {
        NAS_WARNING_LOG1(WUEPS_PID_MMC, "NAS_MMC_StartTimer:too many timer", enTimerId);

        return VOS_FALSE;
    }

    if ( ulLen >= VOS_TIMER_MAX_LENGTH )
    {
        ulLen = VOS_TIMER_MAX_LENGTH - 1;
    }

    ulPrecision = NAS_MMC_GetTimerPrecision(enTimerId);

    ulRet = VOS_StartRelTimer(&(pstMmcTimerCtx[i].hTimer),
                              WUEPS_PID_MMC,
                              ulLen,
                              enTimerId,
                              0,
                              VOS_RELTIMER_NOLOOP,
                              ulPrecision);

    if ( VOS_OK != ulRet)
    {
        NAS_WARNING_LOG(WUEPS_PID_MMC, "NAS_MMC_StartTimer:NAS_StartRelTimer failed");

        return VOS_FALSE;
    }

    pstMmcTimerCtx[i].enTimerId     = enTimerId;
    pstMmcTimerCtx[i].enTimerStatus = NAS_MMC_TIMER_STATUS_RUNING;


    /* 定时器状态勾包出来 */
    NAS_MMC_SndOmMmcTimerStatus(NAS_MMC_TIMER_STATUS_RUNING, enTimerId, ulLen);


    NAS_TIMER_EventReport((VOS_UINT32)enTimerId, WUEPS_PID_MMC, NAS_OM_EVENT_TIMER_OPERATION_START);

    return VOS_TRUE;

}
VOS_VOID  RNIC_StartTimer(
    RNIC_TIMER_ID_ENUM_UINT16           enTimerId,
    VOS_UINT32                          ulLen
)
{
    RNIC_TIMER_CTX_STRU                *pstRnicTimerCtx = VOS_NULL_PTR;
    RNIC_SPEC_CTX_STRU                 *pstNetCntxt     = VOS_NULL_PTR;
    VOS_TIMER_PRECISION_ENUM_UINT32     enTimerPrecision;
    VOS_UINT32                          ulRet;

    /* 目前按需拨号的功能只在网卡0上有 */
    pstNetCntxt      = RNIC_GET_SPEC_NET_CTX(RNIC_RMNET_ID_0);
    pstRnicTimerCtx  = RNIC_GetTimerAddr();
    enTimerPrecision = VOS_TIMER_PRECISION_5;

    /* 不在使用的定时器范围内 */
    if (enTimerId >= RNIC_MAX_TIMER_NUM)
    {
        return;
    }

    /* 如果缓存队列中该定时器已经启动则直接返回 */
    if (RNIC_TIMER_STATUS_RUNING == pstRnicTimerCtx[enTimerId].enTimerStatus)
    {
        return;
    }

    /* 输入参数检查 */
    if (0 == ulLen)
    {
        RNIC_ERROR_LOG1(ACPU_PID_ADS_UL, "ADS_StartTimer:ulLen is",ulLen);
        return;
    }

    if (ulLen >= VOS_TIMER_MAX_LENGTH)
    {
        ulLen = VOS_TIMER_MAX_LENGTH - 1;
    }

#if (FEATURE_ON == FEATURE_LTE)
    /* 如果还未设置唤醒源标志,并且是按需断开定时器,则设置该标志,并且设置32K时钟为唤醒源 */
    if ((VOS_FALSE == RNIC_GetTimer4WakeFlg())
      && (TI_RNIC_DEMAND_DIAL_DISCONNECT == enTimerId))
    {
        BSP_PWC_SetTimer4WakeSrc();

        RNIC_SetTimer4WakeFlg(VOS_TRUE);
    }
#endif

     /* 如果是流量上报定时器,则挂在26M时钟上,以降低功耗 */
    if (RNIC_IS_DSFLOW_TIMER_ID(enTimerId))
    {
        enTimerPrecision = VOS_TIMER_NO_PRECISION;
    }


    /* VOS_StartRelTimer 启动定时器 */
    ulRet = VOS_StartRelTimer(&(pstRnicTimerCtx[enTimerId].hTimer),
                              ACPU_PID_RNIC,
                              ulLen,
                              enTimerId,
                              0,
                              VOS_RELTIMER_NOLOOP,
                              enTimerPrecision);
    if (VOS_OK != ulRet)
    {
        RNIC_WARNING_LOG(ACPU_PID_RNIC, "NAS_MMC_StartTimer:NAS_StartRelTimer failed");
        return;
    }

    if (TI_RNIC_DEMAND_DIAL_DISCONNECT == enTimerId)
    {
        /* 按需拨号统计清零 */
        pstNetCntxt->stDsFlowStats.ulPeriodSendPktNum = 0;
    }

    pstRnicTimerCtx[enTimerId].enTimerStatus = RNIC_TIMER_STATUS_RUNING;


    /* 定时器状态勾包出来 */

}