ssx31bdrv.c

海思KEY驱动

    if (SSX31B_MCInit(pDrvCtrl) == ERR)
    {
        PRINT("\r\nSSX31B MC Init failed.");
        return ERR;
    }


    if (SSX31B_PEInit(pDrvCtrl) == ERR)
    {
        PRINT("\r\nSSX31B PE Init failed.");
        return ERR;
    }


    if (SSX31B_MemoryInit(pDrvCtrl) == ERR)
    {
        PRINT("\r\nSSX31B Mem Init failed.");
        return ERR;
    }


    if (SSX31B_DMAInit(pDrvCtrl) == ERR)
    {
        PRINT("\r\nSSX31B DMA Init failed.");    
        return ERR;
    }
    
    PciWrite32(SSX31B_REG_RNG_CTRL, 0x1083);
    
    SSX31B_ISRInit(pDrvCtrl);

    return OK;
}


ULONG SSX31B_GetInfo(SSX31BDRV_CTRL *  pDrvCtrl, CHAR *pucBuffer)
{

    ULONG ulPktErr, ulEngineErr, ulTotalErr, ulOtherErr;
    ULONG ulRate;


    ulPktErr =    pDrvCtrl->ulPktSPIErr          + pDrvCtrl->ulPktICVErr + \
                  pDrvCtrl->ulPktSeqNumErr       + pDrvCtrl->ulSoftFlowExpireErr + \
                  pDrvCtrl->ulPktUnkownIPHeadErr + pDrvCtrl->ulPktFrgSegErr + \
                  pDrvCtrl->ulAlignErr           + pDrvCtrl->ulHwFlowExpireErr + \
                  pDrvCtrl->ulPktStuctErr        + pDrvCtrl->ulInvalidSAErr + \
                  pDrvCtrl->ulPktPadErr;
   
    ulEngineErr = pDrvCtrl->ulPktProcTimeoutErr + pDrvCtrl->ulPktLenDismatchErr + \
    	          pDrvCtrl->ulPktBDLengErr      + pDrvCtrl->ulOperCodeErr;

    ulOtherErr = pDrvCtrl->ulAssembleFrmErr     + pDrvCtrl->ulGatherSliceErr + \
    	         pDrvCtrl->ulScatterSliceErr;

    ulTotalErr =  ulPktErr + ulEngineErr + ulOtherErr;


    pucBuffer += SPRINTF(pucBuffer, "    %u packets in SSX31B,  %u bytes\r\n",pDrvCtrl->ulInSSX31BPkts, pDrvCtrl->ulInSSX31BBytes);
    pucBuffer += SPRINTF(pucBuffer, "    %u packets out SSX31B, %u bytes\r\n",pDrvCtrl->ulOutSSX31BPkts,pDrvCtrl->ulOutSSX31BBytes);

    pucBuffer += SPRINTF(pucBuffer, "    Total Error: %u\r\n",ulTotalErr);
    pucBuffer += SPRINTF(pucBuffer, "    Packet Error: %u\r\n", ulPktErr);
    pucBuffer += SPRINTF(pucBuffer, "        SPI: %u, ICV: %u, Seq Num: %u, SA: %u, Flow Hard Expire: %u,\r\n",
                                                     pDrvCtrl->ulPktSPIErr,
                                                     pDrvCtrl->ulPktICVErr,
                                                     pDrvCtrl->ulPktSeqNumErr,
                                                     pDrvCtrl->ulInvalidSAErr,
                                                     pDrvCtrl->ulHwFlowExpireErr
                                                     );
    pucBuffer += SPRINTF(pucBuffer, "        Flow Soft Expire: %u, Align: %u, Pad: %u, IP Header Option: %u,\r\n",
                                                     pDrvCtrl->ulSoftFlowExpireErr,
                                                     pDrvCtrl->ulAlignErr,
                                                     pDrvCtrl->ulPktPadErr,
                                                     pDrvCtrl->ulPktUnkownIPHeadErr
                                                     );
    pucBuffer += SPRINTF(pucBuffer, "        IP Fragment Segment: %u, Packect stucture: %u\r\n",
                                                     pDrvCtrl->ulPktFrgSegErr,
                                                     pDrvCtrl->ulPktStuctErr
                                                     );
        
    pucBuffer += SPRINTF(pucBuffer, "    Engine Error: %u\r\n", ulEngineErr);
    pucBuffer += SPRINTF(pucBuffer, "        Process Timeout: %u, Packetlength: %u, BD Opercode: %u, BD Length: %u\r\n",
                                                     pDrvCtrl->ulPktProcTimeoutErr,
                                                     pDrvCtrl->ulPktLenDismatchErr,
                                                     pDrvCtrl->ulOperCodeErr,
                                                     pDrvCtrl->ulPktBDLengErr
                                                     );

    pucBuffer += SPRINTF(pucBuffer, "    Other Error: %u\r\n", ulOtherErr);
    pucBuffer += SPRINTF(pucBuffer, "        Assemble Frame Error: %u, Slice Error: Scatter: %u, Gather: %u\r\n",
                                                     pDrvCtrl->ulAssembleFrmErr,
                                                     pDrvCtrl->ulScatterSliceErr, 
                                                     pDrvCtrl->ulGatherSliceErr
                                                     );
                                                         

    

    pucBuffer += SPRINTF(pucBuffer, "SA BD: RdPtr:%d, WtPtr:%d, FreeBD:%d\r\n",
                                            pDrvCtrl->ulCurrSaBdReadPtr,
                                            pDrvCtrl->ulCurrSaBdWritePtr,
                                            pDrvCtrl->ulFreeSaBDs);

    pucBuffer += SPRINTF(pucBuffer, "SA RD: RdPtr:%d, WtPtr:%d, FreeRD:%d\r\n",
                                            pDrvCtrl->ulCurrSaRdReadPtr,
                                            pDrvCtrl->ulCurrSaRdWritePtr,
                                            pDrvCtrl->ulFreeSaRDs);
        
    pucBuffer += SPRINTF(pucBuffer, "IPSec BD: RdPtr:%d, WtPtr:%d, FreeBD:%d\r\n",
                                            pDrvCtrl->ulCurrIPSecBdReadPtr,
                                            pDrvCtrl->ulCurrIPSecBdWritePtr,
                                            pDrvCtrl->ulFreeIPSecBDs);

    pucBuffer += SPRINTF(pucBuffer, "IPSec RD: RdPtr:%d, WtPtr:%d, FreeRD:%d\r\n",
                                            pDrvCtrl->ulCurrIPSecRdReadPtr,
                                            pDrvCtrl->ulCurrIPSecRdWritePtr,
                                            pDrvCtrl->ulFreeIPSecRDs);


    return OK;

}









VOID SSX31B_ClearPort(SSX31BDRV_CTRL *  pDrvCtrl)
{

    pDrvCtrl->ulOutSSX31BPkts  = 0;
    pDrvCtrl->ulInSSX31BPkts   = 0;
    pDrvCtrl->ulOutSSX31BBytes = 0;
    pDrvCtrl->ulInSSX31BBytes  = 0;

    pDrvCtrl->ulLastOutSSX31BBytes = 0;
    pDrvCtrl->ulLastOutSSX31BPkts  = 0;
    pDrvCtrl->ulLastInSSX31BBytes  = 0;
    pDrvCtrl->ulLastInSSX31BPkts   = 0;

    pDrvCtrl->ulOutSSX31BByteRate   = 0;
    pDrvCtrl->ulInSSX31BByteRate    = 0;
    pDrvCtrl->ulOutSSX31BPacketRate = 0;
    pDrvCtrl->ulInSSX31BPacketRate  = 0;


    pDrvCtrl->ulPktSPIErr          = 0;
    pDrvCtrl->ulPktICVErr          = 0;
    pDrvCtrl->ulPktSeqNumErr       = 0;
    pDrvCtrl->ulPktProcTimeoutErr  = 0;
    pDrvCtrl->ulPktUnkownIPHeadErr = 0;
    pDrvCtrl->ulPktFrgSegErr       = 0;
    pDrvCtrl->ulAlignErr           = 0;
    pDrvCtrl->ulPktLenDismatchErr  = 0;
    pDrvCtrl->ulPktBDLengErr       = 0;
    pDrvCtrl->ulPktStuctErr        = 0;
    pDrvCtrl->ulPktPadErr          = 0;
    pDrvCtrl->ulOperCodeErr        = 0;
    

      pDrvCtrl->ulHwFlowExpireErr  = 0;
      pDrvCtrl->ulInvalidSAErr     = 0;



    pDrvCtrl->ulSoftFlowExpireErr      = 0;

    pDrvCtrl->ulTmtDone = 0;
    pDrvCtrl->ulTmtCall = 0;
    pDrvCtrl->ulTmtSADone = 0;
    
    pDrvCtrl->ulTmtErr = 0;
    pDrvCtrl->ulAssembleFrmErr = 0;
    pDrvCtrl->ulTmtTypeErr = 0;
    pDrvCtrl->ulTmtBDFullErr = 0;

    pDrvCtrl->ulScatterSliceErr = 0;
    pDrvCtrl->ulGatherSliceErr = 0;

    pDrvCtrl->ulIntCounter = 0;

    
    return ;
}


ULONG SSX31B_GetMbufSlice(MBUF_S * pMBuf)
{

    MBUF_DATABLOCKDESCRIPTOR_S * pDataBlkDesc = NULL;
    MBUF_DATABLOCKDESCRIPTOR_S * pNextDataBlkDesc = NULL;

    ULONG ulTotalLen, ulTemp, ulTbdNum, ulSndLen;
    UCHAR *pucData;
    ULONG ulDataLen = 0;
    ULONG ulRealNum = 0;
    ulSndLen = 0;


    ulTbdNum = MBUF_GET_DATA_BLOCK_NUMBER(pMBuf);

    if (ulTbdNum == 0 )
    {
        return 0;
    }


    pDataBlkDesc = MBUF_GET_DATA_BLOCK_DESC(pMBuf);


    ulTotalLen = MBUF_GET_TOTAL_DATA_LENGTH(pMBuf);

    if (ulTotalLen == 0)
    {
        return 0;
    }


    for (ulTemp = 0; ulTemp < ulTbdNum; ulTemp ++)
    {

        MBUF_GET_DATA_BLOCK_DESC_INFO(pDataBlkDesc,
                                  pucData,
                                  ulDataLen,
                                  pNextDataBlkDesc);

        if (ulDataLen)
        {

            ulRealNum++;        

            ulSndLen += ulDataLen;


            if (ulSndLen == ulTotalLen)
            {
                break;
            }

        }
        pDataBlkDesc =  pNextDataBlkDesc;
    }

    return ulRealNum;
}


ULONG SSX31B_IPSecSetBDDst(SSX31BDRV_CTRL *  pDrvCtrl, SSX31B_IPSEC_BD* pCurBD, MBUF_S * pMBuf, UCHAR* pucBuf, dma_addr_t pucBuf_dma_phys, ULONG ulBufLen)
{
    SSX31B_OCD* pScatterDesc;
    ULONG ulTotalLen, ulCnt, ulTmp;
    ULONG pucBufAligned;
    ULONG pucBufAligned_dma_phys;
    dma_addr_t dma_buf_phys;
	
     if (pucBuf == NULL || ulBufLen==0)
     {
         PRINT("SSX31B_IPSecSetBDDst: Output buffer error(=NULL)\r\n");
         return ERR;                               
     }

	pucBufAligned=four_bytes_align_en((ULONG)pucBuf_dma_phys, (ULONG)pucBuf);
	pucBufAligned_dma_phys=SSX31DRV_VIRT2DMA(pucBufAligned, pucBuf, pucBuf_dma_phys);

    ulTotalLen = MBUF_GET_TOTAL_DATA_LENGTH(pMBuf);

    if (ulTotalLen + MAX_LEN_SSX31B_INS_IPSEC > MAX_MEM_LEN_SSX31B_DRVIER)
    {
        ulCnt = (ulTotalLen + MAX_LEN_SSX31B_INS_IPSEC) / MAX_MEM_LEN_SSX31B_DRVIER;
        ulTmp = (ulTotalLen + MAX_LEN_SSX31B_INS_IPSEC) % MAX_MEM_LEN_SSX31B_DRVIER;

        if (ulTmp != 0)
        {
            ulCnt ++;
        }      

        if (ulCnt >= SSX31B_MAX_SCATTER)
        {
            pDrvCtrl->ulScatterSliceErr ++;
            PRINT("\r\nScatter slice > 16");
            return ERR;
        }
		
	ulTmp=ulCnt*SSX31B_OCD_LENGTH;
//	ulTmp= (ulTmp + MAX_MEM_LEN_SSX31B_DRVIER-1)/MAX_MEM_LEN_SSX31B_DRVIER*MAX_MEM_LEN_SSX31B_DRVIER;
//        pScatterDesc = (SSX31B_OCD*)kmalloc(ulCnt * SSX31B_OCD_LENGTH,GFP_ATOMIC);
        pScatterDesc = (SSX31B_OCD*)ssx31_consistent_alloc(GFP_KERNEL|GFP_DMA,ulTmp,&dma_buf_phys);
        if (pScatterDesc == NULL)
        {
            PRINT("SSX31B_IPSecSetBDDst: Alloc SSX31B OCD failed\r\n");
            return ERR;                               
        }
//   printk("SetBDDst: Alloc OCDs =V(%08x),D(%08x),L(%ld)============\n",pScatterDesc,dma_buf_phys,ulTmp);
   	memset(pScatterDesc,0,ulTmp);
        pCurBD->ulOrigBuf = (ULONG)pucBuf;

        pCurBD->ulOutputContext = (ULONG)dma_buf_phys;  
        pCurBD->ulOutputNum     = ulCnt;              
        pCurBD->ulOutputLength  = ulCnt * MAX_MEM_LEN_SSX31B_DRVIER;
        pCurBD->ulScatterEnable = CD_SCATTER_ENABLE;

/*         pucBuf += IPSEC_MBUF_DATA_START; */
                                                                                                                                                                                
        for (ulTmp = 0; ulTmp < ulCnt; ulTmp ++)
        {
            //pScatterDesc->ulOutputPtr = virt_to_bus ((ULONG)(pucBufAligned + ulTmp * MAX_MEM_LEN_SSX31B_DRVIER)); /* 需转化为小模式 */
		pScatterDesc->ulOutputPtr = pucBufAligned_dma_phys + ulTmp * MAX_MEM_LEN_SSX31B_DRVIER; 
		/*attention: Aligned dma--virt  pairs was not mapped, but the un-aligned mapped, 
		so can't map aligned dma addr and virt to each other  directly using ssx31_dma_virt_mapping_findByXXX*/
            pScatterDesc->ulOutputLen = MAX_MEM_LEN_SSX31B_DRVIER;
		/*toy, set attrib*/
		if(ulTmp==ulCnt-1) pScatterDesc->ulOutputAttrib=OCD_LAST_SLICE;
            pScatterDesc ++;
        }

//#ifdef HI_DBG
#if 0
{
	printk("SetBDDst: OrigBuf=V(%08x),D(%08x),L(%08x)\n",pucBuf,pucBuf_dma_phys,ulBufLen);	
	printk("SetBDDst: OCD->ulOutputPtr(Aligned)=V(%08x)\n",pucBufAligned);	
}
#endif

    }
    else
    {
        pCurBD->ulOrigBuf = (ULONG)pucBuf;
/*         pucBuf += IPSEC_MBUF_DATA_START; */

        pCurBD->ulOutputContext = pucBufAligned_dma_phys;

//#ifdef HI_DBG
#if 0
{
	printk("SetBDDst: OrigBuf=V(%08x),D(%08x),L(%08x)\n",pucBuf,pucBuf_dma_phys,ulBufLen);	
	printk("SetBDDst: ulOutputContext(Aligned)=V(%08x)\n",pucBufAligned);	
}
#endif
		
	pCurBD->ulOutputLength = MAX_MEM_LEN_SSX31B_DRVIER - (pucBufAligned - (ULONG)pucBuf);
/*toyinfo*/
	//printk("SSX31B_IPSecSetBDDst: ulOutputLength=%d !\n",pCurBD->ulOutputLength);

/*toytry*/
       //pCurBD->ulOutputLength = MAX_MEM_LEN_SSX31B_DRVIER ;
        pCurBD->ulScatterEnable = 0;

    }

    return OK;
}





ULONG SSX31B_SetIPSecBDSrc(SSX31BDRV_CTRL  *  pDrvCtrl, 
                                  SSX31B_IPSEC_BD *  pCurBD, 
                                  MBUF_S * pMBuf)
{
    SSX31B_ICD* pGatherDesc;
    SSX31B_ICD* pTmpGatherDesc;

    MBUF_DATABLOCKDESCRIPTOR_S * pDataBlkDesc;
    MBUF_DATABLOCKDESCRIPTOR_S * pNextDataBlkDesc;

    UCHAR* pucData;
    ULONG   pucData_dma_phys,ultmpBufLen;
    ULONG* pulPtr;

    ULONG ulTbdNum, ulTotalLen, ulTmp;
    ULONG ulRealNum, ulDataLen, ulSaID, ulINextSaID;
    ULONG ulSliceNum, ulPacketType;
    USHORT usPacketMode; 

//    pGatherDesc = bus_to_virt ((SSX31B_ICD*)pCurBD->ulInputContext);
//    pGatherDesc = (SSX31B_ICD*)pCurBD->ulInputContext_virtaddr;
    pGatherDesc = (SSX31B_ICD*)SSX31DRV_DMA2VIRT(pCurBD->ulInputContext, pDrvCtrl->pstGather,pDrvCtrl->pstGather_dmaaddr);
//    pulPtr = bus_to_virt ((ULONG*)pGatherDesc->ulInputPtr);
//    pulPtr = (ULONG*)pGatherDesc->ulInputPtr_virtaddr;
    pulPtr = (ULONG*)SSX31DRV_DMA2VIRT(pGatherDesc->ulInputPtr,pDrvCtrl->ulCtrlWordMemBase,pDrvCtrl->ulCtrlWordMemBase_dmaaddr);

    MBUF_GET_SECP_PKT_TYPE(ulPacketType, pMBuf);
    * pulPtr= SSX31B_PE_CTRLWORD;
   
    if ( ulPacketType == PACKET_TYPE_OUTBOUND )
    {
        * pulPtr |= SSX31B_PE_CTRLWORD_OUTBOUND;
    }
    MBUF_GET_SECP_PKT_PROCMODE (usPacketMode, pMBuf);
    if ( usPacketMode > IPSEC_SECP_PKT_MODE_AHESP  )
    {
        PRINT ( "\r\nMBUF_GET_SECP_PKT_PROCMODE error: %d", usPacketMode );
        return ERR;
    }    
    * pulPtr |= (usPacketMode << SSX31B_PE_CTRLWORD_PROCMODE);
    
/*toyendian*/    
    //* pulPtr = SWAP32 (* pulPtr);
/* 	SWAP32_LP(pulPtr);*/



    MBUF_GET_SECP_INEXT_SAID(ulINextSaID, pMBuf);

    if (ulINextSaID == 0xFFFFFFFF)
    {
        MBUF_GET_SECP_SAID(ulSaID, pMBuf);