art_if.c

Atheros AP Test with Agilent N4010A source code

		GlobalCmd.devNum = (A_INT8) devNum;
		GlobalCmd.CMD_U.EEPROM_WRITE_BLOCK_CMD.length = length;
		GlobalCmd.CMD_U.EEPROM_WRITE_BLOCK_CMD.startOffset = startOffset;
		memset(GlobalCmd.CMD_U.EEPROM_WRITE_BLOCK_CMD.eepromValue, 0, length * 4);
		memcpy(GlobalCmd.CMD_U.EEPROM_WRITE_BLOCK_CMD.eepromValue, buf, length * 4);
		//printf(" Write the Length %d \n", length);
	/*	for(ii =0 ;ii < 10 ; ii++)
		{
			printf ("Write Block is %x \n",GlobalCmd.CMD_U.EEPROM_WRITE_BLOCK_CMD.eepromValue[ii]);
		}*/
		/* 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;
	A_UINT32 max_locs_per_write;

	if (sdio_client)
		max_locs_per_write = 256;
	else
		max_locs_per_write = 256;

	while( ii > 0)
	{
		if(ii > (max_locs_per_write-1))
		{
			len_ii = max_locs_per_write;
		} 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 */
	int ii;

	//printf("SNOOP: setting eeprom mode\n");
	//art_ap_reg_write(devNum, 0x0c004004, 0x90020044);
	if(!configSetup.remote) {
		eepromReadBlock(devNum,startOffset,length,buf);
	} else {
		/* setup the command struct to send */
		GlobalCmd.cmdID = M_EEPROM_READ_BLOCK_CMD_ID;
		GlobalCmd.devNum = (A_INT8) devNum;
		GlobalCmd.CMD_U.EEPROM_READ_BLOCK_CMD.length = length;
		GlobalCmd.CMD_U.EEPROM_READ_BLOCK_CMD.startOffset = startOffset;
		//printf(" Read  Eeprom the Length %d", length);
				/* 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;
		/*for(ii =0 ;ii < length ; ii++)
		{
			printf ("Read Block is %x \n",GlobalCmd.CMD_U.EEPROM_WRITE_BLOCK_CMD.eepromValue[ii]);
		}*/
		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;
	A_UINT32 max_locs_per_read;

	if (sdio_client)
		max_locs_per_read = 128;
	else
		max_locs_per_read = 256;


	while( ii > 0)
	{
		if(ii > (max_locs_per_read-1))
		{
			len_ii = max_locs_per_read;
		} 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;
}

void art_eepromReadLocs
(
	A_UINT32 devNum,
	A_UINT32 startOffset,
	A_UINT32 length,
	A_UINT8 *buf
)
{
	A_UCHAR  *pReadValues;		  /* pointer to the values that were read */


		/* setup the command struct to send */
		GlobalCmd.cmdID = M_EEPROM_READ_LOCS_CMD_ID;
		GlobalCmd.devNum = (A_INT8) devNum;
		GlobalCmd.CMD_U.EEPROM_READ_LOCS_CMD.length = length;
		GlobalCmd.CMD_U.EEPROM_READ_LOCS_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_LOCS_CMD) + sizeof(GlobalCmd.cmdID)),
					(void **)(&pReadValues))) {
				uiPrintf("Error: Unable to successfully send EEPROM_READ_LOCS command\n");
				return ;
		}
		if(checkLibError(devNum, 1)) { uiPrintf("remote command error\n"); return ;}
		memcpy((void *)buf,(void *)pReadValues, length * NUM_BYTES_PER_EEPROM_LOC);
}

#if 0
void art_eepromWriteLocs
(
	A_UINT32 devNum,
	A_UINT32 startOffset,
	A_UINT32 length,
	A_UINT8 *buf
)
{
	A_UCHAR  *pReadValues;		  /* pointer to the values that were read */
	A_UINT32 *pBuffer;

	//allocate a 32 bit value buffer for sending regular eeprom write command
	pBuffer = malloc(sizeof(A_UINT32) * length);
	if(pBuffer == NULL) {
		uiPrintf("Error: unable to allocate buffer for sending eeprom write, eepromWriteLocs\n");
		return;
	}

	for (i = 0; i < length; i++) {
		pBuffer[i] = buf[i];
	}

	art_eepromWriteBlock
}
#endif

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

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

		if (!artSendCmd(&GlobalCmd, 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 || !configSetup.remote_exec)
	{
		regValue = checkProm(devNum, enablePrint);
	}
	else
	{
		// create cmd to send to client
		GlobalCmd.cmdID = M_CHECK_PROM_CMD_ID;
		GlobalCmd.devNum = (A_INT8) 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 || !configSetup.remote_exec)
	{
		//enableCal = calFlag;
	}
	else
	{
		// create cmd to send to client
		GlobalCmd.cmdID = ENABLE_HW_CAL_CMD;
		GlobalCmd.devNum = (A_INT8) calFlag;

		if (!artSendCmd(&GlobalCmd,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 || !configSetup.remote_exec)
	{
			rereadProm(devNum);
	}
	else
	{
		// create cmd to send to client
		GlobalCmd.cmdID = M_REREAD_PROM_CMD_ID;
		GlobalCmd.devNum = (A_INT8) devNum;

		if (!artSendCmd(&GlobalCmd, 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
)
{

//** the following added by ccshiang
	{
		double cf;

		AgN4010_GetProperty(AgN4010_PropName_CenterFrequency_MHz,&cf);
		if (freq > 10000) {
			if (freq != (A_UINT32) (cf * 10))
				AgN4010_SetProperty(AgN4010_PropName_CenterFrequency_MHz,(double) freq/10.0);
		}
		else {
			if (freq != (A_UINT32) cf)
				AgN4010_SetProperty(AgN4010_PropName_CenterFrequency_MHz,freq);
		}
	}
//** the above added by ccshiang
	if(!configSetup.remote || !configSetup.remote_exec) {
		changeChannel(devNum, freq);
	} else {
		// create cmd to send to client
		GlobalCmd.cmdID = M_CHANGE_CHANNEL_CMD_ID;
		GlobalCmd.devNum = (A_INT8) 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
)
{
	int ii;
	if(!configSetup.remote || !configSetup.remote_exec)
	{
			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.devNum = (A_INT8) 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;
		//printf(">>>>>>rateMask  %x\n",rateMask);
		//GlobalCmd.CMD_U.TX_DATA_SETUP_CMD.numDescPerRate = 10;
		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
)
{
	//printf("*********TIME OUT IS %d*********\n",timeout);
	if(!configSetup.remote || !configSetup.remote_exec)
	{
			txDataBegin(devNum, timeout, remoteStats);
	}
	else
	{
		// create cmd to send to client
		GlobalCmd.cmdID = M_TX_DATA_BEGIN_CMD_ID;
		GlobalCmd.devNum = (A_INT8) 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 || !configSetup.remote_exec)
	{
		rxDataSetup(devNum, numDesc, dataBodyLength, enablePPM);
	}
	else
	{
		// create cmd to send to client
		//printf("CMD ID IS M_RX_DATA_SETUP_CMD_ID :\n");
		GlobalCmd.cmdID = M_RX_DATA_SETUP_CMD_ID;
		GlobalCmd.devNum = (A_INT8) 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 || !configSetup.remote_exec)
	{
			rxDataBegin(devNum, waitTime, timeout, remoteStats, enableCompare, dataPattern, dataPatternLength);
	}
	else
	{
		// create cmd to send to client
		GlobalCmd.cmdID = M_RX_DATA_BEGIN_CMD_ID;
		GlobalCmd.devNum = (A_INT8) 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);
}