dk_client.c

Atheros AP Test with Agilent N4010A source code

        length=(A_UINT16)pCmd->CMD_U.EEPROM_WRITE_BLOCK_CMD.length;

	    //copy the data into 16bit data buffer
	    pTempPtr = pTempBuffer;
	    for(i = 0; i < length; i++) {
		    *pTempPtr = pDwordBuffer->pDword[i] & 0xffff; 
		    pTempPtr++;
	    }

	    pVal = (A_UINT8 *)pTempBuffer;
    // 16 bit addressing
        startOffset = pCmd->CMD_U.EEPROM_WRITE_BLOCK_CMD.startOffset;
         offset = pCmd->CMD_U.EEPROM_WRITE_BLOCK_CMD.startOffset << 1;
         status=sysFlashConfigWrite(offset, pVal, (length * sizeof(A_UINT16)));
  }

   return 0;

}

#else
/***************************************************************************/

A_UINT32 processEepromWriteBlockCmd
(
	struct dkThreadInfo *dkThread
)
{
	PIPE_CMD      *pCmd;
	CMD_REPLY     *ReplyCmd_p;
	A_UCHAR     *replyBuf;
	PDWORDBUFFER pDwordBuffer;
	A_UINT32 i;
    A_INT32	 status=0;

	pCmd = dkThread->PipeBuffer_p;
	ReplyCmd_p = dkThread->ReplyCmd_p;
	replyBuf = (A_UCHAR *)(ReplyCmd_p->cmdBytes);

	#ifdef ENDIAN_SWAP
     		pCmd->CMD_U.EEPROM_WRITE_BLOCK_CMD.length = ltob_l(pCmd->CMD_U.EEPROM_WRITE_BLOCK_CMD.length); 
	#endif


    	if( pCmd->cmdLen != (sizeof(pCmd->cmdID) + 
		       sizeof(pCmd->CMD_U.EEPROM_WRITE_BLOCK_CMD)-
		       ((MAX_BLOCK_DWORDS - pCmd->CMD_U.EEPROM_WRITE_BLOCK_CMD.length) * 4)) + sizeof(pCmd->devNum))
        {
        	uiPrintf("Error: command Len is not equal to size of expected bytes for EEPROM_WRITE_BLOCK_CMD\n");
			uiPrintf(": got %d, expected %d\n", pCmd->cmdLen, (sizeof(pCmd->cmdID) + sizeof(pCmd->CMD_U.EEPROM_WRITE_BLOCK_CMD)
				- ((MAX_BLOCK_DWORDS - pCmd->CMD_U.EEPROM_WRITE_BLOCK_CMD.length) * 4)));
        	return(COMMS_ERR_BAD_LENGTH);
        }


	#ifdef ENDIAN_SWAP
     		pCmd->CMD_U.EEPROM_WRITE_BLOCK_CMD.startOffset = ltob_l(pCmd->CMD_U.EEPROM_WRITE_BLOCK_CMD.startOffset);
	

	#endif

	pDwordBuffer = (PDWORDBUFFER)A_MALLOC(sizeof(DWORDBUFFER));
	if (pDwordBuffer == NULL)
	{
		uiPrintf("Error, unable to allocate memory for mac PDWORDBUFFER struct \n");
		return (COMMS_ERR_ALLOC_FAIL);	
	}
	pDwordBuffer->Length = (A_UINT16)pCmd->CMD_U.EEPROM_WRITE_BLOCK_CMD.length * 4;

	pDwordBuffer->pDword = (A_UINT32 *)A_MALLOC(pDwordBuffer->Length);
	if (pDwordBuffer->pDword == NULL)
	{
		A_FREE(pDwordBuffer);
		uiPrintf("Error, unable to allocate memory for mac array \n");
		return (COMMS_ERR_ALLOC_FAIL);	
	}
	

	for (i=0;i<pCmd->CMD_U.EEPROM_WRITE_BLOCK_CMD.length;i++)
	{
		#ifdef ENDIAN_SWAP
			pDwordBuffer->pDword[i] = ltob_l(pCmd->CMD_U.EEPROM_WRITE_BLOCK_CMD.eepromValue[i]); 
		#else
			pDwordBuffer->pDword[i] = pCmd->CMD_U.EEPROM_WRITE_BLOCK_CMD.eepromValue[i];
		#endif
	}

#if defined(THIN_CLIENT_BUILD)
    {
	    A_UINT8 *pVal;
	    A_UINT16 *pTempBuffer = NULL;
	    A_UINT16 *pTempPtr;
        A_UINT32 length;
        A_UINT32 startOffset, offset;
        length=(A_UINT16)pCmd->CMD_U.EEPROM_WRITE_BLOCK_CMD.length;

	    //copy the data into 16bit data buffer
	    pTempBuffer = (A_UINT16 *)malloc(length * sizeof(A_UINT16));
	    pTempPtr = pTempBuffer;
	    for(i = 0; i < length; i++) {
		    *pTempPtr = pDwordBuffer->pDword[i] & 0xffff; 
		    pTempPtr++;
	    }

	    pVal = (A_UINT8 *)pTempBuffer;
    // 16 bit addressing
        startOffset = pCmd->CMD_U.EEPROM_WRITE_BLOCK_CMD.startOffset;
#if defined(SPIRIT_AP) || defined(FREEDOM_AP) // || defined(PREDATOR)
	    startOffset = startOffset << 1;	
            q_uiPrintf("Write to eeprom @ %x : %x \n",startOffset, *pVal); 
        // write only the lower 2 bytes
        sysFlashConfigWrite(FLC_RADIOCFG, startOffset, pVal , length*sizeof(A_UINT16));
#else // SPIRIT_AP || FREEDOM_AP

#if defined(PHOENIX)
	  if (startOffset & 0x10000000) {
		 pVal = &(pDwordBuffer->pDword[0]);
         status=sysFlashConfigWrite(FLC_BOOTLINE, offset, pVal, length*2);
	  }
	  else {
         offset = pCmd->CMD_U.EEPROM_WRITE_BLOCK_CMD.startOffset << 1;
         status=sysFlashConfigWrite(FLC_RADIOCFG, offset, pVal, (length * sizeof(A_UINT16)));
	  }
#endif
#if defined(PREDATOR)
	  if (startOffset & 0x10000000) {
         offset = pCmd->CMD_U.EEPROM_WRITE_BLOCK_CMD.startOffset << 1 | 0x10000000;
	  }
	  else {
         offset = pCmd->CMD_U.EEPROM_WRITE_BLOCK_CMD.startOffset << 1;
	  }
         status=sysFlashConfigWrite(offset, pVal, (length * sizeof(A_UINT16)));
#endif

#endif // !SPIRIT_AP || !FREEDOM_AP
        	free(pTempBuffer);
  }
#else // THIN_CLIENT_BUILD
    	/* write the eeprom */
    	m_eepromWriteBlock(pCmd->devNum,
			   pCmd->CMD_U.EEPROM_WRITE_BLOCK_CMD.startOffset,
			   pDwordBuffer); 
#endif

	A_FREE(pDwordBuffer->pDword);
	A_FREE(pDwordBuffer);

    	return 0;

}
#endif

/**************************************************************************
* processApRegReadCmd - Process AP_REG_READ_CMD command
*
* RETURNS: 0 processed OK, an Error code if it is not
*/
A_UINT32 processApRegReadCmd
(
	struct dkThreadInfo *dkThread
)
{
	PIPE_CMD      *pCmd;
	CMD_REPLY     *ReplyCmd_p;
	A_UCHAR     *replyBuf;

	pCmd = dkThread->PipeBuffer_p;
	ReplyCmd_p = dkThread->ReplyCmd_p;
	replyBuf = (A_UCHAR *)(ReplyCmd_p->cmdBytes);
    
	/* check that the size is appropriate before we access */
	if( pCmd->cmdLen != sizeof(pCmd->CMD_U.AP_REG_READ_CMD)+sizeof(pCmd->cmdID)+sizeof(pCmd->devNum) ) {
        	uiPrintf("Error, command Len is not equal to size of AP_REG_READ_CMD\n");
        	return(COMMS_ERR_BAD_LENGTH);
        }

#ifdef ENDIAN_SWAP
	pCmd->CMD_U.REG_READ_CMD.readAddr = ltob_l(pCmd->CMD_U.AP_REG_READ_CMD.readAddr);
#endif
    
	// read the register 
#if  defined(MDK_AP) || defined(THIN_CLIENT_BUILD)
#ifdef SOC_LINUX
	*((A_UINT32 *)replyBuf) = apRegRead32(dkThread->currentDevIndex, pCmd->CMD_U.AP_REG_READ_CMD.readAddr);
#else
	*((A_UINT32 *)replyBuf) = apRegRead32(pCmd->CMD_U.AP_REG_READ_CMD.readAddr);
#endif
#else
	*((A_UINT32 *)replyBuf) = 0;
#endif
   

#ifdef ENDIAN_SWAP
	*((A_UINT32 *)replyBuf) = btol_l(*((A_UINT32 *)replyBuf));
#endif
    
	return(0);
}

/**************************************************************************
* processApRegWriteCmd - Process AP_REG_WRITE_CMD command
*
* RETURNS: 0 processed OK, an Error code if it is not
*/
A_UINT32 processApRegWriteCmd
(
	struct dkThreadInfo *dkThread
)
{
	PIPE_CMD      *pCmd;
	CMD_REPLY     *ReplyCmd_p;
	A_UCHAR     *replyBuf;

	pCmd = dkThread->PipeBuffer_p;
	ReplyCmd_p = dkThread->ReplyCmd_p;
	replyBuf = (A_UCHAR *)(ReplyCmd_p->cmdBytes);
    
	/* check that the size is appropriate before we access */
	if( pCmd->cmdLen != sizeof(pCmd->CMD_U.AP_REG_WRITE_CMD)+sizeof(pCmd->cmdID) +sizeof(pCmd->devNum)) {
		uiPrintf("Error, command Len is not equal to size of AP_REG_WRITE_CMD\n");
		return(COMMS_ERR_BAD_LENGTH);
	}

#ifdef ENDIAN_SWAP
	pCmd->CMD_U.AP_REG_WRITE_CMD.writeAddr = ltob_l(pCmd->CMD_U.AP_REG_WRITE_CMD.writeAddr);
	pCmd->CMD_U.AP_REG_WRITE_CMD.regValue  = ltob_l(pCmd->CMD_U.AP_REG_WRITE_CMD.regValue);
#endif

	// write the register
#if  defined(MDK_AP) || defined(THIN_CLIENT_BUILD)
#ifdef SOC_LINUX
	apRegWrite32(dkThread->currentDevIndex, pCmd->CMD_U.AP_REG_WRITE_CMD.writeAddr, pCmd->CMD_U.AP_REG_WRITE_CMD.regValue);
#else
	apRegWrite32(pCmd->CMD_U.AP_REG_WRITE_CMD.writeAddr, pCmd->CMD_U.AP_REG_WRITE_CMD.regValue);
#endif
#endif
  
	return(0);
}

A_UINT32 processWriteProdDataCmd
(
	struct dkThreadInfo *dkThread
)
{
	PIPE_CMD      *pCmd;
	CMD_REPLY     *ReplyCmd_p;
	A_UCHAR     *replyBuf;
	A_UCHAR *wlan0Mac;
    A_UINT16 val;

	pCmd = dkThread->PipeBuffer_p;
	ReplyCmd_p = dkThread->ReplyCmd_p;
	replyBuf = (A_UCHAR *)(ReplyCmd_p->cmdBytes);

	/* check that the size is appropriate before we access */
     	if( pCmd->cmdLen != sizeof(pCmd->CMD_U.WRITE_PROD_DATA_CMD)+sizeof(pCmd->cmdID) +sizeof(pCmd->devNum)) 
        {
        	uiPrintf("Error, command Len is not equal to size of WRITE_PROD_DATA_CMD\n");
        	return(COMMS_ERR_BAD_LENGTH);
        }

#if defined(SPIRIT_AP) || defined(FREEDOM_AP) // || defined(PREDATOR)
	 m_writeProdData
	(
		pCmd->devNum,
		pCmd->CMD_U.WRITE_PROD_DATA_CMD.wlan0Mac,
		pCmd->CMD_U.WRITE_PROD_DATA_CMD.wlan1Mac,
		pCmd->CMD_U.WRITE_PROD_DATA_CMD.enet0Mac, 
		pCmd->CMD_U.WRITE_PROD_DATA_CMD.enet1Mac
	);
#endif

#if defined(PREDATOR) 
	wlan0Mac = pCmd->CMD_U.WRITE_PROD_DATA_CMD.wlan0Mac;
	val = (wlan0Mac[4] << 8) |wlan0Mac[5];
    sysFlashConfigWrite(0x1d<<1, (A_UINT8 *)&val, 2);
	val = (wlan0Mac[2] << 8) |wlan0Mac[3];
    sysFlashConfigWrite(0x1e<<1, (A_UINT8 *)&val, 2);
	val = (wlan0Mac[0] << 8) |wlan0Mac[1];
    sysFlashConfigWrite(0x1f<<1, (A_UINT8 *)&val, 2);
#endif

	return 0;
}

A_UINT32 processFillTxStatsCmd
(
	struct dkThreadInfo *dkThread
)
{

	PIPE_CMD      *pCmd;
	CMD_REPLY     *ReplyCmd_p;
	A_UCHAR     *replyBuf;
    TX_STATS_STRUCT txStats[STATS_BINS];

#ifndef __ATH_DJGPPDOS__
	pCmd = dkThread->PipeBuffer_p;
	ReplyCmd_p = dkThread->ReplyCmd_p;
	replyBuf = (A_UCHAR *)(ReplyCmd_p->cmdBytes);

	#ifdef ENDIAN_SWAP
     		pCmd->CMD_U.FILL_TX_STATS_CMD.descAddress = ltob_l(pCmd->CMD_U.FILL_TX_STATS_CMD.descAddress);
     		pCmd->CMD_U.FILL_TX_STATS_CMD.numDesc = ltob_l(pCmd->CMD_U.FILL_TX_STATS_CMD.numDesc);
     		pCmd->CMD_U.FILL_TX_STATS_CMD.dataBodyLen = ltob_l(pCmd->CMD_U.FILL_TX_STATS_CMD.dataBodyLen);
     		pCmd->CMD_U.FILL_TX_STATS_CMD.txTime = ltob_l(pCmd->CMD_U.FILL_TX_STATS_CMD.txTime);
 	#endif

#ifndef PHOENIX
    fillTxStats (dkThread->currentDevIndex, pCmd->CMD_U.FILL_TX_STATS_CMD.descAddress, \
			pCmd->CMD_U.FILL_TX_STATS_CMD.numDesc, pCmd->CMD_U.FILL_TX_STATS_CMD.dataBodyLen, \
			pCmd->CMD_U.FILL_TX_STATS_CMD.txTime, txStats);

#ifndef MALLOC_ABSENT
    memcpy(replyBuf, txStats, sizeof(TX_STATS_STRUCT)*STATS_BINS);
#else
    A_MEM_CPY(replyBuf, txStats, sizeof(TX_STATS_STRUCT)*STATS_BINS);
#endif
#ifdef ENDIAN_SWAP
    swapBlock_l(replyBuf, sizeof(TX_STATS_STRUCT)*STATS_BINS);
#endif
#endif
#else //__ATH_DJGPPDOS__
	uiPrintf("create descriptors command not supported in DOS client\n");
#endif //__ATH_DJGPPDOS__
	return(0);

}

A_UINT32 processCreateDescCmd
(
	struct dkThreadInfo *dkThread
)
{

	PIPE_CMD      *pCmd;
	CMD_REPLY     *ReplyCmd_p;
	A_UCHAR     *replyBuf;
		A_UINT32 numDescWords;

#ifndef __ATH_DJGPPDOS__
	pCmd = dkThread->PipeBuffer_p;
	ReplyCmd_p = dkThread->ReplyCmd_p;
	replyBuf = (A_UCHAR *)(ReplyCmd_p->cmdBytes);

	#ifdef ENDIAN_SWAP
     		pCmd->CMD_U.CREATE_DESC_CMD.descBaseAddress = ltob_l(pCmd->CMD_U.CREATE_DESC_CMD.descBaseAddress);
     		pCmd->CMD_U.CREATE_DESC_CMD.descInfo = ltob_l(pCmd->CMD_U.CREATE_DESC_CMD.descInfo);
     		pCmd->CMD_U.CREATE_DESC_CMD.bufAddrIncrement = ltob_l(pCmd->CMD_U.CREATE_DESC_CMD.bufAddrIncrement);
     		pCmd->CMD_U.CREATE_DESC_CMD.descOp = ltob_l(pCmd->CMD_U.CREATE_DESC_CMD.descOp);
			numDescWords = (pCmd->CMD_U.CREATE_DESC_CMD.descInfo & DESC_INFO_NUM_DESC_WORDS_MASK) >> DESC_INFO_NUM_DESC_WORDS_BIT_START;
    		swapBlock_l(pCmd->CMD_U.CREATE_DESC_CMD.descWords, (numDescWords * sizeof(A_UINT32)));
 	#endif

#if !defined(PHOENIX) && !defined(SOC_AP)
uiPrintf("dba=%x:dI=%d:dO=%d:devIndex=%d\n",  pCmd->CMD_U.CREATE_DESC_CMD.descBaseAddress, \
			pCmd->CMD_U.CREATE_DESC_CMD.descInfo, pCmd->CMD_U.CREATE_DESC_CMD.descOp, dkThread->currentDevIndex);

    createDescriptors (dkThread->currentDevIndex, pCmd->CMD_U.CREATE_DESC_CMD.descBaseAddress, \
			pCmd->CMD_U.CREATE_DESC_CMD.descInfo, pCmd->CMD_U.CREATE_DESC_CMD.bufAddrIncrement, \
     		pCmd->CMD_U.CREATE_DESC_CMD.descOp, \
			pCmd->CMD_U.CREATE_DESC_CMD.descWords);

#endif
#else //__ATH_DJGPPDOS__
	uiPrintf("create descriptors command not supported in DOS client\n");
#endif //__ATH_DJGPPDOS__
	return(0);

}

A_UINT32 processLoadAndProgramCodeCmd
(
	struct dkThreadInfo *dkThread
)
{
	PIPE_CMD      *pCmd;
	CMD_REPLY     *ReplyCmd_p;
	A_UCHAR     *replyBuf;
	A_UINT32 *pDword;

	pCmd = dkThread->PipeBuffer_p;
	ReplyCmd_p = dkThread->ReplyCmd_p;
	replyBuf = (A_UCHAR *)(ReplyCmd_p->cmdBytes);

	/* check that the size is appropriate before we access */
     	if( pCmd->cmdLen != sizeof(pCmd->CMD_U.LOAD_AND_PROGRAM_CODE_CMD)+sizeof(pCmd->cmdID) +sizeof(pCmd->devNum)) 
        {
        	uiPrintf("Error, command Len is not equal to size of LOAD_AND_PROGRAM_CODE \n");
        	return(COMMS_ERR_BAD_LENGTH);
        }

	#ifdef ENDIAN_SWAP
     		pCmd->CMD_U.LOAD_AND_PROGRAM_CODE_CMD.loadFlag = ltob_l(pCmd->CMD_U.LOAD_AND_PROGRAM_CODE_CMD.loadFlag);
     		pCmd->CMD_U.LOAD_AND_PROGRAM_CODE_CMD.csAddr = ltob_l(pCmd->CMD_U.LOAD_AND_PROGRAM_CODE_CMD.csAddr);
     		pCmd->CMD_U.LOAD_AND_PROGRAM_CODE_CMD.pPhyAddr = ltob_l(pCmd->CMD_U.LOAD_AND_PROGRAM_CODE_CMD.pPhyAddr);
     		pCmd->CMD_U.LOAD_AND_PROGRAM_CODE_CMD.length = ltob_l(pCmd->CMD_U.LOAD_AND_PROGRAM_CODE_CMD.length);
 	#endif

#ifdef PREDATOR
	*(A_UINT32 *)replyBuf = m_loadAndProgramCode(pCmd->CMD_U.LOAD_AND_PROGRAM_CODE_CMD.loadFlag, 
								   	pCmd->CMD_U.LOAD_AND_PROGRAM_CODE_CMD.csAddr, 
     		       			       	pCmd->CMD_U.LOAD_AND_PROGRAM_CODE_CMD.pPhyAddr,
     		       			       	pCmd->CMD_U.LOAD_AND_PROGRAM_CODE_CMD.length,
		       			       		pCmd->CMD_U.LOAD_AND_PROGRAM_CODE_CMD.pBuffer, dkThread->currentDevIndex);
#endif

	#ifdef ENDIAN_SWAP
    		*((A_UINT32 *)replyBuf) = btol_l(*((A_UINT32 *)replyBuf));
	#endif
    	return 0;
}


#ifdef PHOENIX

A_UINT32 processPhsChannelToggleCmd
(
	struct dkThreadInfo *dkThread
)
{
	PIPE_CMD      *pCmd;
	CMD_REPLY     *ReplyCmd_p;
	A_UCHAR     *replyBuf;

	pCmd = dkThread->PipeBuffer_p;
	ReplyCmd_p = dkThread->ReplyCmd