ssx31apke.c

海思KEY驱动

    	PRINT ("\r\nnot finish");
#endif	
	SplX(lIntMask); 

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

            Free( bus_to_virt(pCurBD->ulInputContext) );
            pCurBD->ulInputContext = NULL;
        }
    }
    if (pCurBD->ulScatterEnable == BD_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;

    }

	SplX(lIntMask);
    return OK;


error:
	SplX(lIntMask); 

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

            Free( bus_to_virt(pCurBD->ulInputContext) );
            pCurBD->ulInputContext = NULL;
        }
    }
    if (pCurBD->ulScatterEnable == BD_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 SSX31A_SetBDDstRsaPrivate(PEBD_DESC * pCurBD, UCHAR* pcOD, ULONG ulODlen)
{
    pCurBD->ulOutputContext = (ULONG)virt_to_bus(pcOD);
    pCurBD->ulOutputLength0 = ulODlen;
    pCurBD->ulOutputNum  = 0;
    pCurBD->ulScatterEnable &= ~BD_SCATTER_ENABLE;

    return OK;
}

ULONG SSX31A_SetBDSrcRsaPrivate(PEBD_DESC * pCurBD, SSX31ARSA_S* pSSX31ARsa)
{
	SSX31A_ICD* pGatherDesc = NULL;

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

	
    if (pGatherDesc == NULL)
    {
#ifdef HI_DBG      
        PRINT("SSX31A driver PE send mem alloc fail\r\n");
#endif	
        return ERR;                               
    }

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

	return OK;
}

ULONG SSX31A_SetBDDstRsaPublic(PEBD_DESC * pCurBD, UCHAR* pcOD, ULONG ulODlen)
{
    pCurBD->ulOutputContext = (ULONG)virt_to_bus(pcOD);
    pCurBD->ulOutputLength0 = ulODlen;
    pCurBD->ulOutputNum  = 0;
    pCurBD->ulScatterEnable &= ~BD_SCATTER_ENABLE;

    return OK;
}

ULONG SSX31A_SetBDSrcRsaPublic(PEBD_DESC * pCurBD, SSX31ARSA_S* pSSX31ARsa)
{
	SSX31A_ICD* pGatherDesc = NULL;

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

	
    if (pGatherDesc == NULL)
    {
#ifdef HI_DBG      
        PRINT("SSX31A driver PE send mem alloc fail\r\n");
#endif	
        return ERR;                               
    }

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

	return OK;
}

ULONG SSX31A_RSA(SSX31ADRV_CTRL* pDrvCtrl, SSX31ARSA_S* pSSX31ARsa)
{
    PEBD_DESC * pCurBD = NULL;
    PERD_DESC * pCurRD = NULL;
    UCHAR* pRes = NULL;
    UCHAR* pResAligned = NULL;     
    int i;
    ULONG ulTmt = 0;
    LONG lIntMask;

    if ( pDrvCtrl->ulCurrDMA2BdReadPtr == ((pDrvCtrl->ulCurrDMA2BdWritePtr + 1) & (SSX31A_DMA2_BDQUEUE_LEN - 1)))  /* 发送队列写指针加1取模 */
    {
#ifdef HI_DBG      
        PRINT("BD Queue full:BD Read:%d write %d", 
            pDrvCtrl->ulCurrDMA2BdReadPtr,
            pDrvCtrl->ulCurrDMA2BdWritePtr);
#endif	    
        return ERR;
    }

    SplImp(&lIntMask);


    pCurBD = &((PEBD_DESC *)(pDrvCtrl->ulDMA2BDMemBase))[pDrvCtrl->ulCurrDMA2BdWritePtr];

    switch ( pSSX31ARsa->ucOpCode )
    {
	case BD_OPCODE_RSA_PUBLICKEY_OPERATION:
	
		pRes = Malloc( pSSX31ARsa->ulODlen + 4);
		if (pRes == NULL)
		{
#ifdef HI_DBG  		
			PRINT ("\n can't malloc!");
#endif			
			goto error;
		}
		pResAligned = four_bytes_align (pRes);	
	
   
		if ( SSX31A_SetBDSrcRsaPublic( pCurBD, pSSX31ARsa ) == ERR )
		{
			goto error;						
		}

		if ( SSX31A_SetBDDstRsaPublic(pCurBD, pResAligned, pSSX31ARsa->ulODlen ) == ERR )
	    	{
	    		goto error;
		}
		
		break;
	
	case BD_OPCODE_RSA_PRIVATEKEY_OPERATION:   
	 
		pRes = Malloc( pSSX31ARsa->ulODlen + 4);
		if (pRes == NULL)
		{
#ifdef HI_DBG  		
			PRINT ("\n can't malloc!");
#endif			
			goto error;
		}
		pResAligned = four_bytes_align (pRes);		
	
		if ( SSX31A_SetBDSrcRsaPrivate( pCurBD, pSSX31ARsa ) == ERR )
		{
			goto error;						
		}

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

		break;

	
 
	default:
		break;
	}
    

    pCurBD->ulOpCode = pSSX31ARsa->ucOpCode;
    pCurBD->ulFlag = pSSX31ARsa->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->ulCurrDMA2BdWritePtr = (pDrvCtrl->ulCurrDMA2BdWritePtr + 1) & (SSX31A_DMA2_BDQUEUE_LEN - 1); 
    PciWrite32(SSX31A_BQWP2_RW, pDrvCtrl->ulCurrDMA2BdWritePtr);
    

    pDrvCtrl->ulFreeDMA2BDs --; 

    ulTmt = (DMA2_TMOUT & 0xffff)*100 + 100000;

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


        PciRead32(SSX31A_BQRP2_RW, &pDrvCtrl->ulCurrDMA2BdReadPtr);
        

        PciRead32(SSX31A_RQWP2_RW, &pDrvCtrl->ulCurrDMA2RdWritePtr);

	
        if (pDrvCtrl->ulCurrDMA2RdWritePtr == pDrvCtrl->ulCurrDMA2RdReadPtr)
        {
            continue;
        }
        else
        {
            pCurRD = &((PERD_DESC *)(pDrvCtrl->ulDMA2RDMemBase))[pDrvCtrl->ulCurrDMA2RdReadPtr];	
	    if ((pCurRD->ulStatus & MASK_RD_STATUS_ERRCODE) != RD_STATUS_RDVALID)
	    {
#ifdef HI_DBG  	    
	    	PRINT ("\nPKE err!");
		PRINT ("\nstatus: %04x", pCurRD->ulStatus);
#endif		
		goto error; 
	    }
#ifdef HI_DBG  	    
{

	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 == BD_GATHER_ENABLE )
    	    {
    	    	if (pCurRD->ulInputContext )
            	{
           		 Free( bus_to_virt(pCurRD->ulInputContext) );
        	         pCurRD->ulInputContext = NULL;
            	}
            }
           if (pCurRD->ulScatterEnable == BD_SCATTER_ENABLE )
           {
               if (pCurRD->ulOutputContext )
               {
                   Free( bus_to_virt(pCurRD->ulOutputContext) );
                   pCurRD->ulOutputContext = NULL;
               }
	   }
    
          memcpy (pSSX31ARsa->pcOD, pResAligned, pSSX31ARsa->ulODlen);

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


            if (pDrvCtrl->ulCurrDMA2RdWritePtr == pDrvCtrl->ulCurrDMA2RdReadPtr)
            {

                PciWrite32(SSX31A_RQRP2_RW, pDrvCtrl->ulCurrDMA2RdReadPtr); 

               pDrvCtrl->ulFreeDMA2BDs ++;

               break;
            }
	    

        }
	

    }

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

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

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

    }

	SplX(lIntMask);
    return OK;


error:
	SplX(lIntMask);

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

            Free( bus_to_virt (pCurBD->ulInputContext) );
            pCurBD->ulInputContext = NULL;
        }
    }
    if (pCurBD->ulScatterEnable == BD_SCATTER_ENABLE )
    {
        if (pCurBD->ulOutputContext )
        {
            Free( bus_to_virt (pCurBD->ulOutputContext) );
            pCurBD->ulOutputContext = NULL;
        }
    }
	    if (pRes != NULL)
	    {
	    	Free (pRes);
	    }   
  
    return ERR;
}
/*********************************************************DSA*******************************************************************************/
/*********************************************************DSA*******************************************************************************/
/*********************************************************DSA*******************************************************************************/
ULONG SSX31A_SetBDSrcDsaSign(PEBD_DESC * pCurBD, SSX31ADSA_S* pSSX31ADsa)