art_if.c

atheros ar5001 5002 driver

	A_UINT32 newValue
)
{
	
	if	(!configSetup.remote) 
	{
		writeField(devNum, fieldName, newValue);
	} 
	else 
	{
		// create cmd to send to client
		GlobalCmd.cmdID = M_WRITE_FIELD_CMD_ID;
		GlobalCmd.CMD_U.WRITE_FIELD_CMD.devNum = devNum;
		strcpy(GlobalCmd.CMD_U.WRITE_FIELD_CMD.fieldName, 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) 
	{
		changeMultipleFieldsAllModes(devNum, pFieldsToChange, numFields);
	} 
	else 
	{
		GlobalCmd.cmdID = M_CHANGE_MULTIPLE_FIELDS_ALL_MODES_CMD_ID;
		GlobalCmd.CMD_U.CHANGE_MULTI_FIELDS_ALL_MODES_CMD.devNum = 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) 
	{
		changeMultipleFields(devNum, pFieldsToChange, numFields);
	} 
	else 
	{
		GlobalCmd.cmdID = M_CHANGE_MULTIPLE_FIELDS_CMD_ID;
		GlobalCmd.CMD_U.CHANGE_MULTI_FIELDS_CMD.devNum = 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)
	{
		teardownDevice(devNum);
	}
	else
	{
		GlobalCmd.cmdID = M_CLOSE_DEVICE_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: problem sending CLOSE_DEVICE cmd to client!\n");
		}
#ifndef __ATH_DJGPPDOS__
		globalNumInstances--;
		if (globalNumInstances == 0) {
			GlobalCmd.cmdID = DISCONNECT_PIPE_CMD_ID;
			if (!artSendCmd(&GlobalCmd, 
							sizeof(GlobalCmd.cmdID), 
							NULL)) 
			{
				uiPrintf("Error: problem sending DISCONNECT cmd to client in dkPerlCleanup()!\n");
			}
			osSockClose(artSockInfo);
			pArtPrimarySock = NULL;
		}
#endif //__ATH_DJGPPDOS__
	}
}

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

	ret = FALSE;

	if (!configSetup.remote)
	{
		ret = testLib(devNum, timeout);
	} 
	else 
	{
		// create cmd to send to client
		GlobalCmd.cmdID = M_TEST_LIB_CMD_ID;
		GlobalCmd.CMD_U.SET_ONE_CMD.devNum = 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)
	{
		ForceSinglePCDACTable(devNum,pcdac);
	} 
	else 
	{
		// create cmd to send to client
		GlobalCmd.cmdID = M_FORCE_SINGLE_PCDAC_TABLE_CMD_ID;
		GlobalCmd.CMD_U.FORCE_SINGLE_PCDAC_TABLE_CMD.devNum = 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_ForcePCDACTable
(
	A_UINT32 devNum, 
	A_UINT16 *pcdac
)
{
	if (!configSetup.remote)
	{
		forcePCDACTable(devNum, pcdac);
	} 
	else 
	{
		GlobalCmd.cmdID = M_FORCE_PCDAC_TABLE_CMD_ID;
		GlobalCmd.CMD_U.FORCE_SINGLE_PCDAC_TABLE_CMD.devNum = 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_UINT32		devNum,
	A_UINT16		*pRatesPower
)
{
	if (!configSetup.remote)
	{
		forcePowerTxMax(devNum, (A_INT16 *)pRatesPower);
	} 
	else 
	{
		/* setup the command struct to send */
		GlobalCmd.cmdID = M_FORCE_POWER_TX_MAX_CMD_ID;
		GlobalCmd.CMD_U.FORCE_POWER_TX_MAX_CMD.devNum = devNum;
		GlobalCmd.CMD_U.FORCE_POWER_TX_MAX_CMD.length = NUM_RATES;
		memcpy(GlobalCmd.CMD_U.FORCE_POWER_TX_MAX_CMD.ratesPower, pRatesPower, NUM_RATES * 2);
	
		/* send the command.  Note that the size to send is only for num bytes want to write */
		if(!artSendCmd(&GlobalCmd,
					   (sizeof(GlobalCmd.CMD_U.FORCE_POWER_TX_MAX_CMD) + sizeof(GlobalCmd.cmdID) - ((MAX_BLOCK_SWORDS - NUM_RATES)*2)),
					   NULL)) {
			uiPrintf("Error: Unable to successfully send FORCE_POWER_TX_MAX command\n");
			return;
		}
	}
	checkLibError(devNum, 1);
	return;
}

void art_forceSinglePowerTxMax 
(
	A_UINT32		devNum,
	A_UINT16		powerValue
)
{
	if (!configSetup.remote)
	{
		forceSinglePowerTxMax(devNum, powerValue);
	} 
	else 
	{
		// create cmd to send to client
		GlobalCmd.cmdID = M_FORCE_SINGLE_POWER_TX_MAX_CMD_ID;
		GlobalCmd.CMD_U.SET_ONE_CMD.devNum = devNum;
		GlobalCmd.CMD_U.SET_ONE_CMD.param = (A_UINT32)powerValue;

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

A_INT16 art_GetMacAddr
(
	A_UINT32 devNum,
	A_UINT16 wmac,
	A_UINT16 instNo,
	A_UINT8	*macAddr
)
{
	A_UCHAR  *pReadValues;		  
	A_UCHAR	 buf[6];
	
	if (!configSetup.remote)
	{
		getMacAddr(devNum, wmac, instNo, buf);
		pReadValues = buf;
	}
	else 
	{
		// setup the command struct to send 
		GlobalCmd.cmdID = M_GET_MAC_ADDR_CMD_ID;
		GlobalCmd.CMD_U.GET_MAC_ADDR_CMD.devNum = devNum;
		GlobalCmd.CMD_U.GET_MAC_ADDR_CMD.instNo = instNo;
		GlobalCmd.CMD_U.GET_MAC_ADDR_CMD.wmac = wmac;

		/* send the command.  Note that the size to send is only for num bytes want to write */

		if(!artSendCmd(&GlobalCmd,
					(sizeof(GlobalCmd.CMD_U.GET_MAC_ADDR_CMD) + sizeof(GlobalCmd.cmdID)),
					(void **)(&pReadValues))) {
				uiPrintf("Error: Unable to successfully send GET_MAC_ADDR command\n");
				return -1;
		}
	}

	if(checkLibError(devNum, 1)) {
		return -1;
	}

	memcpy((void *)macAddr, (void *)pReadValues, 6); // copy the mac address
	return(0);
}

A_INT16 art_configureLibParams
(
	A_UINT32 devNum
)
{

	LIB_PARAMS  LibParams;

	LibParams.beanie2928Mode = configSetup.beanie2928Mode;
	LibParams.refClock  = configSetup.refClk;
	LibParams.enableXR  = configSetup.enableXR;
	LibParams.loadEar = configSetup.loadEar;
#ifndef __ATH_DJGPPDOS__
	LibParams.artAniEnable = configSetup.artAniEnable;
	LibParams.artAniReuse  = configSetup.artAniReuse;
#else
	LibParams.artAniEnable = ART_ANI_DISABLED;
#endif

	if (!configSetup.remote)
	{
		configureLibParams(devNum, &LibParams);
	}
	else 
	{
		// setup the command struct to send 
		GlobalCmd.cmdID = M_SET_LIB_CONFIG_CMD_ID;
		GlobalCmd.CMD_U.SET_LIB_CONFIG_CMD.devNum = devNum;
		memcpy(&(GlobalCmd.CMD_U.SET_LIB_CONFIG_CMD.libParams), &LibParams, sizeof(LIB_PARAMS));

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

	if(checkLibError(devNum, 1)) {
		return -1;
	}
	return(0);
}

A_UINT16 art_GetEepromStruct
(
 A_UINT32 devNum,
 A_UINT16 eepStructFlag,	//which eeprom strcut
 void **ppReturnStruct		//return ptr to struct asked for
)
{
	A_UINT32	sizeStruct; //don't need to pass back the size of the struct,
							//this is needed for remove command on the client side.
	A_UCHAR  *pReadValues;		  
	
	if (!configSetup.remote)
	{
		getEepromStruct(devNum, eepStructFlag, ppReturnStruct, &sizeStruct);
	}
	else 
	{
		// setup the command struct to send 
		GlobalCmd.cmdID = M_GET_EEPROM_STRUCT_CMD_ID;
		GlobalCmd.CMD_U.GET_EEPROM_STRUCT_CMD.devNum = devNum;
		GlobalCmd.CMD_U.GET_EEPROM_STRUCT_CMD.eepStructFlag = eepStructFlag;

			    /* send the command.  Note that the size to send is only for num bytes want to write */

		if(!artSendCmd(&GlobalCmd,
					(sizeof(GlobalCmd.CMD_U.GET_EEPROM_STRUCT_CMD) + sizeof(GlobalCmd.cmdID)),
					(void **)(&pReadValues))) {
				uiPrintf("Error: Unable to successfully send GET_EEPROM_STRUCT command\n");
				return 0xffff;
		}
		sizeStruct = *((A_UINT32 *)pReadValues);
		*ppReturnStruct = (void *)(pReadValues+4);
	}
	if(checkLibError(devNum, 1)) {
		return 0xffff;
	}
	return(0);
}

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

	if (!configSetup.remote)
	{
		returnValue = getXpdgainForPower(devNum, power);
	}
	else {
		GlobalCmd.cmdID = M_GET_XPDGAIN_CMD_ID;
		GlobalCmd.CMD_U.GET_XPDGAIN_CMD.devNum = devNum;
		GlobalCmd.CMD_U.GET_XPDGAIN_CMD.power = power;
		if(!artSendCmd(&GlobalCmd,
					    sizeof(GlobalCmd.CMD_U.GET_XPDGAIN_CMD)+sizeof(GlobalCmd.cmdID),
						(void **)&pRegValue)) 
		{
			uiPrintf("Error: Unable to successfully send GET_XPDGAIN_CMD command\n");
			return 0xdead;
		}
		if (checkLibError(devNum, 1)) {
			return(0xdead);
		} 
		returnValue = *pRegValue;

	}
	return returnValue;
}

void art_writeProdData
(
 A_UINT32 devNum,
 A_UCHAR wlan0Mac[6],
 A_UCHAR wlan1Mac[6],
 A_UCHAR enet0Mac[6],
 A_UCHAR enet1Mac[6]
)
{
	if (configSetup.remote)
	{
		// setup the command struct to send 
		GlobalCmd.cmdID = M_WRITE_PROD_DATA_CMD_ID;
		GlobalCmd.CMD_U.WRITE_PROD_DATA_CMD.devNum = devNum;

		memcpy((void *)GlobalCmd.CMD_U.WRITE_PROD_DATA_CMD.wlan0Mac,(void *)wlan0Mac,6);
		memcpy((void *)GlobalCmd.CMD_U.WRITE_PROD_DATA_CMD.wlan1Mac,(void *)wlan1Mac,6);
		memcpy((void *)GlobalCmd.CMD_U.WRITE_PROD_DATA_CMD.enet0Mac,(void *)enet0Mac,6);
		memcpy((void *)GlobalCmd.CMD_U.WRITE_PROD_DATA_CMD.enet1Mac,(void *)enet1Mac,6);
		
		 /* send the command.  Note that the size to send is only for num bytes want to write */

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

A_BOOL art_waitForGenericCmd
(
 void *pSock,
 A_UCHAR   *pStringVar,
 A_UINT32  *pIntVar1,
 A_UINT32  *pIntVar2,
 A_UINT32  *pIntVar3
)
{

#ifndef __ATH_DJGPPDOS__
	if(waitForGenericCmd(pSock, pStringVar, pIntVar1, pIntVar2, pIntVar3) != A_OK) {
		return 0;
	}
#else
	return 0;
#endif
	return 1;
}

A_BOOL art_sendGenericCmd
(
 A_UINT32 devNum,
 A_CHAR *stringVar,
 A_INT32 intVar1,
 A_INT32 intVar2,
 A_INT32 intVar3
)
{
	A_UINT16 stringVarLength;

	if (!configSetup.remote)
	{
		uiPrintf("Error: art_sendGenericCmd() remote flag must be set\n");  
		return 0;
	}

	// setup the command struct to send 
	GlobalCmd.cmdID = M_GENERIC_CMD_ID;
	GlobalCmd.CMD_U.GENERIC_CMD.devNum = devNum;

	stringVarLength = strlen(stringVar);
	if(stringVarLength >= MAX_GENERIC_CMD_LEN) {
		uiPrintf("Error: art_sendGenericCmd() stringVar length must be less than %d\n", MAX_GENERIC_CMD_LEN);
		return 0;
	}
	memcpy((void *)GlobalCmd.CMD_U.GENERIC_CMD.stringVar, (void *)stringVar, stringVarLength);
	GlobalCmd.CMD_U.GENERIC_CMD.stringVar[stringVarLength] = '\0';
	stringVarLength ++;