dk_client.c

Atheros AP Test with Agilent N4010A source code

							}
#if !defined(PHOENIX_UART_WAKEUP_FEATURE)
								pOSSock->sockDisconnect = 0; // add this in the next line, later
#else
							if (pOSSock->sockDisconnect) {
								pOSSock->sockDisconnect = 0;
							   /**** ENABLE UART Wakeup and Sleep */
							   /* Begin */
							   sysRegWrite(UART0_WAKEUP_ADDRESS, UART0_WAKEUP_ENABLE_SET(1));
							   // Read the sleep registers sysRegRead(
						   	asm volatile (
	  									"mcr p15, 0, r0, c7, c0, 4\n"
							   );
						   
							   /* End */
							}
#endif
							continue;
					}
					else
	 					break;
   	 		}
  	}


	semLock(sem);
#ifndef MALLOC_ABSENT
	A_FREE(ReplyCmd_p);
	A_FREE(PipeBuffer_p);
#endif
	
#if defined(THIN_CLIENT_BUILD)
#else // THIN_CLIENT_BUILD
	for (i=0;i<MAX_CLIENTS_PER_THREAD;i++) {
		if (dkThread->devNum[i] != INVALID_ENTRY) {
			closeMLIB(dkThread->devNum[i]);	
		}

		if (dkThread->devIndex[i] != (A_UINT32)INVALID_ENTRY) {	
			deviceCleanup((A_UINT16)dkThread->devIndex[i]);
          	}
	}
#endif // THIN_CLIENT_BUILD

	osSockClose(pOSSock); 
	putThreadEntry(dkThread);
	semUnLock(sem);

  	return;
}


/**************************************************************************
* processInitF2Cmd - Process INIT_F2_CMD command
*
* RETURNS: 0 processed OK, an Error code if it is not
*/
A_UINT32 processInitF2Cmd
(
	struct dkThreadInfo *dkThread
)
{
	PIPE_CMD      *pCmd;
	CMD_REPLY     *ReplyCmd_p;
	A_UCHAR     *replyBuf;
	MDK_WLAN_DEV_INFO    *pdevInfo;
	A_UINT32 devNum;
	A_UINT32 devIndex;
	A_UINT16 device_fn;

	device_fn = WMAC_FUNCTION;
	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.INIT_F2_CMD)+sizeof(pCmd->cmdID)+sizeof(pCmd->devNum) ) {
		uiPrintf("Error, command Len is not equal to size of INIT_F2_CMD:Exp=%d:Recd=%d\n", sizeof(pCmd->CMD_U.INIT_F2_CMD)+sizeof(pCmd->cmdID)+sizeof(pCmd->devNum), pCmd->cmdLen);
		return(COMMS_ERR_BAD_LENGTH);
	}	

#ifdef ENDIAN_SWAP
     pCmd->CMD_U.INIT_F2_CMD.whichF2 = ltob_l(pCmd->CMD_U.INIT_F2_CMD.whichF2);
#endif

	devIndex =  pCmd->CMD_U.INIT_F2_CMD.whichF2;
//#if defined(AR6000)
//	devIndex = devIndex - SDIO_FN_DEV_START_NUM;
//#endif
	uiPrintf("F2 to init = %d\n", devIndex);
    
	/* validate the F2 required; see that it is a valid index */
	if (devIndex > WLAN_MAX_DEV ) {
		/* don't have a large enough array to accommodate this device */
		uiPrintf("Error: devInfo array not large enough, only support %d devices\n", WLAN_MAX_DEV);
		return(COMMS_ERR_INDEX_TOO_LARGE);
	}

	if (devIndex == 0) {
		uiPrintf("Error: Cannot have a zero index \n");
		return(COMMS_ERR_DEV_INIT_FAIL);
	}

	semLock(sem);
	devIndex = devIndex - 1;
#if defined(VXWORKS) || defined(ECOS)
	if (A_FAILED(deviceInit((A_UINT16)devIndex, device_fn)) ) {
#else
	if (A_FAILED(deviceInit((A_UINT16)devIndex, device_fn, NULL)) ) {
#endif
		uiPrintf("Error: Failed call to deviceInit() \n");
		semUnLock(sem);
		return(COMMS_ERR_DEV_INIT_FAIL);
	}

	pdevInfo = globDrvInfo.pDevInfoArray[devIndex];
		
#if defined(THIN_CLIENT_BUILD)
    devNum = pCmd->devNum;
#else
	devNum = initializeMLIB(pdevInfo);
#endif
	if (devNum == -1) {
		uiPrintf("Cannot initalize MLIB \n");
		semUnLock(sem);
		return(COMMS_ERR_DEV_INIT_FAIL);
	}
	if (addClientToThread(dkThread,(A_UINT16)devIndex,devNum) < 0) {
		uiPrintf("Cannot add thread to client \n");
		semUnLock(sem);
		return(COMMS_ERR_DEV_INIT_FAIL);
	}
    	// make this the current device
   	dkThread->currentDevIndex = (A_UINT16)devIndex;
	semUnLock(sem);

#if defined(THIN_CLIENT_BUILD)
	*((A_UINT32 *)replyBuf) = (devNum | 0x10000000);
#else
	*((A_UINT32 *)replyBuf) = devNum;
#endif

#if defined(THIN_CLIENT_BUILD)
#ifndef MALLOC_ABSENT
    memcpy(replyBuf+4, pdevInfo->pdkInfo, sizeof(DK_DEV_INFO));
#else
    A_MEM_CPY(replyBuf+4, pdevInfo->pdkInfo, sizeof(DK_DEV_INFO));
#endif
#ifdef ENDIAN_SWAP
    swapBlock_l(replyBuf+4, sizeof(DK_DEV_INFO));
#endif
#endif
#ifdef ENDIAN_SWAP
        *((A_UINT32 *)replyBuf) = btol_l(*((A_UINT32 *)replyBuf));
#endif

	return (0);
}


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

	pdevInfo = globDrvInfo.pDevInfoArray[dkThread->currentDevIndex];
	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.REG_READ_CMD)+sizeof(pCmd->cmdID) + sizeof(pCmd->devNum) )
        {
        uiPrintf("Error, command Len is not equal to size of REG_READ_CMD\n");
        return(COMMS_ERR_BAD_LENGTH);
        }

#ifdef ENDIAN_SWAP
	pCmd->CMD_U.REG_READ_CMD.readAddr = ltob_l(pCmd->CMD_U.REG_READ_CMD.readAddr);
#endif

#ifndef PHOENIX
	/* check that the register is within the range of registers */
    	if (pCmd->CMD_U.REG_READ_CMD.readAddr > MAX_REG_OFFSET) {
		uiPrintf("Error:  Not a valid register offset\n");
		return(COMMS_ERR_BAD_OFFSET);
        }
#endif


 
      /* read the register */
#ifdef JUNGO
	*((A_UINT32 *)replyBuf) = hwMemRead32(dkThread->currentDevIndex,pdevInfo->pdkInfo->pSharedInfo->devMapAddress + pCmd->CMD_U.REG_READ_CMD.readAddr); 
#else
#ifdef PREDATOR
	//*((A_UINT32 *)replyBuf) = sysRegRead(pdevInfo->pdkInfo->f2MapAddress + pCmd->CMD_U.REG_READ_CMD.readAddr);
	rAddr = pdevInfo->pdkInfo->f2MapAddress + pCmd->CMD_U.REG_READ_CMD.readAddr;
	//uiPrintf("A:%x:", rAddr);
	*((A_UINT32 *)replyBuf) = sysRegRead(rAddr);
#else
	*((A_UINT32 *)replyBuf) = hwMemRead32((A_UINT16)dkThread->currentDevIndex,pdevInfo->pdkInfo->f2MapAddress + pCmd->CMD_U.REG_READ_CMD.readAddr);
#endif
#endif

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

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

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

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

#ifndef PHOENIX
	/* check that the register is within the range of registers */
    	if (pCmd->CMD_U.REG_WRITE_CMD.writeAddr > MAX_REG_OFFSET) {
		uiPrintf("Error:  Not a valid register offset\n");
		return(COMMS_ERR_BAD_OFFSET);
        }
#endif

    /* write the register */
#ifdef JUNGO
	hwMemWrite32(dkThread->currentDevIndex,pdevInfo->pdkInfo->pSharedInfo->devMapAddress + pCmd->CMD_U.REG_WRITE_CMD.writeAddr, pCmd->CMD_U.REG_WRITE_CMD.regValue); 
#else
#ifdef PREDATOR
	wAddr = pdevInfo->pdkInfo->f2MapAddress + pCmd->CMD_U.REG_WRITE_CMD.writeAddr;
	//uiPrintf("B:%x:", wAddr);
	sysRegWrite(wAddr, pCmd->CMD_U.REG_WRITE_CMD.regValue);
#else
	hwMemWrite32((A_UINT16)dkThread->currentDevIndex,pdevInfo->pdkInfo->f2MapAddress + pCmd->CMD_U.REG_WRITE_CMD.writeAddr, pCmd->CMD_U.REG_WRITE_CMD.regValue);
#endif
#endif
  
    return(0);
}

/**************************************************************************
* processCfgReadCmd - Process CFG_READ_CMD command
*
* RETURNS: 0 processed OK, an Error code if it is not
*/
A_UINT32 processCfgReadCmd
(
	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.CFG_READ_CMD)+sizeof(pCmd->cmdID) + sizeof(pCmd->devNum) )
        {
        uiPrintf("Error, command Len is not equal to size of CFG_READ_CMD\n");
        return(COMMS_ERR_BAD_LENGTH);
        }

#ifdef ENDIAN_SWAP
	pCmd->CMD_U.CFG_READ_CMD.cfgReadAddr = ltob_l(pCmd->CMD_U.CFG_READ_CMD.cfgReadAddr);        
	pCmd->CMD_U.CFG_READ_CMD.readSize = ltob_l(pCmd->CMD_U.CFG_READ_CMD.readSize);
#endif

    /* read the register */
    switch(pCmd->CMD_U.CFG_READ_CMD.readSize)
        {
#if !defined(ART) && !defined(THIN_CLIENT_BUILD)
        case 8:
            *((A_UINT32 *)replyBuf) = (A_UINT32)hwCfgRead8(dkThread->currentDevIndex, pCmd->CMD_U.CFG_READ_CMD.cfgReadAddr); 
            break;

        case 16:
            *((A_UINT32 *)replyBuf) = (A_UINT32)hwCfgRead16(dkThread->currentDevIndex, pCmd->CMD_U.CFG_READ_CMD.cfgReadAddr); 
            break;
#endif
        case 32:
            *((A_UINT32 *)replyBuf) = hwCfgRead32(dkThread->currentDevIndex, pCmd->CMD_U.CFG_READ_CMD.cfgReadAddr); 
            break;

        default:
            return(COMMS_ERR_BAD_CFG_SIZE);

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



    
    return(0);
}

/**************************************************************************
* processCfgWriteCmd - Process CFG_WRITE_CMD command
*
* RETURNS: 0 processed OK, an Error code if it is not
*/
A_UINT32 processCfgWriteCmd
(
	struct dkThreadInfo *dkThread
)
{

#ifndef PREDATOR
	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.CFG_WRITE_CMD)+sizeof(pCmd->cmdID) + sizeof(pCmd->devNum))
        {
        uiPrintf("Error, command Len is not equal to size of CFG_WRITE_CMD\n");
        return(COMMS_ERR_BAD_LENGTH);
        }

#ifdef ENDIAN_SWAP
	pCmd->CMD_U.CFG_WRITE_CMD.writeSize = ltob_l(pCmd->CMD_U.CFG_WRITE_CMD.writeSize);
	pCmd->CMD_U.CFG_WRITE_CMD.cfgWriteAddr = ltob_l(pCmd->CMD_U.CFG_WRITE_CMD.cfgWriteAddr);
	pCmd->CMD_U.CFG_WRITE_CMD.cfgValue = ltob_l(pCmd->CMD_U.CFG_WRITE_CMD.cfgValue);
#endif

    /* write the register */
    switch(pCmd->CMD_U.CFG_WRITE_CMD.writeSize)
        {
#if !defined(ART) && !defined(THIN_CLIENT_BUILD)
        case 8:
            hwCfgWrite8(dkThread->currentDevIndex, pCmd->CMD_U.CFG_WRITE_CMD.cfgWriteAddr, (A_UINT8)pCmd->CMD_U.CFG_WRITE_CMD.cfgValue); 
            break;

        case 16:
            hwCfgWrite16(dkThread->currentDevIndex, pCmd->CMD_U.CFG_WRITE_CMD.cfgWriteAddr, (A_UINT16)pCmd->CMD_U.CFG_WRITE_CMD.cfgValue); 
            break;
#endif
        case 32:
            hwCfgWrite32(dkThread->currentDevIndex, pCmd->CMD_U.CFG_WRITE_CMD.cfgWriteAddr, pCmd->CMD_U.CFG_WRITE_CMD.cfgValue); 
            break;

        default:
            return(COMMS_ERR_BAD_CFG_SIZE);

        }
#endif
    
    return(0);
    }


/**************************************************************************
* processMemReadBlockCmd - Process MEM_READ_BLOCK_CMD command
*
* RETURNS: 0 processed OK, an Error code if it is not
*/
A_UINT32 processMemReadBlockCmd
(
	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.MEM_READ_BLOCK_CMD)+sizeof(pCmd->cmdID) + sizeof(pCmd->devNum))
        {
        uiPrintf("Error, command Len is not equal to size of MEM_READ_BLOCK_CMD\n");
        return(COMMS_ERR_BAD_LENGTH);
        }

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

    /* read the memory */