コード例 #1
0
/*****************************************************************************
* 函 数 名  : IPF_Resume
*
* 功能描述  : 该接口用于IPF低功耗resume流程处理
*
* 输入参数  : pdev
*
* 输出参数  : 无
*
* 返 回 值  : int
*
* 修改记录  : 2014年04月25日   z00212992  创建
*****************************************************************************/
static int IPF_Resume(struct platform_device *pdev)
{
    /* 打开IPF hclk时钟、axi总线时钟 */
    IPF_REG_WRITE(SOC_PERI_SCTRL_SC_PERIPH_CLKEN2_ADDR(ipf_peri_ctrl_base), \
                (0x1 << SOC_PERI_SCTRL_SC_PERIPH_CLKEN2_periph_clken2_ipf_acpu_START));

    return 0;
}
コード例 #2
0
/*****************************************************************************
* 函 数 名  : IPF_Suspend
*
* 功能描述  : 该接口用于IPF低功耗suspend流程处理
*
* 输入参数  : pdev、state
*
* 输出参数  : 无
*
* 返 回 值  : int
*
* 修改记录  : 2014年04月25日   z00212992  创建
*****************************************************************************/
static int IPF_Suspend(struct platform_device *pdev,pm_message_t state)
{
    /* 关闭IPF hclk时钟、axi总线时钟 */
    IPF_REG_WRITE(SOC_PERI_SCTRL_SC_PERIPH_CLKDIS2_ADDR(ipf_peri_ctrl_base), \
                (0x1 << SOC_PERI_SCTRL_SC_PERIPH_CLKDIS2_periph_clkdis2_ipf_acpu_START));

    return 0;
}
コード例 #3
0
/*****************************************************************************
* 函 数 名  : BSP_IPF_ConfigTimeout
*
* 功能描述  : 调试使用,配置超时时间接口
*
* 输入参数  : unsigned int u32Timeout 配置的超时时间
* 输出参数  : 无
* 返 回 值  : IPF_SUCCESS                   成功
*             BSP_ERR_IPF_INVALID_PARA      参数无效
*
* 说明      : 1代表256个时钟周期
*
* 修改记录   : 2011年11月30日   鲁婷  创建
*****************************************************************************/
int BSP_IPF_ConfigTimeout(unsigned int u32Timeout)
{
    SOC_IPF_TIME_OUT_UNION unTimeout;

    unTimeout.value = 0;
    if((u32Timeout == 0) || (u32Timeout > 0xFFFF))
    {
        IPF_PRINT_ERROR("parameter is error\n");
        return BSP_ERR_IPF_INVALID_PARA;
    }
    unTimeout.reg.time_out_cfg = u32Timeout;
    unTimeout.reg.time_out_valid = 1;

    IPF_REG_WRITE(SOC_IPF_TIME_OUT_ADDR(IPF_REGBASE_ADR), unTimeout.value);

    return IPF_SUCCESS;
}
コード例 #4
0
/*****************************************************************************
* 函 数 名  : BSP_IPF_PktLen
*
* 功能描述  : 该接口用来配置过滤器的最大和最小包长
*
* 输入参数  : unsigned int MaxLen   最大包长
*             unsigned int MinLen   最小包长
*
* 输出参数  : 无
* 返 回 值  : IPF_SUCCESS                成功
*             BSP_ERR_IPF_INVALID_PARA   参数错误(最大包长比最小包长小)
*
* 修改记录  :2011年2月17日   鲁婷  创建
*****************************************************************************/
int BSP_IPF_SetPktLen(unsigned int u32MaxLen, unsigned int u32MinLen)
{
    SOC_IPF_PKT_LEN_UNION unPktLen;

    unPktLen.value = 0;
    /* 参数检查 */
    if(u32MaxLen < u32MinLen)
    {
        IPF_PRINT_ERROR("parameter is error\n");
        return BSP_ERR_IPF_INVALID_PARA;
    }

    unPktLen.reg.max_pkt_len = u32MaxLen;
    unPktLen.reg.min_pkt_len = u32MinLen;

    IPF_REG_WRITE(SOC_IPF_PKT_LEN_ADDR(IPF_REGBASE_ADR), unPktLen.value);
    return IPF_SUCCESS;
}
コード例 #5
0
BSP_VOID BSP_IPF_FilterInfo(BSP_U32 u32FilterID)
{
    IPF_MATCH_INFO_S stMatchInfo = {0};

    if(u32FilterID < IPF_BF_NUM)
    {
         /* 写过滤表操作地址 */
        IPF_REG_WRITE(SOC_IPF_BFLT_INDEX_ADDR(IPF_REGBASE_ADR), u32FilterID);

        /* 读出过滤器的配置 */
        memcpy(&stMatchInfo, (BSP_VOID*)SOC_IPF_FLT_LOCAL_ADDR0_ADDR(IPF_REGBASE_ADR), sizeof(IPF_MATCH_INFO_S));
    }
    else
    {
        memcpy(&stMatchInfo, (BSP_VOID*)(g_pstExFilterAddr + u32FilterID - IPF_BF_NUM), sizeof(IPF_MATCH_INFO_S));
    }

    IPF_PRINT("src ADDR0 :      %x.%x.%x.%x\n", stMatchInfo.u8SrcAddr[0], stMatchInfo.u8SrcAddr[1], stMatchInfo.u8SrcAddr[2], stMatchInfo.u8SrcAddr[3]);
    IPF_PRINT("src ADDR1 :      %x.%x.%x.%x\n", stMatchInfo.u8SrcAddr[4], stMatchInfo.u8SrcAddr[5], stMatchInfo.u8SrcAddr[6], stMatchInfo.u8SrcAddr[7]);
    IPF_PRINT("src ADDR2 :      %x.%x.%x.%x\n", stMatchInfo.u8SrcAddr[8], stMatchInfo.u8SrcAddr[9], stMatchInfo.u8SrcAddr[10], stMatchInfo.u8SrcAddr[11]);
    IPF_PRINT("src ADDR3 :      %x.%x.%x.%x\n", stMatchInfo.u8SrcAddr[12], stMatchInfo.u8SrcAddr[13], stMatchInfo.u8SrcAddr[14], stMatchInfo.u8SrcAddr[15]);
    IPF_PRINT("dst ADDR0 :      %x.%x.%x.%x\n", stMatchInfo.u8DstAddr[0], stMatchInfo.u8DstAddr[1], stMatchInfo.u8DstAddr[2], stMatchInfo.u8DstAddr[3]);
    IPF_PRINT("dst ADDR1 :      %x.%x.%x.%x\n", stMatchInfo.u8DstAddr[4], stMatchInfo.u8DstAddr[5], stMatchInfo.u8DstAddr[6], stMatchInfo.u8DstAddr[7]);
    IPF_PRINT("dst ADDR2 :      %x.%x.%x.%x\n", stMatchInfo.u8DstAddr[8], stMatchInfo.u8DstAddr[9], stMatchInfo.u8DstAddr[10], stMatchInfo.u8DstAddr[11]);
    IPF_PRINT("dst ADDR3 :      %x.%x.%x.%x\n", stMatchInfo.u8DstAddr[12], stMatchInfo.u8DstAddr[13], stMatchInfo.u8DstAddr[14], stMatchInfo.u8DstAddr[15]);
    IPF_PRINT("dst MASK0 :      %x.%x.%x.%x\n", stMatchInfo.u8DstMsk[0], stMatchInfo.u8DstMsk[1], stMatchInfo.u8DstMsk[2], stMatchInfo.u8DstMsk[3]);
    IPF_PRINT("dst MASK1 :      %x.%x.%x.%x\n", stMatchInfo.u8DstMsk[4], stMatchInfo.u8DstMsk[5], stMatchInfo.u8DstMsk[6], stMatchInfo.u8DstMsk[7]);
    IPF_PRINT("dst MASK2 :      %x.%x.%x.%x\n", stMatchInfo.u8DstMsk[8], stMatchInfo.u8DstMsk[9], stMatchInfo.u8DstMsk[10], stMatchInfo.u8DstMsk[11]);
    IPF_PRINT("dst MASK3 :      %x.%x.%x.%x\n", stMatchInfo.u8DstMsk[12], stMatchInfo.u8DstMsk[13], stMatchInfo.u8DstMsk[14], stMatchInfo.u8DstMsk[15]);
    IPF_PRINT("SrcPort   :      %x\n", stMatchInfo.unSrcPort.u32SrcPort);
    IPF_PRINT("DstPort   :      %x\n", stMatchInfo.unDstPort.u32DstPort);
    IPF_PRINT("TrafficClass :   %x\n", stMatchInfo.unTrafficClass.u32TrafficClass);
    IPF_PRINT("local MASK:      %d\n", stMatchInfo.u32LocalAddressMsk);
    IPF_PRINT("Protocol  :      %x\n", stMatchInfo.unNextHeader.u32Protocol);
    IPF_PRINT("FlowLable :      %x\n", stMatchInfo.u32FlowLable);
    IPF_PRINT("CodeType  :      %x\n", stMatchInfo.unFltCodeType.u32CodeType);
    IPF_PRINT("NextIndex : %d  FltPri: %d\n", stMatchInfo.unFltChain.Bits.u16NextIndex, stMatchInfo.unFltChain.Bits.u16FltPri);
    IPF_PRINT("FltSpi :             %d\n", stMatchInfo.u32FltSpi);
    IPF_PRINT("FltRuleCtrl :        %x\n", stMatchInfo.unFltRuleCtrl.u32FltRuleCtrl);
    IPF_PRINT("============================\n");
}
コード例 #6
0
/*****************************************************************************
* 函 数 名  : 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;
}
コード例 #7
0
/*****************************************************************************
* 函 数 名  : 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;
}
コード例 #8
0
/*****************************************************************************
* 函 数 名  : IPF_Init
*
* 功能描述  : IPF初始化     内部使用,不作为接口函数
*
* 输入参数  : void
* 输出参数  : 无
* 返 回 值  : IPF_SUCCESS    初始化成功
*             IPF_ERROR      初始化失败
*
* 修改记录  :2011年1月21日   鲁婷  创建
*   1.修改日期 : 2012年11月29日
*     修改作者 : z00212992
*     修改记录 : 增加ADQ初始化
*****************************************************************************/
int IPF_Init(void)
{
    int s32Ret = 0;

    /* IPF内存配置越界检查 */
    if(IPF_MEM_USED_SIZE > IPF_AXI_MEM_SIZE)
    {
        IPF_PRINT_ERROR("memory overstep the boundary\n");
        return IPF_ERROR;
    }


    hisi_io_memset((BSP_VOID*)&g_stIpfCtx, 0x0, sizeof(IPF_CONTEXT_S));

    IPF_ULBD_MEM_ADDR = HISI_VA_ADDRESS(IPF_AXI_MEM_ADDR);

    if (0 == (IPF_REGBASE_ADR = (unsigned long)ioremap(REG_BASE_IPF,REG_IPF_IOSIZE))){
        BUG_ON(1);
        return IPF_ERROR;
    }

    /* 为上行BD、RD描述符分配一段连续的物理地址 */
    g_stIpfUl.pstIpfBDQ = (IPF_BD_DESC_S*)IPF_ULBD_MEM_ADDR;
    g_stIpfUl.pstIpfRDQ = (IPF_RD_DESC_S*)IPF_ULRD_MEM_ADDR;

    /* 为上行AD描述符分配一段连续内存(首地址8字节对齐)*/
    g_stIpfUl.pstIpfADQ0 = (IPF_AD_DESC_S*)IPF_ULAD0_MEM_ADDR;
    g_stIpfUl.pstIpfADQ1 = (IPF_AD_DESC_S*)IPF_ULAD1_MEM_ADDR;

    /* 为下行BD、RD描述符分配一段连续的物理地址 */
    g_stIpfDl.pstIpfBDQ = (IPF_BD_DESC_S*)IPF_DLBD_MEM_ADDR;
    g_stIpfDl.pstIpfRDQ = (IPF_RD_DESC_S*)IPF_DLRD_MEM_ADDR;

    /* 为下行AD描述符分配一段连续内存(首地址8字节对齐)*/
    g_stIpfDl.pstIpfADQ0 = (IPF_AD_DESC_S*)IPF_DLAD0_MEM_ADDR;
    g_stIpfDl.pstIpfADQ1 = (IPF_AD_DESC_S*)IPF_DLAD1_MEM_ADDR;

    /* 为下行CD描述符分配一段连续的物理地址 */
    g_stIpfDl.pstIpfCDQ = (IPF_CD_DESC_S*)IPF_DLCD_MEM_ADDR;

    /* 记录IPF上行空闲BD个数 */
    g_stIpfUl.pu32IdleBd = (unsigned int*)IPF_ULBD_IDLENUM_ADDR;

#ifdef __BSP_IPF_DEBUG__
    /* 记录IPF debug信息 */
    g_stIPFDebugInfo = (IPF_DEBUG_INFO_S*)IPF_DEBUG_INFO_ADDR;

    /* 记录IPF 下行CDdebug信息 */
    g_stIpfDl.pstIpfDebugCDQ = (IPF_CD_DESC_S*)IPF_DEBUG_DLCD_ADDR;
#endif

    /* 记录IPF 下行CD读写指针 */
    g_stIpfDl.u32IpfCdRptr = (unsigned int*)IPF_DLCD_PTR_ADDR;
    g_stIpfDl.u32IpfCdWptr = (unsigned int*)(IPF_DLCD_PTR_ADDR+4);

    /* 挂接IPF中断 */
    IPF_Int_Connect();

    /* 注册IPF设备 */
    s32Ret = platform_device_register(&ipf_pfdev);
    if(s32Ret)
    {
        IPF_PRINT_ERROR("ipf device register fail\n");
        return s32Ret;
    }

    /* 注册IPF驱动 */
    s32Ret = platform_driver_register(&ipf_pfdrv);
    if(s32Ret)
    {
        platform_device_unregister(&ipf_pfdev);
        IPF_PRINT_ERROR("ipf driver register fail\n");
        return s32Ret;
    }

    ipf_peri_ctrl_base = (unsigned long)HISI_VA_ADDRESS(SOC_PERI_SCTRL_BASE_ADDR);
	if (!ipf_peri_ctrl_base)
	{
        IPF_PRINT_ERROR("unable to ioremap ipf peri ctrl\n");
	}

    /* 打开IPF hclk时钟、axi总线时钟 */
    IPF_REG_WRITE(SOC_PERI_SCTRL_SC_PERIPH_CLKEN2_ADDR(ipf_peri_ctrl_base), \
                (0x1 << SOC_PERI_SCTRL_SC_PERIPH_CLKEN2_periph_clken2_ipf_acpu_START));

    /* 等待另外一个core ipf初始化同步完成 */
    s32Ret = BSP_SYNC_Wait(SYNC_MODULE_IPF, 5000);
    if(s32Ret != BSP_OK)
    {
        IPF_PRINT_ERROR("BSP_SYNC_Wait timeout\n");
        return IPF_ERROR;
    }

    /* IPF初始化完成 */
    g_stIpfCtx.isInit = BSP_TRUE;


    IPF_PRINT_ERROR("success\n");
    return IPF_SUCCESS;
}
コード例 #9
0
/*****************************************************************************
* 函 数 名  : 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;
}
コード例 #10
0
/*****************************************************************************
* 函 数 名  : 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;
}