art_if.c

atheros ar5001 5002 driver

/* art_if.c -  contains the ART wrapper functions */

/* Copyright (c) 2000 Atheros Communications, Inc., All Rights Reserved */

#ifdef __ATH_DJGPPDOS__
#include <unistd.h>
#ifndef EILSEQ  
    #define EILSEQ EIO
#endif	// EILSEQ

 #define __int64	long long
 #define HANDLE long
 typedef unsigned long DWORD;
 #define Sleep	delay
 #include <bios.h>
#endif	// #ifdef __ATH_DJGPPDOS__

#include <string.h>
#include <stdio.h>
#include <malloc.h>
#include "wlantype.h"
#include "wlanproto.h"
#include "athreg.h"
#include "manlib.h"
#include "test.h"
#include "dk_cmds.h"
#include "art_if.h"
#ifndef __ATH_DJGPPDOS__
#include "MLIBif.h"    
#ifdef LINUX
#include "sock_linux.h"
#else
#include "sock_win.h"
#endif
#else
#include "mlibif_dos.h"
#endif

extern MLD_CONFIG configSetup;
extern A_BOOL printLocalInfo;
	   
// extern declarations for dut-golden sync
extern ART_SOCK_INFO *artSockInfo;
extern ART_SOCK_INFO *pArtPrimarySock;
extern ART_SOCK_INFO *pArtSecondarySock;

static A_UINT32 globalNumInstances = 0;

extern void *artConnect(void);
extern A_BOOL prepare2WayComms
(
 void
);

extern void cleanupSockMem
(
	void*			pOSSock,
	A_BOOL			closeSocket
);

static void selectDevNum (A_UINT32 devNum);

// Error number and error string 
A_INT32 art_mdkErrNo = 0;
A_CHAR art_mdkErrStr[SIZE_ERROR_BUFFER];
//  Remote error number and error string
A_INT32 remoteMdkErrNo = 0;
A_CHAR remoteMdkErrStr[SIZE_ERROR_BUFFER];
//static A_BOOL  ownSocketClose = 0;

// holds the cmd replies sent over channel 
PIPE_CMD GlobalCmd;
CMD_REPLY cmdReply;

// forward function declaration
ART_SOCK_INFO *openCommsChannel(A_CHAR *machineName);

A_BOOL artSendCmd(PIPE_CMD *pCmdStruct,A_UINT32 cmdSize,void **returnCmdStruct);
A_BOOL receiveCmdReturn(A_UINT32 *pReturnLength);
A_UINT32 art_createEvent(A_UINT32 devNum,A_UINT32 type, A_UINT32 persistent,
						 A_UINT32 param1,A_UINT32 param2,A_UINT32 param3);


A_INT32  art_setupDevice(A_UINT32 whichDevice)
{
	A_UINT32 devNum;
	A_UINT32 *pRegValue;

	//at setup time, remote flag being set, applies to primary ART session being AP
	if (configSetup.remote)
	{
		if(pArtPrimarySock == NULL) {
			artSockInfo = openCommsChannel(configSetup.machName);
			pArtPrimarySock = artSockInfo;
			if (artSockInfo == NULL) {
				uiPrintf("Error: Unable to open communications channel to AP!\n");
				return -1;
			}
		} 
		
		globalNumInstances++;	
	}
	if (!configSetup.remote)
	{
		devNum= setupDevice(whichDevice);
		if (devNum == -1) {
			return -1;
		}
	}
	else
    {
		GlobalCmd.cmdID = INIT_F2_CMD_ID;
		GlobalCmd.CMD_U.INIT_F2_CMD.whichF2 = whichDevice;
		if (!artSendCmd(&GlobalCmd,
			 sizeof(GlobalCmd.CMD_U.INIT_F2_CMD) + sizeof(GlobalCmd.cmdID), 
			(void **)&pRegValue) ) 
		{
			uiPrintf("Error: Unable to send command to client! Handle not created.\n");
			return -1;
		}
		devNum = *pRegValue;
	}

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



#ifndef __ATH_DJGPPDOS__
/**************************************************************************
* create_event - Create an event
*
* RETURNS: The event handle for the event.
*/
A_UINT32 art_createEvent
(
	A_UINT32 devNum,
    A_UINT32 type,
    A_UINT32 persistent,
    A_UINT32 param1,
    A_UINT32 param2,
    A_UINT32 param3
)
{
    EVT_HANDLE		eventHdl;
	A_UINT16 devIndex;

        // check to see if we have a valid type
    if (ISR_INTERRUPT != type) 
	{
		uiPrintf("Error: Illegal event type\n");
		return 0xffffffff;
    }

	eventHdl.eventID = 0;
	eventHdl.f2Handle = (A_UINT16)devNum;

	if (!configSetup.remote)
	{
			devIndex = (A_UINT16)dev2drv(devNum);
			if (!hwCreateEvent(devIndex, ISR_INTERRUPT, 1, 0, 0, 0, eventHdl)) return 0xffffffff;
	}
    else
	{
	    //this command does not send devNum to client, so make sure it is selected
		selectDevNum(devNum);

 		// create cmd to send 
		GlobalCmd.cmdID		= CREATE_EVENT_CMD_ID;
		GlobalCmd.CMD_U.CREATE_EVENT_CMD.type	       = type;
		GlobalCmd.CMD_U.CREATE_EVENT_CMD.persistent    = persistent;
		GlobalCmd.CMD_U.CREATE_EVENT_CMD.param1	       = param1;
		GlobalCmd.CMD_U.CREATE_EVENT_CMD.param2	       = param2;
		GlobalCmd.CMD_U.CREATE_EVENT_CMD.param3	       = param3;
		GlobalCmd.CMD_U.CREATE_EVENT_CMD.eventHandle   = eventHdl;
			
		if (!artSendCmd(&GlobalCmd,
						sizeof(GlobalCmd.CMD_U.CREATE_EVENT_CMD)+sizeof(GlobalCmd.cmdID),
						NULL)) 
		{
				uiPrintf("Error: Unable to successfully send CREATE_EVENT command to client!\n");
				return 0xffffffff;
		}
	}

	return 0;
}
#endif

/**************************************************************************
* cfg_read - User interface command for reading a pci configuration register
*
*
* RETURNS: value read
*/
A_UINT32 art_cfgRead
(
	A_UINT32 devNum,
    A_UINT32 regOffset
)
{
     A_UINT32	     *pRegValue, regReturn;

	
	if(!configSetup.remote) 
	{
			regReturn = OScfgRead(devNum, regOffset);
			pRegValue = &regReturn;
	} 
	else 
	{
	    //this command does not send devNum to client, so make sure it is selected
		selectDevNum(devNum);

	    /* create cmd structure and send command */
		GlobalCmd.cmdID = CFG_READ_CMD_ID;
		GlobalCmd.CMD_U.CFG_READ_CMD.cfgReadAddr = regOffset;
		GlobalCmd.CMD_U.CFG_READ_CMD.readSize = 32;

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

    /* display the value */
    q_uiPrintf("%08lx: ", regOffset);
    q_uiPrintf("%08x\n", *pRegValue);

    return(*pRegValue);
}

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

	if (!configSetup.remote)
	{
		/* read the register */
		regReturn = REGR(devNum, regOffset);
		pRegValue = &regReturn;
	} 
	else 
	{
	    //this command does not send devNum to client, so make sure it is selected
		selectDevNum(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);

	if(checkLibError(devNum, 1)) {
		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
)
{
    
	if (!configSetup.remote)
	{
			REGW(devNum,regOffset,regValue);
	} 
	else 
	{
	    //this command does not send devNum to client, so make sure it is selected
		selectDevNum(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;
		}
	}
    return 1;
}


void selectDevNum 
(
 A_UINT32 devNum
)
{
	// create cmd to send to client
	GlobalCmd.cmdID = M_SELECT_DEV_NUM_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 SELECT_DEV_NUM_CMD command to client!\n");
	}
	checkLibError(devNum, 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)
	{
		setResetParams(devNum,pFilename,eePromLoad, forceCfgLoad, mode, initCodeFlag);
	}
	else
	{
			// create cmd to send to client
		GlobalCmd.cmdID = M_SET_RESET_PARAMS_CMD_ID;
		GlobalCmd.CMD_U.SET_RESET_PARAMS_CMD.devNum = 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
)
{
    
	if(!configSetup.remote)
	{
			resetDevice(devNum, mac, bss, freq, turbo);
	} 
	else 
	{
		// create cmd to send to client
		GlobalCmd.cmdID = M_RESET_DEVICE_CMD_ID;
		GlobalCmd.CMD_U.RESET_DEVICE_CMD.devNum = 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!\n");
			return 0;
		}
	}

	if(checkLibError(devNum, 1)) {
		return 0;
	}
	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)
	{
		getDeviceInfo(devNum, devStruct);
	}
	else {
				// create cmd to send to client
		GlobalCmd.cmdID = M_GET_DEVICE_INFO_CMD_ID;
		GlobalCmd.CMD_U.DEV_NUM_CMD.devNum = devNum;
		
		if ( !artSendCmd(&GlobalCmd,
						sizeof(GlobalCmd.CMD_U.DEV_NUM_CMD)+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.CMD_U.EEPROM_READ_CMD.devNum = 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");
				return 0xdeadbeef;
		}
		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.CMD_U.EEPROM_WRITE_CMD.devNum = 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
)
{
	if (!configSetup.remote) {
		eepromWriteBlock(devNum,startOffset,length,buf);
	} else {
		/* setup the command struct to send */
		GlobalCmd.cmdID = M_EEPROM_WRITE_BLOCK_CMD_ID;
		GlobalCmd.CMD_U.EEPROM_WRITE_BLOCK_CMD.devNum = devNum;