dk_client.c

atheros ar5001 5002 driver

        }

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

    return(0);
    }

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

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

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

#ifdef ENDIAN_SWAP
	pCmd->CMD_U.MEM_WRITE_CMD.writeSize = ltob_l(pCmd->CMD_U.MEM_WRITE_CMD.writeSize);
	pCmd->CMD_U.MEM_WRITE_CMD.writeAddr = ltob_l(pCmd->CMD_U.MEM_WRITE_CMD.writeAddr);
//	pCmd->CMD_U.MEM_WRITE_CMD.writeValue = ltob_l(pCmd->CMD_U.MEM_WRITE_CMD.writeValue);
#endif
  
    /* write the register */
    switch(pCmd->CMD_U.MEM_WRITE_CMD.writeSize)
        {
#ifndef ART
        case 8:
            hwMemWrite8(dkThread->currentDevIndex,pCmd->CMD_U.MEM_WRITE_CMD.writeAddr, (A_UINT8)pCmd->CMD_U.MEM_WRITE_CMD.writeValue); 
            break;

        case 16:
            hwMemWrite16(dkThread->currentDevIndex,pCmd->CMD_U.MEM_WRITE_CMD.writeAddr, (A_UINT16)pCmd->CMD_U.MEM_WRITE_CMD.writeValue); 
            break;
#endif
        case 32:
            hwMemWrite32(dkThread->currentDevIndex,pCmd->CMD_U.MEM_WRITE_CMD.writeAddr, pCmd->CMD_U.MEM_WRITE_CMD.writeValue); 
            break;

        default:
            return(COMMS_ERR_BAD_MEM_SIZE);

        }
    
    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;
	A_UINT32       cmdLen;        
	CMD_REPLY     *ReplyCmd_p;
	A_UCHAR     *replyBuf;
	MDK_WLAN_DEV_INFO    *pdevInfo;

	pdevInfo = globDrvInfo.pDevInfoArray[dkThread->currentDevIndex];
	pCmd = dkThread->PipeBuffer_p;
	cmdLen = pCmd->cmdLen;
	ReplyCmd_p = dkThread->ReplyCmd_p;
	replyBuf = (A_UCHAR *)(ReplyCmd_p->cmdBytes);
    
    /* check that the size is appropriate before we access */
    if( cmdLen != sizeof(pCmd->CMD_U.REG_READ_CMD)+sizeof(pCmd->cmdID) )
        {
        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

	/* 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);
        }
    
      /* read the register */
#ifdef JUNGO
	*((A_UINT32 *)replyBuf) = hwMemRead32(dkThread->currentDevIndex,pdevInfo->pdkInfo->pSharedInfo->devMapAddress + pCmd->CMD_U.REG_READ_CMD.readAddr); 
#else
	*((A_UINT32 *)replyBuf) = hwMemRead32(dkThread->currentDevIndex,pdevInfo->pdkInfo->f2MapAddress + pCmd->CMD_U.REG_READ_CMD.readAddr);
#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;
	A_UINT32       cmdLen;        
	CMD_REPLY     *ReplyCmd_p;
	A_UCHAR     *replyBuf;
	MDK_WLAN_DEV_INFO    *pdevInfo;

	pCmd = dkThread->PipeBuffer_p;
	cmdLen = pCmd->cmdLen;
	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( cmdLen != sizeof(pCmd->CMD_U.REG_WRITE_CMD)+sizeof(pCmd->cmdID) )
        {
        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

	/* 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);
        }

    /* 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
	hwMemWrite32(dkThread->currentDevIndex,pdevInfo->pdkInfo->f2MapAddress + pCmd->CMD_U.REG_WRITE_CMD.writeAddr, pCmd->CMD_U.REG_WRITE_CMD.regValue);
#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;
	A_UINT32       cmdLen;        
	CMD_REPLY     *ReplyCmd_p;
	A_UCHAR     *replyBuf;

	pCmd = dkThread->PipeBuffer_p;
	cmdLen = pCmd->cmdLen;
	ReplyCmd_p = dkThread->ReplyCmd_p;
	replyBuf = (A_UCHAR *)(ReplyCmd_p->cmdBytes);
    
    /* check that the size is appropriate before we access */
    if( cmdLen != sizeof(pCmd->CMD_U.CFG_READ_CMD)+sizeof(pCmd->cmdID) )
        {
        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)
        {
#ifndef ART
        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
)
{
	PIPE_CMD      *pCmd;
	A_UINT32       cmdLen;        
	CMD_REPLY     *ReplyCmd_p;
	A_UCHAR     *replyBuf;

	pCmd = dkThread->PipeBuffer_p;
	cmdLen = pCmd->cmdLen;
	ReplyCmd_p = dkThread->ReplyCmd_p;
	replyBuf = (A_UCHAR *)(ReplyCmd_p->cmdBytes);
    
    /* check that the size is appropriate before we access */
    if( cmdLen != sizeof(pCmd->CMD_U.CFG_WRITE_CMD)+sizeof(pCmd->cmdID) )
        {
        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)
        {
#ifndef ART
        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);

        }
    
    return(0);
    }

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

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

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

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

    /* do a sanity check to see that we have a devInfo structure for this F2 */
    if(globDrvInfo.pDevInfoArray[pCmd->CMD_U.SELECT_HW_CMD.whichF2 - 1] == NULL)
        {
        /* for some reason don't seem to have a structure for this, return error */
        return(COMMS_ERR_NO_F2_TO_SELECT);
        }

    /* make this new F2 the current F2 */
    dkThread->currentDevIndex = (A_UINT16)pCmd->CMD_U.SELECT_HW_CMD.whichF2 - 1;

    return(0);
    }

/**************************************************************************
* processMemAllocCmd - Process NEN_ALLOC_CMD command
*
* RETURNS: 0 processed OK, an Error code if it is not
*/
A_UINT32 processMemAllocCmd
(
	struct dkThreadInfo *dkThread
)
{
	PIPE_CMD      *pCmd;
	A_UINT32       cmdLen;        
	CMD_REPLY     *ReplyCmd_p;
	A_UCHAR     *replyBuf;
	A_UINT32       *pVirtAddress;        /* virtual address of mem block */

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

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

#ifdef ENDIAN_SWAP
	pCmd->CMD_U.MEM_ALLOC_CMD.allocSize = ltob_l(pCmd->CMD_U.MEM_ALLOC_CMD.allocSize);
	pCmd->CMD_U.MEM_ALLOC_CMD.physAddr = ltob_l(pCmd->CMD_U.MEM_ALLOC_CMD.physAddr);
#endif

    /* do the allocation */
    pVirtAddress = (A_UINT32 *)hwGetPhysMem(dkThread->currentDevIndex, pCmd->CMD_U.MEM_ALLOC_CMD.allocSize, 
								    &(pCmd->CMD_U.MEM_ALLOC_CMD.physAddr));

    if (pVirtAddress == NULL)
        {
        return(COMMS_ERR_ALLOC_FAIL);
        } 
    
    /* copy the address into the return buffer */
    *(A_UINT32 *)replyBuf = pCmd->CMD_U.MEM_ALLOC_CMD.physAddr;

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

    return(0);
    }

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

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

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

    /* do the free */
    hwFreeAll(dkThread->currentDevIndex);
    
    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;
	A_UINT32       cmdLen;        
	CMD_REPLY     *ReplyCmd_p;
	A_UCHAR     *replyBuf;

	pCmd = dkThread->PipeBuffer_p;
	cmdLen = pCmd->cmdLen;