mdata.c

atheros ar5001 5002 driver

	rxStatsInfo.descToRead = pLibDev->rx.descAddress;

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

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

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

	//start transmit
	ar5kInitData[pLibDev->ar5kInitIndex].pMacAPI->txBeginConfig(devNum, 1);
	start= milliTime();

	startTime = milliTime();
	do {
		if (!txComplete) {
			event = pLibDev->devMap.getISREvent(devNum);
		}

		//check for transmit
		if ((event.valid) && 
			(ar5kInitData[pLibDev->ar5kInitIndex].pMacAPI->isTxdescEvent(event.ISRValue)) && 
			!txComplete) {

				finish= milliTime();


			//ar5kInitData[pLibDev->ar5kInitIndex].pMacAPI->sendTxEndPacket(devNum, queueIndex );
			sendEndPacket(devNum, queueIndex);

			if(pLibDev->libCfgParams.enableXR) {
				REGW(devNum, XRMODE_REG, REGR(devNum, XRMODE_REG) | (0x1 << BITS_TO_XR_WAIT_FOR_POLL));
			}

			txComplete = TRUE;
			txAccumulateStats(devNum, finish - start, queueIndex);
		}

		//read descriptor status words
		pLibDev->devMap.OSmemRead(devNum, rxStatsInfo.descToRead + SECOND_STATUS_WORD, 
					(A_UCHAR *)&rxStatsInfo.status2, sizeof(rxStatsInfo.status2));

		if (rxStatsInfo.status2 & DESC_DONE) {
			pLibDev->devMap.OSmemRead(devNum, rxStatsInfo.descToRead + FIRST_STATUS_WORD, 
					(A_UCHAR *)&rxStatsInfo.status1, sizeof(rxStatsInfo.status1));
			pLibDev->devMap.OSmemRead(devNum, rxStatsInfo.descToRead + BUFFER_POINTER, 
					(A_UCHAR *)&rxStatsInfo.bufferAddr, sizeof(rxStatsInfo.bufferAddr));
			rxStatsInfo.descRate = descRate2bin((rxStatsInfo.status1 >> BITS_TO_RX_DATA_RATE) & pLibDev->rxDataRateMsk);

			// Initialize loop variables
			rxStatsInfo.badPacket = 0;
			rxStatsInfo.gotHeaderInfo = FALSE; // TODO: FIX for multi buffer packet support
			rxStatsInfo.illegalBuffSize = 0;
			rxStatsInfo.controlFrameReceived = 0;
			rxStatsInfo.mdkPktType = 0;
			//reset our timeout counter
			i = 0;

			// Increase buffer address for PPM
			if(pLibDev->rx.enablePPM) {
				rxStatsInfo.bufferAddr += PPM_DATA_SIZE;
			}
						
			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:txrxDataBegin:  ran out of receive descriptors\n", devNum);
				break;
			}
			mdkExtractAddrAndSequence(devNum, &rxStatsInfo);

			//only process packets if things are good
			if ( !((rxStatsInfo.status1 & DESC_MORE) || rxStatsInfo.badPacket || rxStatsInfo.controlFrameReceived || 
				rxStatsInfo.illegalBuffSize) ) {
				
				//check for this being "last packet" or stats packet
				//mdkExtractAddrAndSequence also pulled mdkPkt type info from packet
				if ((rxStatsInfo.status2 & DESC_FRM_RCV_OK) 
				 && (rxStatsInfo.mdkPktType == MDK_LAST_PKT)){
					lastPktReceived = TRUE;
					
					//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) && txComplete) {
						for (i = 0; i < 1 /*MAX_TX_QUEUE*/; i++ )
						{
							for(statsLoop = 1; statsLoop < STATS_BINS; statsLoop++) {
								// Need to check if we have transmit OR receive stats for this rate
								if((pLibDev->rx.rxStats[i][statsLoop].crcPackets > 0) ||
									(pLibDev->rx.rxStats[i][statsLoop].goodPackets > 0) ||
									(pLibDev->tx[queueIndex].txStats[statsLoop].excessiveRetries > 0) ||
									(pLibDev->tx[queueIndex].txStats[statsLoop].goodPackets > 0)) {
									sendStatsPkt(devNum, statsLoop, MDK_TXRX_STATS_PKT, pLibDev->tx[queueIndex].destAddr.octets);
								}
							}
							sendStatsPkt(devNum, 0, MDK_TXRX_STATS_PKT, pLibDev->tx[queueIndex].destAddr.octets);
							statsSent = TRUE;
						}
					}
				}
				else if((rxStatsInfo.status2 & DESC_FRM_RCV_OK) 
					 && (rxStatsInfo.mdkPktType >= MDK_TX_STATS_PKT)
					 && (rxStatsInfo.mdkPktType <= MDK_TXRX_STATS_PKT)) {
					statsPktReceived = mdkExtractRemoteStats(devNum, &rxStatsInfo);
					rxComplete = statsPktReceived;
				}
				else if (rxStatsInfo.mdkPktType == MDK_NORMAL_PKT){
					if (enableCompare) {
						comparePktData(devNum, &rxStatsInfo);
					}
					if (pLibDev->rx.enablePPM) {
						extractPPM(devNum, &rxStatsInfo);
					}

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

				}
				else {
					if(rxStatsInfo.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, 
							rxStatsInfo.mdkPktType);
					}
					if (rxStatsInfo.status2 & DESC_CRC_ERR)
					{
						pLibDev->rx.rxStats[rxStatsInfo.qcuIndex][0].crcPackets++;
						pLibDev->rx.rxStats[rxStatsInfo.qcuIndex][rxStatsInfo.descRate].crcPackets++;
						pLibDev->rx.haveStats = 1;
					}
					else if (rxStatsInfo.status2 & pLibDev->decryptErrMsk)
					{
						pLibDev->rx.rxStats[rxStatsInfo.qcuIndex][0].decrypErrors++;
						pLibDev->rx.rxStats[rxStatsInfo.qcuIndex][rxStatsInfo.descRate].decrypErrors++;
						pLibDev->rx.haveStats = 1;
					}

				}
			}

			if(txComplete && rxComplete) {
				break;
			}

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

	if (i == timeout)
	{
		if (!txComplete) {
			mError(devNum, EIO, "Device Number %d:txrxDataBegin: timeout reached before all frames transmitted\n", devNum);
		}
		else {
			mError(devNum, EIO, 
			"Device Number %d:txrxDataBegin: timeout reached, without receiving all packets.  Number received = %lu\n", devNum,
			numDesc);

			if (!lastPktReceived) {
				mError(devNum, EIO, 
				"Device Number %d:txrxDataBegin: timeout reached, without receiving last packet\n", devNum);
			}

			if (!statsPktReceived && (remoteStats == ENABLE_STATS_RECEIVE)) {
				mError(devNum, EIO, 
				"Device Number %d:txrxDataBegin: timeout reached, without receiving stats packet\n", devNum);
			} 
			   
		}
	}



	if((remoteStats & ENABLE_STATS_SEND) && !statsSent) {
		for( i = 0; i < MAX_TX_QUEUE; i++ )
		{
			for(statsLoop = 1; statsLoop < STATS_BINS; statsLoop++) {
				// Need to check if we have transmit OR receive stats for this rate
				if((pLibDev->rx.rxStats[i][statsLoop].crcPackets > 0) ||
					(pLibDev->rx.rxStats[i][statsLoop].goodPackets > 0) ||
					(pLibDev->tx[queueIndex].txStats[statsLoop].excessiveRetries > 0) ||
					(pLibDev->tx[queueIndex].txStats[statsLoop].goodPackets > 0)) {
					sendStatsPkt(devNum, statsLoop, MDK_TXRX_STATS_PKT, pLibDev->tx[queueIndex].destAddr.octets);
				}
			}
			sendStatsPkt(devNum, 0, MDK_TXRX_STATS_PKT, pLibDev->tx[queueIndex].destAddr.octets);
		}
	}

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

	//write back the retry value
	//REGW(devNum, F2_RETRY_LMT, pLibDev->tx[queueIndex].retryValue);
	ar5kInitData[pLibDev->ar5kInitIndex].pMacAPI->setRetryLimit( devNum, 0 );	//__TODO__

	if(enableCompare) {
		free(rxStatsInfo.pCompareData);
	}

	return;
}

/**************************************************************************
* txGetStats - Read and return the tx stats values
*
* remote: set to 1 if want to get stats that were sent from a remote stn
*/
MANLIB_API void txGetStats
(
 A_UINT32 devNum, 
 A_UINT32 rateInMb,
 A_UINT32 remote,
 TX_STATS_STRUCT *pReturnStats 
)
{
	LIB_DEV_INFO *pLibDev = gLibInfo.pLibDevArray[devNum];
	A_UINT16	queueIndex = pLibDev->selQueueIndex;
	A_UINT32  rateBinIndex = rate2bin(rateInMb);
	
	memset(pReturnStats, 0, sizeof(TX_STATS_STRUCT));

	if (checkDevNum(devNum) == FALSE) {
		mError(devNum, EINVAL, "Device Number %d:txGetStats\n", devNum);
		return;
	}
//	if ( (rateInMb > 54) || ((rateBinIndex == 0) && (rateInMb)) ) {
//		mError(devNum, EINVAL, "Device Number %d:txGetStats: Invalid rateInMb value %x - use 0 for all rates\n", devNum,
//			rateInMb);
//		return;
//	}
	if (remote) {
		//check to see if we received remote stats
		if ((pLibDev->remoteStats == MDK_TX_STATS_PKT) || 
			(pLibDev->remoteStats == MDK_TXRX_STATS_PKT)) {
			memcpy(pReturnStats, &(pLibDev->txRemoteStats[rateBinIndex]), sizeof(TX_STATS_STRUCT)); 
		}
		else {
			mError(devNum, EIO, "Device Number %d:txGetStats: no remote stats were received\n", devNum);
			return;
		}
	}
	else {
		if(pLibDev->tx[queueIndex].haveStats) {
			memcpy(pReturnStats, &(pLibDev->tx[queueIndex].txStats[rateBinIndex]), sizeof(TX_STATS_STRUCT)); 
		}
		else {
			mError(devNum, EIO, "Device Number %d:txGetStats: no tx stats have been collected\n", devNum);
			return;
		}

	}
	return;
}

/**************************************************************************
* rxGetStats - Read and return the rx stats values
*
* remote: set to 1 if want to get stats that were sent from a remote stn
*/
MANLIB_API void rxGetStats
(
 A_UINT32 devNum,
 A_UINT32 rateInMb,
 A_UINT32 remote,
 RX_STATS_STRUCT *pReturnStats 
)
{
	LIB_DEV_INFO *pLibDev = gLibInfo.pLibDevArray[devNum];
	A_UINT32 rateBinIndex = rate2bin(rateInMb);

	//work around for venice to get to the correct CCK rate bins
	if(((pLibDev->swDevID & 0xff) >= 0x0013) && (pLibDev->mode == MODE_11B)){
		if((rateBinIndex > 0) && (rateBinIndex < 9)) {
			if(rateBinIndex == 1){
				rateBinIndex += 8;
			}
			else {
				rateBinIndex += 7;
			}
		}
	}

	memset(pReturnStats, 0, sizeof(RX_STATS_STRUCT));

	if (checkDevNum(devNum) == FALSE) {
		mError(devNum, EINVAL, "Device Number %d:rxGetStats\n", devNum);
		return;
	}
	if ( /*(rateInMb > 54) ||*/ ((rateBinIndex == 0) && (rateInMb)) ) {
		mError(devNum, EINVAL, "Device Number %d:rxGetStats: Invalid rateInMb value %d - use 0 for all rates\n", devNum,
			rateInMb);
		return;
	}

	if (remote) {
		//check to see if we received remote stats
		if ((pLibDev->remoteStats == MDK_RX_STATS_PKT) || 
			(pLibDev->remoteStats == MDK_TXRX_STATS_PKT)) {
			memcpy(pReturnStats, &(pLibDev->rxRemoteStats[rateBinIndex]), sizeof(RX_STATS_STRUCT)); 
		}
		else {
			mError(devNum, EIO, "Device Number %d:rxGetStats: no remote stats were received\n", devNum);
			return;
		}
	}
	else {
		if(pLibDev->rx.haveStats) { // __TODO__ 
			memcpy(pReturnStats, &(pLibDev->rx.rxStats[0][rateBinIndex]), sizeof(RX_STATS_STRUCT)); 
		}
		else {
			mError(devNum, EIO, "Device Number %d:rxGetStats: no rx stats have been collected\n", devNum);
			return;
		}
	}
	return;
}

/**************************************************************************
* rxGetData - Get data from a particular descriptor
*
* 
*/
MANLIB_API void rxGetData
(
 A_UINT32 devNum, 
 A_UINT32 bufferNum, 
 A_UCHAR *pReturnBuffer, 
 A_UINT32 sizeBuffer
)
{
	LIB_DEV_INFO *pLibDev = gLibInfo.pLibDevArray[devNum];
	A_UINT32 readSize, readAddr;
	A_UINT32 status;
	A_UINT32 descAddr;

	if (checkDevNum(devNum) == FALSE) {
		mError(devNum, EINVAL, "Device Number %d:rxGetData\n", devNum);
		return;
	}
	if(pLibDev->devState < RESET_STATE) {
		mError(devNum, EILSEQ, "Device Number %d:rxGetData: device not out of reset state - resetDevice must be run first\n", devNum);
	return;
	}
	if(pLibDev->rx.bufferAddress == 0) {
		mError(devNum, EILSEQ, "Device Number %d:rxGetData: receive buffer is empty - no valid data to read\n", devNum);
		return;
	}
	if(bufferNum > pLibDev->rx.numDesc) {
		mError(devNum, EINVAL, "Device Number %d:rxGetData: Asking for a buffer beyond the number setup for receive\n", devNum);
		return;
	}

	readSize = A_MIN(pLibDev->rx.bufferSize, sizeBuffer);
	readAddr = pLibDev->rx.bufferAddress + (pLibDev->rx.bufferSize * bufferNum);
	//read only if the descriptor is good, otherwise, move onto next descriptor
	descAddr = pLibDev->rx.descAddress + (sizeof(MDK_ATHEROS_DESC) * bufferNum);
	while(bufferNum < pLibDev->rx.numDesc) {
		pLibDev->devMap.OSmemRead(devNum, descAddr + SECOND_STATUS_WORD, 
					(A_UCHAR *)&status, sizeof(status));

		if (status & DESC_DONE) {
			if(status & DESC_FRM_RCV_OK) { 		
				pLibDev->devMap.OSmemRead(devNum, readAddr, pReturnBuffer, readSize);
				return;
			}
		} else {
			//found a descriptor that's not done, assume all others are same
			mError(devNum, EIO, "Device Number %d:rxGetData: Found descriptor not done before valid receive descriptor", devNum);
			return;
		}
		descAddr += sizeof(MDK_ATHEROS_DESC);
		readAddr += pLibDev->rx.bufferSize;
		bufferNum++;
	}
	//if got to here then ran out of descriptors
	mError(devNum, EIO, "Device Number %d:rxGetData: Unable to find a descriptor with RX_OK\n", devNum);
}


/**************************************************************************
* createTransmitPacket - create packet for transmission
*
*/
void createTransmitPacket
(
 A_UINT32 devNum, 
 A_UINT16 mdkType,
 A_UCHAR *dest, 
 A_UINT32 numDesc,
 A_UINT32 dataBodyLength, 
 A_UCHAR *dataPattern, 
 A_UINT32 da