ssx31bpke.c

海思KEY驱动

	{
		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
    
    for (i=1; i<SSX31B_PKE_BDQUEUE_LEN; i++)
    {
    	pCurBDTmp = &((SSX31B_PKE_BD*)(pDrvCtrl->ulPkeBDMemBase))[ (pDrvCtrl->ulCurrPkeBdWritePtr+i)&(SSX31B_PKE_BDQUEUE_LEN - 1) ];
	memcpy (pCurBDTmp, pCurBD, sizeof (SSX31B_PKE_BD) );
    }   

    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);
	    }   
    SplX(lIntMask);
    return ERR;
}
/*********************************************************DSA*******************************************************************************/
/*********************************************************DSA*******************************************************************************/
/*********************************************************DSA*******************************************************************************/
ULONG SSX31B_SetBDSrcDsaSign(SSX31B_PKE_BD * pCurBD, SSX31BDSA_S* pSd707Dsa)
{
	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= pSd707Dsa->ulPlen + pSd707Dsa->ulQlen + pSd707Dsa->ulGlen + pSd707Dsa->ulXlen + pSd707Dsa->ulKlen +
                                                                                                                   pSd707Dsa->ulMlen;
    pCurBD->ulGatherEnable = CD_GATHER_ENABLE;
    
    pGatherDesc->ulInputPtr = (ULONG)virt_to_bus(pSd707Dsa->pcP);
    pGatherDesc->ulInputLen = pSd707Dsa->ulPlen;
    pGatherDesc->ulInputAttrib = ICD_LAST_SLICE_PKE;
    pGatherDesc->ulOrig = 0;
    
    pGatherDesc ++;
    pGatherDesc->ulInputPtr = (ULONG)virt_to_bus(pSd707Dsa->pcQ);
    pGatherDesc->ulInputLen = pSd707Dsa->ulQlen;
    pGatherDesc->ulInputAttrib = ICD_LAST_SLICE_PKE;
    pGatherDesc->ulOrig = 0;
    
    pGatherDesc ++;        
    pGatherDesc->ulInputPtr = (ULONG)virt_to_bus(pSd707Dsa->pcG);
    pGatherDesc->ulInputLen = pSd707Dsa->ulGlen;
    pGatherDesc->ulInputAttrib = ICD_LAST_SLICE_PKE;
    pGatherDesc->ulOrig = 0;
        
    pGatherDesc ++;
    pGatherDesc->ulInputPtr = (ULONG)virt_to_bus(pSd707Dsa->pcX);
    pGatherDesc->ulInputLen = pSd707Dsa->ulXlen;
    pGatherDesc->ulInputAttrib = ICD_LAST_SLICE_PKE;
    pGatherDesc->ulOrig = 0;
    
    pGatherDesc ++;
    pGatherDesc->ulInputPtr = (ULONG)virt_to_bus(pSd707Dsa->pcK);
    pGatherDesc->ulInputLen = pSd707Dsa->ulKlen;
    pGatherDesc->ulInputAttrib = ICD_LAST_SLICE_PKE;
    pGatherDesc->ulOrig = 0;
    
    pGatherDesc ++;
    pGatherDesc->ulInputPtr = (ULONG)virt_to_bus(pSd707Dsa->pcM);
    pGatherDesc->ulInputLen = pSd707Dsa->ulMlen;
    pGatherDesc->ulInputAttrib = ICD_LAST_SLICE_PKE;
    pGatherDesc->ulOrig = pSd707Dsa->bHash;

    return OK;
}
ULONG SSX31B_SetBDDstDsaSign(SSX31B_PKE_BD * pCurBD, UCHAR* pcR, ULONG ulRlen, UCHAR* pcS, ULONG ulSlen )
{
	SSX31B_PKE_OCD* pScatterDesc = NULL;
	ULONG* ulTmp;

    pScatterDesc = (SSX31B_PKE_OCD*)Malloc( 2 * sizeof(SSX31B_PKE_OCD) );

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

    pCurBD->ulOutputContext  = (ULONG)virt_to_bus(pScatterDesc);  
    pCurBD->ulOutputNum = 2;
    pCurBD->ulOutputLength0= ulRlen + ulSlen;
    pCurBD->ulScatterEnable = CD_SCATTER_ENABLE;
  
    pScatterDesc->ulOutputPtr = (ULONG)virt_to_bus(pcR);
    pScatterDesc->ulOutputLen = ulRlen;
    pScatterDesc->ulOutputAttrib = OCD_LAST_SLICE_PKE;
    pScatterDesc->ulOrig = 0;
    
        
    pScatterDesc ++;
    pScatterDesc->ulOutputPtr = (ULONG)virt_to_bus(pcS);
    pScatterDesc->ulOutputLen = ulSlen;
    pScatterDesc->ulOutputAttrib = OCD_LAST_SLICE_PKE;
    pScatterDesc->ulOrig = 0;
    
    
    return OK;
}

ULONG SSX31B_SetBDSrcDsaAuth(SSX31B_PKE_BD * pCurBD, SSX31BDSA_S* pSd707Dsa)
{
	SSX31B_PKE_ICD* pGatherDesc = NULL;

    pGatherDesc = (SSX31B_PKE_ICD*)Malloc( 7 * 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 = 7;
    pCurBD->ulInputLength= pSd707Dsa->ulPlen + pSd707Dsa->ulQlen + pSd707Dsa->ulGlen + pSd707Dsa->ulYlen + pSd707Dsa->ulRlen +
                                                                                                    pSd707Dsa->ulSlen + pSd707Dsa->ulMlen;
    pCurBD->ulGatherEnable = CD_GATHER_ENABLE;
    
    pGatherDesc->ulInputPtr = (ULONG)virt_to_bus(pSd707Dsa->pcP);
    pGatherDesc->ulInputLen = pSd707Dsa->ulPlen;
    pGatherDesc->ulInputAttrib = ICD_LAST_SLICE_PKE;
    pGatherDesc->ulOrig = 0;
    
    pGatherDesc ++;
    pGatherDesc->ulInputPtr = (ULONG)virt_to_bus(pSd707Dsa->pcQ);
    pGatherDesc->ulInputLen = pSd707Dsa->ulQlen;
    pGatherDesc->ulInputAttrib = ICD_LAST_SLICE_PKE;
    pGatherDesc->ulOrig = 0;
    
    pGatherDesc ++;    
    pGatherDesc->ulInputPtr = (ULONG)virt_to_bus(pSd707Dsa->pcG);
    pGatherDesc->ulInputLen = pSd707Dsa->ulGlen;
    pGatherDesc->ulInputAttrib = ICD_LAST_SLICE_PKE;
    pGatherDesc->ulOrig = 0;
        
    pGatherDesc ++;
    pGatherDesc->ulInputPtr = (ULONG)virt_to_bus(pSd707Dsa->pcY);
    pGatherDesc->ulInputLen = pSd707Dsa->ulYlen;
    pGatherDesc->ulInputAttrib = ICD_LAST_SLICE_PKE;
    pGatherDesc->ulOrig = 0;
    
    pGatherDesc ++;
    pGatherDesc->ulInputPtr = (ULONG)virt_to_bus(pSd707Dsa->pcR);
    pGatherDesc->ulInputLen = pSd707Dsa->ulRlen;
    pGatherDesc->ulInputAttrib = ICD_LAST_SLICE_PKE;
    pGatherDesc->ulOrig = 0;
    
    pGatherDesc ++;
    pGatherDesc->ulInputPtr = (ULONG)virt_to_bus(pSd707Dsa->pcS);
    pGatherDesc->ulInputLen = pSd707Dsa->ulSlen;
    pGatherDesc->ulInputAttrib = ICD_LAST_SLICE_PKE;
    pGatherDesc->ulOrig = 0;
    
    pGatherDesc ++;
    pGatherDesc->ulInputPtr = (ULONG)virt_to_bus(pSd707Dsa->pcM);
    pGatherDesc->ulInputLen = pSd707Dsa->ulMlen;
    pGatherDesc->ulInputAttrib = ICD_LAST_SLICE_PKE;
    pGatherDesc->ulOrig = pSd707Dsa->bHash;

    return OK;
}

ULONG SSX31B_SetBDDstDsaAuth(SSX31B_PKE_BD * pCurBD, CHAR* pcV, ULONG ulVlen)
{
    pCurBD->ulOutputContext = (ULONG)virt_to_bus(pcV);
    pCurBD->ulOutputLength0 = ulVlen;
    pCurBD->ulOutputNum  = 0;
    pCurBD->ulScatterEnable &= ~CD_SCATTER_ENABLE;
    
    return OK;
}



ULONG SSX31B_DSA(SSX31BDRV_CTRL* pDrvCtrl, SSX31BDSA_S* pSd707Dsa)
{
    SSX31B_PKE_BD * pCurBD = NULL;
    SSX31B_PKE_RD * pCurRD = NULL;
    UCHAR* pRes = NULL;
    UCHAR* pRes1 = NULL;
    UCHAR* pResAligned = NULL;  
    UCHAR* pResAligned1 = 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 ( pSd707Dsa->ucOpCode )
    {
	case SSX31B_OPER_DH_DSA_SIGNAL:
	{     
		
		pRes = Malloc( pSd707Dsa->ulRlen + 4);
		if (pRes == NULL)
		{
			PRINT ("\n can't malloc!");
			goto error;
		}
		pResAligned = four_bytes_align (pRes); 
		
		pRes1 = Malloc( pSd707Dsa->ulSlen + 4);
		if (pRes1 == NULL)
		{
			PRINT ("\n can't malloc!");
			goto error;
		}
		pResAligned1 = four_bytes_align (pRes1); 
		
		if ( SSX31B_SetBDSrcDsaSign( pCurBD, pSd707Dsa ) == ERR )
		{
			goto error;						
		}

		if ( SSX31B_SetBDDstDsaSign(pCurBD, pResAligned, pSd707Dsa->ulRlen, pResAligned1, pSd707Dsa->ulSlen) == ERR )
	    	{
	    		goto error;
		}
		
		break;
	}	
	
	case SSX31B_OPER_DH_DSA_AUTH:   
	{ 
		pRes = Malloc( pSd707Dsa->ulVlen + 4);
		if (pRes == NULL)
		{
			PRINT ("\n can't malloc!");
			goto error;
		}
		pResAligned = four_bytes_align (pRes); 
		
		if ( SSX31B_SetBDSrcDsaAuth(pCurBD, pSd707Dsa ) == ERR )
		{
			goto error;
		}

		if ( SSX31B_SetBDDstDsaAuth(pCurBD, pResAligned, pSd707Dsa->ulVlen) == ERR )
	   	{
	    		goto error;
		}

		break;
	}

	default:
		break;
	}
    

    pCurBD->ulOpCode = pSd707Dsa->ucOpCode;
    pCurBD->ulFlag = pSd707Dsa->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<7; 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
{
	PRINT ("\r\nres: %08x %08x %08x", *((ULONG*)pResAligned),  *((ULONG*)pResAligned+4), *((ULONG*)pResAligned+8) );
}
#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;
               }
           }
	   
   	   switch ( pSd707Dsa->ucOpCode )
    	   {
		case SSX31B_OPER_DH_DSA_SIGNAL:
		{     
		
	            if (pResAligned != NULL)
	            {
		          memcpy (pSd707Dsa->pcR, pResAligned, pSd707Dsa->ulRlen);
    	            }
	            if (pResAligned1 != NULL)
	            {
		          memcpy (pSd707Dsa->pcS, pResAligned1, pSd707Dsa->ulSlen);
              	    }
  	
			break;
		}	
	
		case SSX31B_OPER_DH_DSA_AUTH:   
		{ 
	            if (pResAligned != NULL)
	            {
		          memcpy (pSd707Dsa->pcV, pResAligned, pSd707Dsa->ulVlen);
    	            }

			break;
		}

		default:
			break;
	    }
    
	    if (pRes != NULL)
	    {
	    	Free (pRes);
	    }
	    if (pRes1 != NULL)
	    {
	    	Free (pRes1);
	    }
   
            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);
	    }
	    if (pRes1 != NULL)
	    {
	    	Free (pRes1);
	    }

        SplX(lIntMask);
    
    
        return ERR;


    }