art_if.c

atheros ar5001 5002 driver

	{
		cleanupTxRxMemory(devNum, flags);
	} 
	else 
	{
		// create cmd to send to client
		GlobalCmd.cmdID = M_CLEANUP_TXRX_MEMORY_CMD_ID;
		GlobalCmd.CMD_U.SET_ONE_CMD.devNum = devNum;
		GlobalCmd.CMD_U.SET_ONE_CMD.param = flags;

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

void art_txrxDataBegin
(
	A_UINT32 devNum,
	A_UINT32 waitTime,
	A_UINT32 timeout,
	A_UINT32 remoteStats,
	A_UINT32 enableCompare,
	A_UCHAR *dataPattern, 
	A_UINT32 dataPatternLength
)
{
	if (!configSetup.remote)
	{
		txrxDataBegin(devNum, waitTime, timeout, remoteStats, enableCompare, dataPattern, dataPatternLength);
	} 
	else 
	{
		// create cmd to send to client
		GlobalCmd.cmdID = M_TXRX_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),
						NULL)) 
		{
			uiPrintf("Error: Unable to successfully send TXRX_DATA_BEGIN_CMD command to client!\n");
		}
	}
	checkLibError(devNum, 1);
}

void art_setAntenna
(
	A_UINT32 devNum,
	A_UINT32 antenna
)
{
	if(!configSetup.remote)
	{
	    setAntenna(devNum, antenna);
	} 
	else 
	{
		// create cmd to send to client
		GlobalCmd.cmdID = M_SET_ANTENNA_CMD_ID;
		GlobalCmd.CMD_U.SET_ONE_CMD.devNum = devNum;
		GlobalCmd.CMD_U.SET_ONE_CMD.param = antenna;

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


// Continuous Transmit Functions
void art_txContBegin
(
	A_UINT32 devNum,
	A_UINT32 type,
	A_UINT32 typeOption1,
	A_UINT32 typeOption2,
	A_UINT32 antenna
)
{
	if (!configSetup.remote)
	{
			txContBegin(devNum, type, typeOption1, typeOption2, antenna);
	} 
	else 
	{
		// create cmd to send to client
		GlobalCmd.cmdID = M_TX_CONT_BEGIN_CMD_ID;
		GlobalCmd.CMD_U.TX_CONT_BEGIN_CMD.devNum = devNum;
		GlobalCmd.CMD_U.TX_CONT_BEGIN_CMD.type = type;
		GlobalCmd.CMD_U.TX_CONT_BEGIN_CMD.typeOption1 = typeOption1;
		GlobalCmd.CMD_U.TX_CONT_BEGIN_CMD.typeOption2 = typeOption2;
		GlobalCmd.CMD_U.TX_CONT_BEGIN_CMD.antenna = antenna;

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

// agehari
void art_txContFrameBegin
(
	A_UINT32 devNum,
	A_UINT32 length,
	A_UINT32 ifswait,
	A_UINT32 typeOption1,
	A_UINT32 typeOption2,
	A_UINT32 antenna,
	A_BOOL   performStabilizePower,
	A_UINT32 numDescriptors,
	A_UCHAR *dest
)
{
	if (!configSetup.remote)
	{
		txContFrameBegin(devNum, length, ifswait, typeOption1, typeOption2, antenna, performStabilizePower, numDescriptors, dest);
	} 
	else 
	{
		// create cmd to send to client
		GlobalCmd.cmdID = M_TX_CONT_FRAME_BEGIN_CMD_ID;
		GlobalCmd.CMD_U.TX_CONT_FRAME_BEGIN_CMD.devNum = devNum;
		GlobalCmd.CMD_U.TX_CONT_FRAME_BEGIN_CMD.length = length;
		GlobalCmd.CMD_U.TX_CONT_FRAME_BEGIN_CMD.ifswait = ifswait;
		GlobalCmd.CMD_U.TX_CONT_FRAME_BEGIN_CMD.typeOption1 = typeOption1;
		GlobalCmd.CMD_U.TX_CONT_FRAME_BEGIN_CMD.typeOption2 = typeOption2;
		GlobalCmd.CMD_U.TX_CONT_FRAME_BEGIN_CMD.antenna = antenna;
		GlobalCmd.CMD_U.TX_CONT_FRAME_BEGIN_CMD.performStabilizePower = performStabilizePower;
		GlobalCmd.CMD_U.TX_CONT_FRAME_BEGIN_CMD.numDescriptors = numDescriptors;
		if(dest) {
			memcpy(GlobalCmd.CMD_U.TX_CONT_FRAME_BEGIN_CMD.dest, dest, 6);
		}
		else {
			memset(GlobalCmd.CMD_U.TX_CONT_FRAME_BEGIN_CMD.dest, 0, 6);
		}

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

void art_txContEnd
(
	A_UINT32 devNum
)
{
	
	if (!configSetup.remote)
	{
			txContEnd(devNum);
	} 
	else 
	{
		// create cmd to send to client
		GlobalCmd.cmdID = M_TX_CONT_END_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 TX_CONT_END_CMD command to client!\n");
		}
	}
	checkLibError(devNum, 1);
}

void art_txGetStats
(
 A_UINT32 devNum, 
 A_UINT32 rateInMb,
 A_UINT32 remote,
 TX_STATS_STRUCT *pReturnStats 
)
{
    A_UCHAR  *pReadValues;		  /* pointer to the values that were read */
	if (!configSetup.remote)
	{
		txGetStats(devNum, rateInMb, remote, pReturnStats);
	}
	else 
	{
		// create cmd to send to client
		GlobalCmd.cmdID = M_TX_GET_STATS_CMD_ID;
		GlobalCmd.CMD_U.GET_STATS_CMD.devNum = devNum;
		GlobalCmd.CMD_U.GET_STATS_CMD.rateInMb = rateInMb;
		GlobalCmd.CMD_U.GET_STATS_CMD.remote = remote;

		if (!artSendCmd(&GlobalCmd,
						sizeof(GlobalCmd.CMD_U.GET_STATS_CMD)+sizeof(GlobalCmd.cmdID),
						(void **)&pReadValues)) 
		{
			uiPrintf("Error: Unable to successfully send TX_GET_STATS_CMD command to client!\n");
			
		}
		if(checkLibError(devNum, 1)) return;
		/* copy the data from command receive buffer into buffer for perl */
		memcpy(pReturnStats, pReadValues, sizeof(TX_STATS_STRUCT));
	}
	checkLibError(devNum, 1);
	return;
}

void art_rxGetStats
(
	A_UINT32 devNum,
	A_UINT32 rateInMb,
	A_UINT32 remote,
	RX_STATS_STRUCT *pReturnStats 
)
{
	    A_UCHAR  *pReadValues;		  /* pointer to the values that were read */

		if (!configSetup.remote)
		{
				rxGetStats(devNum, rateInMb, remote, pReturnStats);
		}
		else 
		{
			// create cmd to send to client
			GlobalCmd.cmdID = M_RX_GET_STATS_CMD_ID;
			GlobalCmd.CMD_U.GET_STATS_CMD.devNum = devNum;
			GlobalCmd.CMD_U.GET_STATS_CMD.rateInMb = rateInMb;
			GlobalCmd.CMD_U.GET_STATS_CMD.remote = remote;

			if (!artSendCmd(&GlobalCmd,
							sizeof(GlobalCmd.CMD_U.GET_STATS_CMD)+sizeof(GlobalCmd.cmdID),
							(void **)&pReadValues)) 
			{
				uiPrintf("Error: Unable to successfully send RX_GET_STATS_CMD command to client!\n");
				
			}
		if(checkLibError(devNum, 1)) return;
			/* copy the data from command receive buffer into buffer for perl */
			memcpy(pReturnStats, pReadValues, sizeof(RX_STATS_STRUCT));
		}
	checkLibError(devNum, 1);
}

void art_rxDataStart
(
 A_UINT32 devNum
)
{
	if (!configSetup.remote)
	{
		rxDataStart(devNum);
	}
	else 
	{
		// create cmd to send to client
		GlobalCmd.cmdID = M_RX_DATA_START_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 RX_DATA_START command to client!\n");
		}
	}
	checkLibError(devNum, 1);

	return;
}

void art_setSingleTransmitPower
(
 A_UINT32 devNum,
 A_UCHAR pcdac
)
{
	if	(!configSetup.remote)
	{
			setSingleTransmitPower(devNum, pcdac);
	} 
	else 
	{
		// create cmd to send to client
		GlobalCmd.cmdID = M_SET_SINGLE_TRANSMIT_POWER_CMD_ID;
		GlobalCmd.CMD_U.SET_ONE_CMD.devNum = devNum;
		GlobalCmd.CMD_U.SET_ONE_CMD.param = pcdac;

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

void art_specifySubSystemID
(
 A_UINT32 devNum,
 A_INT16  subsystemID
)
{
	if	(!configSetup.remote)
	{
		specifySubSystemID(devNum, subsystemID);
	} 
	else 
	{
		// create cmd to send to client
		GlobalCmd.cmdID = M_SPECIFY_SUBSYSTEM_CMD_ID;
		GlobalCmd.CMD_U.SET_ONE_CMD.devNum = 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	(!configSetup.remote) 
	{
		returnValue = getMaxPowerForRate(devNum, (A_UINT32)freq, (A_UINT32)rate);
	} 
	else {
		GlobalCmd.cmdID = M_GET_MAX_POWER_CMD_ID;
		GlobalCmd.CMD_U.GET_MAX_POWER_CMD.devNum = 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) 
	{
		returnValue = getPcdacForPower(devNum, (A_UINT32)freq, power);
	} 
	else {
		GlobalCmd.cmdID = M_GET_MAX_POWER_CMD_ID;
		GlobalCmd.CMD_U.GET_PCDAC_FOR_POWER_CMD.devNum = 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) 
	{
		returnValue = getFieldForMode(devNum, fieldName, mode, turbo);
	} 
	else 
	{
	    /* create cmd structure and send command */
		GlobalCmd.cmdID = M_GET_FIELD_FOR_MODE_CMD_ID;
		GlobalCmd.CMD_U.GET_FIELD_FOR_MODE_CMD.devNum = 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);
}

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

	if	(!configSetup.remote) 
	{
		getField(devNum, fieldName, baseValue, turboValue);
	} 
	else 
	{
		// create cmd to send to client
		GlobalCmd.cmdID = M_GET_FIELD_VALUE_CMD_ID;
		GlobalCmd.CMD_U.GET_FIELD_VALUE_CMD.devNum = 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) 
	{
			changeField(devNum, fieldName, newValue);
	} 
	else 
	{
		// create cmd to send to client
		GlobalCmd.cmdID = M_CHANGE_FIELD_CMD_ID;
		GlobalCmd.CMD_U.CHANGE_FIELD_CMD.devNum = 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,