/***************************************************************************** * 函 数 名 : BSP_IPF_SetControlFLagForCcoreReset * * 功能描述 : ccore复位时,设置IPF标志,用于控制IPF上行 * * 输入参数 : IPF_FORRESET_CONTROL_E flagvalue,0:允许;1:不允许上行 * 输出参数 : 无 * 返 回 值 : IPF_SUCCESS 初始化成功 * IPF_ERROR 初始化失败 * * 修改记录 :2013年4月19日 卢彦胜 创建 * 1.修改日期 :2013年9月12 * 修改作者 :周珊 * 修改记录 :添加入参检查、forbidden之后等待idle *****************************************************************************/ void BSP_IPF_SetControlFLagForCcoreReset(IPF_FORRESET_CONTROL_E flagvalue) { unsigned int u32UlState = 0; unsigned int u32DlState = 0; unsigned int u32Cnt = 0; /* 入参检查 */ if(IPF_FORRESET_CONTROL_MAX <= flagvalue) { IPF_PRINT_ERROR("parameter is error\n"); } /* 设置当前IPF状态 */ g_forCcore_reset_Up_flag = flagvalue; if(IPF_FORRESET_CONTROL_FORBID == flagvalue) { /* 等待IPF进入idle态(不释放CPU但加入等待超时),如果无法进入idle,则等待时间后确保IPF不再处理数据为止 */ do{ IPF_REG_READ(SOC_IPF_CH0_STATE_ADDR(IPF_REGBASE_ADR), u32UlState); IPF_REG_READ(SOC_IPF_CH1_STATE_ADDR(IPF_REGBASE_ADR), u32DlState); msleep(10); u32Cnt++; }while(((u32UlState != IPF_CH_IDLE) || (u32DlState != IPF_CH_IDLE)) && (u32Cnt <= IPF_IDLE_TIMEOUT_NUM)); if(u32UlState != IPF_CH_IDLE) { IPF_PRINT_ERROR("ul is not idle\n"); } if(u32DlState != IPF_CH_IDLE) { IPF_PRINT_ERROR("ul is not idle\n"); } } }
/***************************************************************************** * 函 数 名 : BSP_IPF_GetDlAdNum * * 功能描述 : 获取下行通道ADQ0和ADQ1队列中空闲AD个数 * * 输入参数 : 无 * * 输出参数 : pu32AD0Num 下行ADQ0队列中空闲AD个数 * pu32AD1Num 下行ADQ1队列中空闲AD个数 * 返 回 值 : IPF_SUCCESS * IPF_ERROR * * 修改记录 : 2012年11月29日 z00212992 创建 * *****************************************************************************/ int BSP_IPF_GetDlAdNum(unsigned int* pu32AD0Num, unsigned int* pu32AD1Num) { unsigned int u32DlAd0Depth = 0; unsigned int u32DlAd1Depth = 0; unsigned int u32DlAd0wptr = 0; unsigned int u32DlAd0rptr = 0; unsigned int u32DlAd1wptr = 0; unsigned int u32DlAd1rptr = 0; unsigned int u32AD0Num = 0; unsigned int u32AD1Num = 0; /*入参检测*/ if((NULL == pu32AD0Num)||(NULL == pu32AD1Num)) { IPF_PRINT_ERROR("parameter is error\n"); return BSP_ERR_IPF_INVALID_PARA; } /* 计算空闲AD0数量 */ IPF_REG_READ(SOC_IPF_CH1_ADQ0_WPTR_ADDR(IPF_REGBASE_ADR), u32DlAd0wptr); IPF_REG_READ(SOC_IPF_CH1_ADQ0_RPTR_ADDR(IPF_REGBASE_ADR), u32DlAd0rptr); if (u32DlAd0wptr >= u32DlAd0rptr)/*写指针在前,正常顺序*/ u32DlAd0Depth = IPF_DLAD0_DESC_SIZE - (u32DlAd0wptr - u32DlAd0rptr+1); else u32DlAd0Depth = u32DlAd0rptr - u32DlAd0wptr - 1; u32AD0Num = (u32DlAd0Depth > IPF_OBLIGATE_AD_NUM) ? (u32DlAd0Depth - IPF_OBLIGATE_AD_NUM) : 0; if(u32AD0Num > IPF_DLAD0_DESC_SIZE) { IPF_PRINT_ERROR("adq0 num is error\n"); return BSP_ERR_IPF_INVALID_PARA; } *pu32AD0Num = u32AD0Num; /* 计算空闲AD1数量 */ IPF_REG_READ(SOC_IPF_CH1_ADQ1_WPTR_ADDR(IPF_REGBASE_ADR), u32DlAd1wptr); IPF_REG_READ(SOC_IPF_CH1_ADQ1_RPTR_ADDR(IPF_REGBASE_ADR), u32DlAd1rptr); if (u32DlAd1wptr >= u32DlAd1rptr)/*写指针在前,正常顺序*/ u32DlAd1Depth = IPF_DLAD1_DESC_SIZE - (u32DlAd1wptr - u32DlAd1rptr+1); else u32DlAd1Depth = u32DlAd1rptr - u32DlAd1wptr - 1; u32AD1Num = (u32DlAd1Depth > IPF_OBLIGATE_AD_NUM) ? (u32DlAd1Depth - IPF_OBLIGATE_AD_NUM) : 0; if(u32AD1Num > IPF_DLAD1_DESC_SIZE) { IPF_PRINT_ERROR("adq1 num is error\n"); return BSP_ERR_IPF_INVALID_PARA; } *pu32AD1Num = u32AD1Num; return IPF_SUCCESS; }
/***************************************************************************** * 函 数 名 : BSP_IPF_GetDlRdNum * * 功能描述 : 该接口用于获取下行通道中可以读取RD个数 * * 输入参数 : * * 输出参数 : * * 返 回 值 : unsigned int 可以读取的RD数目 * * 修改记录 :2012年11月29日 z00212992 创建 *****************************************************************************/ unsigned int BSP_IPF_GetDlRdNum(void) { SOC_IPF_CH1_DQ_DEPTH_UNION unRdqDepth; /* 读取上行RD深度寄存器 */ unRdqDepth.value = 0; IPF_REG_READ(SOC_IPF_CH1_DQ_DEPTH_ADDR(IPF_REGBASE_ADR), unRdqDepth.value); return unRdqDepth.reg.dl_rdq_depth; }
/***************************************************************************** * 函 数 名 : BSP_IPF_UlStateIdle * * 功能描述 : 该接口用于获取上行通道是否为空闲 * * 输入参数 : 无 * * 输出参数 : 无 * 返 回 值 : IPF_SUCCESS 表示上行空闲,可以切换模式 * IPF_ERROR 表示上行非空闲,不可以切换模式 * * 修改记录 :2011年12月9日 鲁婷 创建 *****************************************************************************/ int BSP_IPF_UlStateIdle(void) { unsigned int u32UlState = 0; IPF_REG_READ(SOC_IPF_CH0_STATE_ADDR(IPF_REGBASE_ADR), u32UlState); if(u32UlState != IPF_CH_IDLE) { return IPF_ERROR; } return IPF_SUCCESS; }
/***************************************************************************** * 函 数 名 : BSP_IPF_GetUlBDNum * * 功能描述 : 该接口用于获取上行空闲BD 数目 * * 输入参数 : 无 * * 输出参数 : 无 * 返 回 值 : 空闲BD数目 * * 修改记录 :2011年11月30日 鲁婷 创建 *****************************************************************************/ unsigned int BSP_IPF_GetUlBDNum(void) { SOC_IPF_CH0_DQ_DEPTH_UNION unUlBdDepth; unsigned int u32IdleBd = 0; unUlBdDepth.value = 0; /* 计算空闲BD数量 */ IPF_REG_READ(SOC_IPF_CH0_DQ_DEPTH_ADDR(IPF_REGBASE_ADR), unUlBdDepth.value); u32IdleBd = IPF_ULBD_DESC_SIZE - unUlBdDepth.reg.ul_bdq_depth; *(g_stIpfUl.pu32IdleBd) = u32IdleBd; return u32IdleBd; }
BSP_S32 BSP_IPF_RegDump(BSP_VOID) { BSP_U32 i = 0; BSP_U32 u32RegValue = 0; IPF_PRINT("============BEGIN===========\n"); for(i = 0; i < IPF_REG_NUM; i++) { IPF_REG_READ(IPF_REG_OFFSET_TO_ADDR(i), u32RegValue); IPF_PRINT("[0x%x]: 0x%x\n", IPF_REG_OFFSET_TO_ADDR(i), u32RegValue); } IPF_PRINT("=============END============\n"); return 0; }
/***************************************************************************** * 函 数 名 : IPF_ObligateAdqRpt * * 功能描述 : 根据adq状态寄存器和当前adq读指针获取adq回退读指针 * * 输入参数 : eChId 通道ID * eType AD类型 * 输出参数 : pu32Rpt 保存AD读指针 * 返 回 值 : IPF_SUCCESS 成功 * IPF_ERROR(其他错误码) 失败 * * 修改记录 : 2013年9月9日 z00212992 创建 * 1.修改日期 : 2014年05月27日 * 修改作者 : z00212992 * 修改记录 : 芯片修改adq buff预读机制,软件不再需要根据adq状态寄存器来获取adq读指针 *****************************************************************************/ static int IPF_ObligateAdqRpt(IPF_CHANNEL_TYPE_E eChId, IPF_AD_TYPE_E eType, unsigned int *pu32Rpt) { unsigned int u32Index = 0; unsigned int u32RptValue = 0; IPF_ADQ_INFO_S *pIpfAdqReg = NULL; /* ADQ读指针和状态寄存器表 */ IPF_ADQ_INFO_S stIpfAdqReg[4] = {{0}}; pIpfAdqReg = &stIpfAdqReg[0]; pIpfAdqReg->pu32RptReg = (unsigned int *)(SOC_IPF_CH0_ADQ0_RPTR_ADDR(IPF_REGBASE_ADR)); pIpfAdqReg = &stIpfAdqReg[1]; pIpfAdqReg->pu32RptReg = (unsigned int *)(SOC_IPF_CH0_ADQ1_RPTR_ADDR(IPF_REGBASE_ADR)); pIpfAdqReg = &stIpfAdqReg[2]; pIpfAdqReg->pu32RptReg = (unsigned int *)(SOC_IPF_CH1_ADQ0_RPTR_ADDR(IPF_REGBASE_ADR)); pIpfAdqReg = &stIpfAdqReg[3]; pIpfAdqReg->pu32RptReg = (unsigned int *)(SOC_IPF_CH1_ADQ1_RPTR_ADDR(IPF_REGBASE_ADR)); /* 入参检查 */ if((IPF_CHANNEL_MAX <= eChId) || (IPF_AD_MAX <= eType) || (NULL == pu32Rpt)) { IPF_PRINT_ERROR("parameter is error\n"); return BSP_ERR_IPF_INVALID_PARA; } /* 根据通道ID和AD类型获取操作寄存器对象index值 */ switch (eChId) { case IPF_CHANNEL_UP: u32Index = (IPF_AD_0 == eType) ? 0 : 1; break; case IPF_CHANNEL_DOWN: u32Index = (IPF_AD_0 == eType) ? 2 : 3; break; default: IPF_PRINT_ERROR("parameter is error\n"); u32Index = 0; break; } /* 读取ADQ读指针寄存器 */ IPF_REG_READ(stIpfAdqReg[u32Index].pu32RptReg, u32RptValue); /* 保存ADQ读指针 */ *pu32Rpt = u32RptValue; return IPF_SUCCESS; }
/***************************************************************************** * 函 数 名 : BSP_IPF_GetDlRd * * 功能描述 : 该接口用于读取下行BD, 支持一次读取多个BD * * 输入参数 : unsigned int* pu32Num * IPF_RD_DESC_S *pstRd * * 输出参数 : unsigned int* pu32Num 实际读取的RD数目 * * 返 回 值 : IPF_SUCCESS 操作成功 * IPF_ERROR 操作失败 * * 修改记录 :2011年11月30日 鲁婷 创建 * 1.修改日期 : 2012年8月4日 * 修改作者 : z00212992 * 修改记录 : 源地址内存释放上移修改 *****************************************************************************/ void BSP_IPF_GetDlRd(unsigned int* pu32Num, IPF_RD_DESC_S *pstRd) { SOC_IPF_CH1_DQ_DEPTH_UNION unDqDepth; unsigned int u32CdqRptr = 0; unsigned int u32RdqRptr = 0; unsigned int u32RdqDepth = 0; unsigned int u32Num = 0; unsigned int i = 0; if((NULL == pu32Num) || (NULL == pstRd)) { IPF_PRINT_ERROR("parameter is error\n"); return; } /* 读取RD深度 */ unDqDepth.value = 0; IPF_REG_READ(SOC_IPF_CH1_DQ_DEPTH_ADDR(IPF_REGBASE_ADR), unDqDepth.value); u32RdqDepth = unDqDepth.reg.dl_rdq_depth; u32Num = (u32RdqDepth < *pu32Num)?u32RdqDepth:*pu32Num; if(u32Num > 0) { g_stIPFDebugInfo->u32DlRdNum += u32Num; for(i = 0; i < u32Num; i++) { /* 读取RD读指针 */ IPF_REG_READ(SOC_IPF_CH1_RDQ_RPTR_ADDR(IPF_REGBASE_ADR), u32RdqRptr); if(u32RdqRptr >= IPF_DLRD_DESC_SIZE) { IPF_PRINT_ERROR("u32RdqRptr = %d\n", u32RdqRptr); } /* 获取RD */ pstRd[i].u16Attribute = g_stIpfDl.pstIpfRDQ[u32RdqRptr].u16Attribute; pstRd[i].u16PktLen = g_stIpfDl.pstIpfRDQ[u32RdqRptr].u16PktLen; pstRd[i].u16Result = g_stIpfDl.pstIpfRDQ[u32RdqRptr].u16Result; pstRd[i].u32InPtr = g_stIpfDl.pstIpfRDQ[u32RdqRptr].u32InPtr; pstRd[i].u32OutPtr = g_stIpfDl.pstIpfRDQ[u32RdqRptr].u32OutPtr; if((0 == pstRd[i].u32OutPtr)/* || (0x55555555 == pstRd[i].u32OutPtr) || (0xAAAAAAAA == pstRd[i].u32OutPtr)*/) { IPF_PRINT_ERROR("invalid rd of dl\n"); IPF_Assert(BSP_ERR_IPF_INVALID_DLRD); } pstRd[i].u16UsrField1 = g_stIpfDl.pstIpfRDQ[u32RdqRptr].u16UsrField1; pstRd[i].u32UsrField2 = g_stIpfDl.pstIpfRDQ[u32RdqRptr].u32UsrField2; pstRd[i].u32UsrField3 = g_stIpfDl.pstIpfRDQ[u32RdqRptr].u32UsrField3; u32RdqRptr = ((u32RdqRptr+1) < IPF_DLRD_DESC_SIZE)?(u32RdqRptr+1):0; /* 更新RD读指针 */ IPF_REG_WRITE(SOC_IPF_CH1_RDQ_RPTR_ADDR(IPF_REGBASE_ADR), u32RdqRptr); /* 更新CD读指针 */ u32CdqRptr = (unsigned int)((char *)(HISI_VA_ADDRESS(pstRd[i].u32InPtr)) - (char *)g_stIpfDl.pstIpfCDQ)/sizeof(IPF_CD_DESC_S); while(g_stIpfDl.pstIpfCDQ[u32CdqRptr].u16Attribute != 1) { /* 将释放的CD清0 */ g_stIpfDl.pstIpfCDQ[u32CdqRptr].u16Attribute = 0; g_stIpfDl.pstIpfCDQ[u32CdqRptr].u16PktLen = 0; g_stIpfDl.pstIpfCDQ[u32CdqRptr].u32Ptr = 0; u32CdqRptr = ((u32CdqRptr+1) < IPF_DLCD_DESC_SIZE)?(u32CdqRptr+1):0; } u32CdqRptr = ((u32CdqRptr+1) < IPF_DLCD_DESC_SIZE)?(u32CdqRptr+1):0; *(g_stIpfDl.u32IpfCdRptr) = u32CdqRptr; } } *pu32Num = u32Num; }
/***************************************************************************** * 函 数 名 : BSP_IPF_GetUlDescNum * * 功能描述 : 该接口用于读取上行可发送包数 * * 输入参数 : 无 * * 输出参数 : 无 * * 返 回 值 : 上行可发送包数 * * 修改记录 :2013年12月17日 z00212992 创建 *****************************************************************************/ unsigned int BSP_IPF_GetUlDescNum(void) { unsigned int u32UlAd0Num = 0; unsigned int u32UlAd1Num = 0; unsigned int u32UlBdNum = 0; unsigned int u32UlAdwptr = 0; unsigned int u32UlAdrptr = 0; unsigned int u32UlBdDepth = 0; SOC_IPF_CH0_DQ_DEPTH_UNION unDQDepth; /* 计算BD深度 */ unDQDepth.value = 0; IPF_REG_READ(SOC_IPF_CH0_DQ_DEPTH_ADDR(IPF_REGBASE_ADR), unDQDepth.value); u32UlBdDepth = unDQDepth.reg.ul_bdq_depth; /* 计算空闲AD0数量 */ IPF_REG_READ(SOC_IPF_CH0_ADQ0_WPTR_ADDR(IPF_REGBASE_ADR), u32UlAdwptr); IPF_REG_READ(SOC_IPF_CH0_ADQ0_RPTR_ADDR(IPF_REGBASE_ADR), u32UlAdrptr); /*写指针在前,正常顺序*/ if (u32UlAdwptr >= u32UlAdrptr) { u32UlAd0Num = u32UlAdwptr - u32UlAdrptr; } else { u32UlAd0Num = IPF_ULAD0_DESC_SIZE - (u32UlAdrptr -u32UlAdwptr); } if(u32UlAd0Num > u32UlBdDepth) { u32UlAd0Num -= u32UlBdDepth; } else { u32UlAd0Num = 0; g_stIPFDebugInfo->u32UlAd0NotEnough++; } /* 计算空闲AD1数量 */ IPF_REG_READ(SOC_IPF_CH0_ADQ1_WPTR_ADDR(IPF_REGBASE_ADR), u32UlAdwptr); IPF_REG_READ(SOC_IPF_CH0_ADQ1_RPTR_ADDR(IPF_REGBASE_ADR), u32UlAdrptr); if (u32UlAdwptr >= u32UlAdrptr)/*写指针在前,正常顺序*/ { u32UlAd1Num = u32UlAdwptr - u32UlAdrptr; } else { u32UlAd1Num = IPF_ULAD1_DESC_SIZE - (u32UlAdrptr -u32UlAdwptr); } if(u32UlAd1Num > u32UlBdDepth) { u32UlAd1Num -= u32UlBdDepth; } else { u32UlAd1Num = 0; g_stIPFDebugInfo->u32UlAd1NotEnough++; } u32UlBdNum = BSP_IPF_GetUlBDNum(); if(0 == u32UlBdNum) { g_stIPFDebugInfo->u32UlBdNotEnough++; } if(u32UlBdNum > u32UlAd0Num) { u32UlBdNum = u32UlAd0Num; } if(u32UlBdNum > u32UlAd1Num) { u32UlBdNum = u32UlAd1Num; } return u32UlBdNum; }
/***************************************************************************** * 函 数 名 : BSP_IPF_ConfigUpFilter * * 功能描述 : IPF上行IP过滤函数 * * 输入参数 : unsigned int u32Num, IPF_CONFIG_ULPARAM_S* pstUlPara, BSP_BOOL bintFlag * 输出参数 : 无 * 返 回 值 : IPF_SUCCESS 配置成功 * IPF_ERROR 配置失败 * BSP_ERR_IPF_NOT_INIT 模块未初始化 * BSP_ERR_IPF_INVALID_PARA 参数错误 * * 修改记录 :2011年11月30日 鲁婷 创建 * 1.修改日期 : 2012年11月29日 * 修改作者 : z00212992 * 修改记录 : 增加IPF备份恢复机制修改 *****************************************************************************/ int BSP_IPF_ConfigUpFilter(unsigned int u32Num, IPF_CONFIG_ULPARAM_S* pstUlPara) { unsigned int i = 0; unsigned int u32BdqWptr = 0; IPF_CONFIG_ULPARAM_S* pstUlParam = pstUlPara; #ifdef __BSP_IPF_DEBUG__ SOC_IPF_CH0_ADQ_CTRL_UNION unCh0AdqCtrl; #endif /*Modify_for_c_reset, l00212112,20130511, starts*/ /*如果C核复位,则返回*/ if (IPF_FORRESET_CONTROL_FORBID == IPF_GetControlFLagForCcoreReset()) { IPF_PRINT_ERROR("ccore is resetting\n"); return BSP_ERR_IPF_CCORE_RESETTING; } /*Modify_for_c_reset, l00212112,20130511, ends*/ /* 参数检查 */ if((NULL == pstUlPara)) { IPF_PRINT_ERROR("point is null\n"); return BSP_ERR_IPF_INVALID_PARA; } /* 检查模块是否初始化 */ IPF_INIT_CHECK(); if(u32Num > *(g_stIpfUl.pu32IdleBd)) { #ifdef __BSP_IPF_DEBUG__ g_stIPFDebugInfo->u32UlBdNotEnough++; #endif return IPF_ERROR; } #ifdef __BSP_IPF_DEBUG__ IPF_REG_READ(SOC_IPF_CH0_ADQ_CTRL_ADDR(IPF_REGBASE_ADR), unCh0AdqCtrl.value); if(unCh0AdqCtrl.reg.ul_adq_en != IPF_BOTH_ADQ_EN) { IPF_PRINT_ERROR("adq is not supported\n"); return IPF_ERROR; } g_stIPFDebugInfo->u32UlBdNum += u32Num; #endif /* 确保IPF已恢复 */ if(IPF_ERROR == IPF_WaitResume()) { IPF_PRINT_ERROR("wait for resume timeout\n"); g_stIPFDebugInfo->u32UlResumeTimeoutCnt++; return BSP_ERR_IPF_RESUME_TIMEOUT; } /* 读出BD写指针,将u32BdqWptr作为临时写指针使用 */ IPF_REG_READ(SOC_IPF_CH0_BDQ_WPTR_ADDR(IPF_REGBASE_ADR), u32BdqWptr); for(i = 0; i < u32Num; i++) { if(0 == pstUlParam[i].u32Data) { IPF_PRINT_ERROR("ulbd inptr is null\n"); return BSP_ERR_IPF_INVALID_PARA; } if(0 == pstUlParam[i].u16Len) { IPF_PRINT_ERROR("ulbd len is zero\n"); g_stIPFDebugInfo->u32UlBdSizeErr = 1; return BSP_ERR_IPF_INVALID_PARA; } g_stIpfUl.pstIpfBDQ[u32BdqWptr].u16Attribute = pstUlParam[i].u16Attribute; g_stIpfUl.pstIpfBDQ[u32BdqWptr].u32InPtr = pstUlParam[i].u32Data; g_stIpfUl.pstIpfBDQ[u32BdqWptr].u16PktLen = pstUlParam[i].u16Len; g_stIpfUl.pstIpfBDQ[u32BdqWptr].u16UsrField1 = pstUlParam[i].u16UsrField1; g_stIpfUl.pstIpfBDQ[u32BdqWptr].u32UsrField2= pstUlParam[i].u32UsrField2; g_stIpfUl.pstIpfBDQ[u32BdqWptr].u32UsrField3 = pstUlParam[i].u32UsrField3; u32BdqWptr = ((u32BdqWptr + 1) < IPF_ULBD_DESC_SIZE)? (u32BdqWptr + 1) : 0; } /* 更新BD写指针*/ IPF_REG_WRITE(SOC_IPF_CH0_BDQ_WPTR_ADDR(IPF_REGBASE_ADR), u32BdqWptr); return IPF_SUCCESS; }
/***************************************************************************** * 函 数 名 : IPF_IntHandler * * 功能描述 : IPF中断处理函数 * * 输入参数 : 无 * 输出参数 : 无 * 返 回 值 : 无 * * 修改记录 :2011年1月24日 鲁婷 创建 * 1.修改日期 : 2012年11月29日 * 修改作者 : z00212992 * 修改记录 : 增加ADQ队列为空中断处理 * 2.修改日期 : 2012年1月28日 * 修改作者 : z00212992 * 修改记录 : DTS2013012800111 *****************************************************************************/ irqreturn_t IPF_IntHandler (int irq, void* dev) { unsigned int u32IpfAdqInt = 0; SOC_IPF_INT1_UNION unIpfInt; unIpfInt.value = 0; /* 读取中断状态 */ IPF_REG_READ(SOC_IPF_INT1_ADDR(IPF_REGBASE_ADR), unIpfInt.value); /* 下行结果上报和结果超时上报 */ if((unIpfInt.reg.dl_rpt_int1) || (unIpfInt.reg.dl_timeout_int1)) { /* 写1清除下行结果和结果超时中断 */ IPF_REG_WRITE(SOC_IPF_INT_STATE_ADDR(IPF_REGBASE_ADR), (IPF_DL_RPT_INT | IPF_DL_TIMEOUT_INT)); #ifdef __BSP_IPF_DEBUG__ if(unIpfInt.reg.dl_rpt_int1) { g_stIPFDebugInfo->u32DlResultCnt++; } if(unIpfInt.reg.dl_timeout_int1) { g_stIPFDebugInfo->u32DlResultTimeoutCnt++; } #endif /* 唤醒ps下行任务 */ if(g_stIpfDl.pFnDlIntCb != NULL) { (void)g_stIpfDl.pFnDlIntCb(); } else { IPF_PRINT_ERROR("dl int callback is null\n"); } } /* 下行ADQ0、ADQ1空指示 */ if((unIpfInt.reg.dl_adq0_epty_int1) || (unIpfInt.reg.dl_adq1_epty_int1)) { /* 写1清除下行ADQ、ADQ1空中断 */ IPF_REG_WRITE(SOC_IPF_INT_STATE_ADDR(IPF_REGBASE_ADR), (IPF_DL_ADQ0_EMPTY_INT | IPF_DL_ADQ1_EMPTY_INT)); if(unIpfInt.reg.dl_adq0_epty_int1) { #ifdef __BSP_IPF_DEBUG__ g_stIPFDebugInfo->u32DlAdq0Empty++; #endif u32IpfAdqInt += IPF_EMPTY_ADQ0; } if(unIpfInt.reg.dl_adq1_epty_int1) { #ifdef __BSP_IPF_DEBUG__ g_stIPFDebugInfo->u32DlAdq1Empty++; #endif u32IpfAdqInt += IPF_EMPTY_ADQ1; } if(g_stIpfDl.pAdqEmptyDlCb != NULL) { (void)g_stIpfDl.pAdqEmptyDlCb(u32IpfAdqInt); } else { IPF_PRINT_ERROR("dl adq callback is null\n"); } } return IRQ_HANDLED; }
/***************************************************************************** * 函 数 名 : BSP_IPF_GetUsedDlAd * * 功能描述 : 获取下行ADQ队列中已经被配置使用的AD信息,调用者必须确保调用过程中不会再配置BD * * 输入参数 : eAdType 下行AD的类型 * 输出参数 : pu32AdNum 保存该下行AD类型队列中已经被配置使用的AD数目指针 * pstAdDesc 保存该下行AD类型队列中已经被配置使用的AD结构体指针 (需要调用者事先申请好,大小为IPF_DLAD_DESC_SIZE*IPF_AD_DESC_S) * 返 回 值 : IPF_SUCCESS 成功 * IPF_ERROR(其他错误码) 失败 * * 修改记录 : 2013年9月9日 z00212992 创建 * *****************************************************************************/ int BSP_IPF_GetUsedDlAd(IPF_AD_TYPE_E eAdType, unsigned int *pu32AdNum, IPF_AD_DESC_S *pstAdDesc) { unsigned int i = 0; unsigned int u32IpfAdqRpt = 0; unsigned int u32IpfAdqWpt = 0; unsigned int u32IpfAdqSize = 0; IPF_AD_DESC_S *pstIpfADQ = (IPF_AD_DESC_S*)NULL; unsigned int u32AdNum = 0; /* 入参检查 */ if((IPF_AD_MAX <= eAdType)|| (NULL == pu32AdNum) || (NULL == pstAdDesc)) { IPF_PRINT_ERROR("parameter is error\n"); return BSP_ERR_IPF_INVALID_PARA; } /* 获取真实的读指针 */ if(IPF_SUCCESS != IPF_ObligateAdqRpt(IPF_CHANNEL_DOWN, eAdType, &u32IpfAdqRpt)) { IPF_PRINT_ERROR("IPF_ObligateAdqRpt error\n"); return IPF_ERROR; } /* 根据通道ID和AD类型获取操作寄存器对象(写指针、大小、队列) */ switch (eAdType) { case IPF_AD_0: IPF_REG_READ(SOC_IPF_CH1_ADQ0_WPTR_ADDR(IPF_REGBASE_ADR), u32IpfAdqWpt); u32IpfAdqSize = IPF_DLAD0_DESC_SIZE; pstIpfADQ = g_stIpfDl.pstIpfADQ0; break; case IPF_AD_1: IPF_REG_READ(SOC_IPF_CH1_ADQ1_WPTR_ADDR(IPF_REGBASE_ADR), u32IpfAdqWpt); u32IpfAdqSize = IPF_DLAD1_DESC_SIZE; pstIpfADQ = g_stIpfDl.pstIpfADQ1; break; default: IPF_PRINT_ERROR("parameter is error\n"); break; } if((IPF_AD_DESC_S*)NULL == pstIpfADQ) { return BSP_ERR_IPF_INVALID_PARA; } /* 根据获取下行ADQ队列(对应类型)中已经被配置使用的AD信息,并传给pu32AdNum和pstAdDesc */ for(i = u32IpfAdqRpt; i != u32IpfAdqWpt; i %= u32IpfAdqSize) { if(NULL == pstAdDesc) { IPF_PRINT_ERROR("point is null\n"); return BSP_ERR_IPF_INVALID_PARA; } pstAdDesc->u32OutPtr0 = pstIpfADQ[i].u32OutPtr0; pstAdDesc->u32OutPtr1 = pstIpfADQ[i].u32OutPtr1; u32AdNum++; pstAdDesc++; i++; } *pu32AdNum = u32AdNum; return IPF_SUCCESS; }
/***************************************************************************** * 函 数 名 : BSP_IPF_ConfigDlAd * * 功能描述 : 配置下行ADQ队列,给空闲的AD分配新的内存缓冲区 * * 输入参数 : eAdType 配置下行AD的类型 * u32AdNum 配置下行AD的数目 * pstAdDesc 下行AD分配的缓存空间对应的数据结构首地址 * 输出参数 : 无 * * 返 回 值 : IPF_SUCCESS * IPF_ERROR * * 修改记录 : 2012年11月29日 z00212992 创建 * *****************************************************************************/ int BSP_IPF_ConfigDlAd(IPF_AD_TYPE_E eAdType, unsigned int u32AdNum, IPF_AD_DESC_S *pstAdDesc ) { unsigned int i; unsigned int u32ADQ0wptr; unsigned int u32ADQ1wptr; /*Modify_for_c_reset, l00212112,20130511, starts*/ /*如果C核复位,则返回*/ if (IPF_FORRESET_CONTROL_FORBID == IPF_GetControlFLagForCcoreReset()) { IPF_PRINT_ERROR("ccore is resetting\n"); return BSP_ERR_IPF_CCORE_RESETTING; } /*Modify_for_c_reset, l00212112,20130511, ends*/ /* 入参检查 */ if((IPF_AD_MAX <= eAdType) || (NULL == pstAdDesc)) { IPF_PRINT_ERROR("parameter is error\n"); return BSP_ERR_IPF_INVALID_PARA; } /* 检查模块是否初始化 */ IPF_INIT_CHECK(); if(IPF_AD_0 == eAdType) { g_stIPFDebugInfo->u32DlAdq0Num += u32AdNum; /* 读取ADQ0写指针 */ IPF_REG_READ(SOC_IPF_CH1_ADQ0_WPTR_ADDR(IPF_REGBASE_ADR), u32ADQ0wptr); /* 获取目的结构体指针和目的结构体数据指针,插入到ADQ中 */ for(i=0; i < u32AdNum; i++) { if((0 == pstAdDesc[i].u32OutPtr0) || (0 == pstAdDesc[i].u32OutPtr1)) { IPF_PRINT_ERROR("point is null\n"); return BSP_ERR_IPF_INVALID_PARA; } g_stIpfDl.pstIpfADQ0[u32ADQ0wptr].u32OutPtr0 = pstAdDesc[i].u32OutPtr0; g_stIpfDl.pstIpfADQ0[u32ADQ0wptr].u32OutPtr1 = pstAdDesc[i].u32OutPtr1; u32ADQ0wptr = ((u32ADQ0wptr + 1) < IPF_DLAD0_DESC_SIZE)? (u32ADQ0wptr + 1) : 0; } /* 更新ADQ0写指针 */ IPF_REG_WRITE(SOC_IPF_CH1_ADQ0_WPTR_ADDR(IPF_REGBASE_ADR), u32ADQ0wptr); } else { g_stIPFDebugInfo->u32DlAdq1Num += u32AdNum; /* 读取ADQ1写指针 */ IPF_REG_READ(SOC_IPF_CH1_ADQ1_WPTR_ADDR(IPF_REGBASE_ADR), u32ADQ1wptr); /* 获取目的结构体指针和目的结构体数据指针,插入到ADQ中 */ for(i=0; i < u32AdNum; i++) { if((0 == pstAdDesc[i].u32OutPtr0) || (0 == pstAdDesc[i].u32OutPtr1)) { IPF_PRINT_ERROR("point is null\n"); return BSP_ERR_IPF_INVALID_PARA; } g_stIpfDl.pstIpfADQ1[u32ADQ1wptr].u32OutPtr0 = pstAdDesc[i].u32OutPtr0; g_stIpfDl.pstIpfADQ1[u32ADQ1wptr].u32OutPtr1 = pstAdDesc[i].u32OutPtr1; u32ADQ1wptr = ((u32ADQ1wptr + 1) < IPF_DLAD1_DESC_SIZE)? (u32ADQ1wptr + 1) : 0; } /* 更新ADQ1写指针 */ IPF_REG_WRITE(SOC_IPF_CH1_ADQ1_WPTR_ADDR(IPF_REGBASE_ADR), u32ADQ1wptr); } return IPF_SUCCESS; }
BSP_S32 BSP_IPF_CHInfo(IPF_CHANNEL_TYPE_E eChnType) { BSP_U32 u32ChanCtrlInfo = 0; BSP_U32 u32ChanStateInfo = 0; BSP_U32 u32BdqBaseAddr = 0; BSP_U32 u32BdqDepth = 0; BSP_U32 u32BdqWptr = 0; BSP_U32 u32BdqRptr = 0; BSP_U32 u32BdqWaddr = 0; BSP_U32 u32BdqRaddr = 0; BSP_U32 u32RdqBaseAddr = 0; BSP_U32 u32RdqDepth = 0; BSP_U32 u32RdqRptr = 0; BSP_U32 u32RdqWptr = 0; BSP_U32 u32RdqWaddr = 0; BSP_U32 u32RdqRaddr = 0; BSP_U32 u32Depth = 0; BSP_U32 u32AdqCtrlInfo = 0; BSP_U32 u32Adq0BaseAddr = 0; BSP_U32 u32Adq0StateInfo = 0; BSP_U32 u32Adq0Wptr = 0; BSP_U32 u32Adq0Rptr = 0; BSP_U32 u32Adq1BaseAddr = 0; BSP_U32 u32Adq1StateInfo = 0; BSP_U32 u32Adq1Wptr = 0; BSP_U32 u32Adq1Rptr = 0; switch (eChnType) { case IPF_CHANNEL_UP: IPF_REG_READ(SOC_IPF_CH0_CTRL_ADDR(IPF_REGBASE_ADR), u32ChanCtrlInfo); IPF_REG_READ(SOC_IPF_CH0_STATE_ADDR(IPF_REGBASE_ADR), u32ChanStateInfo); IPF_REG_READ(SOC_IPF_CH0_BDQ_BADDR_ADDR(IPF_REGBASE_ADR), u32BdqBaseAddr); IPF_REG_READ(SOC_IPF_CH0_BDQ_SIZE_ADDR(IPF_REGBASE_ADR), u32BdqDepth); IPF_REG_READ(SOC_IPF_CH0_BDQ_WPTR_ADDR(IPF_REGBASE_ADR), u32BdqWptr); IPF_REG_READ(SOC_IPF_CH0_BDQ_RPTR_ADDR(IPF_REGBASE_ADR), u32BdqRptr); IPF_REG_READ(SOC_IPF_CH0_BDQ_WADDR_ADDR(IPF_REGBASE_ADR), u32BdqWaddr); IPF_REG_READ(SOC_IPF_CH0_BDQ_RADDR_ADDR(IPF_REGBASE_ADR), u32BdqRaddr); IPF_REG_READ(SOC_IPF_CH0_RDQ_BADDR_ADDR(IPF_REGBASE_ADR), u32RdqBaseAddr); IPF_REG_READ(SOC_IPF_CH0_RDQ_SIZE_ADDR(IPF_REGBASE_ADR), u32RdqDepth); IPF_REG_READ(SOC_IPF_CH0_RDQ_RPTR_ADDR(IPF_REGBASE_ADR), u32RdqRptr); IPF_REG_READ(SOC_IPF_CH0_RDQ_WPTR_ADDR(IPF_REGBASE_ADR), u32RdqWptr); IPF_REG_READ(SOC_IPF_CH0_RDQ_WADDR_ADDR(IPF_REGBASE_ADR), u32RdqWaddr); IPF_REG_READ(SOC_IPF_CH0_RDQ_RADDR_ADDR(IPF_REGBASE_ADR), u32RdqRaddr); IPF_REG_READ(SOC_IPF_CH0_DQ_DEPTH_ADDR(IPF_REGBASE_ADR), u32Depth); IPF_REG_READ(SOC_IPF_CH0_ADQ_CTRL_ADDR(IPF_REGBASE_ADR), u32AdqCtrlInfo); IPF_REG_READ(SOC_IPF_CH0_ADQ0_BASE_ADDR(IPF_REGBASE_ADR), u32Adq0BaseAddr); IPF_REG_READ(SOC_IPF_CH0_ADQ0_STAT_ADDR(IPF_REGBASE_ADR), u32Adq0StateInfo); IPF_REG_READ(SOC_IPF_CH0_ADQ0_WPTR_ADDR(IPF_REGBASE_ADR), u32Adq0Wptr); IPF_REG_READ(SOC_IPF_CH0_ADQ0_RPTR_ADDR(IPF_REGBASE_ADR), u32Adq0Rptr); IPF_REG_READ(SOC_IPF_CH0_ADQ1_BASE_ADDR(IPF_REGBASE_ADR), u32Adq1BaseAddr); IPF_REG_READ(SOC_IPF_CH0_ADQ1_STAT_ADDR(IPF_REGBASE_ADR), u32Adq1StateInfo); IPF_REG_READ(SOC_IPF_CH0_ADQ1_WPTR_ADDR(IPF_REGBASE_ADR), u32Adq1Wptr); IPF_REG_READ(SOC_IPF_CH0_ADQ1_RPTR_ADDR(IPF_REGBASE_ADR), u32Adq1Rptr); break; case IPF_CHANNEL_DOWN: IPF_REG_READ(SOC_IPF_CH1_CTRL_ADDR(IPF_REGBASE_ADR), u32ChanCtrlInfo); IPF_REG_READ(SOC_IPF_CH1_STATE_ADDR(IPF_REGBASE_ADR), u32ChanStateInfo); IPF_REG_READ(SOC_IPF_CH1_BDQ_BADDR_ADDR(IPF_REGBASE_ADR), u32BdqBaseAddr); IPF_REG_READ(SOC_IPF_CH1_BDQ_SIZE_ADDR(IPF_REGBASE_ADR), u32BdqDepth); IPF_REG_READ(SOC_IPF_CH1_BDQ_WPTR_ADDR(IPF_REGBASE_ADR), u32BdqWptr); IPF_REG_READ(SOC_IPF_CH1_BDQ_RPTR_ADDR(IPF_REGBASE_ADR), u32BdqRptr); IPF_REG_READ(SOC_IPF_CH1_BDQ_WADDR_ADDR(IPF_REGBASE_ADR), u32BdqWaddr); IPF_REG_READ(SOC_IPF_CH1_BDQ_RADDR_ADDR(IPF_REGBASE_ADR), u32BdqRaddr); IPF_REG_READ(SOC_IPF_CH1_RDQ_BADDR_ADDR(IPF_REGBASE_ADR), u32RdqBaseAddr); IPF_REG_READ(SOC_IPF_CH1_RDQ_SIZE_ADDR(IPF_REGBASE_ADR), u32RdqDepth); IPF_REG_READ(SOC_IPF_CH1_RDQ_RPTR_ADDR(IPF_REGBASE_ADR), u32RdqRptr); IPF_REG_READ(SOC_IPF_CH1_RDQ_WPTR_ADDR(IPF_REGBASE_ADR), u32RdqWptr); IPF_REG_READ(SOC_IPF_CH1_RDQ_WADDR_ADDR(IPF_REGBASE_ADR), u32RdqWaddr); IPF_REG_READ(SOC_IPF_CH1_RDQ_RADDR_ADDR(IPF_REGBASE_ADR), u32RdqRaddr); IPF_REG_READ(SOC_IPF_CH1_DQ_DEPTH_ADDR(IPF_REGBASE_ADR), u32Depth); IPF_REG_READ(SOC_IPF_CH1_ADQ_CTRL_ADDR(IPF_REGBASE_ADR), u32AdqCtrlInfo); IPF_REG_READ(SOC_IPF_CH1_ADQ0_BASE_ADDR(IPF_REGBASE_ADR), u32Adq0BaseAddr); IPF_REG_READ(SOC_IPF_CH1_ADQ0_STAT_ADDR(IPF_REGBASE_ADR), u32Adq0StateInfo); IPF_REG_READ(SOC_IPF_CH1_ADQ0_WPTR_ADDR(IPF_REGBASE_ADR), u32Adq0Wptr); IPF_REG_READ(SOC_IPF_CH1_ADQ0_RPTR_ADDR(IPF_REGBASE_ADR), u32Adq0Rptr); IPF_REG_READ(SOC_IPF_CH1_ADQ1_BASE_ADDR(IPF_REGBASE_ADR), u32Adq1BaseAddr); IPF_REG_READ(SOC_IPF_CH1_ADQ1_STAT_ADDR(IPF_REGBASE_ADR), u32Adq1StateInfo); IPF_REG_READ(SOC_IPF_CH1_ADQ1_WPTR_ADDR(IPF_REGBASE_ADR), u32Adq1Wptr); IPF_REG_READ(SOC_IPF_CH1_ADQ1_RPTR_ADDR(IPF_REGBASE_ADR), u32Adq1Rptr); break; default: IPF_PRINT("invalidable channel type \n"); break; } IPF_PRINT("============BEGIN===========\n"); IPF_PRINT("通道控制寄存器: 0x%x\n", u32ChanCtrlInfo); IPF_PRINT("通道状态寄存器: 0x%x\n", u32ChanStateInfo); IPF_PRINT("BD 基地址: 0x%x\n", u32BdqBaseAddr); IPF_PRINT("BD 深度: 0x%x\n", u32BdqDepth); IPF_PRINT("BD 写指针: 0x%x\n", u32BdqWptr); IPF_PRINT("BD 读指针: 0x%x\n", u32BdqRptr); IPF_PRINT("BD 写地址: 0x%x\n", u32BdqWaddr); IPF_PRINT("BD 读地址: 0x%x\n", u32BdqRaddr); IPF_PRINT("RD 基地址: 0x%x\n", u32RdqBaseAddr); IPF_PRINT("RD 深度: 0x%x\n", u32RdqDepth); IPF_PRINT("RD 读指针: 0x%x\n", u32RdqRptr); IPF_PRINT("RD 写指针: 0x%x\n", u32RdqWptr); IPF_PRINT("RD 读地址: 0x%x\n", u32RdqRaddr); IPF_PRINT("RD 写地址: 0x%x\n", u32RdqWaddr); IPF_PRINT("通道深度寄存器: 0x%x\n", u32Depth); IPF_PRINT("ADQ控制寄存器: 0x%x\n", u32AdqCtrlInfo); IPF_PRINT("ADQ0 基地址: 0x%x\n", u32Adq0BaseAddr); IPF_PRINT("ADQ0 状态寄存器: 0x%x\n", u32Adq0StateInfo); IPF_PRINT("ADQ0 写指针: 0x%x\n", u32Adq0Wptr); IPF_PRINT("ADQ0 读指针: 0x%x\n", u32Adq0Rptr); IPF_PRINT("ADQ1 基地址: 0x%x\n", u32Adq1BaseAddr); IPF_PRINT("ADQ1 状态寄存器: 0x%x\n", u32Adq1StateInfo); IPF_PRINT("ADQ1 写指针: 0x%x\n", u32Adq1Wptr); IPF_PRINT("ADQ1 读指针: 0x%x\n", u32Adq1Rptr); IPF_PRINT("=============END============\n"); return 0; }