art_if.c

atheros ar5001 5002 driver

		GlobalCmd.CMD_U.EEPROM_WRITE_BLOCK_CMD.length = length;
		GlobalCmd.CMD_U.EEPROM_WRITE_BLOCK_CMD.startOffset = startOffset;
		memcpy(GlobalCmd.CMD_U.EEPROM_WRITE_BLOCK_CMD.eepromValue, buf, length * 4);
	
		/* send the command.  Note that the size to send is only for num bytes want to write */
		if(!artSendCmd(&GlobalCmd,
					   (sizeof(GlobalCmd.CMD_U.EEPROM_WRITE_BLOCK_CMD) + sizeof(GlobalCmd.cmdID) - ((MAX_BLOCK_DWORDS - length)*4)),
					   NULL)) {
				uiPrintf("Error: Unable to successfully send EEPROM_WRITE_BLOCK command\n");
				return 0;
		}
	}

	if (checkLibError(devNum, 1)) return 0;

	return 1;
}

void art_eepromWriteBlock
(
	A_UINT32 devNum,
	A_UINT32 startOffset,
	A_UINT32 length,
	A_UINT32 *buf
)
{
	A_UINT32 ii = length, startAddr_ii=startOffset, len_ii, arrayStart_ii=0;

	while( ii > 0)
	{
		if(ii > 255)
		{
			len_ii = 256;
		} else
		{
			len_ii = ii;
		}
		if (!art_eepromWriteBlock_256(devNum, startAddr_ii, len_ii, &(buf[arrayStart_ii]))) break;
		startAddr_ii += len_ii;
		ii -= len_ii;
		arrayStart_ii += len_ii;
	}

	return;
}

static A_INT32 art_eepromReadBlock_256
(
	A_UINT32 devNum,
	A_UINT32 startOffset,
	A_UINT32 length,
	A_UINT32 *buf
)
{
    A_UCHAR  *pReadValues;		  /* pointer to the values that were read */
	

	if(!configSetup.remote) {
		eepromReadBlock(devNum,startOffset,length,buf);
	} else {
		/* setup the command struct to send */
		GlobalCmd.cmdID = M_EEPROM_READ_BLOCK_CMD_ID;
		GlobalCmd.CMD_U.EEPROM_READ_BLOCK_CMD.devNum = devNum;
		GlobalCmd.CMD_U.EEPROM_READ_BLOCK_CMD.length = length;
		GlobalCmd.CMD_U.EEPROM_READ_BLOCK_CMD.startOffset = startOffset;
			
			    /* send the command.  Note that the size to send is only for num bytes want to write */
		if(!artSendCmd(&GlobalCmd,
					(sizeof(GlobalCmd.CMD_U.EEPROM_READ_BLOCK_CMD) + sizeof(GlobalCmd.cmdID)),
					(void **)(&pReadValues))) {
				uiPrintf("Error: Unable to successfully send EEPROM_READ_BLOCK command\n");
				return 0;
		}
		if(checkLibError(devNum, 1)) return 0;
		memcpy((void *)buf,(void *)pReadValues, length * 4);
    }
	if (checkLibError(devNum, 1)) return 0;
    return 1;
}

void art_eepromReadBlock
(
	A_UINT32 devNum,
	A_UINT32 startOffset,
	A_UINT32 length,
	A_UINT32 *buf
)
{
	A_UINT32 ii = length, startAddr_ii=startOffset, len_ii, arrayStart_ii=0;


	while( ii > 0)
	{
		if(ii > 255)
		{
			len_ii = 256;
		} else
		{
			len_ii = ii;
		}
		if (!art_eepromReadBlock_256(devNum, startAddr_ii, len_ii, &(buf[arrayStart_ii]))) return;
		startAddr_ii += len_ii;
		ii -= len_ii;
		arrayStart_ii += len_ii;
	}

	return;
}

A_UINT32 art_checkRegs
(
	A_UINT32 devNum
)
{
	A_UINT32	    *pRegValue;
	A_UINT32		regValue;

	if(!configSetup.remote)
	{
			regValue = checkRegs(devNum);
	} 
	else 
	{
		// create cmd to send to client
		GlobalCmd.cmdID = M_CHECK_REGS_CMD_ID;
		GlobalCmd.CMD_U.DEV_NUM_CMD.devNum = devNum;

		if (!artSendCmd(&GlobalCmd,
						sizeof(GlobalCmd.CMD_U.DEV_NUM_CMD)+sizeof(GlobalCmd.cmdID),
						(void **)&pRegValue)) 
		{
			uiPrintf("Error: Unable to successfully send EEPROM_READ_CMD command to client!\n");
			return 0xdeadbeef;
		}
		regValue = *pRegValue;
	}
	if(checkLibError(devNum, 1)) {
		return 0xdeadbeef;
	}
	return regValue;
}


A_UINT32 art_checkProm
(
	A_UINT32 devNum,
	A_UINT32 enablePrint
)
{
	A_UINT32	    *pRegValue;
	A_UINT32		regValue;

	if(!configSetup.remote)
	{
		regValue = checkProm(devNum, enablePrint);
	} 
	else 
	{
		// create cmd to send to client
		GlobalCmd.cmdID = M_CHECK_PROM_CMD_ID;
		GlobalCmd.CMD_U.SET_ONE_CMD.devNum = devNum;
		GlobalCmd.CMD_U.SET_ONE_CMD.param = enablePrint;

		if (!artSendCmd(&GlobalCmd,
						sizeof(GlobalCmd.CMD_U.SET_ONE_CMD)+sizeof(GlobalCmd.cmdID),
						(void **)&pRegValue)) 
		{
			uiPrintf("Error: Unable to successfully send CHECK_PROM_CMD command to client!\n");
			return(1);
		}
		regValue = *pRegValue;
	}
	if(checkLibError(devNum, 1)) {
		return 1;
	}
	return regValue;
}

void art_enableHwCal
(
 A_UINT32 devNum,	
 A_UINT32 calFlag
)
{
	if(!configSetup.remote)
	{
		enableCal = calFlag;
	}
	else 
	{
		// create cmd to send to client
		GlobalCmd.cmdID = ENABLE_HW_CAL_CMD;
		GlobalCmd.CMD_U.DEV_NUM_CMD.devNum = calFlag;

		if (!artSendCmd(&GlobalCmd,
						sizeof(GlobalCmd.CMD_U.DEV_NUM_CMD)+sizeof(GlobalCmd.cmdID), 
						NULL)) 
		{
			uiPrintf("Error: Unable to successfully send ENABLE_HW_CAL_CMD command to client!\n");
		}
	}
	checkLibError(devNum, 1);

}

void art_rereadProm
(
	A_UINT32 devNum
)
{
	if(!configSetup.remote)
	{
		    rereadProm(devNum);
	} 
	else 
	{
		// create cmd to send to client
		GlobalCmd.cmdID = M_REREAD_PROM_CMD_ID;
		GlobalCmd.CMD_U.DEV_NUM_CMD.devNum = devNum;

		if (!artSendCmd(&GlobalCmd,
						sizeof(GlobalCmd.CMD_U.DEV_NUM_CMD)+sizeof(GlobalCmd.cmdID), 
						NULL)) 
		{
			uiPrintf("Error: Unable to successfully send REREAD_PROM_CMD command to client!\n");
		}
	}
	checkLibError(devNum, 1);
}

void art_changeChannel
(
	A_UINT32 devNum,
	A_UINT32 freq
)
{
    
	if(!configSetup.remote) {
		changeChannel(devNum, freq);
	} else {
		// create cmd to send to client
		GlobalCmd.cmdID = M_CHANGE_CHANNEL_CMD_ID;
		GlobalCmd.CMD_U.SET_ONE_CMD.devNum = devNum;
		GlobalCmd.CMD_U.SET_ONE_CMD.param = freq;

		if ( !artSendCmd(&GlobalCmd,
			 sizeof(GlobalCmd.CMD_U.SET_ONE_CMD)+sizeof(GlobalCmd.cmdID), NULL)) {
			uiPrintf("Error: Unable to successfully send CHANGE_CHANNEL_CMD command to client!\n");
		}
	}
	checkLibError(devNum, 1);
}


void art_txDataSetup
(
	A_UINT32 devNum,
	A_UINT32 rateMask,
	A_UCHAR *dest, 
	A_UINT32 numDescPerRate,
	A_UINT32 dataBodyLength,
	A_UCHAR *dataPattern, 
	A_UINT32 dataPatternLength, 
	A_UINT32 retries,
	A_UINT32 antenna,
	A_UINT32 broadcast
)
{
	if(!configSetup.remote)
	{	
			txDataSetup(devNum, rateMask, dest, numDescPerRate, dataBodyLength,
				dataPattern, dataPatternLength, retries, antenna, broadcast);
	} else {
		// create cmd to send to client
		GlobalCmd.cmdID = M_TX_DATA_SETUP_CMD_ID;
		GlobalCmd.CMD_U.TX_DATA_SETUP_CMD.devNum = devNum;
		GlobalCmd.CMD_U.TX_DATA_SETUP_CMD.rateMask = rateMask;
		memcpy(GlobalCmd.CMD_U.TX_DATA_SETUP_CMD.dest, dest, 6);
		GlobalCmd.CMD_U.TX_DATA_SETUP_CMD.numDescPerRate = numDescPerRate;
		GlobalCmd.CMD_U.TX_DATA_SETUP_CMD.dataBodyLength = dataBodyLength;
		memcpy(GlobalCmd.CMD_U.TX_DATA_SETUP_CMD.dataPattern, dataPattern, dataPatternLength);
		GlobalCmd.CMD_U.TX_DATA_SETUP_CMD.dataPatternLength = dataPatternLength;
		GlobalCmd.CMD_U.TX_DATA_SETUP_CMD.retries = retries;
		GlobalCmd.CMD_U.TX_DATA_SETUP_CMD.antenna = antenna;
		GlobalCmd.CMD_U.TX_DATA_SETUP_CMD.broadcast = broadcast;


		if (!artSendCmd(&GlobalCmd,
						(sizeof(GlobalCmd.CMD_U.TX_DATA_SETUP_CMD)+
						sizeof(GlobalCmd.cmdID)-
						MAX_BLOCK_BYTES+
						GlobalCmd.CMD_U.TX_DATA_SETUP_CMD.dataPatternLength), 
						NULL)) 
		{
			uiPrintf("Error: Unable to successfully send TX_DATA_SETUP_CMD command to client!\n");
		}
	}
	checkLibError(devNum, 1);
}

void art_txDataBegin
(
	A_UINT32 devNum,
	A_UINT32 timeout,
	A_UINT32 remoteStats
)
{
	if(!configSetup.remote)
    {
			txDataBegin(devNum, timeout, remoteStats);
	} 
	else 
	{
		// create cmd to send to client
		GlobalCmd.cmdID = M_TX_DATA_BEGIN_CMD_ID;
		GlobalCmd.CMD_U.TX_DATA_BEGIN_CMD.devNum = devNum;
		GlobalCmd.CMD_U.TX_DATA_BEGIN_CMD.timeout = timeout;
		GlobalCmd.CMD_U.TX_DATA_BEGIN_CMD.remoteStats = remoteStats;

		if (!artSendCmd(&GlobalCmd,
						sizeof(GlobalCmd.CMD_U.TX_DATA_BEGIN_CMD)+sizeof(GlobalCmd.cmdID),
						NULL)) 
		{
			uiPrintf("Error: Unable to successfully send TX_DATA_BEGIN_CMD command to client!\n");
		}
	}
	checkLibError(devNum, 1);
}

void art_rxDataSetup
(
	A_UINT32 devNum,
	A_UINT32 numDesc,
	A_UINT32 dataBodyLength,
	A_UINT32 enablePPM
)
{
	if(!configSetup.remote)
	{		
		rxDataSetup(devNum, numDesc, dataBodyLength, enablePPM);
	} 
	else 
	{
		// create cmd to send to client
		GlobalCmd.cmdID = M_RX_DATA_SETUP_CMD_ID;
		GlobalCmd.CMD_U.RX_DATA_SETUP_CMD.devNum = devNum;
		GlobalCmd.CMD_U.RX_DATA_SETUP_CMD.numDesc = numDesc;
		GlobalCmd.CMD_U.RX_DATA_SETUP_CMD.dataBodyLength = dataBodyLength;
		GlobalCmd.CMD_U.RX_DATA_SETUP_CMD.enablePPM = enablePPM;

		if (!artSendCmd(&GlobalCmd,
						sizeof(GlobalCmd.CMD_U.RX_DATA_SETUP_CMD)+sizeof(GlobalCmd.cmdID), 
						NULL)) 
		{
			uiPrintf("Error: Unable to successfully send RX_DATA_SETUP_CMD command to client!\n");
		}
	}
	checkLibError(devNum, 1);
}

void art_rxDataBegin
(
	A_UINT32 devNum,
	A_UINT32 waitTime,
	A_UINT32 timeout,
	A_UINT32 remoteStats,
	A_UINT32 enableCompare,
	A_UCHAR *dataPattern, 
	A_UINT32 dataPatternLength
)
{
	if(!configSetup.remote)
	{
			rxDataBegin(devNum, waitTime, timeout, remoteStats, enableCompare, dataPattern, dataPatternLength);
	} 
	else 
	{
		// create cmd to send to client
		GlobalCmd.cmdID = M_RX_DATA_BEGIN_CMD_ID;
		GlobalCmd.CMD_U.RX_DATA_BEGIN_CMD.devNum = devNum;
		GlobalCmd.CMD_U.RX_DATA_BEGIN_CMD.waitTime = waitTime;
		GlobalCmd.CMD_U.RX_DATA_BEGIN_CMD.timeout = timeout;
		GlobalCmd.CMD_U.RX_DATA_BEGIN_CMD.remoteStats = remoteStats;
		GlobalCmd.CMD_U.RX_DATA_BEGIN_CMD.enableCompare = enableCompare;
		GlobalCmd.CMD_U.RX_DATA_BEGIN_CMD.dataPatternLength = dataPatternLength;
		memcpy(GlobalCmd.CMD_U.RX_DATA_BEGIN_CMD.dataPattern, dataPattern, dataPatternLength);

		if (!artSendCmd(&GlobalCmd,
						(sizeof(GlobalCmd.CMD_U.RX_DATA_BEGIN_CMD) +
						sizeof(GlobalCmd.cmdID) -
						MAX_BLOCK_BYTES +
						GlobalCmd.CMD_U.RX_DATA_BEGIN_CMD.dataPatternLength), 
						NULL)) 
		{
			uiPrintf("Error: Unable to successfully send RX_DATA_BEGIN_CMD command to client!\n");
		}
	}
	checkLibError(devNum, 1);
}

void art_rxDataComplete
(
	A_UINT32 devNum,
	A_UINT32 waitTime,
	A_UINT32 timeout,
	A_UINT32 remoteStats,
	A_UINT32 enableCompare,
	A_UCHAR *dataPattern, 
	A_UINT32 dataPatternLength
)
{
	if(!configSetup.remote)
	{
		rxDataComplete(devNum, waitTime, timeout, remoteStats, enableCompare, dataPattern, dataPatternLength);
	} 
	else 
	{
		// create cmd to send to client
		GlobalCmd.cmdID = M_RX_DATA_COMPLETE_CMD_ID;
		GlobalCmd.CMD_U.RX_DATA_BEGIN_CMD.devNum = devNum;
		GlobalCmd.CMD_U.RX_DATA_BEGIN_CMD.waitTime = waitTime;
		GlobalCmd.CMD_U.RX_DATA_BEGIN_CMD.timeout = timeout;
		GlobalCmd.CMD_U.RX_DATA_BEGIN_CMD.remoteStats = remoteStats;
		GlobalCmd.CMD_U.RX_DATA_BEGIN_CMD.enableCompare = enableCompare;
		GlobalCmd.CMD_U.RX_DATA_BEGIN_CMD.dataPatternLength = dataPatternLength;
		memcpy(GlobalCmd.CMD_U.RX_DATA_BEGIN_CMD.dataPattern, dataPattern, dataPatternLength);

		if (!artSendCmd(&GlobalCmd,
						(sizeof(GlobalCmd.CMD_U.RX_DATA_BEGIN_CMD) +
						sizeof(GlobalCmd.cmdID) -
						MAX_BLOCK_BYTES +
						GlobalCmd.CMD_U.RX_DATA_BEGIN_CMD.dataPatternLength), 
						NULL)) 
		{
			uiPrintf("Error: Unable to successfully send RX_DATA_COMPLETE_CMD command to client!\n");
		}
	}
	checkLibError(devNum, 1);
}

void art_rxGetData
(
 A_UINT32 devNum, 
 A_UINT32 bufferNum, 
 A_UCHAR *pReturnBuffer, 
 A_UINT32 sizeBuffer
)
{
    A_UCHAR  *pReadValues;		  /* pointer to the values that were read */

	if(!configSetup.remote)
	{		
		rxGetData(devNum, bufferNum, pReturnBuffer, sizeBuffer);
	} 
	else 
	{
		// create cmd to send to client
		GlobalCmd.cmdID = M_RX_GET_DATA_CMD_ID;
		GlobalCmd.CMD_U.RX_GET_DATA_CMD.devNum = devNum;
		GlobalCmd.CMD_U.RX_GET_DATA_CMD.bufferNum = bufferNum;
		GlobalCmd.CMD_U.RX_GET_DATA_CMD.sizeBuffer = sizeBuffer;

		if (!artSendCmd(&GlobalCmd,
						sizeof(GlobalCmd.CMD_U.RX_GET_DATA_CMD)+sizeof(GlobalCmd.cmdID), 
						(void **)&pReadValues)) 
		{
			uiPrintf("Error: Unable to successfully send RX_GET_DATA_CMD command to client!\n");
		}
		if(checkLibError(devNum, 1)) return;
		memcpy(pReturnBuffer, pReadValues, sizeBuffer);
	}
	checkLibError(devNum, 1);
}


A_BOOL art_rxLastDescStatsSnapshot
(
 A_UINT32 devNum, 
 RX_STATS_SNAPSHOT *pRxStats
)
{
	A_BOOL returnFlag = TRUE;
	A_UCHAR *pReadValues;

	if(!configSetup.remote)
	{
		returnFlag = rxLastDescStatsSnapshot(devNum, pRxStats);
	}
	else
	{
		// create cmd to send to client
		GlobalCmd.cmdID = M_RX_STATS_SNAPSHOT_CMD_ID;
		GlobalCmd.CMD_U.DEV_NUM_CMD.devNum = devNum;
		if (!artSendCmd(&GlobalCmd,
						sizeof(GlobalCmd.CMD_U.DEV_NUM_CMD)+sizeof(GlobalCmd.cmdID),
						(void **)&pReadValues)) 
		{
			uiPrintf("Error: Unable to successfully send M_RX_STATS_SNAPSHOT_CMD command to client!\n");
			return 0;
			
		}
		if(checkLibError(devNum, 1)) return 0;
		//get the returnFlag from the start of the return buffer
		returnFlag = *pReadValues;
		
		pReadValues+=4;
		/* copy the data from command receive buffer into buffer */
		memcpy(pRxStats, pReadValues, sizeof(RX_STATS_SNAPSHOT));
	}
	if(checkLibError(devNum, 1)) {
		return 0;
	}
	return(returnFlag);
}

void art_cleanupTxRxMemory
(
 A_UINT32 devNum,
 A_UINT32 flags
)
{
	if(!configSetup.remote)