art_if.c

Atheros AP Test with Agilent N4010A source code

		GlobalCmd.cmdID = M_SPECIFY_SUBSYSTEM_CMD_ID;
		GlobalCmd.devNum = (A_INT8) devNum;
		GlobalCmd.CMD_U.SET_ONE_CMD.param = subsystemID;

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

A_UINT16 art_getMaxPowerForRate
(
 A_UINT32 devNum,
 A_UINT16 freq,
 A_UINT16 rate
)
{
	A_UINT16 returnValue;
	A_UINT16 *pRegValue;

	if	(0)
	{
		returnValue = getMaxPowerForRate(devNum, (A_UINT32)freq, (A_UINT32)rate);
	}
	else {
		GlobalCmd.cmdID = M_GET_MAX_POWER_CMD_ID;
		GlobalCmd.devNum = (A_INT8) devNum;
		GlobalCmd.CMD_U.GET_MAX_POWER_CMD.freq = freq;
		GlobalCmd.CMD_U.GET_MAX_POWER_CMD.rate = rate;
		if(!artSendCmd(&GlobalCmd,
						sizeof(GlobalCmd.CMD_U.GET_MAX_POWER_CMD)+sizeof(GlobalCmd.cmdID),
						(void **)&pRegValue))
		{
			uiPrintf("Error: Unable to successfully send GET_MAX_POWER_CMD command\n");
			return 0xdead;
		}
		returnValue = *pRegValue;

	}


	return(returnValue);
}

A_UINT16 art_getPcdacForPower
(
 A_UINT32 devNum,
 A_UINT16 freq,
 A_INT16 power
)
{
	A_UINT16 returnValue;
	A_UINT16 *pRegValue;

	if	(!configSetup.remote || !configSetup.remote_exec )
	{
		returnValue = getPcdacForPower(devNum, (A_UINT32)freq, power);
	}
	else {
		GlobalCmd.cmdID = M_GET_MAX_POWER_CMD_ID;
		GlobalCmd.devNum = (A_INT8) devNum;
		GlobalCmd.CMD_U.GET_PCDAC_FOR_POWER_CMD.freq = freq;
		GlobalCmd.CMD_U.GET_PCDAC_FOR_POWER_CMD.power = power;
		if(!artSendCmd(&GlobalCmd,
						sizeof(GlobalCmd.CMD_U.GET_PCDAC_FOR_POWER_CMD)+sizeof(GlobalCmd.cmdID),
						(void **)&pRegValue))
		{
			uiPrintf("Error: Unable to successfully send GET_PCDAC_FOR_POWER_CMD command\n");
			return 0xdead;
		}
		returnValue = *pRegValue;

	}


	return(returnValue);
}

A_INT32 art_getFieldForMode
(
 A_UINT32 devNum,
 A_CHAR   *fieldName,
 A_UINT32  mode,			//desired mode
 A_UINT32  turbo		//Flag for base or turbo value
)
{

	A_INT32 returnValue;
	A_INT32	     *pRegValue;

	if	(!configSetup.remote || !configSetup.remote_exec)
	{
		returnValue = getFieldForMode(devNum, fieldName, mode, turbo);
	}
	else
	{
		/* create cmd structure and send command */
		GlobalCmd.cmdID = M_GET_FIELD_FOR_MODE_CMD_ID;
		GlobalCmd.devNum = (A_INT8) devNum;
		GlobalCmd.CMD_U.GET_FIELD_FOR_MODE_CMD.mode = mode;
		GlobalCmd.CMD_U.GET_FIELD_FOR_MODE_CMD.turbo = turbo;
		strcpy(GlobalCmd.CMD_U.GET_FIELD_FOR_MODE_CMD.fieldName, fieldName);
		if(!artSendCmd(&GlobalCmd,
						sizeof(GlobalCmd.CMD_U.GET_FIELD_FOR_MODE_CMD)+sizeof(GlobalCmd.cmdID),
						(void **)&pRegValue))
		{
			uiPrintf("Error: Unable to successfully send GET_FIELD_FOR_MODE command\n");
			return 0xdeadbeef;
		}
		returnValue = *pRegValue;
	}
	if (checkLibError(devNum, 1)) {
		return(0xdeadbeef);
	}
	return (returnValue);
}

// art_getFieldForMode returns 0xdeadbeef even if the field doesn't exist
// and it DOES NOT WARN/ERROR in this case. don't know what the legacy reason
// is for suppressing warning on something so gross. adding a checked routine to
// visibly warn if returned value is 0xdeadbeef. Use this wherever you care about value
// being valid.  -- P.D. 2/04
A_INT32 art_getFieldForModeChecked
(
 A_UINT32 devNum,
 A_CHAR   *fieldName,
 A_UINT32  mode,			//desired mode
 A_UINT32  turbo		//Flag for base or turbo value
)
{

	A_INT32 returnValue;
	A_INT32	     *pRegValue;

	if	(!configSetup.remote || !configSetup.remote_exec)
	{
		returnValue = getFieldForMode(devNum, fieldName, mode, turbo);
	}
	else
	{
		/* create cmd structure and send command */
		GlobalCmd.cmdID = M_GET_FIELD_FOR_MODE_CMD_ID;
		GlobalCmd.devNum = (A_INT8) devNum;
		GlobalCmd.CMD_U.GET_FIELD_FOR_MODE_CMD.mode = mode;
		GlobalCmd.CMD_U.GET_FIELD_FOR_MODE_CMD.turbo = turbo;
		strcpy(GlobalCmd.CMD_U.GET_FIELD_FOR_MODE_CMD.fieldName, fieldName);
		if(!artSendCmd(&GlobalCmd,
						sizeof(GlobalCmd.CMD_U.GET_FIELD_FOR_MODE_CMD)+sizeof(GlobalCmd.cmdID),
						(void **)&pRegValue))
		{
			uiPrintf("Error: Unable to successfully send GET_FIELD_FOR_MODE command\n");
			return 0xdeadbeef;
		}
		returnValue = *pRegValue;
	}
	if ((checkLibError(devNum, 1)) || (returnValue == 0xdeadbeef)) {
		printf("***************************************************************\n");
		printf("ERROR : art_getFieldForModeChecked : fieldname %s does not exist or other major error happened\n", fieldName);
		printf("***************************************************************\n");
		return(0xdeadbeef);
	}
	return (returnValue);
}

void art_getField
(
	A_UINT32 devNum,
	A_CHAR   *fieldName,
	A_UINT32 *baseValue,
	A_UINT32 *turboValue
)
{
	A_UINT32 *pRegValue;

	if	(!configSetup.remote || !configSetup.remote_exec)
	{
		getField(devNum, fieldName, baseValue, turboValue);
	}
	else
	{
		// create cmd to send to client
		GlobalCmd.cmdID = M_GET_FIELD_VALUE_CMD_ID;
		GlobalCmd.devNum = (A_INT8) devNum;
		strcpy(GlobalCmd.CMD_U.GET_FIELD_VALUE_CMD.fieldName, fieldName);
		GlobalCmd.CMD_U.GET_FIELD_VALUE_CMD.turbo = 0;

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

void art_changeField
(
	A_UINT32 devNum,
	A_CHAR *fieldName,
	A_UINT32 newValue
)
{

	if	(!configSetup.remote || !configSetup.remote_exec)
	{
			changeField(devNum, fieldName, newValue);
	}
	else
	{
		// create cmd to send to client
		GlobalCmd.cmdID = M_CHANGE_FIELD_CMD_ID;
		GlobalCmd.devNum = (A_INT8) devNum;
		strcpy(GlobalCmd.CMD_U.CHANGE_FIELD_CMD.fieldName, fieldName);
		GlobalCmd.CMD_U.CHANGE_FIELD_CMD.newValue = newValue;

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

	checkLibError(devNum, 1);
	return;
}

void art_writeField
(
	A_UINT32 devNum,
	A_CHAR *fieldName,
	A_UINT32 newValue
)
{

	if	(!configSetup.remote || !configSetup.remote_exec)
	{
		writeField(devNum, fieldName, newValue);
	}
	else
	{
		// create cmd to send to client
		GlobalCmd.cmdID = M_WRITE_FIELD_CMD_ID;
		GlobalCmd.devNum = (A_INT8) devNum;
		strcpy(GlobalCmd.CMD_U.WRITE_FIELD_CMD.fieldName, fieldName);
		//printf(" field name is %s \n", GlobalCmd.CMD_U.WRITE_FIELD_CMD.fieldName);
		GlobalCmd.CMD_U.WRITE_FIELD_CMD.newValue = newValue;

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


void art_changeMultipleFieldsAllModes
(
 A_UINT32		  devNum,
 PARSE_MODE_INFO *pFieldsToChange,
 A_UINT32		  numFields
)
{
	if	(!configSetup.remote || !configSetup.remote_exec)
	{
		changeMultipleFieldsAllModes(devNum, pFieldsToChange, numFields);
	}
	else
	{
		GlobalCmd.cmdID = M_CHANGE_MULTIPLE_FIELDS_ALL_MODES_CMD_ID;
		GlobalCmd.devNum = (A_INT8) devNum;
		GlobalCmd.CMD_U.CHANGE_MULTI_FIELDS_ALL_MODES_CMD.numFields = numFields;
		memcpy(GlobalCmd.CMD_U.CHANGE_MULTI_FIELDS_ALL_MODES_CMD.FieldsToChange, pFieldsToChange, numFields * sizeof(PARSE_MODE_INFO));

		/* send the command.  Note that the size to send is only for num bytes want to write */
		if(!artSendCmd(&GlobalCmd,
					   (sizeof(GlobalCmd.CMD_U.CHANGE_MULTI_FIELDS_ALL_MODES_CMD) + sizeof(GlobalCmd.cmdID) - ((MAX_NUM_FIELDS - numFields)*sizeof(PARSE_MODE_INFO))),
					   NULL)) {
			uiPrintf("Error: Unable to successfully send CHANGE_MULTIPLE_FIELDS_ALL_MODES command\n");
			return;
		}
	}
	checkLibError(devNum, 1);
	return;
}

void art_changeMultipleFields
(
 A_UINT32		  devNum,
 PARSE_FIELD_INFO *pFieldsToChange,
 A_UINT32		  numFields
)
{
	if	(!configSetup.remote || !configSetup.remote_exec)
	{
		changeMultipleFields(devNum, pFieldsToChange, numFields);
	}
	else
	{
		GlobalCmd.cmdID = M_CHANGE_MULTIPLE_FIELDS_CMD_ID;
		GlobalCmd.devNum = (A_INT8) devNum;
		GlobalCmd.CMD_U.CHANGE_MULTI_FIELDS_CMD.numFields = numFields;
		memcpy(GlobalCmd.CMD_U.CHANGE_MULTI_FIELDS_CMD.FieldsToChange, pFieldsToChange, numFields * sizeof(PARSE_FIELD_INFO));

		/* send the command.  Note that the size to send is only for num bytes want to write */
		if(!artSendCmd(&GlobalCmd,
					   (sizeof(GlobalCmd.CMD_U.CHANGE_MULTI_FIELDS_CMD) + sizeof(GlobalCmd.cmdID) - ((MAX_NUM_FIELDS - numFields)*sizeof(PARSE_FIELD_INFO))),
					   NULL)) {
			uiPrintf("Error: Unable to successfully send CHANGE_MULTIPLE_FIELDS command\n");
			return;
		}
	}
	checkLibError(devNum, 1);
	return;
}


void art_teardownDevice
(
	A_UINT32 devNum
)
{
	if(configSetup.remote)
	{
		GlobalCmd.devNum = (A_INT8) devNum;
		GlobalCmd.cmdID = M_CLOSE_DEVICE_CMD_ID;
		if (!artSendCmd(&GlobalCmd, sizeof(GlobalCmd.cmdID),
						NULL))
		{
			uiPrintf("Error: problem sending CLOSE_DEVICE cmd to client!\n");
		}
#ifndef __ATH_DJGPPDOS__
		globalNumInstances--;
		if (globalNumInstances == 0) {
			GlobalCmd.devNum = (A_INT8) devNum;
			GlobalCmd.cmdID = DISCONNECT_PIPE_CMD_ID;
			if (!artSendCmd(&GlobalCmd,
							sizeof(GlobalCmd.cmdID),
							NULL))
			{
				uiPrintf("Error: problem sending DISCONNECT cmd to client in teardownDevice()!\n");
			}
			osSockClose(artSockInfo);
			pArtPrimarySock = NULL;
		}
		if (!configSetup.remote_exec) {
			teardownDevice(devNum);
		}
#endif //__ATH_DJGPPDOS__
	}
	if (!configSetup.remote)
	{
		teardownDevice(devNum);
	}
}

A_BOOL art_testLib
(
 A_UINT32 devNum,
 A_UINT32 timeout
)
{
	A_BOOL ret;
	A_UINT32 *pRegValue;

	ret = FALSE;

	if (!configSetup.remote || !configSetup.remote_exec)
	{
		ret = testLib(devNum, timeout);
	}
	else
	{
		// create cmd to send to client
		GlobalCmd.cmdID = M_TEST_LIB_CMD_ID;
		GlobalCmd.devNum = (A_INT8) devNum;
		GlobalCmd.CMD_U.SET_ONE_CMD.param = timeout;

		if ( !artSendCmd(&GlobalCmd,
						sizeof(GlobalCmd.CMD_U.SET_ONE_CMD)+sizeof(GlobalCmd.cmdID),
						(void **)&pRegValue))
		{
			uiPrintf("Error: Unable to successfully send TEST_LIB_CMD command to client!\n");
			return FALSE;

		}
		ret = (A_BOOL) *pRegValue;
	}

	if(checkLibError(devNum, 1)) {
		return FALSE;
	}
	return ret;

}

void art_ForceSinglePCDACTable
(
	A_UINT32 devNum,
	A_UINT16 pcdac
)
{
	if (!configSetup.remote || !configSetup.remote_exec)
	{
		ForceSinglePCDACTable(devNum,pcdac);
	}
	else
	{
		// create cmd to send to client
		GlobalCmd.cmdID = M_FORCE_SINGLE_PCDAC_TABLE_CMD_ID;
		GlobalCmd.devNum = (A_INT8) devNum;
		GlobalCmd.CMD_U.FORCE_SINGLE_PCDAC_TABLE_CMD.pcdac = pcdac;

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

void art_ForceSinglePCDACTableGriffin
(
	A_UINT32 devNum,
	A_UINT16 pcdac,
	A_UINT16 offset
)
{
	if (!configSetup.remote || !configSetup.remote_exec)
	{
		ForceSinglePCDACTableGriffin(devNum,pcdac,offset);
	}
	else
	{
		// create cmd to send to client
		GlobalCmd.cmdID = M_FORCE_SINGLE_PCDAC_TABLE_GRIFFIN_CMD_ID;
		GlobalCmd.devNum = (A_INT8) devNum;
		GlobalCmd.CMD_U.FORCE_SINGLE_PCDAC_TABLE_GRIFFIN_CMD.pcdac = pcdac;
		GlobalCmd.CMD_U.FORCE_SINGLE_PCDAC_TABLE_GRIFFIN_CMD.offset = offset;

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

void art_ForcePCDACTable
(
	A_UINT32 devNum,
	A_UINT16 *pcdac
)
{
	if (!configSetup.remote || !configSetup.remote_exec)
	{
		forcePCDACTable(devNum, pcdac);
	}
	else
	{
		GlobalCmd.cmdID = M_FORCE_PCDAC_TABLE_CMD_ID;
		GlobalCmd.devNum = (A_INT8) devNum;
		memcpy(GlobalCmd.CMD_U.FORCE_PCDAC_TABLE_CMD.pcdac, pcdac, MAX_PCDACS * 2);

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

void art_forcePowerTxMax
(
	A_UIN