mdata.c

Atheros AP Test with Agilent N4010A source code

			//only process packets if things are good
			if ( !((statsInfo.status1 & DESC_MORE) || statsInfo.badPacket || statsInfo.controlFrameReceived || 
				statsInfo.illegalBuffSize) ) {
#ifdef DEBUG_MEMORY
printf("SNOOP::Processing packet\n");
#endif
				//check for this being "last packet" or stats packet
				//mdkExtractAddrAndSequence also pulled mdkPkt type info from packet
				if ((statsInfo.status2 & DESC_FRM_RCV_OK) 
				 && (statsInfo.mdkPktType == MDK_LAST_PKT)){
					//if were not expecting remote stats then we are done
					if (!(remoteStats & ENABLE_STATS_RECEIVE)) {
						rxComplete = TRUE;
					}

					//we have done with receive so can send stats
					if(remoteStats & ENABLE_STATS_SEND) {
						for (i = 0; i < MAX_TX_QUEUE; i++ )
						{
							for(statsLoop = 1; statsLoop < STATS_BINS; statsLoop++) {
								if((pLibDev->rx.rxStats[i][statsLoop].crcPackets > 0) ||
									(pLibDev->rx.rxStats[i][statsLoop].goodPackets > 0)) {
									sendStatsPkt(devNum, statsLoop, MDK_RX_STATS_PKT, statsInfo.addrPacket.octets);
								}
							}
						}
						sendStatsPkt(devNum, 0, MDK_RX_STATS_PKT, statsInfo.addrPacket.octets);
						statsSent = TRUE;
					}
				}
				else if((statsInfo.status2 & DESC_FRM_RCV_OK) 
					 && (statsInfo.mdkPktType >= MDK_TX_STATS_PKT) 
					 && (statsInfo.mdkPktType <= MDK_TXRX_STATS_PKT)) {
					rxComplete = mdkExtractRemoteStats(devNum, &statsInfo);
				}
				else if (statsInfo.mdkPktType == MDK_NORMAL_PKT) {
					if (enableCompare) {
						comparePktData(devNum, &statsInfo);
					}
					if (pLibDev->rx.enablePPM) {
						extractPPM(devNum, &statsInfo);
					}

					if(skipStats && (numStatsToSkip != 0)) {
						numStatsToSkip --;
					}
					else {
						mdkExtractRxStats(devNum, &statsInfo);
					}
 				}

				else if ((statsInfo.mdkPktType == MDK_PROBE_PKT) ||
						(statsInfo.mdkPktType == MDK_PROBE_LAST_PKT)) {
					//Want to ignore probe packets, do nothing

				}
				else {
					if(statsInfo.status2 & DESC_FRM_RCV_OK) {
						mError(devNum, EIO, "Device Number %d:A good matching packet with an unknown MDK_PKT type detected MDK_PKT: %d\n", devNum, 
							statsInfo.mdkPktType);
						{
							A_UINT32 iIndex;
							printf("Frame Info\n");
							for(iIndex=0; iIndex<statsInfo.frame_info_len; iIndex++) {
								printf("%X ", statsInfo.frame_info[iIndex]);
							}
							printf("\n");
							printf("PPM Data Info\n");
							for(iIndex=0; iIndex<statsInfo.ppm_data_len; iIndex++) {
								printf("%X ", statsInfo.ppm_data[iIndex]);
							}
							printf("\n");
						}
					}
					if (statsInfo.status2 & DESC_CRC_ERR)
					{
						pLibDev->rx.rxStats[statsInfo.qcuIndex][0].crcPackets++;
						pLibDev->rx.rxStats[statsInfo.qcuIndex][statsInfo.descRate].crcPackets++;
						pLibDev->rx.haveStats = 1;
					}
					else if (statsInfo.status2 & pLibDev->decryptErrMsk)
					{
						pLibDev->rx.rxStats[statsInfo.qcuIndex][0].decrypErrors++;
						pLibDev->rx.rxStats[statsInfo.qcuIndex][statsInfo.descRate].decrypErrors++;
						pLibDev->rx.haveStats = 1;
					}

					
				}
			}

			if(rxComplete) {
				break;
			}

			//get next descriptor to process
			statsInfo.descToRead += sizeof(MDK_ATHEROS_DESC);
			numDesc ++;
		}
		else {
			curTime = milliTime();
			if (curTime > (startTime+timeout)) {
				i = timeout;
				break;
			}
			mSleep(1);
			i++;
		}

	} while (i < timeout);

	milliTime();
	
	if((remoteStats & ENABLE_STATS_SEND) && !statsSent) {
		for( i = 0; i < MAX_TX_QUEUE; i++ )
		{
			for(statsLoop = 1; statsLoop < STATS_BINS; statsLoop++) {
				if((pLibDev->rx.rxStats[i][statsLoop].crcPackets > 0) ||
					(pLibDev->rx.rxStats[i][statsLoop].goodPackets > 0)) {
					sendStatsPkt(devNum, statsLoop, MDK_RX_STATS_PKT, statsInfo.addrPacket.octets);
				}
			}
			sendStatsPkt(devNum, 0, MDK_RX_STATS_PKT, statsInfo.addrPacket.octets);
		}
	}

	//cleanup
	ar5kInitData[pLibDev->ar5kInitIndex].pMacAPI->rxCleanupConfig(devNum);

	if(pLibDev->tx[queueIndex].txEnable) {
		//write back the retry value
		//REGW(devNum, F2_RETRY_LMT, pLibDev->tx[queueIndex].retryValue);	__TODO__
	}

	//do any other register cleanup required
	if(enableCompare) {
		free(statsInfo.pCompareData);
	}

	if ((i == timeout) && (rxComplete != TRUE))
	{
		mError(devNum, EIO, 
			"Device Number %d:rxDataBegin: timeout reached, without receiving all packets.  Number received = %lu\n", devNum,
			numDesc);
		ar5kInitData[pLibDev->ar5kInitIndex].pMacAPI->rxCleanupConfig(devNum);
	}

	return;
}

/**************************************************************************
* rxDataCompleteSG - Start reception : Adjustment for Signal Generators
*
*/
MANLIB_API void rxDataCompleteSG
(
 A_UINT32 devNum, 
 A_UINT32 waitTime, 
 A_UINT32 timeout, 
 A_UINT32 remoteStats,
 A_UINT32 enableCompare,
 A_UCHAR *dataPattern, 
 A_UINT32 dataPatternLength,
 A_UINT32 sgpacketnumber
)
{
	ISR_EVENT	event;
	A_UINT32	i, statsLoop, jj;
	A_UINT32	numDesc = 0;
	LIB_DEV_INFO *pLibDev = gLibInfo.pLibDevArray[devNum];
	RX_STATS_TEMP_INFO	statsInfo;
	A_BOOL		statsSent = FALSE;
	A_BOOL		rxComplete = FALSE;
	A_UINT16	queueIndex = pLibDev->selQueueIndex;
	A_UINT32	startTime;
	A_UINT32	curTime;
	A_BOOL		skipStats = FALSE;
	A_UINT16    numStatsToSkip = 0;		
	A_UINT32    tempBuff[2] = {0, 0};
//A_UINT16  junkSeqCounter;
//A_UINT16  junkErrCounter;
	A_BOOL      falconTrue = FALSE;
	A_UINT32    ppm_data_padding = PPM_DATA_SIZE;
	A_UINT32    status1_offset, status2_offset, status3_offset; // legacy status1 - datalen/rate, 
	                                                            // legacy status2 - done/error/timestamp
	                                                            // new with falcon status3 - rssi for 4 ant

        A_UINT32     temp_buff_ind;
//	A_UINT32     temp_reg_rd;
        A_UINT32     pktcount = 0;
        A_UINT32     pktmon = 0;
        A_UINT32     storVar;
// 

	falconTrue = isFalcon(devNum) || isDragon(devNum);

	if (falconTrue) {
		status1_offset = FIRST_FALCON_RX_STATUS_WORD;
		status2_offset = SECOND_FALCON_RX_STATUS_WORD;
		status3_offset = FALCON_ANT_RSSI_RX_STATUS_WORD;
		if (pLibDev->libCfgParams.chainSelect == 2) {
			ppm_data_padding = PPM_DATA_SIZE_FALCON_DUAL_CHAIN;
		} else {
			ppm_data_padding = PPM_DATA_SIZE_FALCON_SINGLE_CHAIN;
		}
	} else {
		status1_offset = FIRST_STATUS_WORD;
		status2_offset = SECOND_STATUS_WORD;
		status3_offset = status2_offset; // to avoid illegal value. should never be used besides multAnt chips
	}
     
	 //store register to restore later
	storVar = REGR(devNum, 0x803C);

	REGW(devNum, 0x803C, storVar | 0x00000005); 

	startTime = milliTime();
    timeout = timeout * 10;

#ifdef DEBUG_MEMORY
printf("Desc Base address = %x:RXDP=%x:RXE/RXD=%x\n", pLibDev->rx.descAddress, REGR(devNum, 0xc), REGR(devNum, 0x8));
memDisplay(devNum, pLibDev->rx.descAddress, 12);
printf("reg8000=%x:reg8004=%x:reg8008=%x:reg800c=%x:reg8014=%x\n", REGR(devNum, 0x8000), REGR(devNum, 0x8004), REGR(devNum, 0x8008), REGR(devNum, 0x800c), REGR(devNum, 0x8014));

#endif

	// wait for event
	event.valid = 0;
	event.ISRValue = 0;
	for (i = 0; i < waitTime; i++)
	{
		event = pLibDev->devMap.getISREvent(devNum);
		if (event.valid) {
			if(ar5kInitData[pLibDev->ar5kInitIndex].pMacAPI->isRxdescEvent(event.ISRValue)) {
				break;
			}
		}

		curTime = milliTime();
		if (curTime > (startTime+waitTime)) {
			i = waitTime;
			break;
		}
		mSleep(1);	
	}

#ifdef DEBUG_MEMORY
printf("waitTime = %d\n", waitTime);
printf("Desc Base address = %x:RXDP=%x:RXE/RXD=%x\n", pLibDev->rx.descAddress, REGR(devNum, 0xc), REGR(devNum, 0x8));
memDisplay(devNum, pLibDev->rx.descAddress, 12);
printf("reg8000=%x:reg8004=%x:reg8008=%x:reg800c=%x:reg8014=%x\n", REGR(devNum, 0x8000), REGR(devNum, 0x8004), REGR(devNum, 0x8008), REGR(devNum, 0x800c), REGR(devNum, 0x8014));

#endif
	
	// This is a special case to allow the script multitest.pl to send and receive between
	// two cards in the same machine.  A wait time of 1 will setup RX and exit
	// A second rxDataBegin will collect the statistics.
	if (waitTime == 1) {
		return;
	}
	else if ((i == waitTime) && (waitTime !=0)) {
		mError(devNum, EIO, "Device Number %d:rxDataBegin: nothing received within %d millisecs (waitTime)\n", devNum, waitTime);
		ar5kInitData[pLibDev->ar5kInitIndex].pMacAPI->rxCleanupConfig(devNum);
		return;
	}

	i = 0;
	memset(&statsInfo, 0, sizeof(RX_STATS_TEMP_INFO));
	for(statsLoop = 0; statsLoop < STATS_BINS; statsLoop++) {
		statsInfo.sigStrength[statsLoop].rxMinSigStrength = 127;
		if (falconTrue) {
			for (jj = 0; jj < 4; jj++ ) {
				statsInfo.multAntSigStrength[statsLoop].rxMinSigStrengthAnt[jj] = 127;
				statsInfo.multAntSigStrength[statsLoop].rxMaxSigStrengthAnt[jj] = -127;
			}
		}
	}

	if(remoteStats & SKIP_SOME_STATS) {
		//extract and set number to skip
		skipStats = 1;
		numStatsToSkip = (A_UINT16)((remoteStats & NUM_TO_SKIP_M) >> NUM_TO_SKIP_S);
	}

	if(pLibDev->rx.enablePPM) {
		for( i = 0; i < MAX_TX_QUEUE; i++ )
		{
			for(statsLoop = 0; statsLoop < STATS_BINS; statsLoop++) 
			{
				pLibDev->rx.rxStats[i][statsLoop].ppmMax = -1000;
				pLibDev->rx.rxStats[i][statsLoop].ppmMin = 1000;
			}
		}
	}

	statsInfo.descToRead = pLibDev->rx.descAddress;
	if (falconTrue) {
		statsInfo.descToRead &= FALCON_DESC_ADDR_MASK;
	}

	if (enableCompare) {
		//create a max size compare buffer for easy compare
		statsInfo.pCompareData = (A_UCHAR *)malloc(FRAME_BODY_SIZE);

		if(!statsInfo.pCompareData) {
			mError(devNum, ENOMEM, "Device Number %d:rxDataBegin: Unable to allocate memory for compare buffer\n", devNum);
			ar5kInitData[pLibDev->ar5kInitIndex].pMacAPI->rxCleanupConfig(devNum);
			return;
		}

		fillCompareBuffer(statsInfo.pCompareData, FRAME_BODY_SIZE, dataPattern, dataPatternLength);
	}	

	startTime=milliTime();
//	junkSeqCounter = 0;
//	junkErrCounter = 0;
	//sit in polling loop, looking for descriptors to be done.
	do {
		//read descriptor status words

	   	// Read descriptor at once
		fillRxDescAndFrame(devNum, &statsInfo);


// Ignore 2 descriptors for the setup delay
	if(numDesc == 0) {
		//extract and set number to skip
		skipStats = 1;
		numStatsToSkip = 2;
	}

/* Siva
		pLibDev->devMap.OSmemRead(devNum, statsInfo.descToRead + status2_offset, 
					(A_UCHAR *)&statsInfo.status2, sizeof(statsInfo.status2));
*/

		if (statsInfo.status2 & DESC_DONE) {
/* Siva
			pLibDev->devMap.OSmemRead(devNum, statsInfo.descToRead + status1_offset, 
					(A_UCHAR *)&statsInfo.status1, sizeof(statsInfo.status1));
			if (falconTrue) {
					pLibDev->devMap.OSmemRead(devNum, statsInfo.descToRead + status3_offset, 
						(A_UCHAR *)&statsInfo.status3, sizeof(statsInfo.status3));
			}
			pLibDev->devMap.OSmemRead(devNum, statsInfo.descToRead + BUFFER_POINTER, 
					(A_UCHAR *)&statsInfo.bufferAddr, sizeof(statsInfo.bufferAddr));
*/
			if (falconTrue) {
				statsInfo.bufferAddr &= FALCON_DESC_ADDR_MASK;
			}

			if (!(remoteStats & LEAVE_DESC_STATUS)) {
			    //zero out status
			    pLibDev->devMap.OSmemWrite(devNum, statsInfo.descToRead + status1_offset, 
						(A_UCHAR *)tempBuff, 8);
			}

//pLibDev->devMap.OSmemWrite(devNum, statsInfo.descToRead + status2_offset, 
//			(A_UCHAR *)&tempBuff, 4);


			statsInfo.descRate = descRate2bin((statsInfo.status1 >> BITS_TO_RX_DATA_RATE) & pLibDev->rxDataRateMsk);
			// Initialize loop variables
			statsInfo.badPacket = 0;
			statsInfo.gotHeaderInfo = FALSE; // TODO: FIX for multi buffer packet support
			statsInfo.illegalBuffSize = 0;
			statsInfo.controlFrameReceived = 0;
			statsInfo.mdkPktType = 0;

			// Increase buffer address for PPM
			if(pLibDev->rx.enablePPM) {
				statsInfo.bufferAddr += ppm_data_padding;
			}

			//reset our timeout counter
			i = 0;

			if (numDesc == pLibDev->rx.numDesc - 1) {
				//This is the final looped rx desc and done bit is set, we ran out of receive descriptors, 
				//so return with an error
				mError(devNum, ENOMEM, "Device Number %d:rxDataCompleteSG:  ran out of receive descriptors\n", devNum);
				break;
			}

			mdkExtractAddrAndSequence(devNum, &statsInfo);

// Reciving Packets count
	if ((statsInfo.status2 & DESC_DONE)) {
		pktcount = pktcount + 1;
	}

#ifdef DEBUG_MEMORY
printf("SNOOP::mdkPkt s1=%X:s2=%X:Type = %x\n", statsInfo.status1, statsInfo.status2, statsInfo.mdkPktType);
printf("SNOOP::Process packet:bP=%d:cFR=%d:iBS=%d\n", statsInfo.badPacket, statsInfo.controlFrameReceived, statsInfo.illegalBuffSize);
#endif
			//only process packets if things are good
			if ( !((statsInfo.status1 & DESC_MORE) || statsInfo.badPacke