art_if.c

Atheros AP Test with Agilent N4010A source code

	A_UINT32 devNum,
	 A_UINT32 physAddr,
	 A_UINT32 length,
	 A_UCHAR  *buf
)
{
	 A_UINT32        *pAddr;
	A_UINT16 devIndex;
	devIndex = (A_UINT16)dev2drv(devNum);

	 /* check to see if the size will make us bigger than the send buffer */
	 if (length > MAX_BLOCK_BYTES) {
		 uiPrintf("Error: block size too large, can only write %x bytes\n", MAX_BLOCK_BYTES);
		 return(0);
	 }

	if (!configSetup.remote) {
#ifndef __ATH_DJGPPDOS__
		 /* write the memory */
		 if(hwMemWriteBlock(devIndex, buf, length,  &(physAddr)) == -1) {
			uiPrintf("Failed call to hwMemWriteBlock()\n");
			return(0);
		 }
#else
		 uiPrintf(" NOt Implemented in DOS Version \n");
#endif
		 pAddr = &physAddr;
	  } else {

		GlobalCmd.devNum = (A_INT8) devNum;
		/* create cmd structure and send command */
		GlobalCmd.cmdID = MEM_WRITE_BLOCK_CMD_ID;
		GlobalCmd.CMD_U.MEM_WRITE_BLOCK_CMD.physAddr = physAddr;
		GlobalCmd.CMD_U.MEM_WRITE_BLOCK_CMD.length = length;
		memcpy(GlobalCmd.CMD_U.MEM_WRITE_BLOCK_CMD.bytes, buf, length);


		if(!artSendCmd(&GlobalCmd,
						(sizeof(GlobalCmd.CMD_U.MEM_WRITE_BLOCK_CMD)+sizeof(GlobalCmd.cmdID) - MAX_BLOCK_BYTES + length),
					   (void **)&pAddr))
		{
			uiPrintf("Error: Unable to successfully send MEM_WRITE_BLOCK command\n");
			return 0;
		}
	   }
   return(*pAddr);
}


/**************************************************************************
* mem_write - Command for write a block of memory
*
* RETURNS: value write
*/
A_UINT32 art_memWrite
(
	A_UINT32 devNum,
	A_UINT32 physAddr,
	A_UCHAR  *bytesWrite,
	A_UINT32 length
)
{
	A_UINT32 ii, startAddr_ii, len_ii, arrayStart_ii;
	A_UINT32 retAddr=0;
	A_UINT32 ret;
	A_UINT16 devIndex = (A_UINT16)dev2drv(devNum);

   //uiPrintf("SNOOP::art_memWrite:devNum=%d:physAddr=%x:length=%d\n", devNum, physAddr, length);

	// Split the writes into blocks of 2048 bytes only if the memory is already allocated
	if (!physAddr) {
	   physAddr = art_memAlloc(length, 0, devNum);
	}
		ii = length;
		startAddr_ii= physAddr;
		arrayStart_ii=0;

		while( ii > 0)
		{
			  if(ii > MAX_MEM_CMD_BLOCK_SIZE) {
				  len_ii = MAX_MEM_CMD_BLOCK_SIZE;
			  } else {
				  len_ii = ii;
			  }
			  ret = mem_write_block_2048(devNum, startAddr_ii, len_ii, ((A_UCHAR *)bytesWrite+arrayStart_ii));
			  if (ret == 0) return 0;
			  if (retAddr == 0)  retAddr = ret;
			  startAddr_ii += len_ii;
			  ii -= len_ii;
			  arrayStart_ii += len_ii;
		}

	return retAddr;
}



/**************************************************************************
* reg_read - Command for reading a register
*
* RETURNS: value read
*/
A_UINT32 art_regRead
(
	A_UINT32 devNum,
	A_UINT32 regOffset
)
{
	A_UINT32	     *pRegValue, regReturn;
	A_UINT16 devIndex;
	devIndex = (A_UINT16)dev2drv(devNum);

	//sent_bytes=received_bytes=0;
	//uiPrintf("SNOOP::art_regRead:offset=%x:sent_bytes=%d:recd_bytes=%d\n", regOffset, sent_bytes, received_bytes);

	if (!configSetup.remote)
	{
		/* read the register */
	  if (thin_client) {
		#ifndef __ATH_DJGPPDOS__
					regReturn = hwMemRead32(devIndex, (globDrvInfo.pDevInfoArray[devIndex]->pdkInfo->aregPhyAddr[globDrvInfo.pDevInfoArray[devIndex]->pdkInfo->bar_select]) + regOffset);
		#endif
		//regReturn = hwMemRead32(devIndex, regOffset);
	  }
	  else {
		regReturn = REGR(devNum, regOffset);
	  }
	  pRegValue = &regReturn;
	}
	else
	{
		GlobalCmd.devNum = (A_INT8) devNum;
		/* create cmd structure and send command */
		GlobalCmd.cmdID = REG_READ_CMD_ID;
		GlobalCmd.CMD_U.REG_READ_CMD.readAddr = regOffset;
		if(!artSendCmd(&GlobalCmd,
						sizeof(GlobalCmd.CMD_U.REG_READ_CMD)+sizeof(GlobalCmd.cmdID),
						(void **)&pRegValue))
		{
			uiPrintf("Error: Unable to successfully send REG_READ command\n");
			return 0xdeadbeef;
		}
	}
//	q_uiPrintf("Register at offset %08lx: %08lx\n", regOffset, *pRegValue);
	//uiPrintf("SNOOP::AFTER art_regRead:offset=%x:sent_bytes=%d:recd_bytes=%d\n", regOffset, sent_bytes, received_bytes);

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

	return(*pRegValue);
}

A_UINT32 art_hwReset(A_UINT32 devNum, A_UINT32 rMask) {

	A_UINT32	     *pRevIdValue;
	A_UINT16 devIndex;
	devIndex = (A_UINT16)dev2drv(devNum);

	//uiPrintf("SNOOP::art_hwReset:rMask=%x\n", rMask);

		GlobalCmd.devNum = (A_INT8) devNum;
		/* create cmd structure and send command */
		GlobalCmd.cmdID = M_HW_RESET_CMD_ID;
		GlobalCmd.CMD_U.HW_RESET_CMD.resetMask = (A_UINT8) rMask;
		if(!artSendCmd(&GlobalCmd, sizeof(GlobalCmd.CMD_U.HW_RESET_CMD)+sizeof(GlobalCmd.cmdID),
						(void **)&pRevIdValue))
		{
			uiPrintf("Error: Unable to successfully send HW_RESET command\n");
			return 0xdeadbeef;
		}
	if(checkLibError(devNum, 1)) {
		return 0xdeadbeef;
	}

	return(*pRevIdValue);

}

void art_pllProgram(A_UINT32 devNum, A_UINT32 turbo, A_UINT32 mode) {

	A_UINT32	     *pRevIdValue;
	A_UINT16 devIndex;
	devIndex = (A_UINT16)dev2drv(devNum);

		GlobalCmd.devNum = (A_INT8) devNum;
		/* create cmd structure and send command */
		GlobalCmd.cmdID = M_PLL_PROGRAM_CMD_ID;
		GlobalCmd.CMD_U.PLL_PROGRAM_CMD.turbo = (A_UINT8) turbo;
		GlobalCmd.CMD_U.PLL_PROGRAM_CMD.mode = (A_UINT8) mode;
		if(!artSendCmd(&GlobalCmd,
						sizeof(GlobalCmd.CMD_U.PLL_PROGRAM_CMD)+sizeof(GlobalCmd.cmdID),
						(void **)&pRevIdValue))
		{
			uiPrintf("Error: Unable to successfully send PLL_PROGRAM command\n");
		}
}

void art_pciWrite(A_UINT32 devNum, PCI_VALUES *pPciValues, A_UINT32 length) {
	A_UINT32 dataSize;

	GlobalCmd.devNum = (A_INT8) devNum;
	GlobalCmd.cmdID = M_PCI_WRITE_CMD_ID;
	GlobalCmd.CMD_U.PCI_WRITE_CMD.length = length;
	memcpy(GlobalCmd.CMD_U.PCI_WRITE_CMD.pPciValues, pPciValues, length * sizeof(PCI_VALUES));

	dataSize = sizeof(GlobalCmd.CMD_U.PCI_WRITE_CMD) - ((MAX_PCI_ENTRIES-length) * sizeof(PCI_VALUES));

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

A_UINT32 art_calCheck (A_UINT32 devNum, A_UINT32 enableCal, A_UINT32 timeout ) {
	A_UINT32	    *pRegValue;

	GlobalCmd.devNum = (A_INT8) devNum;
	GlobalCmd.cmdID = M_CAL_CHECK_CMD_ID;
	GlobalCmd.CMD_U.CAL_CHECK_CMD.enableCal = enableCal;
	GlobalCmd.CMD_U.CAL_CHECK_CMD.timeout = timeout;

	if (!artSendCmd(&GlobalCmd, sizeof(GlobalCmd.CMD_U.CAL_CHECK_CMD)+sizeof(GlobalCmd.cmdID), (void **)&pRegValue))
	{
			uiPrintf("Error: Unable to successfully send CAL_CHECK command\n");
			return(0xdeadbeef);
	}
		return(*pRegValue);


}

/**************************************************************************
* reg_write - User interface command for writing a register
*
*
* RETURNS: 1 if OK, 0 if error
*/
A_UINT32 art_regWrite
(
	A_UINT32 devNum,
	A_UINT32 regOffset,
	A_UINT32 regValue
)
{

	A_UINT16 devIndex = (A_UINT16)dev2drv(devNum);

	//sent_bytes=received_bytes=0;
	//uiPrintf("SNOOP::art_regWrite:offset=%x\n", regOffset);
	//uiPrintf("SNOOP::art_regWrite:offset=%x:sent_bytes=%d:recd_bytes=%d\n", regOffset, sent_bytes, received_bytes);

	if (!configSetup.remote)
	{
	if (thin_client) {
#ifndef __ATH_DJGPPDOS__
	   hwMemWrite32(devIndex, (globDrvInfo.pDevInfoArray[devIndex]->pdkInfo->aregPhyAddr[globDrvInfo.pDevInfoArray[devIndex]->pdkInfo->bar_select]) + regOffset, regValue);
#endif
	 }
	 else {
	   REGW(devNum,regOffset,regValue);
	 }
	}
	else
	{
		GlobalCmd.devNum = (A_INT8) devNum;
		/* create cmd structure and send command */
		GlobalCmd.cmdID = REG_WRITE_CMD_ID;
		GlobalCmd.CMD_U.REG_WRITE_CMD.writeAddr = regOffset;
		GlobalCmd.CMD_U.REG_WRITE_CMD.regValue = regValue;

		if(!artSendCmd(&GlobalCmd,
						sizeof(GlobalCmd.CMD_U.REG_WRITE_CMD)+sizeof(GlobalCmd.cmdID),
						NULL))
		{
			uiPrintf("Error: Unable to successfully send REG_WRITE command\n");
			return 0;
		}
	}
	//uiPrintf("SNOOP::AFTER art_regWrite:offset=%x:sent_bytes=%d:recd_bytes=%d\n", regOffset, sent_bytes, received_bytes);
	return 1;
}


void art_setResetParams
(
 A_UINT32   devNum,
 A_CHAR     *pFilename,
 A_BOOL		eePromLoad,
 A_BOOL		forceCfgLoad,
 A_UCHAR	mode,
 A_UINT16     initCodeFlag
)
{
	A_UINT32 *pRegValue;

	if (!configSetup.remote || !configSetup.remote_exec)
	{
		setResetParams(devNum,pFilename,eePromLoad, forceCfgLoad, mode, initCodeFlag);
	}
	else
	{
			// create cmd to send to client
		GlobalCmd.cmdID = M_SET_RESET_PARAMS_CMD_ID;
		GlobalCmd.devNum = (A_INT8) devNum;
		GlobalCmd.CMD_U.SET_RESET_PARAMS_CMD.eePromLoad = (A_UINT32)eePromLoad;
		GlobalCmd.CMD_U.SET_RESET_PARAMS_CMD.forceCfgLoad = (A_UINT32)forceCfgLoad;
		GlobalCmd.CMD_U.SET_RESET_PARAMS_CMD.mode = (A_UINT32)mode;
		GlobalCmd.CMD_U.SET_RESET_PARAMS_CMD.use_init = (A_UINT16)initCodeFlag;
		if (pFilename) strcpy(GlobalCmd.CMD_U.SET_RESET_PARAMS_CMD.fileName, pFilename);
		else GlobalCmd.CMD_U.SET_RESET_PARAMS_CMD.fileName[0] = '\0';

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

A_UINT32 art_resetDevice
(
	A_UINT32 devNum,
	A_UCHAR *mac,
	A_UCHAR *bss,
	A_UINT32 freq,
	A_UINT32 turbo
)
{
//** 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 a quarter channel has been requested, then add the flag onto turbo
	//do it here, so can contain the changes to one place
	if(configSetup.quarterChannel) {
		freq = freq * 10 + 25;
	}

	if(!configSetup.remote || !configSetup.remote_exec)
	{
			resetDevice(devNum, mac, bss, freq, turbo);
	}
	else
	{
		// create cmd to send to client
		GlobalCmd.cmdID = M_RESET_DEVICE_CMD_ID;
		GlobalCmd.devNum = (A_INT8) devNum;
		memcpy(GlobalCmd.CMD_U.RESET_DEVICE_CMD.mac, mac, 6);
		memcpy(GlobalCmd.CMD_U.RESET_DEVICE_CMD.bss, bss, 6);
		GlobalCmd.CMD_U.RESET_DEVICE_CMD.freq = freq;
		GlobalCmd.CMD_U.RESET_DEVICE_CMD.turbo = turbo;

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

	if(checkLibError(devNum, 1)) {
		uiPrintf("Error: resetDevice command was unsuccessful, exiting!!\n");
//		exit(0);
	}
	//printf("SNOOP: writing pll\n");
	//Sleep(5);
	//art_ap_reg_write(devNum, 0x0c000014, 0x502c);
	//printf("SNOOP: pll written\n");
	//Sleep(10);
	return 1;
}

void art_getDeviceInfo
(
 A_UINT32 devNum,
 SUB_DEV_INFO *devStruct
)
{
	A_UCHAR  *pReadValues;		  /* pointer to the values that were read */

	if (!configSetup.remote || !configSetup.remote_exec)
	{
		getDeviceInfo(devNum, devStruct);
	}
	else {
				// create cmd to send to client
		GlobalCmd.cmdID = M_GET_DEVICE_INFO_CMD_ID;
		GlobalCmd.devNum = (A_INT8) devNum;

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

A_UINT32 art_eepromRead
(
	A_UINT32  devNum,
	A_UINT32 eepromOffset
)
{
	A_UINT32 	*pRegValue;
	A_UINT32	eepromValue;

	if (!configSetup.remote)
	{
		eepromValue = eepromRead(devNum, eepromOffset);
	}
	else
	{
		// create cmd to send to client
		GlobalCmd.cmdID = M_EEPROM_READ_CMD_ID;
		GlobalCmd.devNum = (A_INT8) devNum;
		GlobalCmd.CMD_U.EEPROM_READ_CMD.offset	= eepromOffset;

		if ( !artSendCmd(&GlobalCmd,
						sizeof(GlobalCmd.CMD_U.EEPROM_READ_CMD)+sizeof(GlobalCmd.cmdID),
						(void **)&pRegValue))
		{
				uiPrintf("Error: Unable to successfully send EEPROM_READ_CMD command to client!\n");
				//printf("IF EEPRO< DEAD \n" );
				return 0xdeadbeef;
		}
		eepromValue = *pRegValue;
		//printf("SNOOP::art_eepromRead::eepromValue=%x:*pRegValue=%x\n", eepromValue, *pRegValue);
	}
	//printf("SNOOP::art_eepromRead::eepromValue=%x:*pRegValue=%x\n", eepromValue, *pRegValue);
	if(checkLibError(devNum, 1)) {
		return 0xdeadbeef;
	}
	return eepromValue;
}

void art_eepromWrite
(
	A_UINT32 devNum,
	A_UINT32 eepromOffset,
	A_UINT32 eepromValue
)
{
	if (!configSetup.remote)
	{
			eepromWrite(devNum, eepromOffset, eepromValue);
	}
	else
	{
		// create cmd to send to client
		GlobalCmd.cmdID = M_EEPROM_WRITE_CMD_ID;
		GlobalCmd.devNum = (A_INT8) devNum;
		GlobalCmd.CMD_U.EEPROM_WRITE_CMD.offset = eepromOffset;
		GlobalCmd.CMD_U.EEPROM_WRITE_CMD.value = eepromValue;

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

static A_INT32 art_eepromWriteBlock_256
(
	A_UINT32 devNum,
	A_UINT32 startOffset,
	A_UINT32 length,
	A_UINT32 *buf
)
{
	int ii;
	if (!configSetup.remote) {
		eepromWriteBlock(devNum,startOffset,length,buf);
	} else {
		/* setup the command struct to send */
		GlobalCmd.cmdID = M_EEPROM_WRITE_BLOCK_CMD_ID;