mdata.c

atheros ar5001 5002 driver

	pLibDev->rx.bufferSize = dataBodyLength + sizeof(MDK_PACKET_HEADER) 
					+ sizeof(WLAN_DATA_MAC_HEADER3) + FCS_FIELD;
	/* The above calculation makes the receive buffer the exact size.  Want to
	 * add some extra bytes to end and also make sure buffers and 32 byte aligned.
	 * will have at least 0x20 spare bytes	
	 */
	if ((pLibDev->rx.bufferSize & (CACHE_LINE_SIZE - 1)) > 0) {
		pLibDev->rx.bufferSize += (0x20 - (pLibDev->rx.bufferSize & (CACHE_LINE_SIZE - 1))); 
	}

	if ((pLibDev->rx.bufferSize + 0x20) < 4096) {
		pLibDev->rx.bufferSize += 0x20;
	}
	
	sizeBufferMem = pLibDev->rx.numDesc * pLibDev->rx.bufferSize;

	//check to see if should try overlapping buffers 
	if(sizeBufferMem > pLibDev->devMap.DEV_MEMORY_RANGE) {
		//allocate 1 full buffer (as spare) then add headers + 32 bytes for each required descriptor
		sizeBufferMem = pLibDev->rx.bufferSize +
			(pLibDev->rx.numDesc * (sizeof(MDK_PACKET_HEADER) + sizeof(WLAN_DATA_MAC_HEADER3) + 0x22
		                            + (enablePPM ? PPM_DATA_SIZE : 0) ));
		if(sizeBufferMem > pLibDev->devMap.DEV_MEMORY_RANGE) {
			mError(devNum, ENOMEM, "Device Number %d:rxDataSetup: unable to allocate memory for buffers (even overlapped)\n", devNum);
			return;
		}
		pLibDev->rx.overlappingDesc = TRUE;
	}

	pLibDev->rx.bufferAddress = memAlloc(devNum, sizeBufferMem);
	
	if (0 == pLibDev->rx.bufferAddress) {
		mError(devNum, ENOMEM, "Device Number %d:rxDataSetup: unable to allocate memory for buffers\n", devNum);
		return;
	}

	//initialize descriptors
	descAddress = pLibDev->rx.descAddress;
	bufferAddress = pLibDev->rx.bufferAddress;
	for (i = 0; i < pLibDev->rx.numDesc; i++)
	{
		localDesc.bufferPhysPtr = bufferAddress;
		
		//update the link pointer
		if (i == pLibDev->rx.numDesc - 1) { //ie its the last descriptor
			//link it to itself
			localDesc.nextPhysPtr = descAddress;
			pLibDev->rx.lastDescAddress = descAddress;
		}
		else {
			localDesc.nextPhysPtr = descAddress + sizeof(MDK_ATHEROS_DESC);
		}
		//update the buffer size, and set interrupt for first descriptor
		localDesc.hwControl[1] = pLibDev->rx.bufferSize;
		if (i == 0) {	
			 localDesc.hwControl[1] |= DESC_RX_INTER_REQ;
		}
//		else if ((i == (numDesc  - 1)) && (mode == RX_FIXED_NUMBER))
//		{
//			 localDesc.hwControl[1] |= DESC_RX_INTER_REQ;
//		}
		
		localDesc.hwControl[0] = 0;
		
		localDesc.hwStatus[0] = 0;
		localDesc.hwStatus[1] = 0;

		writeDescriptor(devNum, descAddress, &localDesc);


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

	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
)
{
	rxDataStart(devNum);
	rxDataComplete(devNum, waitTime, timeout, remoteStats, enableCompare, dataPattern, dataPatternLength);
}

/**************************************************************************
* 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;
	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_UINT16  junkSeqCounter;
//A_UINT16  junkErrCounter;

	startTime = milliTime();

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

	
	// 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(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 (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
		pLibDev->devMap.OSmemRead(devNum, statsInfo.descToRead + SECOND_STATUS_WORD, 
					(A_UCHAR *)&statsInfo.status2, sizeof(statsInfo.status2));

		if (statsInfo.status2 & DESC_DONE) {
			pLibDev->devMap.OSmemRead(devNum, statsInfo.descToRead + FIRST_STATUS_WORD, 
					(A_UCHAR *)&statsInfo.status1, sizeof(statsInfo.status1));
			pLibDev->devMap.OSmemRead(devNum, statsInfo.descToRead + BUFFER_POINTER, 
					(A_UCHAR *)&statsInfo.bufferAddr, sizeof(statsInfo.bufferAddr));
			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_SIZE;
			}

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

			mdkExtractAddrAndSequence(devNum, &statsInfo);

			
			//only process packets if things are good
			if ( !((statsInfo.status1 & DESC_MORE) || statsInfo.badPacket || statsInfo.controlFrameReceived || 
				statsInfo.illegalBuffSize) ) {
				//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.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);
					}
					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