ssx31bpke.c

海思KEY驱动

    }
	
	
    SplX(lIntMask);
    
    
    return OK;


error:
	SplX(lIntMask); 

    if (pCurBD->ulGatherEnable == CD_GATHER_ENABLE )
    {
        if (pCurBD->ulInputContext )
        {

            Free( bus_to_virt(pCurBD->ulInputContext) );
            pCurBD->ulInputContext = NULL;
        }
    }
    if (pCurBD->ulScatterEnable == CD_SCATTER_ENABLE )
    {
        if (pCurBD->ulOutputContext )
        {

            Free( bus_to_virt(pCurBD->ulOutputContext) );
            pCurBD->ulOutputContext = NULL;
        }
    }
	    if (pRes != NULL)
	    {
	    	Free (pRes);
	    }
	    if (pRes1 != NULL)
	    {
	    	Free (pRes1);
	    }
   
    return ERR;
}

/*********************************************************RSA*******************************************************************************/
/*********************************************************RSA*******************************************************************************/
/*********************************************************RSA*******************************************************************************/
ULONG SSX31B_SetBDDstRsaPrivate(SSX31B_PKE_BD * pCurBD, UCHAR* pcOD, ULONG ulODlen)
{
    pCurBD->ulOutputContext = (ULONG)virt_to_bus(pcOD);
    pCurBD->ulOutputLength0 = ulODlen;
    pCurBD->ulOutputNum  = 0;
    pCurBD->ulScatterEnable &= ~CD_SCATTER_ENABLE;

    return OK;
}

ULONG SSX31B_SetBDSrcRsaPrivate(SSX31B_PKE_BD * pCurBD, SSX31BRSA_S* pSd707Rsa)
{
	SSX31B_PKE_ICD* pGatherDesc = NULL;

    pGatherDesc = (SSX31B_PKE_ICD*)Malloc( 6 * sizeof(SSX31B_PKE_ICD) );

	
    if (pGatherDesc == NULL)
    {
        PRINT("SSX31B driver PE send mem alloc fail\r\n");
        return ERR;                               
    }

    pCurBD->ulInputContext  = (ULONG)virt_to_bus(pGatherDesc);  
    pCurBD->ulInputNum = 6;
    pCurBD->ulInputLength= pSd707Rsa->ulPlen + pSd707Rsa->ulQlen + pSd707Rsa->ulDPlen + pSd707Rsa->ulDQlen + pSd707Rsa->ulIDlen +
                                                                                                                   pSd707Rsa->ulQinvlen;
    pCurBD->ulGatherEnable = CD_GATHER_ENABLE;
    
    pGatherDesc->ulInputPtr = (ULONG)virt_to_bus(pSd707Rsa->pcP);
    pGatherDesc->ulInputLen = pSd707Rsa->ulPlen;
    pGatherDesc->ulInputAttrib = ICD_LAST_SLICE_PKE;
    pGatherDesc->ulOrig = 0;
    
    pGatherDesc ++;
    pGatherDesc->ulInputPtr = (ULONG)virt_to_bus(pSd707Rsa->pcQ);
    pGatherDesc->ulInputLen = pSd707Rsa->ulQlen;
    pGatherDesc->ulInputAttrib = ICD_LAST_SLICE_PKE;
    pGatherDesc->ulOrig = 0;
    
    pGatherDesc ++;    
    pGatherDesc->ulInputPtr = (ULONG)virt_to_bus(pSd707Rsa->pcID);
    pGatherDesc->ulInputLen = pSd707Rsa->ulIDlen;
    pGatherDesc->ulInputAttrib = ICD_LAST_SLICE_PKE;
    pGatherDesc->ulOrig = 0;
        
    pGatherDesc ++;
    pGatherDesc->ulInputPtr = (ULONG)virt_to_bus(pSd707Rsa->pcDP);
    pGatherDesc->ulInputLen = pSd707Rsa->ulDPlen;
    pGatherDesc->ulInputAttrib = ICD_LAST_SLICE_PKE;
    pGatherDesc->ulOrig = 0;
    
    pGatherDesc ++;
    pGatherDesc->ulInputPtr = (ULONG)virt_to_bus(pSd707Rsa->pcDQ);
    pGatherDesc->ulInputLen = pSd707Rsa->ulDQlen;
    pGatherDesc->ulInputAttrib = ICD_LAST_SLICE_PKE;
    pGatherDesc->ulOrig = 0;
    
    pGatherDesc ++;
    pGatherDesc->ulInputPtr = (ULONG)virt_to_bus(pSd707Rsa->pcQinv);
    pGatherDesc->ulInputLen = pSd707Rsa->ulQinvlen;
    pGatherDesc->ulInputAttrib = ICD_LAST_SLICE_PKE;
    pGatherDesc->ulOrig = 0;

    return OK;
}

ULONG SSX31B_SetBDDstRsaPublic(SSX31B_PKE_BD * pCurBD, UCHAR* pcOD, ULONG ulODlen)
{
    pCurBD->ulOutputContext = (ULONG)virt_to_bus(pcOD);
    pCurBD->ulOutputLength0 = ulODlen;
    pCurBD->ulOutputNum  = 0;
    pCurBD->ulScatterEnable &= ~CD_SCATTER_ENABLE;

    return OK;
}

ULONG SSX31B_SetBDSrcRsaPublic(SSX31B_PKE_BD * pCurBD, SSX31BRSA_S* pSd707Rsa)
{
	SSX31B_PKE_ICD* pGatherDesc = NULL;

    pGatherDesc = (SSX31B_PKE_ICD*)Malloc( 3 * sizeof(SSX31B_PKE_ICD) );

	
    if (pGatherDesc == NULL)
    {
        PRINT("SSX31B driver PE send mem alloc fail\r\n");
        return ERR;                               
    }

    pCurBD->ulInputContext  = (ULONG)virt_to_bus(pGatherDesc);  
    pCurBD->ulInputNum = 3;
    pCurBD->ulInputLength= pSd707Rsa->ulMlen + pSd707Rsa->ulElen + pSd707Rsa->ulIDlen;
    pCurBD->ulGatherEnable = CD_GATHER_ENABLE;
    
    pGatherDesc->ulInputPtr = (ULONG)virt_to_bus(pSd707Rsa->pcM);
    pGatherDesc->ulInputLen = pSd707Rsa->ulMlen;
    pGatherDesc->ulInputAttrib = ICD_LAST_SLICE_PKE;
    pGatherDesc->ulOrig = 0;
        
    pGatherDesc ++;
    pGatherDesc->ulInputPtr = (ULONG)virt_to_bus(pSd707Rsa->pcE);
    pGatherDesc->ulInputLen = pSd707Rsa->ulElen;
    pGatherDesc->ulInputAttrib = ICD_LAST_SLICE_PKE;
    pGatherDesc->ulOrig = 0;
    
    pGatherDesc ++;
    pGatherDesc->ulInputPtr = (ULONG)virt_to_bus(pSd707Rsa->pcID);
    pGatherDesc->ulInputLen = pSd707Rsa->ulIDlen;
    pGatherDesc->ulInputAttrib = ICD_LAST_SLICE_PKE;
    pGatherDesc->ulOrig = 0;

    return OK;
}

ULONG SSX31B_RSA(SSX31BDRV_CTRL* pDrvCtrl, SSX31BRSA_S* pSd707Rsa)
{
    SSX31B_PKE_BD * pCurBD = NULL;
    SSX31B_PKE_RD * pCurRD = NULL;
    UCHAR* pRes = NULL;
    UCHAR* pResAligned = NULL;   
    ULONG ulTmt = 0;      
    int i;
    LONG lIntMask;


    if ( pDrvCtrl->ulCurrPkeBdReadPtr == ((pDrvCtrl->ulCurrPkeBdWritePtr + 1) & (SSX31B_PKE_BDQUEUE_LEN - 1)))  
    {
        PRINT("BD Queue full:BD Read:%d write %d", 
            pDrvCtrl->ulCurrPkeBdReadPtr,
            pDrvCtrl->ulCurrPkeBdWritePtr);
        return ERR;
    }

    SplImp(&lIntMask);


    pCurBD = &((SSX31B_PKE_BD *)(pDrvCtrl->ulPkeBDMemBase))[pDrvCtrl->ulCurrPkeBdWritePtr];

    switch ( pSd707Rsa->ucOpCode )
    {
	case SSX31B_OPER_DH_RSA_PUBKEY:
	
		pRes = Malloc( pSd707Rsa->ulODlen + 4);
		if (pRes == NULL)
		{
			PRINT ("\n can't malloc!");
			goto error;
		}
		pResAligned = four_bytes_align (pRes);	
	
   
		if ( SSX31B_SetBDSrcRsaPublic( pCurBD, pSd707Rsa ) == ERR )
		{
			goto error;						
		}

		if ( SSX31B_SetBDDstRsaPublic(pCurBD, pResAligned, pSd707Rsa->ulODlen ) == ERR )
	    	{
	    		goto error;
		}
		
		break;
	
	case SSX31B_OPER_DH_RSA_PRIVKEY:   
	 
		pRes = Malloc( pSd707Rsa->ulODlen + 4);
		if (pRes == NULL)
		{
			PRINT ("\n can't malloc!");
			goto error;
		}
		pResAligned = four_bytes_align (pRes);		
	
		if ( SSX31B_SetBDSrcRsaPrivate( pCurBD, pSd707Rsa ) == ERR )
		{
			goto error;						
		}

		if ( SSX31B_SetBDDstRsaPrivate(pCurBD, pResAligned, pSd707Rsa->ulODlen ) == ERR )
	    	{
	    		goto error;
		}

		break;

	
 
	default:
		break;
	}
    

    pCurBD->ulOpCode = pSd707Rsa->ucOpCode;
    pCurBD->ulFlag = pSd707Rsa->ucFlg;
    
    
    
#if 0
{
	ULONG* pulTmp = NULL;
	ULONG* pulTmp1 = NULL;
	int i;
	
	pulTmp = (ULONG*)pCurBD;
	
	PRINT ("\r\nBD: %08x %08x %08x %08x %08x %08x ", pulTmp[0], pulTmp[1], pulTmp[2], pulTmp[3], pulTmp[4], pulTmp[5]); 
	
	pulTmp1 = (ULONG*)((ULONG)bus_to_virt ( pulTmp[1] ));
	for (i=0; i<6; i++)
	{
		PRINT ("\r\nicd %d: %08x %08x", i, pulTmp1[0], pulTmp1[1]);
		pulTmp = (ULONG*)((ULONG)bus_to_virt ( pulTmp1[0] ));
		PRINT ("\r\n buf: %08x", pulTmp[0]);
		
		pulTmp1 += 2;
	}
	
}
#endif
    
    
   

    pDrvCtrl->ulCurrPkeBdWritePtr = (pDrvCtrl->ulCurrPkeBdWritePtr + 1) & (SSX31B_PKE_BDQUEUE_LEN - 1); 
    PciWrite32(SSX31B_REG_BQWP2, pDrvCtrl->ulCurrPkeBdWritePtr);
    

    pDrvCtrl->ulFreePkeBDs --; 

    ulTmt = (DMA2_TIMEOUT_DMA2)*100 + 100000;

    for (i = 0; i < ulTmt; i ++)
    {
        UsDelay(10);


        PciRead32(SSX31B_REG_BQRP2, &pDrvCtrl->ulCurrPkeBdReadPtr);
        

        PciRead32(SSX31B_REG_RQWP2, &pDrvCtrl->ulCurrPkeRdWritePtr);

	
        if (pDrvCtrl->ulCurrPkeRdWritePtr == pDrvCtrl->ulCurrPkeRdReadPtr)
        {
            continue;
        }
        else
        {
            pCurRD = &((SSX31B_PKE_RD *)(pDrvCtrl->ulPkeRDMemBase))[pDrvCtrl->ulCurrPkeRdReadPtr];	
	    if ((pCurRD->ulStatus & DMA1_ERR_MASK) != MDA1_STATUS_OK)
	    {
	    	PRINT ("\nPKE err!");
		PRINT ("\nstatus: %04x", pCurRD->ulStatus);
		goto error; 
	    }
#if 0	    
{

	ULONG* pulTmp = (ULONG*)pCurRD;
	PRINT ("\r\n RD:");
	PRINT ("\r\nBD: %08x %08x %08x %08x %08x %08x ", pulTmp[0], pulTmp[1], pulTmp[2], pulTmp[3], pulTmp[4], pulTmp[5]); 
}
#endif  

	    if (pCurRD->ulGatherEnable == CD_GATHER_ENABLE )
    	    {
    	    	if (pCurRD->ulInputContext )
            	{
            		
           		 Free( bus_to_virt(pCurRD->ulInputContext) );
        	         pCurRD->ulInputContext = NULL;
            	}
            }
           if (pCurRD->ulScatterEnable == CD_SCATTER_ENABLE )
           {
               if (pCurRD->ulOutputContext )
               {
                   
                   Free( bus_to_virt(pCurRD->ulOutputContext) );
                   pCurRD->ulOutputContext = NULL;
               }
	   }
    
          memcpy (pSd707Rsa->pcOD, pResAligned, pSd707Rsa->ulODlen);

	    
	    if (pRes != NULL)
	    {
	    	Free (pRes);
	    }
    
   
	    
	    
            pDrvCtrl->ulCurrPkeRdReadPtr = (pDrvCtrl->ulCurrPkeRdReadPtr + 1) & (SSX31B_PKE_RDQUEUE_LEN - 1);  


            
            if (pDrvCtrl->ulCurrPkeRdWritePtr == pDrvCtrl->ulCurrPkeRdReadPtr)
            {
            
                PciWrite32(SSX31B_REG_RQRP2, pDrvCtrl->ulCurrPkeRdReadPtr); 

               pDrvCtrl->ulFreePkeBDs ++;
               pDrvCtrl->ulTmtPKEDone ++;

               break;
            }
	    

        }
	

    }


        if (i >= ulTmt)
    {
#ifdef HI_DBG    
    	PRINT ("\r\nnot finish");
#endif	

	    if (pCurBD->ulGatherEnable == CD_GATHER_ENABLE )
    	    {
    	    	if (pCurBD->ulInputContext )
            	{
            		
           		 Free( bus_to_virt(pCurBD->ulInputContext) );
        	         pCurBD->ulInputContext = NULL;
            	}
            }
           if (pCurBD->ulScatterEnable == CD_SCATTER_ENABLE )
           {
               if (pCurBD->ulOutputContext )
               {

                   Free( bus_to_virt(pCurBD->ulOutputContext) );
                   pCurBD->ulOutputContext = NULL;
               }
           }
	   

	    if (pRes != NULL)
	    {
	    	Free (pRes);
	    }


        SplX(lIntMask);
    
    
        return ERR;


    }



	SplX(lIntMask);
    return OK;


error:


    if (pCurBD->ulGatherEnable == CD_GATHER_ENABLE )
    {
        if (pCurBD->ulInputContext )
        {

            Free( bus_to_virt (pCurBD->ulInputContext) );
            pCurBD->ulInputContext = NULL;
        }
    }
    if (pCurBD->ulScatterEnable == CD_SCATTER_ENABLE )
    {
        if (pCurBD->ulOutputContext )
        {

            Free( bus_to_virt (pCurBD->ulOutputContext) );
            pCurBD->ulOutputContext = NULL;
        }
    }
	    if (pRes != NULL)
	    {
	    	Free (pRes);
	    }   
  
    return ERR;
}


ULONG SSX31B_RSACRT_PERF_PRE(SSX31BDRV_CTRL* pDrvCtrl, SSX31BRSA_S* pSd707Rsa)
{
    SSX31B_PKE_BD * pCurBD = NULL;
    SSX31B_PKE_BD * pCurBDTmp = NULL;
    SSX31B_PKE_RD * pCurRD = NULL;
    UCHAR* pRes = NULL;
    UCHAR* pResAligned = NULL;   
    ULONG ulTmt = 0;      
    int i;
    LONG lIntMask;


    if ( pDrvCtrl->ulCurrPkeBdReadPtr == ((pDrvCtrl->ulCurrPkeBdWritePtr + 1) & (SSX31B_PKE_BDQUEUE_LEN - 1)))  
    {
        PRINT("BD Queue full:BD Read:%d write %d", 
            pDrvCtrl->ulCurrPkeBdReadPtr,
            pDrvCtrl->ulCurrPkeBdWritePtr);
        return ERR;
    }

    SplImp(&lIntMask);


    pCurBD = &((SSX31B_PKE_BD *)(pDrvCtrl->ulPkeBDMemBase))[pDrvCtrl->ulCurrPkeBdWritePtr];


		pRes = Malloc( pSd707Rsa->ulODlen + 4);
		if (pRes == NULL)
		{
			PRINT ("\n can't malloc!");
			goto error;
		}
		pResAligned = four_bytes_align (pRes);		
	
		if ( SSX31B_SetBDSrcRsaPrivate( pCurBD, pSd707Rsa ) == ERR )
		{
			goto error;						
		}

		if ( SSX31B_SetBDDstRsaPrivate(pCurBD, pResAligned, pSd707Rsa->ulODlen ) == ERR )
	    	{
	    		goto error;
		}
    

    pCurBD->ulOpCode = pSd707Rsa->ucOpCode;
    pCurBD->ulFlag = pSd707Rsa->ucFlg;
    
    
    
#if 0
{
	ULONG* pulTmp = NULL;
	ULONG* pulTmp1 = NULL;
	int i;
	
	pulTmp = (ULONG*)pCurBD;
	
	PRINT ("\r\nBD: %08x %08x %08x %08x %08x %08x ", pulTmp[0], pulTmp[1], pulTmp[2], pulTmp[3], pulTmp[4], pulTmp[5]); 
	
	pulTmp1 = (ULONG*)((ULONG)bus_to_virt ( pulTmp[1] ));
	for (i=0; i<6; i++)