📄 ssx31apke.c
字号:
{
if (pCurBD->ulOutputContext )
{
Free( bus_to_virt(pCurBD->ulOutputContext) );
pCurBD->ulOutputContext = NULL;
}
}
if (pRes != NULL)
{
Free (pRes);
}
if (pRes1 != NULL)
{
Free (pRes1);
}
return ERR;
}
/*********************************************************DH*******************************************************************************/
/*********************************************************DH*******************************************************************************/
/*********************************************************DH*******************************************************************************/
ULONG SSX31A_SetBDSrcDhPub(PEBD_DESC * pCurBD, SSX31ADH_S* pSSX31ADh)
{
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= pSSX31ADh->ulNlen + pSSX31ADh->ulXalen + pSSX31ADh->ulGlen;
pCurBD->ulGatherEnable = BD_GATHER_ENABLE;
pGatherDesc->ulInputPtr = (ULONG)virt_to_bus(pSSX31ADh->pcN);
pGatherDesc->ulInputLen = pSSX31ADh->ulNlen;
pGatherDesc->ulInputAttrib = ICD_ATTRIB_LAST_PART;
pGatherDesc->ulOrig = 0;
pGatherDesc ++;
pGatherDesc->ulInputPtr = (ULONG)virt_to_bus(pSSX31ADh->pcXa);
pGatherDesc->ulInputLen = pSSX31ADh->ulXalen;
pGatherDesc->ulInputAttrib = ICD_ATTRIB_LAST_PART;
pGatherDesc->ulOrig = pSSX31ADh->ucXaFlg;
pGatherDesc ++;
pGatherDesc->ulInputPtr = (ULONG)virt_to_bus(pSSX31ADh->pcG);
pGatherDesc->ulInputLen = pSSX31ADh->ulGlen;
pGatherDesc->ulInputAttrib = ICD_ATTRIB_LAST_PART;
pGatherDesc->ulOrig = 0;
return OK;
}
ULONG SSX31A_SetBDDstDhPub(PEBD_DESC * pCurBD, UCHAR* pcYa, ULONG ulYalen, UCHAR* pcXaOut, ULONG ulXaOutlen )
{
SSX31A_OCD* pScatterDesc = NULL;
ULONG* ulTmp;
pScatterDesc = (SSX31A_OCD*)Malloc( 2 * sizeof(SSX31A_OCD) );
if (pScatterDesc == NULL)
{
#ifdef HI_DBG
PRINT("SSX31A driver PE send mem alloc fail\r\n");
#endif
return ERR;
}
pCurBD->ulOutputContext = (ULONG)virt_to_bus(pScatterDesc);
pCurBD->ulOutputNum = 2;
pCurBD->ulOutputLength0= ulYalen + ulXaOutlen;
pCurBD->ulScatterEnable = BD_SCATTER_ENABLE;
pScatterDesc->ulOutputPtr = (ULONG)virt_to_bus(pcYa);
pScatterDesc->ulOutputLen = ulYalen;
pScatterDesc->ulOutputAttrib = ICD_ATTRIB_LAST_PART;
pScatterDesc->ulOrig = 0;
pScatterDesc ++;
pScatterDesc->ulOutputPtr = (ULONG)virt_to_bus(pcXaOut);
pScatterDesc->ulOutputLen = ulXaOutlen;
pScatterDesc->ulOutputAttrib = ICD_ATTRIB_LAST_PART;
pScatterDesc->ulOrig = 0;
return OK;
}
ULONG SSX31A_SetBDSrcDhPri(PEBD_DESC * pCurBD, SSX31ADH_S* pSSX31ADh)
{
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= pSSX31ADh->ulNlen + pSSX31ADh->ulXalen + pSSX31ADh->ulYblen;
pCurBD->ulGatherEnable = BD_GATHER_ENABLE;
pGatherDesc->ulInputPtr = (ULONG)virt_to_bus(pSSX31ADh->pcN);
pGatherDesc->ulInputLen = pSSX31ADh->ulNlen;
pGatherDesc->ulInputAttrib = ICD_ATTRIB_LAST_PART;
pGatherDesc->ulOrig = 0;
pGatherDesc ++;
pGatherDesc->ulInputPtr = (ULONG)virt_to_bus(pSSX31ADh->pcXa);
pGatherDesc->ulInputLen = pSSX31ADh->ulXalen;
pGatherDesc->ulInputAttrib = ICD_ATTRIB_LAST_PART;
pGatherDesc->ulOrig = 0;
pGatherDesc ++;
pGatherDesc->ulInputPtr = (ULONG)virt_to_bus(pSSX31ADh->pcYb);
pGatherDesc->ulInputLen = pSSX31ADh->ulYblen;
pGatherDesc->ulInputAttrib = ICD_ATTRIB_LAST_PART;
pGatherDesc->ulOrig = 0;
return OK;
}
ULONG SSX31A_SetBDDstDhPri(PEBD_DESC * pCurBD, CHAR* pcXab, ULONG ulXablen)
{
pCurBD->ulOutputContext = (ULONG)virt_to_bus(pcXab);
pCurBD->ulOutputLength0 = ulXablen;
pCurBD->ulOutputNum = 0;
pCurBD->ulScatterEnable &= ~BD_SCATTER_ENABLE;
return OK;
}
ULONG SSX31A_DH(SSX31ADRV_CTRL* pDrvCtrl, SSX31ADH_S* pSSX31ADh)
{
PEBD_DESC * pCurBD = NULL;
PERD_DESC * pCurRD = NULL;
UCHAR* pRes = NULL;
UCHAR* pRes1 = NULL;
UCHAR* pResAligned = NULL;
UCHAR* pResAligned1 = 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 ( pSSX31ADh->ucOpCode )
{
case BD_OPCODE_DH_PUBLICKEY_PRODUCT:
{
pRes = Malloc( pSSX31ADh->ulYalen + 4);
if (pRes == NULL)
{
#ifdef HI_DBG
PRINT ("\n can't malloc!");
#endif
goto error;
}
pResAligned = four_bytes_align (pRes);
pRes1 = Malloc( pSSX31ADh->ulXaOutlen + 4);
if (pRes1 == NULL)
{
#ifdef HI_DBG
PRINT ("\n can't malloc!");
#endif
goto error;
}
pResAligned1 = four_bytes_align (pRes1);
if ( SSX31A_SetBDSrcDhPub( pCurBD, pSSX31ADh ) == ERR )
{
goto error;
}
if ( SSX31A_SetBDDstDhPub(pCurBD, pResAligned, pSSX31ADh->ulYalen, pResAligned1, pSSX31ADh->ulXaOutlen) == ERR )
{
goto error;
}
break;
}
case BD_OPCODE_DH_PRIVATEKEY_PRODUCT:
{
pRes = Malloc( pSSX31ADh->ulXablen + 4);
if (pRes == NULL)
{
#ifdef HI_DBG
PRINT ("\n can't malloc!");
#endif
goto error;
}
pResAligned = four_bytes_align (pRes);
if ( SSX31A_SetBDSrcDhPri(pCurBD, pSSX31ADh ) == ERR )
{
goto error;
}
if ( SSX31A_SetBDDstDhPri(pCurBD, pResAligned, pSSX31ADh->ulXablen) == ERR )
{
goto error;
}
break;
}
default:
break;
}
pCurBD->ulOpCode = pSSX31ADh->ucOpCode;
pCurBD->ulFlag = pSSX31ADh->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<3; 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;
}
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;
}
}
switch ( pSSX31ADh->ucOpCode )
{
case BD_OPCODE_DH_PUBLICKEY_PRODUCT:
{
if (pResAligned != NULL)
{
memcpy (pSSX31ADh->pcYa, pResAligned, pSSX31ADh->ulYalen);
}
if (pResAligned1 != NULL)
{
memcpy (pSSX31ADh->pcXaOut, pResAligned1, pSSX31ADh->ulXaOutlen);
}
break;
}
case BD_OPCODE_DH_PRIVATEKEY_PRODUCT:
{
if (pResAligned != NULL)
{
memcpy (pSSX31ADh->pcXab, pResAligned, pSSX31ADh->ulXablen);
}
break;
}
default:
break;
}
if (pRes != NULL)
{
Free (pRes);
}
if (pRes1 != NULL)
{
Free (pRes1);
}
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);
}
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;
}
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -