VOS_UINT32 GU_OamSndPcMsgToCcpu(VOS_UINT8 *pucData, VOS_UINT32 ulSize)
{
VOS_INT32 lResult = VOS_ERROR;
lResult = DRV_UDI_WRITE(g_astOMACPUIccCtrlTable[OM_OM_ICC_CHANNEL].UDIHdle, pucData, ulSize);
/* 由于C核复位，写ICC通道失败会返回一个特殊值，不能复位单板 */
if (BSP_ERR_ICC_CCORE_RESETTING == lResult )
{
LogPrint1("\n# GU_OamSndPcMsgToCcpu Error,Ccore Reset,ulSize %d .\n",(VOS_INT)ulSize);
return VOS_ERR;
}
/* 当前写操作失败 */
if(ulSize != lResult)
{
LogPrint2("GU_OamSndPcMsgToCcpu: The ICC UDI Write is Error.Size:%d,lResult:%d\n",(VOS_INT)ulSize,lResult);
g_stAcpuPcToUeErrRecord.stICCSendFailInfo.ulICCOmSendErrNum++;
g_stAcpuPcToUeErrRecord.stICCSendFailInfo.ulICCOmSendErrLen += ulSize;
g_stAcpuPcToUeErrRecord.stICCSendFailInfo.ulICCOmSendErrSlice= VOS_GetSlice();
return VOS_ERR;
}
g_stAcpuPcToUeSucRecord.stICCSendSUCInfo.ulICCOmSendMsgNum++;
g_stAcpuPcToUeSucRecord.stICCSendSUCInfo.ulICCOmSendLen += ulSize;
g_stAcpuPcToUeSucRecord.stICCSendSUCInfo.ulICCOmSendSlice= VOS_GetSlice();
return VOS_OK;
}
/*****************************************************************************
函 数 名 : GU_OamVComStatus
功能描述 : 用于ACPU上面处理VCom端口断开后的OM链接断开
输入参数 : pucData: 需要发送的数据内容
ulDataLen: 数据长度
输出参数 : 无
返 回 值 : 无
调用函数 :
被调函数 :
修改历史 :
1.日 期 : 2012年2月2日
作 者 : zhuli
修改内容 : Creat Function
*****************************************************************************/
VOS_VOID GU_OamVComStatus(APP_VCOM_EVT_UINT32 enPortState)
{
if(APP_VCOM_EVT_RELEASE == enPortState)
{
g_stVComDebugInfo.ulVCOMOutNum++;
g_stVComDebugInfo.ulVCOMOutTime = OM_GetSlice();
if (CPM_VCOM_PORT == CPM_QueryPhyPort(CPM_OM_COMM))
{
GU_OamDisconnectPorts(CPM_VCOM_PORT);
g_stAcpuPcToUeSucRecord.stRlsInfo.ulRlsDrvSuspend++;
g_stAcpuPcToUeSucRecord.stRlsInfo.ulSlice = OM_GetSlice();
}
}
else if(APP_VCOM_EVT_OPEN == enPortState)
{
g_stVComDebugInfo.ulVCOMInNum++;
g_stVComDebugInfo.ulVCOMInTime = OM_GetSlice();
}
else
{
LogPrint1("GU_OamVComStatus: The VCOM Port State %d is Unknow", (VOS_INT)enPortState);
}
return;
}
/*****************************************************************************
函 数 名 : CPM_ComRcv
功能描述 : 接收数据函数，提供给物理通道使用
输入参数 : enPhyPort： 物理通道号
pucData： 接收数据的指针
ulLen: 接收数据的长度
输出参数 : 无
返 回 值 : VOS_OK:成功，其他为失败
*****************************************************************************/
VOS_UINT32 CPM_ComRcv(CPM_PHY_PORT_ENUM_UINT32 enPhyPort, VOS_UINT8 *pucData, VOS_UINT32 ulLen)
{
/* 参数检测 */
if (CPM_PORT_BUTT <= enPhyPort)
{
g_stCPMRcvErrInfo.ulPortErr++;
return VOS_ERR;
}
if ((VOS_NULL_PTR == pucData) || (0 == ulLen))
{
g_stCPMRcvErrInfo.astCPMRcvErrInfo[enPhyPort - CPM_IND_PORT].ulParaErr++;
return VOS_ERR;
}
if (VOS_NULL_PTR == CPM_PHY_RCV_FUNC(enPhyPort - CPM_IND_PORT))
{
LogPrint1("\r\nCPM_ComRcv The Phy Port %d Rec Func is NULL", (VOS_INT)enPhyPort);
g_stCPMRcvErrInfo.astCPMRcvErrInfo[enPhyPort - CPM_IND_PORT].ulNullPtr++;
return VOS_ERR;
}
return CPM_PHY_RCV_FUNC(enPhyPort - CPM_IND_PORT)(pucData, ulLen);
}
VOS_UINT32 VOS_RegisterPIDInfo( VOS_PID ulPID,
Init_Fun_Type pfnInitFun,
Msg_Fun_Type pfnMsgFun)
{
if((ulPID >= VOS_PID_BUTT)||(ulPID < VOS_PID_DOPRAEND))
{
VOS_SetErrorNo(VOS_ERRNO_FIDPID_REGPIDI_INPUTPIDINVALID);
LogPrint1("\r\nVOS_RegisterPIDInfo: Register Wrong PID %d", (VOS_INT)ulPID);
return(VOS_ERRNO_FIDPID_REGPIDI_INPUTPIDINVALID);
}
if(pfnInitFun != VOS_NULL_PTR)
{
vos_PidRecords[ulPID-VOS_PID_DOPRAEND].InitFunc = pfnInitFun;
}
if(pfnMsgFun == VOS_NULL_PTR)
{
VOS_SetErrorNo(VOS_ERRNO_FIDPID_REGPIDI_INPUTFUNCARENULL);
return(VOS_ERRNO_FIDPID_REGPIDI_INPUTFUNCARENULL);
}
else
{
vos_PidRecords[ulPID-VOS_PID_DOPRAEND].MsgFunction = pfnMsgFun;
}
return(VOS_OK);
}
/*****************************************************************************
函 数 名 : CPM_ComRcv
功能描述 : 接收数据函数，提供给物理通道使用
输入参数 : enPhyPort： 物理通道号
pucData： 接收数据的指针
ulLen: 接收数据的长度
输出参数 : 无
返 回 值 : VOS_OK:成功，其他为失败
*****************************************************************************/
VOS_UINT32 CPM_ComRcv(CPM_PHY_PORT_ENUM_UINT32 enPhyPort, VOS_UINT8 *pucData, VOS_UINT32 ulLen)
{
/* 参数检测 */
if (CPM_PORT_BUTT <= enPhyPort)
{
g_stCPMRcvErrInfo.ulPortErr++;
diag_PTR(EN_DIAG_PTR_CPM_ERR1);
return VOS_ERR;
}
if ((VOS_NULL_PTR == pucData) || (0 == ulLen))
{
g_stCPMRcvErrInfo.astCPMRcvErrInfo[enPhyPort - CPM_IND_PORT].ulParaErr++;
diag_PTR(EN_DIAG_PTR_CPM_ERR2);
return VOS_ERR;
}
if (VOS_NULL_PTR == CPM_PHY_RCV_FUNC(enPhyPort - CPM_IND_PORT))
{
/*lint -e534*/
LogPrint1("\r\nCPM_ComRcv The Phy Port %d Rec Func is NULL", (VOS_INT)enPhyPort);
/*lint +e534*/
g_stCPMRcvErrInfo.astCPMRcvErrInfo[enPhyPort - CPM_IND_PORT].ulNullPtr++;
diag_PTR(EN_DIAG_PTR_CPM_ERR3);
return VOS_ERR;
}
diag_PTR(EN_DIAG_PTR_CPM_COMRCV);
return CPM_PHY_RCV_FUNC(enPhyPort - CPM_IND_PORT)(pucData, ulLen);
}
VOS_UINT32 OM_ComRx_ICCDataRec(OM_ICC_CHANNEL_ENUM_UINT32 enChannelId, VOS_INT32 lLen)
{
VOS_UINT8 *pucData;
VOS_INT32 lResult;
/*申请内存用于保存ICC传递的数据*/
pucData = (VOS_UINT8 *)VOS_MemAlloc(WUEPS_PID_OM, DYNAMIC_MEM_PT, (VOS_UINT32)lLen);
if (VOS_NULL_PTR == pucData)
{
LogPrint1("OM_ComRx_ICCDataRec: VOS_MemAlloc is Failed, Data Len is %d.\n", lLen);
return VOS_ERR;
}
/*读取ICC传递的数据*/
lResult = DRV_UDI_READ(g_astOMCCPUIccCtrlTable[enChannelId].UDIHdle, pucData, (VOS_UINT32)lLen);
if (lLen != lResult)
{
VOS_MemFree(WUEPS_PID_OM, pucData);
LogPrint("OM_ComRx_ICCDataRec: DRV_UDI_READ is Failed.\n");
return VOS_ERR;
}
/*ICC数据处理函数返回错误*/
if (VOS_OK != g_astOMComRxCBTable[enChannelId](pucData, (VOS_UINT16)lLen))
{
LogPrint("OM_ComRx_ICCDataRec: The CB function is Failed.\n");
}
VOS_MemFree(WUEPS_PID_OM, pucData);
return VOS_OK;
}
VOS_VOID PPM_GetSendDataLen(SOCP_CODER_DST_ENUM_U32 enChanID, VOS_UINT32 ulDataLen, VOS_UINT32 *pulSendDataLen, CPM_PHY_PORT_ENUM_UINT32 *penPhyport)
{
CPM_PHY_PORT_ENUM_UINT32 enPhyport;
if (SOCP_CODER_DST_OM_CNF == enChanID)
{
enPhyport = CPM_QueryPhyPort(CPM_OM_CFG_COMM);
}
else
{
enPhyport = CPM_QueryPhyPort(CPM_OM_IND_COMM);
}
/*当发送是通过USB并且发送长度大于60k的时候，需要限制发送长度*/
if (((CPM_IND_PORT == enPhyport) || (CPM_CFG_PORT == enPhyport))
&&(ulDataLen > USB_MAX_DATA_LEN))
{
LogPrint1("PPM_GetSendDataLen: Change the send Data Len %d", (VOS_INT)ulDataLen);
*pulSendDataLen = USB_MAX_DATA_LEN;
}
else
{
*pulSendDataLen = ulDataLen; /*其他情况下不需要调整当前的大小，包括sd、wifi*/
}
*penPhyport = enPhyport;
return;
}
/*****************************************************************************
函 数 名 : GU_OamSndPcCmsMsg
功能描述 : 用于ACPU上面把PC侧数据通过ICC发送给CCPU OM模块
输入参数 : pucData: 需要发送的数据内容
ulDataLen: 数据长度
输出参数 : 无
返 回 值 : VOS_ERROR/VOS_OK
调用函数 :
被调函数 :
修改历史 :
1.日 期 : 2011年3月10日
作 者 : l46160
修改内容 : Creat Function
*****************************************************************************/
VOS_UINT32 GU_OamSndPcMsgToCcpu(OMRL_RCV_CHAN_CTRL_INFO_STRU *pstCtrlInfo, VOS_UINT8 *pucData, VOS_UINT32 ulSize)
{
VOS_INT32 lResult = VOS_ERROR;
lResult = DRV_ICC_WRITE(UDI_ICC_GUOM0, pucData, (VOS_INT32)ulSize);
/* 由于C核复位，写ICC通道失败会返回一个特殊值，不能复位单板 */
if (BSP_ERR_ICC_CCORE_RESETTING == lResult )
{
LogPrint1("\n# GU_OamSndPcMsgToCcpu Error,Ccore Reset,ulSize %d .\n",(VOS_INT)ulSize);
return VOS_ERR;
}
/* 当前写操作失败 */
if(ulSize != (VOS_UINT32)lResult)
{
LogPrint2("GU_OamSndPcMsgToCcpu: The ICC UDI Write is Error.Size:%d,lResult:%d\n",(VOS_INT)ulSize,lResult);
pstCtrlInfo->stPcToUeErrRecord.stICCSendFailInfo.ulICCOmSendErrNum++;
pstCtrlInfo->stPcToUeErrRecord.stICCSendFailInfo.ulICCOmSendErrLen += ulSize;
pstCtrlInfo->stPcToUeErrRecord.stICCSendFailInfo.ulICCOmSendErrSlice= VOS_GetSlice();
return VOS_ERR;
}
pstCtrlInfo->stPcToUeSucRecord.stICCSendSUCInfo.ulICCOmSendMsgNum++;
pstCtrlInfo->stPcToUeSucRecord.stICCSendSUCInfo.ulICCOmSendLen += ulSize;
pstCtrlInfo->stPcToUeSucRecord.stICCSendSUCInfo.ulICCOmSendSlice= VOS_GetSlice();
return VOS_OK;
}
/*****************************************************************************
函 数 名 : FC_CPU_Process
功能描述 : C核流控模块提供的CPU负载处理接口，该函数目前在中断中调用，不能有阻塞性操作
输入参数 : ulCpuLoad -- 当前CPU占用率0~100
输出参数 : 无
返 回 值 : 无
调用函数 :
被调函数 :
修改历史 :
1.日 期 : 2011年12月5日
作 者 :
修改内容 : 新生成函数
*****************************************************************************/
unsigned int FC_CPU_Process( unsigned int ulCpuLoad )
{
FC_CFG_CPU_STRU *pstFcCfgCpu;
FC_POLICY_STRU *pstFcPolicy;
VOS_UINT32 ulStartCtrl;
/*====================================*//* 使能检查 */
if ( FC_POLICY_MASK_CPU_C != (FC_POLICY_MASK_CPU_C & g_stFcCfg.ulFcEnbaleMask) )
{
/* CPU流控未使能，在中断中被调用，故使用LogPrint */
LogPrint1("FC_CPU_Process, INFO, CPU FlowCtrl is disabled %d.\r\n", (VOS_INT32)g_stFcCfg.ulFcEnbaleMask );
return 0;
}
/* 记录CPU负载数据到全局变量中 */
g_stFcTraceCpuLoad.ulCpuLoadRecord = ulCpuLoad;
/*================================*//* 参数检查 */
if ( 100 < ulCpuLoad )
{
/* 参数非法，在中断中被调用，故使用LogPrint */
LogPrint1("FC_CPU_Process, WARNING, Invalid Cpu Load %d.\r\n", (VOS_INT32)ulCpuLoad);
return 0;
}
pstFcPolicy = FC_POLICY_Get(FC_PRIVATE_POLICY_ID_CPU_C_MODEM_0);
pstFcCfgCpu = &(g_stFcCfg.stFcCfgCpuC);
/*================================*//* 是否要进行CPU流控 */
ulStartCtrl = FC_CPUC_UpJudge(ulCpuLoad, pstFcCfgCpu, pstFcPolicy);
if (VOS_TRUE == ulStartCtrl)
{
FC_SndCpuMsg(ID_FC_CPU_C_OVERLOAD_IND, ulCpuLoad, 0, 0);
return 0;
}
/*================================*//* 进行CPU解流控判决 */
ulStartCtrl = FC_CPUC_DownJudge(ulCpuLoad, pstFcCfgCpu, pstFcPolicy);
if ( VOS_TRUE == ulStartCtrl )
{
FC_SndCpuMsg(ID_FC_CPU_C_UNDERLOAD_IND, ulCpuLoad, 0, 0);
return 0;
}
return 0;
}
/*****************************************************************************
函 数 名 : GU_OamPortStatusCB
功能描述 : 用于ACPU上面处理物理端口断开后的OM链接断开
输入参数 : pucData: 需要发送的数据内容
ulDataLen: 数据长度
输出参数 : 无
返 回 值 : 无
调用函数 :
被调函数 :
修改历史 :
1.日 期 : 2012年2月2日
作 者 : zhuli
修改内容 : Creat Function
*****************************************************************************/
VOS_VOID GU_OamAppStatusCB(ACM_EVT_E enPortState)
{
if (CPM_APP_PORT == CPM_QueryPhyPort(CPM_PCVOICE_COMM))/*当前运行的是Pcvoice业务，不处理*/
{
LogPrint1("\r\n Info: GU_OamAppStatusCB: Pcvoice Rec The USB Port State %d", enPortState);
return;
}
GU_OamPortStatus(OM_APP_PORT_HANDLE, CPM_APP_PORT, enPortState);
return;
}
VOS_INT32 PPM_ReadPortData(CPM_PHY_PORT_ENUM_UINT32 enPhyPort, UDI_HANDLE UdiHandle, OM_PROT_HANDLE_ENUM_UINT32 enHandle)
{
ACM_WR_ASYNC_INFO stInfo;
if (VOS_ERROR == UdiHandle)
{
LogPrint("\r\n PPM_PortCloseProc: Input HANDLE is err. \n");
g_stAcpuDebugInfo.astPortInfo[enHandle].ulUSBUdiHandleErr++;
return VOS_ERR;
}
VOS_MemSet(&stInfo, 0, sizeof(stInfo));
/* 获取USB的IO CTRL口的读缓存 */
if (VOS_OK != DRV_UDI_IOCTL(UdiHandle, UDI_ACM_IOCTL_GET_READ_BUFFER_CB, &stInfo))
{
LogPrint("\r\n PPM_ReadPortData:Call DRV_UDI_IOCTL is Failed\n");
g_stAcpuDebugInfo.astPortInfo[enHandle].ulUSBUdiHandleReadGetBufferErr++;
return VOS_ERR;
}
/*lint -e40*/
OM_ACPU_DEBUG_CHANNEL_TRACE(enPhyPort, (VOS_UINT8*)stInfo.pVirAddr, stInfo.u32Size, OM_ACPU_USB_CB);
/*lint +e40*/
if(VOS_OK != CPM_ComRcv(enPhyPort, (VOS_UINT8*)stInfo.pVirAddr, stInfo.u32Size))
{
LogPrint1("\r\n Info: PPM_ReadPortData:Call CPM_ComRcv is NULL, PhyPort is %d\n", (VOS_INT)enPhyPort);
g_stAcpuDebugInfo.astPortInfo[enHandle].ulUSBUdiCommRcvNullPtrErr++;
}
g_stAcpuDebugInfo.astPortInfo[enHandle].ulUSBRcvPktNum++;
g_stAcpuDebugInfo.astPortInfo[enHandle].ulUSBRcvPktByte += stInfo.u32Size;
if(VOS_OK != DRV_UDI_IOCTL(UdiHandle, UDI_ACM_IOCTL_RETUR_BUFFER_CB, &stInfo))
{
LogPrint("\r\n PPM_ReadPortData:Call DRV_UDI_IOCTL UDI_ACM_IOCTL_RETUR_BUFFER_CB is Failed\n");
g_stAcpuDebugInfo.astPortInfo[enHandle].ulUSBUdiHandleReadBufferFreeErr++;
}
return VOS_OK;
}
/*****************************************************************************
函 数 名 : GU_OamUSBReadData
功能描述 : 用于ACPU上面底软把数据通过ICC发送给OM模块
输入参数 : enPhyPort: 物理端口
UdiHandle:设备句柄
输出参数 : 无
返 回 值 : VOS_ERR/VOS_OK
调用函数 :
被调函数 :
修改历史 :
1.日 期 : 2012年2月2日
作 者 : zhuli
修改内容 : Creat Function
*****************************************************************************/
VOS_INT32 GU_OamReadPortData(CPM_PHY_PORT_ENUM_UINT32 enPhyPort, UDI_HANDLE UdiHandle)
{
ACM_WR_ASYNC_INFO stInfo;
CPM_PHY_PORT_ENUM_UINT32 enPcvoiceRet;
CPM_PHY_PORT_ENUM_UINT32 enDiagRet;
if (VOS_ERROR == UdiHandle)
{
LogPrint("\r\nGU_OamReadPortData: Input HANDLE is err. \n");
return VOS_ERR;
}
VOS_MemSet(&stInfo, 0, sizeof(stInfo));
/* 获取USB的IO CTRL口的读缓存 */
if (VOS_OK != DRV_UDI_IOCTL(UdiHandle, UDI_ACM_IOCTL_GET_READ_BUFFER_CB, &stInfo))
{
LogPrint("\r\nGU_OamReadPortData:Call DRV_UDI_IOCTL is Failed\n");
return VOS_ERR;
}
/*lint -e40*/
OM_ACPU_DEBUG_TRACE((VOS_UINT8*)stInfo.pBuffer, stInfo.u32Size, OM_ACPU_USB_CB);
/*lint +e40*/
/*判断当前是否承载的是Pcvoice*/
enPcvoiceRet = CPM_QueryPhyPort(CPM_PCVOICE_COMM);
enDiagRet = CPM_QueryPhyPort(CPM_DIAG_COMM);
if ((enPhyPort != enPcvoiceRet)&&(enPhyPort != enDiagRet))
{
CPM_PnpAppPortCB(enPhyPort, VOS_TRUE); /*需要重新链接物理和逻辑端口关系*/
}
if(VOS_OK != CPM_ComRcv(enPhyPort, (VOS_UINT8*)stInfo.pBuffer, stInfo.u32Size))
{
LogPrint1("\r\n Info: GU_OamReadPortData:Call CPM_ComRcv is NULL, PhyPort is %d\n", (VOS_INT)enPhyPort);
}
if(VOS_OK != DRV_UDI_IOCTL(UdiHandle, UDI_ACM_IOCTL_RETUR_BUFFER_CB, &stInfo))
{
LogPrint("\r\nGU_OamReadPortData:Call DRV_UDI_IOCTL UDI_ACM_IOCTL_RETUR_BUFFER_CB is Failed\n");
}
return VOS_OK;
}
/*****************************************************************************
Function : HPA_Write32RegMask
Description: write mask to DSP & BBP
Input : ulRegAddr -- address of DSP & BBP
: ulMask -- mask
Return : void
Other : caution: BIT_N must be used befor call the function
*****************************************************************************/
VOS_VOID HPA_Write32RegMask(VOS_UINT32 ulRegAddr, VOS_UINT32 ulMask)
{
/* Add for L Only version */
if (BOARD_TYPE_LTE_ONLY == BSP_OM_GetBoardType())
{
return;
}
/* Add for L Only version */
if ( 0 != (ulRegAddr & 0x03) )/* not 4byte aligned */
{
LogPrint1("HPA_Write32RegMask Address: 0x%x not aligned.\r\n",(VOS_INT)ulRegAddr);
return;
}
*(volatile VOS_UINT32 *)ulRegAddr |= ulMask;
}
/*****************************************************************************
函 数 名 : CPM_ComRcv
功能描述 : 接收数据函数，提供给物理通道使用
输入参数 : enPhyPort： 物理通道号
pucData： 接收数据的指针
ulLen: 接收数据的长度
输出参数 : 无
返 回 值 : VOS_OK:成功，其他为失败
*****************************************************************************/
VOS_UINT32 CPM_ComRcv(CPM_PHY_PORT_ENUM_UINT32 enPhyPort, VOS_UINT8 *pucData, VOS_UINT32 ulLen)
{
/* 参数检测 */
if ((CPM_PORT_BUTT <= enPhyPort) || (VOS_NULL_PTR == pucData) || (0 == ulLen))
{
return VOS_ERR;
}
if (VOS_NULL_PTR == CPM_PHY_RCV_FUNC(enPhyPort - CPM_APP_PORT))
{
LogPrint1("\r\nCPM_ComRcv The Phy Port %d Rec Func is NULL", (VOS_INT)enPhyPort);
return VOS_ERR;
}
return CPM_PHY_RCV_FUNC(enPhyPort - CPM_APP_PORT)(pucData, ulLen);
}
/*****************************************************************************
Function : HPA_Write16Reg
Description: write 16bit data to DSP & BBP
Input : ulRegAddr -- address of DSP & BBP
: ulRegVal -- 16bit data
Return : void
Other :
*****************************************************************************/
VOS_VOID HPA_Write16Reg( VOS_UINT32 ulRegAddr, VOS_UINT16 usRegVal)
{
/* Add for L Only version */
if (BOARD_TYPE_LTE_ONLY == BSP_OM_GetBoardType())
{
return;
}
/* Add for L Only version */
if ( 0 != (ulRegAddr & 0x01) )/* not 2byte aligned */
{
LogPrint1("HPA_Write16Reg Address: 0x%x not aligned.\r\n",(VOS_INT)ulRegAddr);
return;
}
*(volatile VOS_UINT16 *)ulRegAddr = usRegVal;
}
/*****************************************************************************
Function : HPA_Read16Reg
Description: read 16bit data from DSP & BBP
Input : ulRegAddr -- address of DSP & BBP
: ulRegVal -- 16bit data
Return : void
Other :
*****************************************************************************/
VOS_UINT16 HPA_Read16Reg( VOS_UINT32 ulRegAddr )
{
/* Add for L Only version */
if (BOARD_TYPE_LTE_ONLY == BSP_OM_GetBoardType())
{
return 0;
}
/* Add for L Only version */
if ( 0 != (ulRegAddr & 0x01) )/* not 2byte aligned */
{
LogPrint1("HPA_Read16Reg Address: 0x%x not aligned.\r\n",(VOS_INT)ulRegAddr);
return 0;
}
return *(volatile VOS_UINT16 *)ulRegAddr;
}
VOS_UINT32 GU_OamAppSendDataSync(VOS_UINT8 *pucData, VOS_UINT32 ulDataLen)
{
VOS_INT32 lRetLen;
/* 返回写入数据长度代表写操作成功 */
lRetLen = DRV_UDI_WRITE(g_astOMPortUDIHandle[OM_APP_PORT_HANDLE], pucData, ulDataLen);
if (VOS_OK != lRetLen)
{
/*打印信息，调用UDI接口*/
LogPrint1("\r\nGU_OamAppSendDataSync: DRV_UDI_WRITE Send Data Error is %d", lRetLen);
return VOS_ERR;
}
return VOS_OK;
}
VOS_VOID GU_OamGetSendDataLen(VOS_UINT32 ulDataLen, VOS_UINT32 *pulSendDataLen, CPM_PHY_PORT_ENUM_UINT32 *penPhyport)
{
CPM_PHY_PORT_ENUM_UINT32 enPhyport;
enPhyport = CPM_QueryPhyPort(CPM_OM_COMM);
/*当发送是通过USB并且发送长度大于60k的时候，需要限制发送长度*/
if (((CPM_APP_PORT == enPhyport)||(CPM_CTRL_PORT == enPhyport))
&&(ulDataLen > USB_MAX_DATA_LEN))
{
LogPrint1("GU_OamUSBWriteDataCB: Change the send Data Len %d", (VOS_INT)ulDataLen);
*pulSendDataLen = USB_MAX_DATA_LEN;
}
else
{
*pulSendDataLen = ulDataLen; /*其他情况下不需要调整当前的大小，包括sd、wifi*/
}
*penPhyport = enPhyport;
return;
}
/******************************************************************************
Prototype : R_ITF_ExcFlowCtrl
Description : 执行流控
Input : ulFlowCtrlType -- 流控类型
ulNewLev -- 该流控类型的最新值
ulFlowCtrlCmd -- 流控指令，启动或停止
Output :
Return Value :
Calls :
Called By :
History : ---
1.Date : 2011-04-14
Modification: Created function
******************************************************************************/
VOS_UINT32 R_ITF_ExcFlowCtrl
(
R_ITF_FLOW_CTRL_CMD_ENUM_UINT32 ulFlowCtrlCmd,
VOS_UINT32 ulFlowCtrlType,
VOS_UINT32 *pulNeedTrace
)
{
VOS_UINT32 ulResult = VOS_OK;
if ( R_ITF_FLOW_CTRL_START == ulFlowCtrlCmd )
{
/* PS融合后, 这里只监测内存, 而其余监测对象全部统一到FC的框架下 */
if ((R_ITF_FLOW_CTRL_TYPE_MEM_CNT == ulFlowCtrlType)
|| (R_ITF_FLOW_CTRL_TYPE_MEM_SIZE == ulFlowCtrlType))
{
ulResult = R_ITF_SetGprsFlowCtrl(); /* 调用流控函数 */
*pulNeedTrace = PS_TRUE;
}
}
else if ( R_ITF_FLOW_CTRL_STOP == ulFlowCtrlCmd )
{
/* PS融合后, 这里只监测内存, 而其余监测对象全部统一到FC的框架下 */
if ((R_ITF_FLOW_CTRL_TYPE_MEM_CNT == ulFlowCtrlType)
|| (R_ITF_FLOW_CTRL_TYPE_MEM_SIZE == ulFlowCtrlType))
{
ulResult = R_ITF_StopGprsFlowCtrl(); /* 调用流控解除函数 */
*pulNeedTrace = PS_TRUE;
}
}
else
{
LogPrint1("R_ITF_ExcFlowCtrl, WARNING, Unknow flow control command %u\r\n",
(VOS_INT32)ulFlowCtrlCmd);
return VOS_ERR;
}
return ulResult;
}
VOS_UINT32 CBTPPM_OamUsbCbtSendData(VOS_UINT8 *pucVirAddr, VOS_UINT8 *pucPhyAddr, VOS_UINT32 ulDataLen)
{
VOS_INT32 lRet;
ACM_WR_ASYNC_INFO stVcom;
VOS_UINT32 ulInSlice;
VOS_UINT32 ulOutSlice;
VOS_UINT32 ulWriteSlice;
if ((VOS_NULL_PTR == pucVirAddr) || (VOS_NULL_PTR == pucPhyAddr))
{
/* 打印错误 */
LogPrint("\r\n CBTPPM_OamUsbCbtSendData: Vir or Phy Addr is Null \n");
return CPM_SEND_PARA_ERR;
}
stVcom.pVirAddr = (VOS_CHAR*)pucVirAddr;
stVcom.pPhyAddr = (VOS_CHAR*)pucPhyAddr;
stVcom.u32Size = ulDataLen;
stVcom.pDrvPriv = VOS_NULL_PTR;
g_stAcpuDebugInfo.astPortInfo[OM_USB_CBT_PORT_HANDLE].ulUSBWriteNum1++;
ulInSlice = OM_GetSlice();
lRet = DRV_UDI_IOCTL(g_ulCbtPortUDIHandle, ACM_IOCTL_WRITE_ASYNC, &stVcom);
g_stAcpuDebugInfo.astPortInfo[OM_USB_CBT_PORT_HANDLE].ulUSBWriteNum2++;
ulOutSlice = OM_GetSlice();
if(ulInSlice > ulOutSlice)
{
ulWriteSlice = ulInSlice - ulOutSlice;
}
else
{
ulWriteSlice = ulOutSlice - ulInSlice;
}
if(ulWriteSlice > g_stAcpuDebugInfo.astPortInfo[OM_USB_CBT_PORT_HANDLE].ulUSBWriteMaxTime)
{
g_stAcpuDebugInfo.astPortInfo[OM_USB_CBT_PORT_HANDLE].ulUSBWriteMaxTime = ulWriteSlice;
}
if (BSP_OK == lRet) /*当前发送成功*/
{
if (VOS_OK != VOS_SmP(g_ulCbtUsbPseudoSyncSemId, 0))
{
LogPrint1("\r\n CBTPPM_OamUsbCbtSendData: DRV_UDI_IOCTL Send Data return Error %d\n", lRet);
return VOS_ERR;
}
return VOS_OK;
}
else if (BSP_OK > lRet) /*临时错误*/
{
/*打印信息，调用UDI接口的错误信息*/
LogPrint1("\r\n CBTPPM_OamUsbCbtSendData: DRV_UDI_IOCTL Send Data return Error %d\n", lRet);
g_stAcpuDebugInfo.astPortInfo[OM_USB_CBT_PORT_HANDLE].ulUSBWriteErrNum++;
g_stAcpuDebugInfo.astPortInfo[OM_USB_CBT_PORT_HANDLE].ulUSBWriteErrLen += ulDataLen;
g_stAcpuDebugInfo.astPortInfo[OM_USB_CBT_PORT_HANDLE].ulUSBWriteErrValue = (VOS_UINT32)lRet;
g_stAcpuDebugInfo.astPortInfo[OM_USB_CBT_PORT_HANDLE].ulUSBWriteErrTime = OM_GetSlice();
return VOS_ERR; /*对于临时错误，需要返回NULL丢弃数据*/
}
else /*其他错误需要复位单板*/
{
/*打印信息，调用UDI接口*/
LogPrint1("\r\n CBTPPM_OamUsbCbtSendData: DRV_UDI_IOCTL Send Data return Error %d\n", lRet);
DRV_SYSTEM_ERROR(OAM_USB_SEND_ERROR, (VOS_INT)THIS_FILE_ID, (VOS_INT)__LINE__,
(VOS_CHAR *)&lRet, sizeof(VOS_INT32));
return VOS_ERR;
}
}
VOS_UINT32 OM_ComRx_ICC_Init(VOS_VOID)
{
VOS_INT32 i;
VOS_MemSet(g_astOMComRxCBTable, 0 ,sizeof(g_astOMComRxCBTable));
VOS_MemSet(g_astOMCCPUIccCtrlTable, 0, sizeof(g_astOMCCPUIccCtrlTable));
for (i = 0; i < OM_ICC_CHANNEL_BUTT; i++)
{
g_astOMCCPUIccCtrlTable[i].stUDICtrl.pstICCAttr = (ICC_CHAN_ATTR_S*)VOS_MemAlloc(WUEPS_PID_OM,
STATIC_MEM_PT,
sizeof(ICC_CHAN_ATTR_S));
if(VOS_NULL_PTR == g_astOMCCPUIccCtrlTable[i].stUDICtrl.pstICCAttr)
{
LogPrint1("OM_ComRx_ICC_Init: VOS_MemAlloc Failed, Index is %d.\n", i);
return VOS_ERR;
}
}
g_astOMCCPUIccCtrlTable[OM_OM_ICC_CHANNEL].stUDICtrl.enICCId = UDI_ICC_GUOM0_ID;
g_astOMCCPUIccCtrlTable[OM_OM_ICC_CHANNEL].stUDICtrl.pstICCAttr->read_cb = OM_ComRx_ICC_OM_CB;
g_astOMCCPUIccCtrlTable[OM_OSA_MSG_ICC_CHANNEL].stUDICtrl.enICCId = UDI_ICC_GUOM4_ID;
g_astOMCCPUIccCtrlTable[OM_OSA_MSG_ICC_CHANNEL].stUDICtrl.pstICCAttr->read_cb = V_ICC_OSAMsg_CB;
for(i=0; i<OM_ICC_CHANNEL_BUTT; i++)
{
g_astOMCCPUIccCtrlTable[i].stUDICtrl.pstICCAttr->u32Priority = OM_ICC_CHANNEL_PRIORITY; /* 统一使用最高优先级 */
g_astOMCCPUIccCtrlTable[i].stUDICtrl.pstICCAttr->u32TimeOut = OM_ICC_HANDSHAKE_TIME_MAX;
if( i == OM_OSA_MSG_ICC_CHANNEL)
{
g_astOMCCPUIccCtrlTable[i].stUDICtrl.pstICCAttr->u32FIFOInSize = OSA_ICC_BUFFER_SIZE;
g_astOMCCPUIccCtrlTable[i].stUDICtrl.pstICCAttr->u32FIFOOutSize = OSA_ICC_BUFFER_SIZE;
}
else
{
g_astOMCCPUIccCtrlTable[i].stUDICtrl.pstICCAttr->u32FIFOInSize = OM_ICC_BUFFER_SIZE;
g_astOMCCPUIccCtrlTable[i].stUDICtrl.pstICCAttr->u32FIFOOutSize = OM_ICC_BUFFER_SIZE;
}
g_astOMCCPUIccCtrlTable[i].stUDICtrl.pstICCAttr->enChanMode = ICC_CHAN_MODE_PACKET;
g_astOMCCPUIccCtrlTable[i].stUDICtrl.pstICCAttr->event_cb = OM_ComRx_ICCError_CB;
g_astOMCCPUIccCtrlTable[i].UDIHdle = DRV_UDI_OPEN((UDI_OPEN_PARAM *)&(g_astOMCCPUIccCtrlTable[i].stUDICtrl));
if (VOS_ERROR == g_astOMCCPUIccCtrlTable[i].UDIHdle)
{
/* 打开失败时记录当前ICC通道信息 */
DRV_SYSTEM_ERROR(OM_APP_ICC_INIT_ERROR, THIS_FILE_ID, __LINE__,
(VOS_CHAR*)&i, sizeof(VOS_INT32));
return VOS_ERR;
}
}
g_OSAIccUDIHandle = g_astOMCCPUIccCtrlTable[OM_OSA_MSG_ICC_CHANNEL].UDIHdle;
return VOS_OK;
}
/*****************************************************************************
Function : vos_FidTask
Description: the process entry of every FID
Input : ulQueueID -- the queue of the FID
: the ID of the FID
Return : void
*****************************************************************************/
VOS_VOID vos_FidTask( VOS_UINT32 ulQueueID, VOS_UINT32 FID_value,
VOS_UINT32 Para1, VOS_UINT32 Para2 )
{
MSG_CB *pMsg;
VOS_UINT32 *pulMsgAddr;
VOS_UINT32 iThePid;
VOS_UINT32 Msg_Address;
for(;;)
{
if ( VOS_ERR
== VOS_FixedQueueRead(ulQueueID, 0, &Msg_Address, VOS_FID_MAX_MSG_LENGTH))
{
LogPrint1("# FID fetch message error. the Q ID is %d.\r\n",
(int)ulQueueID);
continue;
}
Msg_Address += VOS_MSG_BLK_HEAD_LEN;
pMsg = (MSG_CB *)Msg_Address;
iThePid = pMsg->ulReceiverPid;
if(iThePid >= VOS_PID_BUTT)
{
LogPrint("# vos_FidTask Pid too big.\r\n");
pulMsgAddr = (VOS_UINT32 *)pMsg;
LogPrint4("# Msg :S pid %08X R Pid %08X Length %08X Name %08X.\r\n",
*(pulMsgAddr + 1), *(pulMsgAddr + 3),
*(pulMsgAddr + 4), *(pulMsgAddr + 5));
VOS_FreeMsg( iThePid, pMsg );
continue;
}
if( FID_value == vos_PidRecords[iThePid-VOS_PID_DOPRAEND].Fid )
{
if ( VOS_NULL_PTR != vos_MsgHook )
{
(vos_MsgHook)(pMsg);
}
(vos_PidRecords[iThePid-VOS_PID_DOPRAEND].MsgFunction)(pMsg);
}
else
{
LogPrint("# vos_FidTask Pid not belong the Fid.\r\n");
pulMsgAddr = (VOS_UINT32 *)pMsg;
LogPrint4("# Msg :S pid %08X R Pid %08X Length %08X Name %08X.\r\n",
*(pulMsgAddr + 1), *(pulMsgAddr + 3),
*(pulMsgAddr + 4), *(pulMsgAddr + 5));
}
VOS_FreeMsg( iThePid, pMsg );
}
}
/*****************************************************************************
函 数 名 : GU_OamReadPortDataInit
功能描述 : 用于初始化OM使用的设备
输入参数 : enPhyPort: 物理端口号
enHandle: 端口的句柄
pReadCB: 该端口上面的读取回调函数
pWriteCB: 该端口上面的异步写回调函数
pStateCB: 该端口上面的状态回调函数
输出参数 : pUdiHandle: 端口的句柄
返 回 值 : VOS_OK/VOS_ERR
调用函数 :
被调函数 :
修改历史 :
1.日 期 : 2012年2月2日
作 者 : zhuli
修改内容 : Creat Function
*****************************************************************************/
VOS_VOID GU_OamReadPortDataInit(CPM_PHY_PORT_ENUM_UINT32 enPhyPort,
OM_PROT_HANDLE_ENUM_UINT32 enHandle,
VOS_VOID *pReadCB,
VOS_VOID *pWriteCB,
VOS_VOID *pStateCB)
{
UDI_OPEN_PARAM stUdiPara;
ACM_READ_BUFF_INFO stReadBuffInfo;
/*初始化当前使用的USB通道*/
if(CPM_APP_PORT == enPhyPort)
{
stUdiPara.devid = UDI_ACM_OM_ID;
}
else if(CPM_CTRL_PORT == enPhyPort)
{
stUdiPara.devid = UDI_ACM_CTRL_ID;
}
else if(CPM_HSIC_PORT == enPhyPort)
{
stUdiPara.devid = UDI_ACM_HSIC_ACM6_ID;
}
else
{
LogPrint1("\r\nGU_OamReadPortDataInit: Open Wrong Port %d!", (VOS_INT)enPhyPort);
return;
}
stReadBuffInfo.u32BuffSize = OM_ICC_BUFFER_SIZE;
stReadBuffInfo.u32BuffNum = OM_DRV_MAX_IO_COUNT;
g_stAcpuDebugInfo.astPortInfo[enHandle].ulUSBOpenNum++;
g_stAcpuDebugInfo.astPortInfo[enHandle].ulUSBOpenSlice = OM_GetSlice();
if (VOS_ERROR != g_astOMPortUDIHandle[enHandle])
{
LogPrint("\r\nGU_OamReadPortDataInit: The UDI Handle is not Null !");
return;
}
/* 打开OM使用的USB通道 */
g_astOMPortUDIHandle[enHandle] = DRV_UDI_OPEN(&stUdiPara);
if (VOS_ERROR == g_astOMPortUDIHandle[enHandle])
{
LogPrint("\r\nGU_OamReadPortDataInit: Open UDI ACM failed!");
return;
}
g_stAcpuDebugInfo.astPortInfo[enHandle].ulUSBOpenOkNum++;
g_stAcpuDebugInfo.astPortInfo[enHandle].ulUSBOpenOkSlice = OM_GetSlice();
/* 配置OM使用的USB通道缓存 */
if (VOS_OK != DRV_UDI_IOCTL(g_astOMPortUDIHandle[enHandle], ACM_IOCTL_RELLOC_READ_BUFF, &stReadBuffInfo))
{
LogPrint("\r\nGU_OamReadPortDataInit, DRV_UDI_IOCTL ACM_IOCTL_RELLOC_READ_BUFF Failed\r\n");
return;
}
/* 获取USB的IO CTRL口的读缓存 */
if (VOS_OK != DRV_UDI_IOCTL(g_astOMPortUDIHandle[enHandle], ACM_IOCTL_SEND_BUFF_CAN_DMA, &stReadBuffInfo))
{
LogPrint("\r\nGU_OamReadPortDataInit, DRV_UDI_IOCTL ACM_IOCTL_SEND_BUFF_CAN_DMA Failed\r\n");
return;
}
/* 注册OM使用的USB读数据回调函数 */
if (VOS_OK != DRV_UDI_IOCTL(g_astOMPortUDIHandle[enHandle], UDI_ACM_IOCTL_SET_READ_CB, pReadCB))
{
LogPrint("\r\nGU_OamReadPortDataInit, DRV_UDI_IOCTL UDI_ACM_IOCTL_SET_READ_CB Failed\r\n");
return;
}
if(VOS_OK != DRV_UDI_IOCTL(g_astOMPortUDIHandle[enHandle], ACM_IOCTL_SET_WRITE_CB, pWriteCB))
{
LogPrint("\r\nGU_OamReadPortDataInit, DRV_UDI_IOCTL ACM_IOCTL_SET_WRITE_CB Failed\r\n");
return;
}
if(VOS_OK != DRV_UDI_IOCTL(g_astOMPortUDIHandle[enHandle], ACM_IOCTL_SET_EVT_CB, pStateCB))
{
LogPrint("\r\nGU_OamReadPortDataInit, DRV_UDI_IOCTL ACM_IOCTL_SET_WRITE_CB Failed\r\n");
return;
}
/* 设置通道 0 copy */
if(VOS_OK != DRV_UDI_IOCTL(g_astOMPortUDIHandle[enHandle], ACM_IOCTL_WRITE_DO_COPY, VOS_NULL_PTR))
{
LogPrint("\r\nGU_OamReadPortDataInit, DRV_UDI_IOCTL ACM_IOCTL_WRITE_DO_COPY Failed\r\n");
return;
}
g_stAcpuDebugInfo.astPortInfo[enHandle].ulUSBOpenOk2Num++;
g_stAcpuDebugInfo.astPortInfo[enHandle].ulUSBOpenOk2Slice = OM_GetSlice();
return;
}
VOS_UINT32 GU_OamPortSend(OM_PROT_HANDLE_ENUM_UINT32 enHandle, VOS_UINT8 *pucData, VOS_UINT32 ulDataLen)
{
VOS_INT32 lRet;
ACM_WR_ASYNC_INFO stVcom;
VOS_UINT32 ulInSlice;
VOS_UINT32 ulOutSlice;
VOS_UINT32 ulWriteSlice;
VOS_CHAR aucUsbLog[100];
stVcom.pBuffer = (VOS_CHAR*)pucData;
stVcom.u32Size = ulDataLen;
stVcom.pDrvPriv= VOS_NULL_PTR;
g_stAcpuDebugInfo.astPortInfo[enHandle].ulUSBWriteNum1++;
if (VOS_ERROR == g_astOMPortUDIHandle[enHandle])
{
LogPrint("\r\nGU_OamPortSend: USB HANDLE is err. \n");
return CPM_SEND_ERR;
}
ulInSlice = OM_GetSlice();
/* 返回写入数据长度代表写操作成功 */
lRet = DRV_UDI_IOCTL(g_astOMPortUDIHandle[enHandle], ACM_IOCTL_WRITE_ASYNC, &stVcom);
g_stAcpuDebugInfo.astPortInfo[enHandle].ulUSBWriteNum2++;
ulOutSlice = OM_GetSlice();
if(ulInSlice > ulOutSlice)
{
ulWriteSlice = ulInSlice - ulOutSlice;
}
else
{
ulWriteSlice = ulOutSlice - ulInSlice;
}
if(ulWriteSlice > g_stAcpuDebugInfo.astPortInfo[enHandle].ulUSBWriteMaxTime)
{
g_stAcpuDebugInfo.astPortInfo[enHandle].ulUSBWriteMaxTime = ulWriteSlice;
}
if (BSP_OK == lRet) /*当前发送成功*/
{
return CPM_SEND_OK;
}
else if(BSP_OK > lRet) /*临时错误*/
{
/*打印信息，调用UDI接口的错误信息*/
LogPrint1("\r\nGU_OamPortSend: DRV_UDI_IOCTL Send Data return Error %d\n", lRet);
g_stAcpuDebugInfo.astPortInfo[enHandle].ulUSBWriteErrNum++;
g_stAcpuDebugInfo.astPortInfo[enHandle].ulUSBWriteErrLen += ulDataLen;
g_stAcpuDebugInfo.astPortInfo[enHandle].ulUSBWriteErrValue = (VOS_UINT32)lRet;
g_stAcpuDebugInfo.astPortInfo[enHandle].ulUSBWriteErrTime = OM_GetSlice();
if (VOS_OK != OM_AcpuGetLogPath(aucUsbLog, OM_USB_LOG_FILE, OM_USB_UNITARY_LOG_FILE))
{
return CPM_SEND_FUNC_NULL;
}
if( 0 == (g_ulUSBSendErrCnt%USB_SEND_DATA_ERROR_MAX)) /*累计丢包超过限制需要记录到log文件中*/
{
OM_Acpu_WriteLogFile(aucUsbLog, (VOS_CHAR *)&g_stAcpuDebugInfo, sizeof(OM_ACPU_DEBUG_INFO));
}
g_ulUSBSendErrCnt++;
return CPM_SEND_FUNC_NULL; /*对于临时错误，需要返回NULL丢弃数据*/
}
else /*其他错误需要复位单板*/
{
/*打印信息，调用UDI接口*/
LogPrint1("\r\nGU_OamPortSend: DRV_UDI_IOCTL Send Data return Error %d\n", lRet);
DRV_SYSTEM_ERROR(OAM_USB_SEND_ERROR, lRet, (VOS_INT)enHandle,
(VOS_CHAR *)&g_stAcpuDebugInfo, sizeof(OM_ACPU_DEBUG_INFO));
return CPM_SEND_ERR;
}
}
VOS_VOID GU_OamSocpSendDataToUDI(SOCP_CODER_DST_ENUM_U32 enChanID, VOS_UINT8 *pucData, VOS_UINT8 *pucPHYData, VOS_UINT32 ulDataLen)
{
VOS_UINT32 ulResult;
VOS_UINT32 ulRet = VOS_ERR;
CPM_PHY_PORT_ENUM_UINT32 enPhyport;
VOS_UINT32 ulSendDataLen;
VOS_BOOL bReadDoneFlag = VOS_FALSE;
VOS_BOOL bUsbSendSucFlag = VOS_FALSE;
/*参数检查*/
SOCP_SEND_DATA_PARA_CHECK(enChanID, ulDataLen, pucData);
GU_OamGetSendDataLen(ulDataLen, &ulSendDataLen, &enPhyport);
/*lint -e40*/
OM_ACPU_DEBUG_TRACE(pucData, ulSendDataLen, OM_ACPU_SEND_USB);
/*lint +e40*/
ulResult = CPM_ComSend(CPM_OM_COMM, pucData, ulSendDataLen);
OMRL_AcpuHdlcData(pucData, ulSendDataLen);
if(CPM_SEND_ERR == ulResult) /*当前通道已经发送失败，调用SOCP通道无数据搬运*/
{
g_stAcpuDebugInfo.ulUSBSendErrNum++;
g_stAcpuDebugInfo.ulUSBSendErrLen += ulSendDataLen;
bReadDoneFlag = VOS_TRUE;
}
else if(CPM_SEND_FUNC_NULL == ulResult) /*当前通道异常，扔掉所有数据*/
{
bReadDoneFlag = VOS_TRUE;
g_stAcpuDebugInfo.ulOmDiscardNum++;
g_stAcpuDebugInfo.ulOmDiscardLen += ulDataLen;
}
else if(CPM_SEND_OK == ulResult)
{
if ((CPM_APP_PORT != enPhyport)&&(CPM_CTRL_PORT != enPhyport)&&(CPM_HSIC_PORT != enPhyport)) /*对于当前是同步步发送的端口需要马上释放SOCP*/
{
bReadDoneFlag = VOS_TRUE;
}
else
{
ulRet = VOS_OK;
}
bUsbSendSucFlag = VOS_TRUE;
}
else
{
LogPrint1("GU_OamUSBWriteDataCB: CPM_ComSend return Error %d", (VOS_INT)ulResult);
}
if (VOS_TRUE == bReadDoneFlag)
{
ulRet = SCM_RlsDestBuf(SOCP_CODER_DST_GU_OM, ulSendDataLen);
if(VOS_OK != ulRet)
{
g_stAcpuDebugInfo.ulSocpReadDoneErrNum++;
g_stAcpuDebugInfo.ulSocpReadDoneErrLen += ulSendDataLen;
LogPrint1("GU_OamSocpSendDataToUDI: SCM_RlsDestBuf return Error %d", (VOS_INT)ulRet);
}
}
if ((VOS_OK == ulRet) && (VOS_TRUE == bUsbSendSucFlag))
{
g_stAcpuDebugInfo.ulUSBSendNum++;
g_stAcpuDebugInfo.ulUSBSendLen += ulSendDataLen;
if(g_stAcpuDebugInfo.ulUSBSendLen > OM_DATA_MAX_LENGTH)
{
g_stAcpuDebugInfo.ulUSBSendRealNum++;
g_stAcpuDebugInfo.ulUSBSendLen -= OM_DATA_MAX_LENGTH;
}
}
return;
}
VOS_VOID Monitor_QueryPA(VOS_INT lSimTemp)
{
VOS_INT lPaTemperature = MONITOR_DEFAULT_PA_TEMPERATURE;
VOS_INT lBatteryVoltage = MONITOR_DEFAULT_BATTERY_VOLTAGE;
VOS_UINT32 RAT_mode;
VOS_INT32 lResult = VOS_ERROR;
VOS_UINT32 ulTempType = CPHY_TEMPERATURE_TYPE_NULL;
VOS_INT32 lSimAverageTemp = 0;
VOS_UINT32 i;
RAT_mode = SHPA_GetRateType();
/* 调用底软接口，读取当前PA温度 */
if( SHPA_SYSTEM_GSM == RAT_mode )
{
lResult = DRV_GET_PA_GTEMP(&lPaTemperature, g_pusAdcTable);
}
else if( SHPA_SYSTEM_WCDMA == RAT_mode )
{
lResult = DRV_GET_PA_WTEMP(&lPaTemperature, g_pusAdcTable);
}
else
{
return;
}
if (VOS_OK != lResult)
{
LogPrint1("\r\nMonitor_QueryPA:Query Tempareture:%d.!", lResult);
return;
}
/* 保存当前温度到循环队列 */
g_ulSimTempBufPointor = g_ulSimTempBufPointor%MONITOR_SIM_TEMP_BUF_LEN;
g_lSimTempBuf[g_ulSimTempBufPointor] = lSimTemp;
g_ulSimTempBufPointor++;
/* 取温度循环队列平均值 */
for(i = 0; i < MONITOR_SIM_TEMP_BUF_LEN; i++)
{
lSimAverageTemp += g_lSimTempBuf[i];
}
lSimAverageTemp = (lSimAverageTemp/MONITOR_SIM_TEMP_BUF_LEN);
/*判断是否需要将SIM卡温度报给物理层*/
if((g_stMonitorUsimAntCtrl.sUsimHigh <= lSimAverageTemp)&&
(MONITOR_SIM_TEMP_LOW_FLAG == g_ulPHYSimTempFlag))
{
g_ulPHYSimTempFlag = MONITOR_SIM_TEMP_HIGH_FLAG;
ulTempType = CPHY_TEMPERATURE_TYPE_SIM;
}
else if((g_stMonitorUsimAntCtrl.sUsimLow > lSimAverageTemp)&&(MONITOR_SIM_TEMP_HIGH_FLAG == g_ulPHYSimTempFlag))
{
g_ulPHYSimTempFlag = MONITOR_SIM_TEMP_LOW_FLAG;
ulTempType = CPHY_TEMPERATURE_TYPE_SIM;
}
else
{
/*do nothing*/
}
/* 如果温度改变超过门限值OM_PA_TEMPERATURE_DIFF_LIMIT */
if ((( lPaTemperature + MONITOR_PA_TEMPERATURE_DIFF_LIMIT ) < g_stMonitorPAPara.lPaTemperature )
|| (( g_stMonitorPAPara.lPaTemperature + MONITOR_PA_TEMPERATURE_DIFF_LIMIT ) < lPaTemperature ))
{
g_stMonitorPAPara.lPaTemperature = lPaTemperature;
ulTempType |= CPHY_TEMPERATURE_TYPE_PA;
}
if(CPHY_TEMPERATURE_TYPE_NULL != ulTempType)
{
Monitor_WakeUpDsp(RAT_mode);
/* 将温度信息发送给DSP*/
Shpa_ProcTemperatureReq(GGPHY_MONITOR_TEMP_REQ, (VOS_INT16)lPaTemperature,
(VOS_INT16)lSimAverageTemp,ulTempType);
}
/* 调用底软接口，读取当前电池电压 */
/* 如果电压改变超过门限值OM_BATTERY_VOLTAGE_DIFF_LIMIT */
if ((( lBatteryVoltage + MONITOR_BATTERY_VOLTAGE_DIFF_LIMIT ) < g_stMonitorPAPara.lBatteryVoltage )
|| (( g_stMonitorPAPara.lBatteryVoltage + MONITOR_BATTERY_VOLTAGE_DIFF_LIMIT ) < lBatteryVoltage ))
{
g_stMonitorPAPara.lBatteryVoltage = lBatteryVoltage;
/* 将当前电池电压信息发送给DSP*/
Shpa_ProcVoltageReq(GGPHY_MONITOR_VOLTAGE_REQ, (VOS_UINT16)lBatteryVoltage);
}
return;
}
