int32 runDes8651bGeneralApiRandTest(uint32 seed, uint32 round) {
uint32 roundIdx, modeIdx, pktLen, i, offset, errCount;
uint32 doneCounter, allDoneCounter;
int32 ret = SUCCESS;
cryptGenAsic = (int8 *) UNCACHED_MALLOC(4352);
tauset(58, (int32)seed);
errCount = 0;
for(roundIdx = 0; roundIdx<round; roundIdx++) {
for(i=0; i<24; i++)
cryptGenKey[i] = taurand(256)&0xFF;
for(i=0; i<8; i++)
cryptGenIv[i] = taurand(256)&0xFF;
modeIdx = taurand(4)&0x3;
pktLen = (taurand(4080)&0xFF8) + 8;
offset = taurand(4)&0x3;
for(i=0; i<pktLen; i++)//8-byte for IV and 4-byte for DMA_addr (0-3) byte offset test
cryptGenAsic[i+offset] = taurand(256)&0xFF;
rtl8651b_cryptoEngineGetIntCounter(&doneCounter, &allDoneCounter);
rtlglue_printf("\r[%05u, %03u]Mode: %s Packet length %04u Offset %u (%u, %u)", roundIdx, errCount, desOpModeString[modeIdx&0x3], pktLen, offset, doneCounter, allDoneCounter);
if(des8651bGeneralApiTestItem(modeIdx&0x3, &cryptGenAsic[offset], pktLen, cryptGenKey, cryptGenIv) == FAILED)
errCount++;
}
UNCACHED_FREE(cryptGenAsic);
rtlglue_printf("\nGeneral API Test Finished\n");
return ret;
}
int32 authTest_hashTest(void) {
uint32 i, dataLen;
for(i=0; i<2048; i++)
asicTestData[i] = 0xFF;//(uint8)taurand(256);
for(dataLen = 8; dataLen<2048; dataLen++) {
rtlglue_printf("\r Hashing 0xFF pattern data length %4u", dataLen);
rtl8651b_authEngine_md5(asicTestData, dataLen, asicDigest);
authSim_md5(asicTestData, dataLen, simDigest);
if(memcmp(asicDigest, simDigest, RTL8651B_MD5_DIGEST_LENGTH)) {
displayDigestMismatch("Hash MD5 Digest mismatch", asicTestData, dataLen, NULL, 0, "ASIC", asicDigest, "SIM", simDigest, RTL8651B_MD5_DIGEST_LENGTH);
if(memcmp(asicDigest, nullPattern, RTL8651B_MD5_DIGEST_LENGTH) != 0)
triggerGpio();
break;
}
}
for(dataLen = 8; dataLen<2048; dataLen++) {
rtlglue_printf("\r Hashing 0xFF pattern data length %4u", dataLen);
rtl8651b_authEngine_sha1(asicTestData, dataLen, asicDigest);
authSim_sha1(asicTestData, dataLen, simDigest);
if(memcmp(asicDigest, simDigest, RTL8651B_SHA1_DIGEST_LENGTH)) {
displayDigestMismatch("Hash SHA1 Digest mismatch", asicTestData, dataLen, NULL, 0, "ASIC", asicDigest, "SIM", simDigest, RTL8651B_SHA1_DIGEST_LENGTH);
if(memcmp(asicDigest, nullPattern, RTL8651B_SHA1_DIGEST_LENGTH) != 0)
triggerGpio();
break;
}
}
rtlglue_printf("\nHash SHA-1 ASIC test PASS\n");
return SUCCESS;
}
/* dump the tx ring info */
int32 rtl_dumpTxRing(void)
{
int idx, cnt;
struct rtl_pktHdr * pPkthdr = NULL;
for(idx=0;idx<RTL865X_SWNIC_TXRING_HW_PKTDESC;idx++)
{
rtlglue_printf("**********************************************\nTxRing%d: cnt %d\n",
idx, txPkthdrRingCnt[idx]);
/* skip the null rx ring */
if (txPkthdrRingCnt[idx]==0)
continue;
/* dump all the pkt header */
for(cnt=0;cnt<txPkthdrRingCnt[idx];cnt++)
{
#ifdef CONFIG_RTL8196C_REVISION_B
if (rtl_chip_version == RTL8196C_REVISION_A)
pPkthdr = (struct rtl_pktHdr *) (txPkthdrRing_backup[idx][cnt] & ~(DESC_OWNED_BIT | DESC_WRAP));
else
#endif
pPkthdr = (struct rtl_pktHdr *) (txPkthdrRing[idx][cnt] & ~(DESC_OWNED_BIT | DESC_WRAP));
rtlglue_printf(" idx[%03d]: 0x%p-->mbuf[0x%p],skb[0x%p]%s%s%s%s\n", cnt, pPkthdr, pPkthdr->ph_mbuf, pPkthdr->ph_mbuf->skb,
(txPkthdrRing[idx][cnt]&DESC_OWNED_BIT)==DESC_RISC_OWNED?" :CPU":" :SWCORE",
(txPkthdrRing[idx][cnt]&DESC_WRAP)!=0?" :WRAP":"",
cnt==currTxPkthdrDescIndex[idx]?" <===currIdx":"",
cnt==txPktDoneDescIndex[idx]?" <===txDoneIdx":"");
}
}
return SUCCESS;
}
int32 swNic_rxRunoutTxPending(struct rtl_pktHdr *pPkthdr){
//exception handling
struct rtl_pktHdr *freePkthdrListHead, *freePkthdrListTail;
struct rtl_mBuf *freeMbufListHead, *freeMbufListTail;
uint32 wrap=0;
rtlglue_printf("Desc %d (ph: %08x): Rx runout by pending Tx\n", rxPhdrIndex,(uint32)pPkthdr );
pPkthdr->ph_rxdesc = totalRxPkthdr;
if (rxPhdrIndex==totalRxPkthdr-1)
wrap=0x2;
if ((mBuf_driverGetPkthdr(1, &freePkthdrListHead, &freePkthdrListTail))!=1){
rtlglue_printf("No more pkthdr. runout NOT solved!!\n");
return FAILED;
}
if(1!=mBuf_driverGet(1, &freeMbufListHead, &freeMbufListTail)){
rtlglue_printf("No more mbuf. runout NOT solved!!\n");
mBuf_driverFreePkthdr(freePkthdrListHead, 1, 0);
return FAILED;
}
#ifndef CONFIG_RTL865X_CACHED_NETWORK_IO
freeMbufListHead->m_extbuf=(uint8 *)UNCACHE(freeMbufListHead->m_extbuf);
freeMbufListHead->m_data=(uint8 *)UNCACHE(freeMbufListHead->m_data);
#endif
#if defined(CONFIG_RTL865X_MBUF_HEADROOM)&&defined(CONFIG_RTL865X_MULTILAYER_BSP)
if(mBuf_reserve(freeMbufListHead, CONFIG_RTL865X_MBUF_HEADROOM))
rtlglue_printf("Failed when init Rx %d\n", rxPhdrIndex);
#endif
freePkthdrListHead->ph_flags&=~PKTHDR_DRIVERHOLD;
RxMbufRing[rxPhdrIndex] = (uint32) freeMbufListHead | DESC_SWCORE_OWNED|wrap;
RxPkthdrRing[rxPhdrIndex] = (uint32) freePkthdrListHead | DESC_SWCORE_OWNED | wrap;
return SUCCESS;
}
// tauset(58, 19);
// taurand(2040);
int32 authTest_hmacTest(void) {
uint32 i, dataLen, keyLen;
dataLen = 2048;
keyLen = 8;
for(i=0; i<2048; i++)
asicTestData[i] = 0xFF;//(uint8)taurand(256);
for(i=0; i<keyLen; i++)
asicTestKey[i] = 0x01;//(uint8)taurand(256);
for(dataLen = 8; dataLen<2048; dataLen++) {
rtlglue_printf("\r HMAC MD5 0xFF pattern data length %4u", dataLen);
rtl8651b_authEngine_hmacMd5(asicTestData, dataLen, asicTestKey, keyLen, asicDigest);
authSim_hmacMd5(asicTestData, dataLen, asicTestKey, keyLen, simDigest);
if(memcmp(asicDigest, simDigest, RTL8651B_MD5_DIGEST_LENGTH)) {
displayDigestMismatch("HMAC MD5 Digest mismatch", asicTestData, dataLen, asicTestKey, keyLen, "ASIC", asicDigest, "SIM", simDigest, RTL8651B_MD5_DIGEST_LENGTH);
if(memcmp(asicDigest, nullPattern, RTL8651B_MD5_DIGEST_LENGTH) != 0)
triggerGpio();
break;
}
}
for(dataLen = 8; dataLen<2048; dataLen++) {
rtlglue_printf("\r HMAC SHA-1 0xFF pattern data length %4u", dataLen);
rtl8651b_authEngine_hmacSha1(asicTestData, dataLen, asicTestKey, keyLen, asicDigest);
authSim_hmacSha1(asicTestData, dataLen, asicTestKey, keyLen, simDigest);
if(memcmp(asicDigest, simDigest, RTL8651B_SHA1_DIGEST_LENGTH)) {
displayDigestMismatch("HMAC SHA1 Digest mismatch", asicTestData, dataLen, asicTestKey, keyLen, "ASIC", asicDigest, "SIM", simDigest, RTL8651B_SHA1_DIGEST_LENGTH);
if(memcmp(asicDigest, nullPattern, RTL8651B_SHA1_DIGEST_LENGTH) != 0)
triggerGpio();
break;
}
}
return SUCCESS;
}
/* dump brief info */
int32 rtl_dumpIndexs(void)
{
int i;
rtlglue_printf("Dump RX infos:\n");
#if defined(DELAY_REFILL_ETH_RX_BUF)
for(i=0;i<RTL865X_SWNIC_RXRING_HW_PKTDESC;i++) {
rtlglue_printf(" TotalCnt: %d, currPkthdrIdx: %d currMbufIdx: %d readyForHwIdx: %d crossBoundFlag: %d.\n",
rxPkthdrRingCnt[i], currRxPkthdrDescIndex[i], currRxMbufDescIndex, rxDescReadyForHwIndex[i], rxDescCrossBoundFlag[i]);
}
#else
for(i=0;i<RTL865X_SWNIC_RXRING_HW_PKTDESC;i++) {
rtlglue_printf(" TotalCnt: %d, currPkthdrIdx: %d currMbufIdx: %d\n",
rxPkthdrRingCnt[i], currRxPkthdrDescIndex[i], currRxMbufDescIndex);
}
#endif
rtlglue_printf("\nDump TX infos:\n");
for(i=0;i<RTL865X_SWNIC_TXRING_HW_PKTDESC;i++) {
rtlglue_printf(" TotalCnt: %d, currPkthdrIdx: %d pktDoneIdx: %d.\n",
txPkthdrRingCnt[i], currTxPkthdrDescIndex[i], txPktDoneDescIndex[i]);
}
return SUCCESS;
}
static int32 swNic_counterCmd(uint32 userId, int32 argc,int8 **saved){
int8 *nextToken;
int32 size;
cle_getNextCmdToken(&nextToken,&size,saved);
if(strcmp(nextToken, "dump") == 0){
swNicCounter_t counter;
rtlglue_printf("Switch NIC statistics:\n\n");
swNic_getCounters(&counter);
rtlglue_printf("rxIntNum: %u, txIntNum: %u, pktRunout: %u, , rxErr: %u, txErr: %u\n",
counter.rxIntNum, counter.txIntNum, counter.rxPkthdrRunoutNum, counter.rxPktErrorNum, counter.txPktErrorNum);
rtlglue_printf("Interrupt register 0x%08x interrupt mask 0x%08x\n", REG32(CPUIISR), REG32(CPUIIMR));
rtlglue_printf("Rx Packet Counter: %d Tx Packet Counter: %d\n", counter.rxPktCounter, counter.txPktCounter);
rtlglue_printf("Run Out: %d Rx solved: %d linkChanged: %d\n", counter.rxPkthdrRunoutNum, counter.rxPkthdrRunoutSolved, counter.linkChanged);
rtlglue_printf("currRxPkthdrDescIndex: %d currRxMbufDescIndex: %d\n",counter.currRxPkthdrDescIndex,counter.currRxMbufDescIndex);
rtlglue_printf("currTxPkthdrDescIndex: %d freeTxPkthdrDescIndex: %d\n",counter.currTxPkthdrDescIndex, counter.freeTxPkthdrDescIndex);
rtlglue_printf("ASIC dropped %d.\n", rtl8651_returnAsicCounter(0x4));
}else{
rtlglue_printf("Reset all NIC internal counters\n");
swNic_resetCounters();
}
return SUCCESS;
int32 des8651bTest(uint32 round, uint32 funStart, uint32 funEnd, uint32 lenStart, uint32 lenEnd, uint32 offsetStart, uint32 offsetEnd) {
uint32 i, pktLen, offset, funIdx, dupRound;
tauset(58, 19);
cryptOrg = (int8 *) UNCACHED_MALLOC(4352);
cryptAsic = (int8 *) UNCACHED_MALLOC(4352);
cryptEncrypt = (int8 *) UNCACHED_MALLOC(4352);
cryptDecrypt = (int8 *) UNCACHED_MALLOC(4352);
cryptKey = (int8 *) UNCACHED_MALLOC(24);
cryptIv = (int8 *) UNCACHED_MALLOC(8);
for(i=0; i<24; i++)
cryptKey[i] = 0x01;//(int8)taurand(256);
for(i=0; i<8; i++)
cryptIv[i] = 0x01;//(int8)taurand(256);
for(i=0; i<2064; i++)//8-byte for IV and 4-byte for DMA_addr (0-3) byte offset test
cryptOrg[i] = 0xff;//(int8)taurand(256);
REG32(0xbd01200c) &= 0x0fffffff;
REG32(0xbd012010) |= 0xf0000000;
REG32(0xbd012014) &= 0x0fffffff;
for(dupRound=0; dupRound<=round; dupRound++) {
for(funIdx=funStart; funIdx<=funEnd; funIdx++) {
for(pktLen = (lenStart&0xFFFFFFF8); pktLen <= (lenEnd&0xFFFFFFF8); pktLen+=8) {
for(offset = offsetStart; offset<=offsetEnd; offset++) {
rtlglue_printf("\rRound %4d %s Offset %2d PktLen %4d", dupRound, testDesItem[funIdx].funcTitle, offset, pktLen);
if(testDesItem[funIdx].func(offset, pktLen)==FAILED) {
rtlglue_printf("\nOffset %2d PktLen %4d %s Failed\n", offset, pktLen, testDesItem[funIdx].funcTitle);
REG32(0xbd012014) |= 0xf0000000;
goto FINISHED;
}
}
}
}
}
FINISHED:
UNCACHED_FREE(cryptOrg);
UNCACHED_FREE(cryptAsic);
UNCACHED_FREE(cryptEncrypt);
UNCACHED_FREE(cryptDecrypt);
UNCACHED_FREE(cryptKey);
UNCACHED_FREE(cryptIv);
return SUCCESS;
}
int32 runAuth8651bGeneralApiTest(uint32 round, uint32 funStart, uint32 funEnd, uint32 lenStart, uint32 lenEnd, uint32 keyLenStart, uint32 keyLenEnd, uint32 offsetStart, uint32 offsetEnd) {
uint32 i, j, pktLen, keyLen, roundIdx, errCount, offset;
uint32 doneCounter, allDoneCounter;
asicTestData = (uint8 *)UNCACHED_MALLOC(4352*sizeof(uint32));
keyLen = 8;
for(i=0; i<keyLen; i++)
asicTestKey[i] = 0x01;//(uint8)taurand(256);
errCount=0;
for(roundIdx=0; roundIdx<round; roundIdx++)
for(i=funStart; i<=funEnd; i++)
for(pktLen=lenStart; pktLen<=lenEnd; pktLen+=8)
for(offset=offsetStart; offset<=offsetEnd; offset++) {
for(j=0; j<pktLen; j++)
asicTestData[j+offset] = (j&0xFF);//(uint8)taurand(256);
rtl8651b_authEngineGetIntCounter(&doneCounter, &allDoneCounter);
rtlglue_printf("\r[%05u, %03u]Mode: %s Packet length %04u Offset %u (%u, %u)", roundIdx, errCount, authModeString[i], pktLen, offset, doneCounter, allDoneCounter);
if(auth8651bGeneralApiTestItem(i, &asicTestData[offset], pktLen, asicTestKey, keyLen) == FAILED) {
errCount++;
break;
}
}
UNCACHED_FREE(asicTestData);
return SUCCESS;
}
int32 swNic_linkChgIntHandler(void){
REG32(CPUIISR) = (uint32)LINK_CHANG_IP;
//rtlglue_printf("interrupt link change %x\n",(uint32)jiffies);
rtl8651_updateLinkChangePendingCount();
if(SUCCESS==rtl8651_updateLinkStatus()){
#if 0
#if defined(CONFIG_RTL865X_BICOLOR_LED)
int32 i;
for(i=0; i<5; i++) {
//while(!(REG32(PHY_BASE+(i<<5)+0x4) & 0x20));
if(REG32((PHY_BASE+(i<<5)+0x4)) & 0x4) { //link is up
//printf("port %d phyControlRegister 0[%08x] 4[%08x]\n",i,REG32(PHY_BASE+(i<<5)),REG32(PHY_BASE+(i<<5)+4));
//printf("Port %d Link Change!\n",i);
if(REG32((PHY_BASE+(i<<5))) & 0x2000){
/* link up speed 100Mbps */
/* set gpio port with high */
//printf("port %d speed 100M %08x\n",i,REG32(PHY_BASE+(i<<5)));
REG32(PABDAT) |= (1<<(16+i));
}else{
/* link up speed 10Mbps */
//rtlglue_printf("linkSpeed10M\n");
/* set gpio port with high */
//printf("port %d speed 10M %08x\n",i,REG32(PHY_BASE+(i<<5)));
REG32(PABDAT) &= ~(1<<(16+i));
} /* end if 100M */
}/* end if link up */
}/* end for */
#endif /* CONFIG_RTL865X_BICOLOR_LED */
#endif
return SUCCESS;
}else
rtlglue_printf("Link chg int handle error!\n");
//rtlglue_printf("interrupt link change %x\n",jiffies);
return FAILED;
}
static proc_input_pkt_funcptr_t old_funcptr=NULL;
static int32 swNic_loopbackCmd(uint32 userId, int32 argc,int8 **saved){
int8 *nextToken;
int32 size;
cle_getNextCmdToken(&nextToken,&size,saved);
if(strcmp(nextToken, "enable") == 0){
REG32(MSCR)&=~0x7;//disable L2~L4
cle_getNextCmdToken(&nextToken,&size,saved);
loopbackPort1=U32_value(nextToken);
cle_getNextCmdToken(&nextToken,&size,saved);
loopbackPort2=U32_value(nextToken);
old_funcptr = swNic_installedProcessInputPacket((proc_input_pkt_funcptr_t)re865x_testL2loopback);
rtlglue_printf("Turn off ASIC L2/3/4 functions. Enter NIC loopback mode. Bridge pkts between port %d and %d\n", loopbackPort1, loopbackPort2);
}else if(old_funcptr){
rtlglue_printf("Turn on ASIC L2/3/4 functions. Exit NIC loopback mode\n");
swNic_installedProcessInputPacket(old_funcptr);
REG32(MSCR)|=0x7;//enable L2~L4
}else
return FAILED;
return SUCCESS;
/* dump the tx ring info */
int32 rtl_dumpMbufRing(void)
{
int idx;
struct rtl_mBuf *mbuf;
idx = 0;
rtlglue_printf("**********************************************\nMbufRing:\n");
while(1)
{
mbuf = (struct rtl_mBuf *)(rxMbufRing[idx] & ~(DESC_OWNED_BIT | DESC_WRAP));
rtlglue_printf("mbuf[%03d]: 0x%p: ==> pkthdr[0x%p] ==> skb[0x%p]%s%s%s\n", idx, mbuf, mbuf->m_pkthdr,
mbuf->skb,
(rxMbufRing[idx]&DESC_OWNED_BIT)==DESC_RISC_OWNED?" :CPU":" :SWCORE",
(rxMbufRing[idx]&DESC_WRAP)==DESC_ENG_OWNED?" :WRAP":"",
idx==currRxMbufDescIndex?" <===currIdx":"");
if ((rxMbufRing[idx]&DESC_WRAP)!=0)
break;
idx++;
}
return SUCCESS;
}
int32 runDes8651bGeneralApiTest(uint32 round, uint32 funStart, uint32 funEnd, uint32 lenStart, uint32 lenEnd, uint32 offsetStart, uint32 offsetEnd) {
uint32 roundIdx, modeIdx, pktLen, i, offset, errCount;
uint32 doneCounter, allDoneCounter;
int32 ret = SUCCESS;
cryptGenAsic = (int8 *) UNCACHED_MALLOC(4352);
for(i=0; i<24; i++)
cryptGenKey[i] = 0x01;
for(i=0; i<8; i++)
cryptGenIv[i] = 0x01;
errCount = 0;
#if 0
for(roundIdx = 0; roundIdx<round; roundIdx++)
for(modeIdx=funStart; modeIdx<=funEnd; modeIdx++)
for(pktLen=lenStart; pktLen<=lenEnd; pktLen+=8)
for(offset=offsetStart; offset<=offsetEnd; offset++) {
for(i=0; i<pktLen; i++)//8-byte for IV and 4-byte for DMA_addr (0-3) byte offset test
cryptGenAsic[i+offset] = 0xff;//(int8)taurand(256);
rtlglue_printf("\r[%05u, %03u]Mode: %s Packet length %04u Offset %u[%08X]", roundIdx, errCount, desModeString[modeIdx], pktLen, offset, &cryptGenAsic[offset]);
if(des8651bGeneralApiTestItem(modeIdx, &cryptGenAsic[offset], pktLen, cryptGenKey, cryptGenIv) == FAILED)
errCount++;
}
#endif
for(roundIdx = 0; roundIdx<round; roundIdx++)
for(modeIdx=funStart; modeIdx<=funEnd; modeIdx++)
for(pktLen=lenStart; pktLen<=lenEnd; pktLen+=8)
for(offset=offsetStart; offset<=offsetEnd; offset++) {
for(i=0; i<pktLen; i++)//8-byte for IV and 4-byte for DMA_addr (0-3) byte offset test
cryptGenAsic[i+offset] = (i&0xFF);//(int8)taurand(256);
rtl8651b_cryptoEngineGetIntCounter(&doneCounter, &allDoneCounter);
rtlglue_printf("\r[%05u, %03u]Mode: %s Packet length %04u Offset %u (%u, %u)", roundIdx, errCount, desOpModeString[modeIdx&0x3], pktLen, offset, doneCounter, allDoneCounter);
if(des8651bGeneralApiTestItem(modeIdx&0x3, &cryptGenAsic[offset], pktLen, cryptGenKey, cryptGenIv) == FAILED)
errCount++;
}
UNCACHED_FREE(cryptGenAsic);
rtlglue_printf("\nGeneral API Test Finished\n");
return ret;
}
/* dump the rx ring info */
int32 rtl_dumpRxRing(void)
{
int idx, cnt;
struct rtl_pktHdr * pPkthdr;
for(idx=0;idx<RTL865X_SWNIC_RXRING_HW_PKTDESC;idx++)
{
#if defined(DELAY_REFILL_ETH_RX_BUF)
rtlglue_printf("**********************************************\nRxRing%d: cnt %d crossFlags[%d]\n",
idx, rxPkthdrRingCnt[idx], rxDescCrossBoundFlag[idx]);
#else
rtlglue_printf("**********************************************\nRxRing%d: cnt %d\n",
idx, rxPkthdrRingCnt[idx]);
#endif
/* skip the null rx ring */
if (rxPkthdrRingCnt[idx]==0)
continue;
/* dump all the pkt header */
for(cnt=0;cnt<rxPkthdrRingCnt[idx];cnt++)
{
pPkthdr = (struct rtl_pktHdr *) (rxPkthdrRing[idx][cnt] & ~(DESC_OWNED_BIT | DESC_WRAP));
#if defined(DELAY_REFILL_ETH_RX_BUF)
rtlglue_printf(" idx[%03d]: 0x%p-->mbuf[0x%p],skb[0x%p]%s%s%s%s\n", cnt, pPkthdr, pPkthdr->ph_mbuf, pPkthdr->ph_mbuf->skb,
(rxPkthdrRing[idx][cnt]&DESC_OWNED_BIT)==DESC_RISC_OWNED?" :CPU":" :SWCORE",
(rxPkthdrRing[idx][cnt]&DESC_WRAP)!=0?" :WRAP":"",
cnt==currRxPkthdrDescIndex[idx]?" <===currIdx":"",
cnt ==rxDescReadyForHwIndex[idx]?" <===readyForHw":"");
#else
rtlglue_printf(" idx[%03d]: 0x%p-->mbuf[0x%p],skb[0x%p]%s%s%s\n", cnt, pPkthdr, pPkthdr->ph_mbuf, pPkthdr->ph_mbuf->skb,
(rxPkthdrRing[idx][cnt]&DESC_OWNED_BIT)==DESC_RISC_OWNED?" :CPU":" :SWCORE",
(rxPkthdrRing[idx][cnt]&DESC_WRAP)!=0?" :WRAP":"",
cnt==currRxPkthdrDescIndex[idx]?" <===currIdx":"");
#endif
}
}
return SUCCESS;
}
static int32 runDes8651TestRoundDesEcb(uint32 offset, uint32 pktLen) {
int32 ret = SUCCESS;
if(desSim_ecb_encrypt(cryptOrg+offset, cryptEncrypt+offset, pktLen, cryptKey, TRUE) == FAILED) {
rtlglue_printf("desSim DES ECB encrypt failed\n");
ret = FAILED;
}
if(desSim_ecb_encrypt(cryptEncrypt+offset, cryptDecrypt+offset, pktLen, cryptKey, FALSE) == FAILED) {
rtlglue_printf("desSim DES ECB decrypt failed\n");
ret = FAILED;
}
if(memcmp(cryptOrg+offset, cryptDecrypt+offset, pktLen) != 0) {
displayDecryptMismatch("desSim DES ECB encrypt->decrypt failed", &cryptOrg[offset], &cryptDecrypt[offset], pktLen);
ret = FAILED;
}
memcpy(cryptAsic+offset, cryptOrg+offset, pktLen);
if(rtl8651b_cryptoEngine_ecb_encrypt(cryptAsic+offset, pktLen, cryptKey, TRUE) == FAILED) {
rtlglue_printf("cryptoEngine DES ECB encrypt failed\n");
ret = FAILED;
}
if(memcmp(cryptAsic+offset, cryptEncrypt+offset, pktLen) != 0) {
displayEncryptMismatch("DES ECB SW and HW results are different", &cryptOrg[offset], &cryptAsic[offset], &cryptEncrypt[offset], pktLen);
if(memcmp(cryptAsic+offset, cryptOrg+offset, pktLen)==0)
rtlglue_printf("cryptoEngine DES ECB do nothing\n");
ret = FAILED;
}
if(rtl8651b_cryptoEngine_ecb_encrypt(cryptAsic+offset, pktLen, cryptKey, FALSE) == FAILED) {
rtlglue_printf("cryptoEngine DES ECB decrypt failed\n");
ret = FAILED;
}
if(memcmp(cryptAsic+offset, cryptOrg+offset, pktLen) != 0) {
displayDecryptMismatch("cryptoEngine DES ECB encrypt->decrypt failed", &cryptOrg[offset], &cryptAsic[offset], pktLen);
ret = FAILED;
}
return ret;
}
static int32 swNic_hubCmd(uint32 userId, int32 argc,int8 **saved){
int8 *nextToken;
int32 size;
cle_getNextCmdToken(&nextToken,&size,saved);
if(strcmp(nextToken, "enable") == 0){
hubMbrmask=0;
REG32(MSCR)&=~0x7;//disable L2~L4
while(cle_getNextCmdToken(&nextToken,&size,saved) !=FAILED){
uint32 thisPort;
thisPort=U32_value(nextToken);
if(thisPort<5)
hubMbrmask|=(1<<thisPort);
}
old_funcptr = swNic_installedProcessInputPacket((proc_input_pkt_funcptr_t)swNic_hubMode);
rtlglue_printf("Turn off ASIC L2/3/4 functions. Enter Hub mode. Portmask:%08x\n", hubMbrmask);
}else if(old_funcptr){
rtlglue_printf("Turn on ASIC L2/3/4 functions. Exit Hub mode\n");
swNic_installedProcessInputPacket(old_funcptr);
REG32(MSCR)|=0x7;//enable L2~L4
}else
return FAILED;
return SUCCESS;
static int32 runDes8651TestRound3DesCbc(uint32 offset, uint32 pktLen) {
int32 ret = SUCCESS;
if(desSim_ede_cbc_encrypt(cryptOrg+offset, cryptEncrypt+offset, pktLen, cryptKey, cryptIv, TRUE) == FAILED) {
rtlglue_printf("desSim 3DES CBC encrypt failed\n");
ret = FAILED;
}
if(desSim_ede_cbc_encrypt(cryptEncrypt+offset, cryptDecrypt+offset, pktLen, cryptKey, cryptIv, FALSE) == FAILED) {
rtlglue_printf("desSim 3DES CBC decrypt failed\n");
ret = FAILED;
}
if(memcmp(cryptOrg+offset, cryptDecrypt+offset, pktLen) != 0) {
displayDecryptMismatch("desSim 3DES CBC encrypt->decrypt failed", &cryptOrg[offset], &cryptDecrypt[offset], pktLen);
ret = FAILED;
}
memcpy(cryptAsic+offset, cryptOrg+offset, pktLen);
if(rtl8651b_cryptoEngine_3des_cbc_encrypt(cryptAsic+offset, pktLen, cryptKey, cryptIv, TRUE) == FAILED) {
rtlglue_printf("cryptoEngine 3DES CBC encryption failed\n");
ret = FAILED;
}
if(memcmp(cryptAsic+offset, cryptEncrypt+offset, pktLen) != 0) {
displayEncryptMismatch("3DES CBC SW and HW results are different", &cryptOrg[offset], &cryptAsic[offset], &cryptEncrypt[offset], pktLen);
if(memcmp(cryptAsic+offset, cryptOrg+offset, pktLen) == 0)
rtlglue_printf("cryptoEngine 3DES CBC do nothing\n");
ret = FAILED;
}
if(rtl8651b_cryptoEngine_3des_cbc_encrypt(cryptAsic+offset, pktLen, cryptKey, cryptIv, FALSE) == FAILED) {
rtlglue_printf("cryptoEngine 3DES CBC decryption failed\n");
ret = FAILED;
}
if(memcmp(cryptAsic+offset, cryptOrg+offset, pktLen) != 0) {
displayDecryptMismatch("cryptoEngine 3DES CBC encrypt->decrypt failed", &cryptOrg[offset], &cryptAsic[offset], pktLen);
ret = FAILED;
}
return ret;
}
/*
@func int32 | _rtl865x_getGpioDataBit | Get the bit value of a specified GPIO ID.
@parm uint32 | gpioId | GPIO ID
@parm uint32* | data | Pointer to store return value
@rvalue SUCCESS | success.
@rvalue FAILED | failed. Parameter error.
@comm
*/
int32 _rtl865x_getGpioDataBit( uint32 gpioId, uint32* pData )
{
uint32 port = GPIO_PORT( gpioId );
uint32 pin = GPIO_PIN( gpioId );
if ( port >= GPIO_PORT_MAX ) return FAILED;
if ( pin >= 8 ) return FAILED;
if ( pData == NULL ) return FAILED;
*pData = _getGpio( GPIO_FUNC_DATA, port, pin );
#if _GPIO_DEBUG_ >= 3
rtlglue_printf("[%s():%d] (port=%d,pin=%d)=%d\n", __FUNCTION__, __LINE__, port, pin, *pData );
#endif
return SUCCESS;
}
/*
@func int32 | _rtl865x_setGpioDataBit | Set the bit value of a specified GPIO ID.
@parm uint32 | gpioId | GPIO ID
@parm uint32 | data | Data to write
@rvalue SUCCESS | success.
@rvalue FAILED | failed. Parameter error.
@comm
*/
int32 _rtl865x_setGpioDataBit( uint32 gpioId, uint32 data )
{
uint32 port = GPIO_PORT( gpioId );
uint32 pin = GPIO_PIN( gpioId );
if ( port >= GPIO_PORT_MAX ) return FAILED;
if ( pin >= 8 ) return FAILED;
#if 0
if ( _getGpio( GPIO_FUNC_DIRECTION, port, pin ) == GPIO_DIR_IN ) return FAILED; /* read only */
#endif
#if _GPIO_DEBUG_ >= 3
rtlglue_printf("[%s():%d] (port=%d,pin=%d)=%d\n", __FUNCTION__, __LINE__, port, pin, data );
#endif
_setGpio( GPIO_FUNC_DATA, port, pin, data );
return SUCCESS;
}
static void displayEncryptMismatch(int8 * title, int8 * org, int8 * data1, int8 * data2, uint32 pktLen) {
uint32 i, j;
rtlglue_printf("\n%s [0x%08x] [0x%08x]\n", title, data1, data2);
for(i=0;i<pktLen;i+=8) {
if(memcmp(&data1[i], &data2[i], 8) != 0) {
rtlglue_printf("%04u:", i);
for(j=0; j<8; j++)
rtlglue_printf("%02x", org[i+j]&0xff);
rtlglue_printf("->[%08x]",&data1[i]);
for(j=0; j<8; j++)
rtlglue_printf("%02x", data1[i+j]&0xff);
rtlglue_printf("!=[%08x]",&data2[i]);
for(j=0; j<8; j++)
rtlglue_printf("%02x", data2[i+j]&0xff);
rtlglue_printf("\n");
}
}
}
int32 des8651bSwThroughput(uint32 round, uint32 startMode, uint32 endMode, uint32 pktLen) {
uint32 testRound, modeIdx, i, bps;
uint32 sTime, eTime;
cryptOrg = (int8 *) UNCACHED_MALLOC(4352);
cryptEncrypt = (int8 *) UNCACHED_MALLOC(4352);
cryptKey = (int8 *) UNCACHED_MALLOC(24);
cryptIv = (int8 *) UNCACHED_MALLOC(8);
for(i=0; i<24; i++)
cryptKey[i] = 0x01;
for(i=0; i<8; i++)
cryptIv[i] = 0x01;
for(i=0; i<pktLen; i++)//8-byte for IV and 4-byte for DMA_addr (0-3) byte offset test
cryptOrg[i] = 0xff;//(int8)taurand(256);
rtlglue_printf("Evaluate software simulation throughput\n");
for(modeIdx=startMode;modeIdx<=endMode;modeIdx++) {
rtlglue_getmstime(&sTime);
for(testRound=0; testRound<=round; testRound++)
{
if ( desSim_des(modeIdx, cryptOrg, cryptEncrypt, pktLen, cryptKey, cryptIv) != SUCCESS )
{
rtlglue_printf("testRound=%d, desSim_des(modeIdx=%d) failed...\n", testRound, modeIdx );
return FAILED;
}
}
rtlglue_getmstime(&eTime);
if ( eTime - sTime == 0 )
{
rtlglue_printf("round is too small to measure throughput, try larger round number!\n");
return FAILED;
}
else
{
bps = pktLen*8*1000/((uint32)(eTime - sTime))*round;
if(bps>1000000)
rtlglue_printf("%s round %u len %u time %u throughput %u.%02u mbps\n", desModeString[modeIdx], round, pktLen, (uint32)(eTime - sTime), bps/1000000, (bps%1000000)/10000);
else if(bps>1000)
rtlglue_printf("%s round %u len %u time %u throughput %u.%02u kbps\n", desModeString[modeIdx], round, pktLen, (uint32)(eTime - sTime), bps/1000, (bps%1000)/10);
else
rtlglue_printf("%s round %u len %u time %u throughput %u bps\n", desModeString[modeIdx], round, pktLen, (uint32)(eTime - sTime), bps);
}
}
UNCACHED_FREE(cryptAsic);
UNCACHED_FREE(cryptKey);
UNCACHED_FREE(cryptIv);
return SUCCESS;
}
int32 auth8651bAsicThroughput(uint32 round, uint32 startMode, uint32 endMode, uint32 pktLen) {
uint32 testRound, modeIdx, i, keyLen, bps;
uint32 sTime, eTime;
if(endMode> 3)
endMode = 3;
if(startMode>3)
startMode = 3;
asicTestData = (uint8 *)UNCACHED_MALLOC(4352*sizeof(uint32));
keyLen = 8;
for(i=0; i<pktLen; i++)
asicTestData[i] = 0xFF;//(uint8)taurand(256);
for(i=0; i<keyLen; i++)
asicTestKey[i] = 0x01;//(uint8)taurand(256);
rtlglue_printf("Evaluate 8651b throughput\n");
for(modeIdx=startMode;modeIdx<=endMode;modeIdx++) {
rtlglue_getmstime(&sTime);
for(testRound=0; testRound<=round; testRound++)
{
if ( rtl8651b_authEngine(modeIdx, asicTestData, pktLen, asicTestKey, keyLen, asicDigest) != SUCCESS )
{
rtlglue_printf("testRound=%d, rtl8651b_authEngine(modeIdx=%d) failed...\n", testRound, modeIdx );
return FAILED;
}
}
rtlglue_getmstime(&eTime);
if ( eTime - sTime == 0 )
{
rtlglue_printf("round is too small to measure throughput, try larger round number!\n");
return FAILED;
}
else
{
bps = pktLen*8*1000/((uint32)(eTime - sTime))*round;
if(bps>1000000)
rtlglue_printf("%s round %u len %u time %u throughput %u.%02u mbps\n", authModeString[modeIdx], round, pktLen, (uint32)(eTime - sTime), bps/1000000, (bps%1000000)/10000);
else if(bps>1000)
rtlglue_printf("%s round %u len %u time %u throughput %u.%02u kbps\n", authModeString[modeIdx], round, pktLen, (uint32)(eTime - sTime), bps/1000, (bps%1000)/10);
else
rtlglue_printf("%s round %u len %u time %u throughput %u bps\n", authModeString[modeIdx], round, pktLen, (uint32)(eTime - sTime), bps);
}
}
UNCACHED_FREE(asicTestData);
return SUCCESS;
}
static void displayDigestMismatch(int8 * title, uint8 * data, uint32 dataLen, uint8 * key, uint32 keyLen,
int8 * digest1Title, uint8 * digest1, int8 *digest2Title, uint8 * digest2, uint32 digestLen) {
uint32 i;
rtlglue_printf("\n%s Data length %u Key length %u\n%s Digest:\n", title, dataLen, keyLen, digest1Title);
for(i=0; i<digestLen; i++) {
rtlglue_printf("%02x ", digest1[i]&0xFF);
if(i%8==7 || i==(digestLen-1))
rtlglue_printf("\n");
}
rtlglue_printf("%s Digest:\n", digest2Title);
for(i=0; i<digestLen; i++) {
rtlglue_printf("%02x ", digest2[i]&0xFF);
if(i%8==7 || i==(digestLen-1))
rtlglue_printf("\n");
}
}
static void displayDesDecryptMismatch(int8 * modeTitle, int8 * title, int8 * org, int8 * data, uint32 pktLen) {
uint32 i, j;
rtlglue_printf("\n%s %s [0x%08x]\n", modeTitle, title, data);
for(i=0;i<pktLen;i+=8) {
if(memcmp(&org[i], &data[i], 8) != 0) {
rtlglue_printf("%04u: ", i);
for(j=0; j<8; j++)
rtlglue_printf("%02x", org[i+j]&0xff);
rtlglue_printf(" ->> [%08x]",&data[i]);
for(j=0; j<8; j++)
rtlglue_printf("%02x", data[i+j]&0xff);
rtlglue_printf("\n");
}
}
}
int32 runAuth8651bGeneralApiRandTest(uint32 seed, uint32 round) {
uint32 i, pktLen, keyLen, roundIdx, modeIdx, errCount, offset;
uint32 doneCounter, allDoneCounter;
tauset(58, (int32)seed);
asicTestData = (uint8 *)UNCACHED_MALLOC(4352*sizeof(uint32));
errCount = 0;
for(roundIdx=0; roundIdx<round; roundIdx++) {
keyLen = taurand(1024)&0x3FF;
for(i=0; i<keyLen; i++)
asicTestKey[i] = taurand(256)&0xFF;
modeIdx = taurand(4)&0x3;
pktLen = taurand(4024);
offset = taurand(4);
for(i=0; i<pktLen; i++)
asicTestData[i+offset] = taurand(256)&0xFF;
rtl8651b_authEngineGetIntCounter(&doneCounter, &allDoneCounter);
rtlglue_printf("\r[%05u, %03u]Mode: %s Packet length %04u Offset %u (%u, %u)", roundIdx, errCount, authModeString[modeIdx], pktLen, offset, doneCounter, allDoneCounter);
if(auth8651bGeneralApiTestItem(modeIdx, &asicTestData[offset], pktLen, asicTestKey, keyLen) == FAILED)
errCount++;
}
UNCACHED_FREE(asicTestData);
return SUCCESS;
}
int32 swNic_setup(uint32 pkthdrs, uint32 mbufs, uint32 txpkthdrs)
{
struct rtl_pktHdr *freePkthdrListHead,*freePkthdrListTail;
struct rtl_mBuf *freeMbufListHead, *freeMbufListTail;
int i;
/* Disable Rx & Tx ,bus burst size, etc */
swNic_txRxSwitch(0,0);
#ifdef SWNIC_EARLYSTOP
nicRxEarlyStop=0;
#endif
/* Initialize index of Tx pkthdr descriptor */
txDoneIndex = 0;
txFreeIndex = 0;
/* Allocate rx pkthdrs */
if(pkthdrs!=mBuf_driverGetPkthdr(pkthdrs, &freePkthdrListHead, &freePkthdrListTail)){
rtlglue_printf("Can't allocate all pkthdrs\n");
return EINVAL;
}
assert(freePkthdrListHead);
assert(freePkthdrListTail);
/* Allocate rx mbufs and clusters */
if(mbufs!=mBuf_driverGet(mbufs, &freeMbufListHead, &freeMbufListTail)){
rtlglue_printf("Can't allocate all mbuf/clusters\n");
return EINVAL;
}
assert(freeMbufListHead);
assert(freeMbufListTail);
/////////////////////////////////////////////////
/* Initialize Tx packet header descriptors */
for (i=0; i<txpkthdrs; i++)
TxPkthdrRing[i] = DESC_RISC_OWNED;
/* Set wrap bit of the last descriptor */
TxPkthdrRing[txpkthdrs - 1] |= DESC_WRAP;
/* Fill Tx packet header FDP */
REG32(CPUTPDCR) = (uint32) TxPkthdrRing;
/////////////////////////////////////////////////
/* Initialize index of current Rx pkthdr descriptor */
rxPhdrIndex = 0;
/* Initialize Rx packet header descriptors */
for (i=0; i<pkthdrs; i++)
{
assert( freePkthdrListHead );
RxPkthdrRing[i] = (uint32) freePkthdrListHead | DESC_SWCORE_OWNED;
if ( (freePkthdrListHead = freePkthdrListHead->ph_nextHdr) == NULL )
freePkthdrListTail = NULL;
}
/* Set wrap bit of the last descriptor */
RxPkthdrRing[pkthdrs - 1] |= DESC_WRAP;
/* Fill Rx packet header FDP */
REG32(CPURPDCR) = (uint32) RxPkthdrRing;
/////////////////////////////////////////////////
/* Initialize index of current Rx pkthdr descriptor */
rxMbufIndex = 0;
/* Initialize Rx mbuf descriptors */
for (i=0; i<mbufs; i++)
{
assert( freeMbufListHead );
RxMbufRing[i] = (uint32) freeMbufListHead | DESC_SWCORE_OWNED;
#ifndef CONFIG_RTL865X_CACHED_NETWORK_IO
freeMbufListHead->m_extbuf=(uint8 *)UNCACHE(freeMbufListHead->m_extbuf);
freeMbufListHead->m_data=(uint8 *)UNCACHE(freeMbufListHead->m_data);
#endif
#if defined(CONFIG_RTL865X_MBUF_HEADROOM)&&defined(CONFIG_RTL865X_MULTILAYER_BSP)
if(mBuf_reserve(freeMbufListHead, CONFIG_RTL865X_MBUF_HEADROOM))
rtlglue_printf("Failed when init Rx %d\n", i);
#endif
if ( (freeMbufListHead = freeMbufListHead->m_next) == NULL )
freeMbufListTail = NULL;
}
/* Set wrap bit of the last descriptor */
RxMbufRing[mbufs - 1] |= DESC_WRAP;
/* Fill Rx mbuf FDP */
REG32(CPURMDCR) = (uint32) RxMbufRing;
REG32(CPUICR) =0;
#ifdef CONFIG_RTL865XB
{
char chipVersion[16];
uint32 align=0;
REG32(CPUICR)|=EXCLUDE_CRC;
GetChipVersion(chipVersion, sizeof(chipVersion), NULL);
if(chipVersion[strlen(chipVersion)-1]=='B')
{
//865xB chips support free Rx align from 0~256 bytes
#ifdef SWNIC_RX_ALIGNED_IPHDR
align+=2;
#endif
REG32(CPUICR)|=align;
rtlglue_printf("Rx shift=%x\n",REG32(CPUICR));
}
}
#endif
/* Enable Rx & Tx. Config bus burst size and mbuf size. */
REG32(CPUICR) |= BUSBURST_32WORDS | MBUF_2048BYTES;
REG32(CPUIIMR) |= LINK_CHANG_IE;
swNic_txRxSwitch(1,1);
return SUCCESS;
}
__IRAM static int32 _swNic_recvLoop(int32 last){
volatile struct rtl_pktHdr * pPkthdr; //don't optimize
volatile struct rtl_mBuf * pMbuf; //don't optimize
int32 count=0;
do{
#ifdef CONFIG_RTL865X_ROMEPERF
rtl8651_romeperfEnterPoint(ROMEPERF_INDEX_RECVLOOP);
#endif
/* Increment counter */
if((RxPkthdrRing[rxPhdrIndex]&DESC_OWNED_BIT)==1){
goto out;
}
#ifdef SWNIC_EARLYSTOP
if(nicRxEarlyStop && ((count & nicRxEarlyStop)==nicRxEarlyStop)){//check global interrupt status
uint32 gisrNow = REG32(GISR);
if(gisrNow & 0x65000000){ //Bit 30: USB, Bit 29:PCMCIA, Bit 26: PCI, Bit 24:GPIO
nicRxAbort=1;
goto out;
}
}
#endif
#ifdef CONFIG_RTL865X_CACHED_NETWORK_IO
#if 0
/*Invalidate D-Cache*/
lx4180_writeCacheCtrl(0);
lx4180_writeCacheCtrl(1);
lx4180_writeCacheCtrl(0);
pPkthdr = (struct rtl_pktHdr *) (RxPkthdrRing[rxPhdrIndex] & ~(DESC_OWNED_BIT | DESC_WRAP));
pMbuf = pPkthdr->ph_mbuf;
#else
pPkthdr = (struct rtl_pktHdr *) (RxPkthdrRing[rxPhdrIndex] & ~(DESC_OWNED_BIT | DESC_WRAP));
pMbuf = pPkthdr->ph_mbuf;
//force update d-cache if hit.
src32=(uint32 *)UNCACHE(pPkthdr);
dst32=(uint32 *)CACHED(pPkthdr);
dst32[0]=src32[0];
dst32[1]=src32[1];
dst32[2]=src32[2];
dst32[3]=src32[3];
src32=(uint32 *)UNCACHE(pMbuf);
dst32=(uint32 *)CACHED(pMbuf);
dst32[0]=src32[0];
dst32[1]=src32[1];
dst32[2]=src32[2];
dst32[3]=src32[3];
//pkt from ASIC, convert to uncached data pointer for used in
//fwd engine
pMbuf->m_data=UNCACHE(pMbuf->m_data);
pMbuf->m_extbuf=UNCACHE(pMbuf->m_extbuf);
#endif
#else
pPkthdr = (struct rtl_pktHdr *) (RxPkthdrRing[rxPhdrIndex] & ~(DESC_OWNED_BIT | DESC_WRAP));
pMbuf = pPkthdr->ph_mbuf;
#endif //CONFIG_RTL865X_CACHED_NETWORK_IO
#ifdef CONFIG_RTL865XB_EXP_PERFORMANCE_EVALUATION
if(_pernicStart == TRUE){
static uint32 start, end;
if(!_pernicPktCount){
startCOP3Counters(_pernicInst);
start = jiffies;
}
else if(_pernicPktCount == _pernicPktLimit){
end = jiffies;
stopCOP3Counters();
printk("%d pkts. Total %d bytes, %d ms. %u KBps\n", _pernicPktCount, _pernicByteCount, (uint32)((end-start)*10), (uint32)(_pernicByteCount/((end-start)*10)));
_pernicStart = FALSE;
}
_pernicPktCount++;
_pernicByteCount += pPkthdr->ph_len + 4;
swNic_isrReclaim(rxPhdrIndex, pPkthdr, pMbuf);
/* Increment index */
if ( ++rxPhdrIndex == totalRxPkthdr )
rxPhdrIndex = 0;
if ( ++rxMbufIndex == totalRxMbuf )
rxMbufIndex = 0;
continue;
}
#endif
assert(pPkthdr->ph_len>0);
if((pPkthdr->ph_flags&PKTHDR_DRIVERHOLD)==0){
//exception handling
swNic_rxRunoutTxPending((struct rtl_pktHdr *)pPkthdr);
goto out;
}
count++;
//SETBITS(pPkthdr->ph_flags, PKT_INCOMING); //packet from physical port
pPkthdr->ph_rxdesc=rxPhdrIndex;
pPkthdr->ph_flags&=~PKTHDR_DRIVERHOLD;
//Transform extension port numbers to continuous number for fwd engine.
#ifdef CONFIG_RTL865X_MULTILAYER_BSP //Default run this except L2 BSP.
//must call this API after rxPhdrIndex is assigned...
if(rtl8651_rxPktPreprocess(pPkthdr)){
rtlglue_printf("Drop rxDesc=%d\n",rxPhdrIndex );
//memDump(pPkthdr->ph_mbuf->m_data, pPkthdr->ph_len,"Loopback Pkt");
swNic_isrReclaim(rxPhdrIndex, pPkthdr, pMbuf);
}else
#endif
{
#ifdef CONFIG_RTL865X_ROMEREAL
rtl8651_romerealRecord( pPkthdr, 0x00000001 );
#endif/*CONFIG_RTL865X_ROMEREAL*/
/* Invoked installed function pointer to handle packet */
(*installedProcessInputPacket)((struct rtl_pktHdr*)pPkthdr);
}
#ifdef SWNIC_DEBUG
assert(rxPhdrIndex==rxMbufIndex);
#endif
/* Increment index */
if ( ++rxPhdrIndex == totalRxPkthdr )
rxPhdrIndex = 0;
if ( ++rxMbufIndex == totalRxMbuf )
rxMbufIndex = 0;
}while(last>=0&&rxPhdrIndex!=last);
out:
return count;
}
static int32 swNic_ringCmd(uint32 userId, int32 argc,int8 **saved){
int8 *nextToken;
int32 size;
cle_getNextCmdToken(&nextToken,&size,saved);
if(strcmp(nextToken, "mbufRxRing") == 0) {
uint32 i, value, asicIdx = ((uint32 *)REG32(CPURMDCR))-RxMbufRing;
rtlglue_printf("Rx mbuf ring starts at 0x%x\n",(uint32)RxMbufRing );
for(i=0;i<totalRxMbuf;i++){
value=RxMbufRing[i];
rtlglue_printf("%3d. 0x%08x ",i, value&~0x3 );
rtlglue_printf("%s ", ((value & 1)== 0)?"(CPU)":"(SWC)");
if(asicIdx==i)
rtlglue_printf("ASIC ");
if(rxMbufIndex==i)
rtlglue_printf("Rx ");
if((value & 2)== 2){
rtlglue_printf("WRAP!!\n");
return SUCCESS;
}else
rtlglue_printf("\n");
}
}else if(strcmp(nextToken, "pkthdrRxRing") == 0) {
swNic_dumpPkthdrDescRing();
return SUCCESS;
}else if(strcmp(nextToken, "txRing") == 0) {
swNic_dumpTxDescRing();
return SUCCESS;
}else{
struct rtl_mBufStatus mbs;
rtlglue_printf("Reset all NIC rings...\n");
swNic_descRingCleanup();
rtlglue_printf(" Init all NIC rings...\n");
swNic_setup(totalRxPkthdr, totalRxMbuf, totalTxPkthdr);
rtlglue_printf(" mbuf pool...\n");
if(mBuf_getBufStat(&mbs)==SUCCESS){
rtlglue_printf( "\tSizeof\tTotal\tFree\n");
rtlglue_printf( "Cluster\t%d\t%d\t%d\n",mbs.m_mclbytes, mbs.m_totalclusters, mbs.m_freeclusters);
rtlglue_printf( "Mbuf\t%d\t%d\t%d\n",mbs.m_msize, mbs.m_totalmbufs, mbs.m_freembufs);
rtlglue_printf( "Pkthdr\t%d\t%d\t%d\n",mbs.m_pkthdrsize, mbs.m_totalpkthdrs, mbs.m_freepkthdrs);
}
}
return SUCCESS;
static void swNic_dumpPkthdrDescRing(void){
uint32 i, *temp=
(uint32 *)rtlglue_malloc(sizeof(uint32)*totalRxPkthdr);
uint32 value,asicIdx = ((uint32 *)REG32(CPURPDCR))-RxPkthdrRing;
for(i=0;i<totalRxPkthdr;i++)
temp[i]=RxPkthdrRing[i];
rtlglue_printf("Rx phdr ring starts at 0x%x\n",(uint32)RxPkthdrRing );
for(i=0;i<totalRxPkthdr;i++){
struct rtl_pktHdr *ph;
struct rtl_mBuf *m;
value=temp[i];
ph=(struct rtl_pktHdr *)(value &~0x3);
rtlglue_printf("%03d.",(uint16)i);
if(ph){
rtlglue_printf("p:%08x ",value &~0x3);
m=ph->ph_mbuf;
if(m)
rtlglue_printf("m:%08x c:%08x d:%08x", (uint32)m, (uint32)m->m_extbuf, (uint32)m->m_data);
else
rtlglue_printf("No mbuf!! ");
}else
rtlglue_printf("No pkthdr!! ");
rtlglue_printf("%s ", ((value & 1)== 0)?"(CPU)":"(SWC)");
if(asicIdx==i)
rtlglue_printf("ASIC ");
if(rxPhdrIndex==i)
rtlglue_printf("Rx ");
if(lastReclaim==i)
rtlglue_printf("Reclaim ");
if((value & 2)== 2){
rtlglue_printf("WRAP!!\n");
return;
}else
rtlglue_printf("\n");
}
rtlglue_free(temp);
void swNic_dumpTxDescRing(void){
int32 i;
uint32 value, asicIdx = ((uint32 *)REG32(CPUTPDCR))-TxPkthdrRing;
rtlglue_printf("Tx phdr ring starts at 0x%x\n",(uint32)TxPkthdrRing );
for(i=0; i<totalTxPkthdr; i++){
volatile struct rtl_pktHdr *ph;
volatile struct rtl_mBuf *m;
value=TxPkthdrRing[i];
ph=(struct rtl_pktHdr *)(value &~0x3);
if(ph){
rtlglue_printf("%3d. p%08x ", i,(uint32)ph);
m=ph->ph_mbuf;
if(m)
rtlglue_printf("m:%08x d:%08x",(uint32)m,(uint32)m->m_data);
else
rtlglue_printf("m=NULL");
}else
rtlglue_printf("%3d. p:NULL", i);
rtlglue_printf("%s ", ((value & 1)== 0)?"(CPU)":"(SWC)");
if(ph){
rtlglue_printf("id:%d ", ph->ph_rxdesc);
rtlglue_printf("s%d:e%02x:p%03x", ph->ph_srcExtPortNum, ph->ph_extPortList, ph->ph_portlist);
}
if(asicIdx==i)
rtlglue_printf("ASIC ");
if(txDoneIndex==i)
rtlglue_printf("Done ");
if(txFreeIndex==i)
rtlglue_printf("Next ");
if((value & 2)== 2){
rtlglue_printf("WRAP!!\n");
return;
}else
rtlglue_printf("\n");
}
return;
