mdata.c

Atheros AP Test with Agilent N4010A source code

		}
		else {
			localDescPtr->nextPhysPtr = falconAddrMod | (descAddress + sizeof(MDK_ATHEROS_DESC));
		}
		//update the buffer size, and set interrupt for first descriptor
		localDescPtr->hwControl[1] = pLibDev->rx.bufferSize;
		if (i == 0) {	
			 localDescPtr->hwControl[1] |= DESC_RX_INTER_REQ;
		}
//		else if ((i == (numDesc  - 1)) && (mode == RX_FIXED_NUMBER))
//		{
//			 localDescPtr->hwControl[1] |= DESC_RX_INTER_REQ;
//		}
		
		localDescPtr->hwControl[0] = 0;		

		localDescPtr->hwStatus[0] = 0;
		localDescPtr->hwStatus[1] = 0;

		localDescPtr->hwExtra[0] = 0; // falcon rx status word 3

		//writeDescriptor(devNum, descAddress, localDescPtr);
		zeroDescriptorStatus(devNum, localDescPtr, pLibDev->swDevID);

		//increment descriptor address
		descAddress += sizeof(MDK_ATHEROS_DESC);
		localDescPtr ++;

		if(pLibDev->rx.overlappingDesc) {
			bufferAddress += (sizeof(MDK_PACKET_HEADER) + sizeof(WLAN_DATA_MAC_HEADER3) + 0x22  + (enablePPM ? ppm_data_padding : 0));
			buffAddrIncrement = (sizeof(MDK_PACKET_HEADER) + sizeof(WLAN_DATA_MAC_HEADER3) + 0x22  + (enablePPM ? ppm_data_padding : 0));
		} else {
			bufferAddress += pLibDev->rx.bufferSize;
			buffAddrIncrement = pLibDev->rx.bufferSize;
		}
	}

    if (pLibDev->devMap.remoteLib) {
		lastDesc = LAST_DESC_LOOP << DESC_INFO_LAST_DESC_BIT_START;
		intrBit = DESC_RX_INTER_REQ_START <<  DESC_OP_INTR_BIT_START;

        if (!isFalcon(devNum) && !isDragon(devNum)) {
		   descOp = intrBit | 0 | (2 << DESC_OP_WORD_OFFSET_BIT_START);
        }
        else{
		   descOp = intrBit | 0 | (3 << DESC_OP_WORD_OFFSET_BIT_START);
        }

		pLibDev->devMap.r_createDescriptors(devNum, pLibDev->rx.descAddress, \
							lastDesc |  pLibDev->rx.numDesc |  \
							(sizeof(MDK_ATHEROS_DESC)/sizeof(A_UINT32) << DESC_INFO_NUM_DESC_WORDS_BIT_START), \
							buffAddrIncrement | (1 << BUF_ADDR_INC_CLEAR_BUF_BIT_START), \
							descOp, \
							(A_UINT32 *)localDescBuffer);
	}
	else {
	    //write all the descriptors in one shot
	    writeDescriptors(devNum, pLibDev->rx.descAddress, localDescBuffer, pLibDev->rx.numDesc);
	}
	free(localDescBuffer);

	ar5kInitData[pLibDev->ar5kInitIndex].pMacAPI->setPPM(devNum, enablePPM);

	pLibDev->rx.rxEnable = 1;

	return;
}


/**************************************************************************
* rxDataBegin - Start and complete reception
*
*/
MANLIB_API void rxDataBegin
(
 A_UINT32 devNum, 
 A_UINT32 waitTime, 
 A_UINT32 timeout, 
 A_UINT32 remoteStats,
 A_UINT32 enableCompare,
 A_UCHAR *dataPattern, 
 A_UINT32 dataPatternLength
)
{
	LIB_DEV_INFO *pLibDev = gLibInfo.pLibDevArray[devNum];
	pLibDev->mdkErrno = 0;
	rxDataStart(devNum);
	if (pLibDev->mdkErrno == 0) {
		rxDataComplete(devNum, waitTime, timeout, remoteStats, enableCompare, dataPattern, dataPatternLength);
	}
}

/**************************************************************************
* rxDataBeginSG - Start and complete reception - signal generator accomodation
*
*/
MANLIB_API void rxDataBeginSG
(
 A_UINT32 devNum, 
 A_UINT32 waitTime, 
 A_UINT32 timeout, 
 A_UINT32 remoteStats,
 A_UINT32 enableCompare,
 A_UCHAR *dataPattern, 
 A_UINT32 dataPatternLength,
 A_UINT32 sgpacketnumber
)
{
	LIB_DEV_INFO *pLibDev = gLibInfo.pLibDevArray[devNum];
	pLibDev->mdkErrno = 0;
	rxDataStart(devNum);
	if (pLibDev->mdkErrno == 0) {
		rxDataCompleteSG(devNum, waitTime, timeout, remoteStats, enableCompare, dataPattern, dataPatternLength, sgpacketnumber);
	}
}

/**************************************************************************
* rxDataBegin - Start and complete reception
*
*/
MANLIB_API void rxDataBeginFixedNumber
(
 A_UINT32 devNum, 
 A_UINT32 timeout, 
 A_UINT32 remoteStats,
 A_UINT32 enableCompare,
 A_UCHAR *dataPattern, 
 A_UINT32 dataPatternLength
)
{
	rxDataStart(devNum);
	rxDataCompleteFixedNumber(devNum, timeout, remoteStats, enableCompare, dataPattern, dataPatternLength);
}


/**************************************************************************
* rxDataStart - Start reception
*
*/
MANLIB_API void rxDataStart
(
 A_UINT32 devNum
)
{
	LIB_DEV_INFO *pLibDev = gLibInfo.pLibDevArray[devNum];
	
	if (checkDevNum(devNum) == FALSE) {
		mError(devNum, EINVAL, "Device Number %d:rxDataBegin\n", devNum);
		return;
	}

	if(pLibDev->devState < RESET_STATE) {
		mError(devNum, EILSEQ, "Device Number %d:rxDataBegin: device not in reset state - resetDevice must be run first\n", devNum);
		return;
	}

	if (!pLibDev->rx.rxEnable) {
		mError(devNum, EILSEQ, 
			"Device Number %d:rxDataBegin: rxDataSetup must successfully complete before running rxDataBegin\n", devNum);
		return; 
	}
	
	// zero out the stats structure
	memset(&(pLibDev->rx.rxStats[0][0]), 0, sizeof(RX_STATS_STRUCT) * STATS_BINS * MAX_TX_QUEUE);
	pLibDev->rx.haveStats = 0;

	// zero out remote transmit stats
//	if(remoteStats & ENABLE_STATS_RECEIVE) {
//		memset(&(pLibDev->txRemoteStats[0][0]), 0, sizeof(TX_STATS_STRUCT) * STATS_BINS * MAX_TX_QUEUE);
//	}

	// program registers
	ar5kInitData[pLibDev->ar5kInitIndex].pMacAPI->rxBeginConfig(devNum);
}


/**************************************************************************
* rxDataComplete - Start reception
*
*/
MANLIB_API void rxDataComplete
(
 A_UINT32 devNum, 
 A_UINT32 waitTime, 
 A_UINT32 timeout, 
 A_UINT32 remoteStats,
 A_UINT32 enableCompare,
 A_UCHAR *dataPattern, 
 A_UINT32 dataPatternLength
)
{
	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


	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
	}

	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);
	   	//



/* 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:rxDataComplete:  ran out of receive descriptors\n", devNum);
				break;
			}

			mdkExtractAddrAndSequence(devNum, &statsInfo);

			
#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