/drivers/net/wireless/tiwlan1251/CUDK/UtilityAdapter/CTI_Adapter.cpp

Large files files are truncated, but you can click here to view the full file

/*******************************************************************************
**+--------------------------------------------------------------------------+**
**|                                                                          |**
**| Copyright 1998-2008 Texas Instruments, Inc. - http://www.ti.com/         |**
**|                                                                          |**
**| Licensed under the Apache License, Version 2.0 (the "License");          |**
**| you may not use this file except in compliance with the License.         |**
**| You may obtain a copy of the License at                                  |**
**|                                                                          |**
**|     http://www.apache.org/licenses/LICENSE-2.0                           |**
**|                                                                          |**
**| Unless required by applicable law or agreed to in writing, software      |**
**| distributed under the License is distributed on an "AS IS" BASIS,        |**
**| WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |**
**| See the License for the specific language governing permissions and      |**
**| limitations under the License.                                           |**
**|                                                                          |**
**+--------------------------------------------------------------------------+**
*******************************************************************************/

//--------------------------------------------------------------------------
// Module:		CTI_Adapter.cpp
//
// Purpose:		implementation of the CTI_WLAN_AdapterAPI class.
//
//--------------------------------------------------------------------------

#include <string.h>

#include "CommonAdapter.h"
#ifdef _WINDOWS
#endif

#ifndef _WINDOWS
	#include "g_tester.h"
#endif  

#include "paramOut.h"

#ifdef _WINDOWS
#endif
TI_OSCriticalSection	m_csInitAdapter; 

#define TI_WLAN_API_VER   0x00400002



_AdapterItem* CTI_WLAN_AdapterAPI::m_pAdaptersList = NULL;
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CTI_WLAN_AdapterAPI::CTI_WLAN_AdapterAPI(tiCHAR* lpszAdapterName)
{
#ifdef TI_EMBEDDED_SUPPLICANT
    m_pSupplicant = NULL;
#endif /* ifdef TI_EMBEDDED_SUPPLICANT */
    m_pszAdapterName = NULL;
    m_pOSLib = TI_OAL::GetInstance();
    m_pRegistry = new TI_OSRegistry; // temporary solution
#ifdef _WINDOWS
#else
    m_pIPCmod = new TI_IPC(/*lpszAdapterName*/);
#endif 

#ifdef TI_EMBEDDED_SUPPLICANT
    m_bSupplicantInUse = FALSE;
#endif /* ifdef TI_EMBEDDED_SUPPLICANT */
    
    if (lpszAdapterName)
    {
        tiUINT32 uSize = 0;
#ifndef  _UNICODE
        uSize = strlen( lpszAdapterName );
#else
        uSize = wcslen( lpszAdapterName );
#endif
        tiUINT32 uBuffLength = sizeof(tiCHAR)*(uSize+1);
        m_pszAdapterName = new tiCHAR[uSize+1];
        
        if (!m_pszAdapterName)
            return ;
        
        memset(m_pszAdapterName, 0, uBuffLength);
        memcpy(m_pszAdapterName, lpszAdapterName, uBuffLength - sizeof(tiCHAR) );
#ifndef _WINDOWS
        m_pIPCmod->IPC_DeviceOpen(m_pszAdapterName);
#endif
    }
}

/********************************************************************/
tiINT32
CTI_WLAN_AdapterAPI::StartSM( )
{
#ifdef TI_EMBEDDED_SUPPLICANT
	#ifndef _WINDOWS
		m_bSupplicantInUse = TRUE;
		if ( m_pSupplicant == NULL )
			m_pSupplicant = new TI_IPC_Supplicant(m_pszAdapterName);
		else
			return TI_RESULT_FAILED;
	#else
	#endif
#endif /* ifdef TI_EMBEDDED_SUPPLICANT */
    
    return TI_RESULT_OK;
}
/********************************************************************/
tiINT32
CTI_WLAN_AdapterAPI::StopSM( )
{
#ifdef TI_EMBEDDED_SUPPLICANT
#ifndef _WINDOWS
    if (m_bSupplicantInUse && m_pSupplicant != NULL )
    {
        delete m_pSupplicant;
        m_pSupplicant = NULL;
        m_bSupplicantInUse = FALSE;
    }
    else
        return TI_RESULT_FAILED;
#else
#endif
#endif
    return TI_RESULT_OK;
}
/********************************************************************/

CTI_WLAN_AdapterAPI::~CTI_WLAN_AdapterAPI()
{
#ifndef _WINDOWS
    if ( m_pIPCmod )
    {
        m_pIPCmod->IPC_DeviceClose();
        delete m_pIPCmod;
        m_pIPCmod = NULL;
    }
#else    
#endif
    if (m_pRegistry)
    {
        delete m_pRegistry;
        m_pRegistry = NULL;
    }
    
    if ( m_pOSLib )
    {
        m_pOSLib->FreeInstance();
        m_pOSLib = NULL;
    }
    
    if ( m_pszAdapterName )
    {
        delete [] m_pszAdapterName;
        m_pszAdapterName = NULL;
    }
#ifdef TI_EMBEDDED_SUPPLICANT
#ifndef _WINDOWS
    if (m_pSupplicant != NULL )
    {
        delete m_pSupplicant;
        m_pSupplicant = NULL;
    }
#endif    
#endif
}

/********************************************************************/

CTI_WLAN_AdapterAPI*
CTI_WLAN_AdapterAPI::GetTIWLANAdapter(tiCHAR* lpszAdapterName, tiBOOL bForce)
{
    
    m_csInitAdapter.Enter();
    
    if ( bForce )
    {
        CTI_WLAN_AdapterAPI* pAdapter = new CTI_WLAN_AdapterAPI(lpszAdapterName);
        m_csInitAdapter.Leave();
        return pAdapter;
    }
    
    _AdapterItem* pCurrentItem = m_pAdaptersList;
    
    BOOL  bNULL = FALSE;
    if (!lpszAdapterName)
    {
        bNULL = TRUE;
        m_csInitAdapter.Leave();
        return NULL;
    }
    
    while( pCurrentItem )
    {
        tiINT32 iResult = -1;
        
        if ( !bNULL )
#ifndef  _UNICODE
            iResult = strcmp(pCurrentItem->m_pAdapterName, lpszAdapterName );
#else
        iResult = wcscmp(pCurrentItem->m_pAdapterName, lpszAdapterName );
#endif
        else
        {
            if ( !pCurrentItem->m_pAdapterName )
                iResult = 0;    
        }   
        
        if (!iResult)
        {
            pCurrentItem->AddRef();
            m_csInitAdapter.Leave();
            return pCurrentItem->m_dwAdapterID;
        }
        
        pCurrentItem = pCurrentItem->m_pNextItem;
    }
    
    pCurrentItem = new _AdapterItem;
    
    pCurrentItem->m_pNextItem = m_pAdaptersList;
    
    if ( m_pAdaptersList )
        m_pAdaptersList->m_pPrevItem = pCurrentItem;
    
    m_pAdaptersList = pCurrentItem;
    
    if (lpszAdapterName)
    {
        tiUINT32 uSize = 0;
#ifndef  _UNICODE
        uSize = strlen( lpszAdapterName );
#else
        uSize = wcslen( lpszAdapterName );
#endif
        tiUINT32 uBuffLenght = sizeof(tiCHAR)*(uSize+1);
        tiCHAR* pBuff = new tiCHAR[uSize+1];
        
        if (!pBuff)
        {
            m_csInitAdapter.Leave();
            return NULL;
        } 
        
        memset(pBuff, 0, uBuffLenght);
        memcpy(pBuff, lpszAdapterName, uBuffLenght - sizeof(tiCHAR) );
        m_pAdaptersList->m_pAdapterName = pBuff;
    }
    
    pCurrentItem->m_dwAdapterID = new CTI_WLAN_AdapterAPI(lpszAdapterName);
    
    m_csInitAdapter.Leave();
    return m_pAdaptersList->m_dwAdapterID;
}

/********************************************************************/

tiINT32 
CTI_WLAN_AdapterAPI::FreeTIWLANAdapter(CTI_WLAN_AdapterAPI* pAdapter, tiBOOL bForce )
{
    m_csInitAdapter.Enter();
    
#ifndef _WINDOWS
    if ( bForce && pAdapter)
    {
        delete pAdapter;
        pAdapter = NULL;
        m_csInitAdapter.Leave();
        return TI_RESULT_OK;
    }
#else   
#endif
    if (
#ifndef _WINDOWS
		!pAdapter ||
#endif
    // TRS:PGK -- If there is no adapter list, exit.  Nothing to free.
		!m_pAdaptersList)
    {
        m_csInitAdapter.Leave();
        return TI_RESULT_FAILED;
    }
    
    _AdapterItem* pCurrentItem = m_pAdaptersList;
    while( pCurrentItem )
    {
        
        if (pCurrentItem->m_dwAdapterID == pAdapter )
        {
            pCurrentItem->DecRef();
            if ( !pCurrentItem->m_uRef )
            {
                _AdapterItem* pPrev = pCurrentItem->m_pPrevItem;
                if ( pPrev )
                    pPrev->m_pNextItem = pCurrentItem->m_pNextItem;
                
                _AdapterItem* pNext = pCurrentItem->m_pNextItem;
                if ( pNext )
                    pNext->m_pPrevItem = pCurrentItem->m_pPrevItem;
                
                if ( !pNext && !pPrev )
                    m_pAdaptersList = NULL;
                
                if ( pCurrentItem->m_pAdapterName )
                    delete [] pCurrentItem->m_pAdapterName;
                
                delete pCurrentItem->m_dwAdapterID;
                delete pCurrentItem;
                
            }
            
            m_csInitAdapter.Leave();
            return TI_RESULT_OK;
        }
        
        pCurrentItem = pCurrentItem->m_pNextItem;
    }
    
    if ( pAdapter )
        delete pAdapter;
    
    m_csInitAdapter.Leave();
    return TI_RESULT_FAILED;
}

/********************************************************************/

tiINT32
CTI_WLAN_AdapterAPI::CheckObjectMemory(tiVOID *pObj, tiUINT32 uSizeObj)
{
    if ( !pObj || !uSizeObj )
        return FALSE;
    
    return !(m_pOSLib->TIIsBadWritePtr(pObj, uSizeObj));
}
/***************************************************************************************/
tiINT32
CTI_WLAN_AdapterAPI::tiMiniportSetInformation(tiUINT32 dwInfoCode,tiVOID* lpInfoBuffer, tiUINT32* lpdwCbInfoBuffer)
{
    tiUINT32    dwRet       = 0;
    tiUINT32    dwLength    = *lpdwCbInfoBuffer + sizeof(dwInfoCode);
    tiUINT8*    lpBuffer    = new tiUINT8[dwLength];
    tiUINT32 dwRetSize;
    
    if ( !lpBuffer )
        return TI_RESULT_NOT_ENOUGH_MEMORY;
    
    memcpy(lpBuffer, &dwInfoCode, sizeof(dwInfoCode));
    memcpy((tiUINT8*)lpBuffer + sizeof(dwInfoCode), lpInfoBuffer, *lpdwCbInfoBuffer);
    
    dwRet = tiIoCtrl(TIWLN_IOCTL_OID_SET_INFORMATION,lpBuffer, dwLength,NULL,0,&dwRetSize);
    
    delete [] lpBuffer;
    return dwRet;
}
/********************************************************************/
tiINT32
CTI_WLAN_AdapterAPI::tiIoCtrl(tiUINT32 dwIoCtrl, tiVOID* pInBuffer, tiUINT32 uInBufferSize,
                              tiVOID* pOutBuffer, tiUINT32 dwOutBufferSize, tiUINT32* dwBytesReturned)
{
	#ifdef TI_EMBEDDED_SUPPLICANT
		if ( m_bSupplicantInUse )
		{
			#ifdef _WINDOWS
			#endif  
				switch (dwIoCtrl)
				{
					case TIWLN_802_11_SSID_SET:
					case TIWLN_802_11_INFRASTRUCTURE_MODE_SET:
					case TIWLN_802_11_AUTHENTICATION_MODE_SET:
					case TIWLN_802_11_WEP_STATUS_SET:
					case TIWLN_802_11_PSK_SET:
					case TIWLN_802_11_EAP_TYPE_SET:
					case TIWLN_802_11_USER_ID_SET:
					case TIWLN_802_11_USER_PASSWORD_SET:
					case TIWLN_802_11_CERT_PARAMS_SHA1_SET:
					case TIWLN_802_11_CERT_PARAMS_FILE_NAME_SET:
					case TIWLN_802_11_KEY_TYPE_SET:
					case TIWLN_802_11_EXC_NETWORK_EAP_SET:
					case TIWLN_802_11_EXC_CONFIGURATION_SET:
					case TIWLN_802_11_ADD_WEP:
					case TIWLN_802_11_WPA_OPTIONS_SET:
					#ifdef _WINDOWS
					#else
						return m_pSupplicant->SendDataProxy(dwIoCtrl, pInBuffer, uInBufferSize);
					#endif
				}
				#ifdef _WINDOWS
				#endif
				}
	#endif /* ifdef TI_EMBEDDED_SUPPLICANT */
#ifdef _WINDOWS
#else   
    tiUINT32 bRet = m_pIPCmod->IPC_DeviceIoControl( dwIoCtrl, pInBuffer, uInBufferSize,
        pOutBuffer, dwOutBufferSize, dwBytesReturned); 
    return bRet;
#endif
}

/********************************************************************/

tiINT32
CTI_WLAN_AdapterAPI::GetStatistics(TIWLN_STATISTICS* ptiStatistics)
{
    tiUINT32 dwRetValue = TI_RESULT_FAILED;
    tiUINT32 dwRetSize;
    
    if (CheckObjectMemory(ptiStatistics, sizeof(TIWLN_STATISTICS)))
    {
        dwRetValue = tiIoCtrl(TIWLN_802_11_STATISTICS, NULL, 0, ptiStatistics, sizeof(TIWLN_STATISTICS),&dwRetSize);
    }
    return dwRetValue;
}

/********************************************************************/

tiINT32
CTI_WLAN_AdapterAPI::GetTxStatistics(TIWLN_TX_STATISTICS* ptiTxStatistics, UINT32 clearStatsFlag)
{
    tiUINT32 dwRetValue = TI_RESULT_FAILED;
    tiUINT32 dwRetSize;
    
    if ( ptiTxStatistics )
    {
        dwRetValue = tiIoCtrl(TIWLN_802_11_TX_STATISTICS, 
            &clearStatsFlag, sizeof(UINT32), 
            ptiTxStatistics, sizeof(TIWLN_TX_STATISTICS),&dwRetSize);
    }
    
    return dwRetValue;
}

/********************************************************************/
tiINT32
CTI_WLAN_AdapterAPI::GetBSSIDList(OS_802_11_BSSID_LIST_EX** ppBSSIDlist)
{
    tiUINT32    nSize = 0;
    if ( ppBSSIDlist == NULL)
        return TI_RESULT_FAILED;
    
    tiINT32 bRet = GetVariableLengthOID(TIWLN_802_11_BSSID_LIST, (tiVOID**)ppBSSIDlist, &nSize, 10000);
    
    return bRet;
}

/********************************************************************/
tiINT32
CTI_WLAN_AdapterAPI::GetFullBSSIDList(OS_802_11_BSSID_LIST_EX** ppBSSIDlist)
{
    tiUINT32    nSize = 0;
    if ( ppBSSIDlist == NULL)
        return TI_RESULT_FAILED;
    
    tiINT32 bRet = GetVariableLengthOID(TIWLN_802_11_FULL_BSSID_LIST, (tiVOID**)ppBSSIDlist, &nSize, 10000);
    
    return bRet;
}

/********************************************************************/
tiINT32
CTI_WLAN_AdapterAPI::GetCurrentAddress( OS_802_11_MAC_ADDRESS*    pCurrentAddr)
{
    tiUINT32 dwRetValue = TI_RESULT_FAILED;
    tiUINT32 dwRetSize;
    
    if (CheckObjectMemory(pCurrentAddr, sizeof (OS_802_11_MAC_ADDRESS)) )
    {
        dwRetValue = tiIoCtrl(TIWLN_802_3_CURRENT_ADDRESS, NULL, 0, pCurrentAddr, sizeof( OS_802_11_MAC_ADDRESS ), &dwRetSize);
    }
    return dwRetValue;
}
/********************************************************************/
tiINT32
CTI_WLAN_AdapterAPI::GetDesiredSSID( OS_802_11_SSID*  pDesiredSSID )
{
    tiUINT32 dwRetValue = TI_RESULT_FAILED;
    tiUINT32 dwRetSize;
    
    if (CheckObjectMemory(pDesiredSSID, sizeof(OS_802_11_SSID)) )
    {
        dwRetValue = tiIoCtrl(TIWLN_802_11_SSID_GET, NULL, 0, pDesiredSSID, sizeof(OS_802_11_SSID),&dwRetSize);
    }
    
    return dwRetValue;
}

/********************************************************************/

tiINT32
CTI_WLAN_AdapterAPI::GetCurrentSSID( OS_802_11_SSID*  pCurrentSSID )
{
    tiUINT32 dwRetValue = TI_RESULT_FAILED;
    tiUINT32 dwRetSize;
    
    if (CheckObjectMemory(pCurrentSSID, sizeof(OS_802_11_SSID)) )
    {
        dwRetValue = tiIoCtrl(TIWLN_802_11_SSID_GET, NULL, 0, pCurrentSSID, sizeof(OS_802_11_SSID),&dwRetSize);
    }
    
    return dwRetValue;
}

/********************************************************************/

tiINT32 CTI_WLAN_AdapterAPI::SetSSID( tiUINT8*  pszSSIDname )
{
#ifdef _WINDOWS     // TRS:WDK
#endif
    tiUINT32 dwRetValue = TI_RESULT_FAILED;
    tiUINT32 dwRetSize;
    
    if ( pszSSIDname && m_pRegistry )
    {
        tiUINT32    uSize = 0;
        
#ifdef _WINDOWS     
#else  // __LINUX__
#ifdef  _UNICODE
        uSize = wcslen( pszSSIDname );
#else
        uSize = strlen((char *)pszSSIDname);  
#endif
        tiUINT32 dwNameSize = 0;
        
        if ( uSize <= MAX_SSID_LENGTH )
            dwNameSize = uSize * sizeof(tiUINT8);
        else
            dwNameSize = MAX_SSID_LENGTH * sizeof(tiUINT8);
#endif
        
        if (pszSSIDname != NULL)
        {
            
            OS_802_11_SSID ssid;
            memset( &ssid, 0, sizeof(OS_802_11_SSID) );
            
#ifdef _WINDOWS     // TRS:WDK
#else // __LINUX__
#ifdef  _UNICODE
            wcstombs((tiCHAR* )ssid.Ssid, pszSSIDname, MAX_SSID_LENGTH);
            ssid.SsidLength = MAX_SSID_LENGTH;
#else
            memcpy((tiCHAR*)ssid.Ssid, pszSSIDname, dwNameSize );
            ssid.SsidLength = dwNameSize;
#endif
#endif
            
            dwRetValue = tiIoCtrl(TIWLN_802_11_SSID_SET, &ssid, sizeof(OS_802_11_SSID),NULL, 0,&dwRetSize);
#ifdef _WINDOWS
#endif           
        }    
    }
    
    return dwRetValue;
}

/********************************************************************/

tiINT32
CTI_WLAN_AdapterAPI::SetBSSType( OS_802_11_NETWORK_MODE   uBSSType )
{
    tiUINT32 dwRetValue = TI_RESULT_FAILED;
    tiUINT32 dwRetSize;
    dwRetValue = tiIoCtrl(TIWLN_802_11_INFRASTRUCTURE_MODE_SET, &uBSSType, sizeof(OS_802_11_NETWORK_MODE),NULL, 0,&dwRetSize);
#ifdef _WINDOWS
#endif           
    return dwRetValue;
}

/********************************************************************/

tiINT32
CTI_WLAN_AdapterAPI::GetBSSType( OS_802_11_NETWORK_MODE*  puBSSType )
{
    tiUINT32 dwRetValue = TI_RESULT_FAILED;
    tiUINT32 dwRetSize;
    if (CheckObjectMemory( puBSSType, sizeof(OS_802_11_NETWORK_MODE)))
    {
        dwRetValue = tiIoCtrl(TIWLN_802_11_INFRASTRUCTURE_MODE_GET, NULL, 0, puBSSType, sizeof(OS_802_11_NETWORK_MODE),&dwRetSize);
    }
    return dwRetValue;
}

/********************************************************************/
tiINT32
CTI_WLAN_AdapterAPI::SetEAPType( OS_802_11_EAP_TYPES  uEAPType )
{
    tiUINT32 dwRetValue = TI_RESULT_FAILED;
    tiUINT32 dwRetSize;
    if (uEAPType)
    {
        dwRetValue = tiIoCtrl(TIWLN_802_11_EAP_TYPE_SET, &uEAPType, sizeof(OS_802_11_EAP_TYPES),NULL, 0,&dwRetSize); 
    } 
    return dwRetValue;
}

/********************************************************************/
tiINT32
CTI_WLAN_AdapterAPI::SetEAPTypeDriver( OS_802_11_EAP_TYPES  uEAPType )
{
    tiUINT32 dwRetValue = TI_RESULT_FAILED;
    tiUINT32 dwRetSize;
    
    dwRetValue = tiIoCtrl(TIWLN_802_11_EAP_TYPE_DRIVER_SET, &uEAPType, sizeof(OS_802_11_EAP_TYPES),NULL,0,&dwRetSize); 
    
    return dwRetValue;
}

/********************************************************************/
tiINT32
CTI_WLAN_AdapterAPI::GetEAPType( OS_802_11_EAP_TYPES* puEAPType )
{
    tiUINT32 dwRetValue = TI_RESULT_FAILED;
    tiUINT32 dwRetSize;
    
    dwRetValue = tiIoCtrl(TIWLN_802_11_EAP_TYPE_GET, NULL, 0, puEAPType, sizeof(OS_802_11_ENCRYPTION_STATUS),&dwRetSize); 
    
    return dwRetValue;
}
/********************************************************************/
tiINT32
CTI_WLAN_AdapterAPI::SetEncryptionType( OS_802_11_ENCRYPTION_TYPES uEncryptType )
{
    tiUINT32 dwRetValue = TI_RESULT_FAILED;
    tiUINT32 dwRetSize;
    
    OS_802_11_ENCRYPTION_STATUS uEncryptStatus = os802_11WEPDisabled;
    
    switch( uEncryptType )
    {
    case    OS_ENCRYPTION_TYPE_NONE:
        uEncryptStatus = os802_11WEPDisabled;
        break;
    case    OS_ENCRYPTION_TYPE_WEP:
        uEncryptStatus = os802_11Encryption1Enabled;
        break;
    case    OS_ENCRYPTION_TYPE_TKIP:
        uEncryptStatus = os802_11Encryption2Enabled;
        break;
    case    OS_ENCRYPTION_TYPE_AES:
        uEncryptStatus = os802_11Encryption3Enabled;
        break;
    default:
        uEncryptStatus = os802_11WEPDisabled;
    }
    
    dwRetValue = tiIoCtrl(TIWLN_802_11_WEP_STATUS_SET, &uEncryptStatus, sizeof(OS_802_11_ENCRYPTION_STATUS),NULL, 0,&dwRetSize);
    
    return dwRetValue;
}

/********************************************************************/

tiINT32
CTI_WLAN_AdapterAPI::GetEncryptionType( OS_802_11_ENCRYPTION_TYPES* puEncryptType )
{
    tiUINT32 dwRetValue = TI_RESULT_INVALID_PARAMETER;
    tiUINT32 dwRetSize;
    
    if ( puEncryptType && CheckObjectMemory( puEncryptType, sizeof(OS_802_11_ENCRYPTION_TYPES)) )
    {
        OS_802_11_ENCRYPTION_STATUS uEncryptStatus;
        dwRetValue = tiIoCtrl(TIWLN_802_11_WEP_STATUS_GET, NULL, 0, &uEncryptStatus, sizeof(OS_802_11_ENCRYPTION_STATUS),&dwRetSize); 
        
        if ( dwRetValue == TI_RESULT_OK )
        {
            switch( uEncryptStatus )
            {
            case    os802_11WEPDisabled:
                *puEncryptType = OS_ENCRYPTION_TYPE_NONE;
                break;
            case    os802_11Encryption1Enabled:
                *puEncryptType =  OS_ENCRYPTION_TYPE_WEP;
                break;
            case    os802_11Encryption2Enabled:
                *puEncryptType = OS_ENCRYPTION_TYPE_TKIP;
                break;
            case    os802_11Encryption3Enabled:
                *puEncryptType =  OS_ENCRYPTION_TYPE_AES;
                break;
            default:
                dwRetValue = TI_RESULT_FAILED;
            } // switch
        }
    } // end of memory check
    
    return dwRetValue;
}
/********************************************************************/
tiINT32
CTI_WLAN_AdapterAPI::SetCredentials( tiCHAR* pszUserName, tiCHAR* pszPassword )
{
    tiUINT32 dwRetValue = TI_RESULT_FAILED;
    tiUINT32 dwRetSize;
    
    if ( pszUserName != NULL )
    {
        tiUINT32    uSize = 0;
        
#ifdef  _UNICODE
        uSize = wcslen( pszUserName );
#else
        uSize = strlen(pszUserName);  
#endif
        tiUINT32 dwNameSize = uSize * sizeof(tiCHAR);
        
        if ( CheckObjectMemory( pszUserName, dwNameSize ))
            dwRetValue = tiIoCtrl(TIWLN_802_11_USER_ID_SET, pszUserName, dwNameSize + sizeof(tiCHAR),NULL, 0,&dwRetSize);
    }
    else
        dwRetValue = tiIoCtrl(TIWLN_802_11_USER_ID_SET, NULL, 0l,NULL, 0,&dwRetSize);
    
    
    if ( pszPassword != NULL )
    {
        tiUINT32    uSize = 0;
        
#ifdef  _UNICODE
        uSize = wcslen( pszPassword );
#else
        uSize = strlen(pszPassword);  
#endif
        tiUINT32 dwNameSize = uSize * sizeof(tiCHAR);
        
        if ( CheckObjectMemory( pszPassword, dwNameSize ))
            dwRetValue = tiIoCtrl(TIWLN_802_11_USER_PASSWORD_SET, pszPassword, dwNameSize + sizeof(tiCHAR),NULL, 0,&dwRetSize);
    }
    else
        dwRetValue = tiIoCtrl(TIWLN_802_11_USER_PASSWORD_SET, NULL, 0l,NULL, 0,&dwRetSize);
    
    return dwRetValue;
}
/********************************************************************/
tiINT32
CTI_WLAN_AdapterAPI::SetPSK( tiCHAR* pszPSK )
{
    tiUINT32 dwRetValue = TI_RESULT_FAILED;
    tiUINT32 dwRetSize;
    
    if ( pszPSK != NULL )
    {
        tiUINT32    uSize = 0;
        
#ifdef  _UNICODE
        uSize = wcslen( pszPSK );
#else
        uSize = strlen(pszPSK);  
#endif
        tiUINT32 dwNameSize = uSize * sizeof(tiCHAR);
        
        if ( CheckObjectMemory( pszPSK, dwNameSize ))
            dwRetValue = tiIoCtrl(TIWLN_802_11_PSK_SET, pszPSK, dwNameSize + sizeof(tiCHAR),NULL, 0,&dwRetSize);
    }
    else
        dwRetValue = tiIoCtrl(TIWLN_802_11_PSK_SET, NULL, 0l,NULL, 0,&dwRetSize);
    
    return dwRetValue;
}
/********************************************************************/
tiINT32
CTI_WLAN_AdapterAPI::SetCertParamsSHA1( TI_SHA1_HASH* pSha1Hash, tiBOOL bValidateServerCert )
{
    tiUINT32 dwRetValue = TI_RESULT_INVALID_PARAMETER;
    tiUINT32 dwRetSize;
    
    if ( pSha1Hash && CheckObjectMemory(pSha1Hash, sizeof(TI_SHA1_HASH)))
    {
        tiUINT32  uSize = sizeof(TI_SHA1_HASH) + sizeof(tiBOOL);
        tiUINT8*  pByte = new tiUINT8[uSize];
        if ( pByte == NULL )
            return TI_RESULT_NOT_ENOUGH_MEMORY;
        
        tiUINT8* pBufferTmp = pByte;
        
        memset(pByte, 0, uSize);
        memcpy(pBufferTmp, &bValidateServerCert, sizeof(tiBOOL));
        pBufferTmp += sizeof(tiBOOL);
        memcpy(pBufferTmp, pSha1Hash, sizeof(TI_SHA1_HASH));
        
        dwRetValue = tiIoCtrl(TIWLN_802_11_CERT_PARAMS_SHA1_SET, pByte, uSize,NULL, 0,&dwRetSize);
        
        delete [] pByte;
    }
    return dwRetValue;
}
/********************************************************************/
tiINT32
CTI_WLAN_AdapterAPI::SetCertParamsFileName( tiCHAR* pszFileName, tiBOOL bValidateServerCert )
{
    tiUINT32 dwRetValue = TI_RESULT_INVALID_PARAMETER;
    tiUINT32 dwRetSize;
    
    if ( pszFileName != NULL )
    {
        tiUINT32    uSize = 0;
        
#ifdef  _UNICODE
        uSize = wcslen( pszFileName );
#else
        uSize = strlen(pszFileName);  
#endif
        tiUINT32 dwSize = (uSize + 1) * sizeof(tiCHAR) + sizeof(tiBOOL);
        
        tiUINT8*  pByte = new tiUINT8[dwSize];
        
        if ( pByte == NULL )
            return TI_RESULT_NOT_ENOUGH_MEMORY;
        
        tiUINT8* pBufferTmp = pByte;
        
        memset(pByte, 0, dwSize);
        memcpy(pBufferTmp, &bValidateServerCert, sizeof(tiBOOL));
        pBufferTmp += sizeof(tiBOOL);
        memcpy(pBufferTmp, pszFileName, uSize);
        
        dwRetValue = tiIoCtrl(TIWLN_802_11_CERT_PARAMS_FILE_NAME_SET, pByte, dwSize,NULL, 0,&dwRetSize);
        
        delete [] pByte;
    }
    return dwRetValue;
}
/********************************************************************/
tiINT32
CTI_WLAN_AdapterAPI::AddWEPKey( OS_802_11_WEP*    pWEP )
{
    tiUINT32 dwRetValue = TI_RESULT_INVALID_PARAMETER;
    tiUINT32 dwRetSize;
    
    if (CheckObjectMemory(pWEP, sizeof(OS_802_11_WEP)))
    {
        dwRetValue = tiIoCtrl(TIWLN_802_11_ADD_WEP, pWEP, sizeof(OS_802_11_WEP),NULL, 0,&dwRetSize);
        
    }
    return dwRetValue;
}
/********************************************************************/
tiINT32                 
CTI_WLAN_AdapterAPI::RemoveWEPKey( tiUINT32 uKeyIndex )
{
    tiUINT32 dwRetValue = TI_RESULT_FAILED;
    tiUINT32 dwRetSize;
    
    dwRetValue = tiIoCtrl(TIWLN_802_11_REMOVE_WEP, &uKeyIndex, sizeof(tiUINT32),NULL, 0,&dwRetSize);
    return dwRetValue;
}
/********************************************************************/
tiINT32
CTI_WLAN_AdapterAPI::SetWPAOptions( tiUINT32 fWPA_options)
{
    tiUINT32 dwRetValue = TI_RESULT_FAILED;
    tiUINT32 dwRetSize;
    
    dwRetValue = tiIoCtrl(TIWLN_802_11_WPA_OPTIONS_SET, &fWPA_options, sizeof(tiUINT32),NULL, 0,&dwRetSize);
    return dwRetValue;
}
/********************************************************************/
tiINT32 CTI_WLAN_AdapterAPI::GetWPAOptions( tiUINT32 * fWPA_options)
{
    tiUINT32 dwRetValue = TI_RESULT_FAILED;
    tiUINT32 dwRetSize;
    
    if (CheckObjectMemory(fWPA_options, sizeof(tiUINT32)))
    {
        dwRetValue = tiIoCtrl(TIWLN_802_11_WPA_OPTIONS_GET, NULL, 0, fWPA_options, sizeof(tiUINT32),&dwRetSize);
    }
    return dwRetValue;
}

/********************************************************************/
tiINT32                 
CTI_WLAN_AdapterAPI::SetPMKIDmap(OS_802_11_PMKID*  pPMKIDMap)
{
    tiUINT32 dwRetValue = TI_RESULT_FAILED;
    tiUINT32 dwRetSize;
    
    if (CheckObjectMemory(pPMKIDMap, pPMKIDMap->Length))
    {
        dwRetValue = tiIoCtrl(TIWLN_802_11_PMKID_SET, pPMKIDMap, pPMKIDMap->Length,NULL, 0,&dwRetSize);
    }
    
    return dwRetValue;
}
/********************************************************************/
tiINT32
CTI_WLAN_AdapterAPI::AddKey( OS_802_11_KEY*   pKey )
{
    tiUINT32 dwRetValue = TI_RESULT_FAILED;
    tiUINT32 dwRetSize;
    
    if (CheckObjectMemory(pKey, pKey->Length))
    {
        dwRetValue = tiIoCtrl(TIWLN_802_11_ADD_KEY, pKey, pKey->Length,NULL, 0,&dwRetSize);
    }
    return dwRetValue;
}
/********************************************************************/
tiINT32
CTI_WLAN_AdapterAPI::RemoveKey( OS_802_11_REMOVE_KEY* pRemoveKey  )
{
    tiUINT32 dwRetValue = TI_RESULT_FAILED;
    tiUINT32 dwRetSize;
    
    if (CheckObjectMemory(pRemoveKey, sizeof(OS_802_11_REMOVE_KEY)))
    {
        dwRetValue = tiIoCtrl(TIWLN_802_11_REMOVE_KEY, pRemoveKey, sizeof(OS_802_11_REMOVE_KEY),NULL, 0,&dwRetSize);
    }
    
    return dwRetValue;
}
/********************************************************************/
tiINT32
CTI_WLAN_AdapterAPI::RegisterEvent( IPC_EVENT_PARAMS* pEventParams )
{
#ifdef _WINDOWS     // TRS:WDK
#else
    return m_pIPCmod->IPC_RegisterEvent(pEventParams);
#endif
}
/********************************************************************/
tiINT32                 
CTI_WLAN_AdapterAPI::UnRegisterEvent( IPC_EVENT_PARAMS* pEventParams/*tiINT32 iRegisterID*/ ) 
{
#ifdef _WINDOWS     // TRS:WDK
#else
    return m_pIPCmod->IPC_UnRegisterEvent(pEventParams);
#endif
}
/********************************************************************/
tiINT32
CTI_WLAN_AdapterAPI::ConfigPowerManagement( OS_802_11_POWER_PROFILE thePowerMgrProfile )
{
    tiUINT32 dwRetValue = TI_RESULT_FAILED;
    tiUINT32 dwRetSize;
    
    dwRetValue = tiIoCtrl(TIWLN_802_11_POWER_MGR_PROFILE, &thePowerMgrProfile, sizeof(OS_802_11_POWER_PROFILE),NULL,0,&dwRetSize);
    
    return dwRetValue;
}
/********************************************************************/
tiINT32
CTI_WLAN_AdapterAPI::GetAssociationInfo( OS_802_11_ASSOCIATION_INFORMATION** ppInfo )
{
    tiUINT32 dwRetValue = TI_RESULT_FAILED;
    
    tiUINT32 nSize = 0;
    
    if ( ppInfo == NULL)
        return TI_RESULT_FAILED;
    
    dwRetValue = GetVariableLengthOID(TIWLN_802_11_ASSOCIATION_INFORMATION, (tiVOID**)ppInfo, &nSize, 10000);
    if ( TI_SUCCEEDED (dwRetValue) )
    {
        if (nSize == 0 || nSize < sizeof(OS_802_11_ASSOCIATION_INFORMATION) || *ppInfo == NULL )
            dwRetValue = TI_RESULT_FAILED;
        
    }
    return dwRetValue;
}

/********************************************************************/
///////////////////////////////////////////////////////////////////////
// Assorted utility functions

// This function queries for a variable length OID. Starting from a
// suggested size (nNextAllocation), it keeps querying until the size
// requirement is met. It does this repeatedly rather than once because
// the size requirement for an OID can vary from one call to the next, and
// also because some adapters don't report the correct required size value.
tiINT32
CTI_WLAN_AdapterAPI::GetVariableLengthOID(tiUINT32 oid, tiVOID** pp, tiUINT32* pnSize, tiUINT32 nNextAllocation)
{
    tiVOID*     p = NULL;
    tiUINT32    nSize;
    tiUINT32 dwRetValue = TI_RESULT_FAILED;
    tiUINT32 dwRetSize;
    
    // reset return values
    *pp = NULL;
    *pnSize = 0;
    
    // query until we have a big enough buffer or get an error
    for( ; ; )
    {
        // try next allocation
        nSize = nNextAllocation;
        
        if ( nSize )
        {
            p = malloc(nSize);
            if (!p) 
                return TI_RESULT_FAILED;
            memset(p,0,nSize);
        }
        
        
        // get OID
        dwRetValue = tiIoCtrl(oid, p, nSize, p, nSize, &dwRetSize);
        
        if( dwRetSize && nNextAllocation <= nSize && nSize != 0 )
            break;
        else
            nNextAllocation = dwRetSize;
        
        // failed: free buffer
        if ( p )
        {
            free(p);
            p = NULL;
        }
        // if buffer overflow but new size is less than we used, return error
        // NOTE: this would be a NIC bug and we have to avoid an infinite loop
        if( nNextAllocation <= nSize )
            return TI_RESULT_FAILED;
    }
    
    // return pointer, size
    *pp = p;
    *pnSize = nNextAllocation;
    
    // success
    return TI_RESULT_OK;
}
/********************************************************************/
tiINT32
CTI_WLAN_AdapterAPI::StartScan( scan_Params_t *pScanParams )
{
    tiUINT32 dwRetValue = TI_RESULT_FAILED;
    tiUINT32 dwRetSize;
    
    dwRetValue = tiIoCtrl(TIWLN_802_11_START_APP_SCAN_SET, pScanParams, sizeof(scan_Params_t),NULL,0,&dwRetSize);
    
    return dwRetValue;
}
/********************************************************************/
tiINT32
CTI_WLAN_AdapterAPI::StopScan( )
{
    tiUINT32 dwRetValue = TI_RESULT_FAILED;
    tiUINT32 dwRetSize;
    
    dwRetValue = tiIoCtrl(TIWLN_802_11_STOP_APP_SCAN_SET, NULL, 0,NULL,0,&dwRetSize);
    
    return dwRetValue;
}
/********************************************************************/
tiINT32
CTI_WLAN_AdapterAPI::SetScanPolicy( UINT8* buffer, UINT16 bufferLength )
{
    tiUINT32 dwRetValue = TI_RESULT_FAILED;
    tiUINT32 dwRetSize;
    
    dwRetValue = tiIoCtrl(TIWLN_802_11_SCAN_POLICY_PARAM_SET, buffer, bufferLength,NULL,0,&dwRetSize);
    
    return dwRetValue;
}
/********************************************************************/
tiINT32
CTI_WLAN_AdapterAPI::GetScanBssList( bssList_t* bssList )
{
    tiUINT32 dwRetValue = TI_RESULT_FAILED;
    tiUINT32 dwRetSize;
    
    dwRetValue = tiIoCtrl(TIWLN_802_11_SCAN_BSS_LIST_GET, NULL, 0, bssList, sizeof(bssList_t),&dwRetSize);
    
    return dwRetValue;
}
/********************************************************************/
tiINT32 
CTI_WLAN_AdapterAPI::PollApPackets( )
{
    tiUINT32 dwRetValue = TI_RESULT_FAILED;
    tiUINT32 dwRetSize;
    
    dwRetValue = tiIoCtrl(TIWLN_802_11_POLL_AP_PACKETS, NULL, 0, NULL, 0,&dwRetSize);
    return dwRetValue;
}
/********************************************************************/
tiINT32
CTI_WLAN_AdapterAPI::PollApPacketsFromAC( tiUINT32 AC )
{
    tiUINT32 dwRetValue = TI_RESULT_FAILED;
    tiUINT32 dwRetSize;
    
    dwRetValue = tiIoCtrl(TIWLN_802_11_POLL_AP_PACKETS_FROM_AC, &AC, sizeof(tiUINT32),NULL, 0,&dwRetSize);
    return dwRetValue;
}
/********************************************************************/
tiINT32 
CTI_WLAN_AdapterAPI::SetTrafficIntensityThresholds ( OS_802_11_TRAFFIC_INTENSITY_THRESHOLD_PARAMS* pTrafficThresholds )
{
    tiUINT32 dwRetValue = TI_RESULT_FAILED;
    tiUINT32 dwRetSize;
    
    if (CheckObjectMemory(pTrafficThresholds, sizeof(OS_802_11_TRAFFIC_INTENSITY_THRESHOLD_PARAMS)))
    {
        dwRetValue = tiIoCtrl(TIWLN_802_11_SET_TRAFFIC_INTENSITY_THRESHOLDS, pTrafficThresholds , sizeof(OS_802_11_TRAFFIC_INTENSITY_THRESHOLD_PARAMS),NULL, 0,&dwRetSize);
    }
    return dwRetValue;
}
/********************************************************************/
tiINT32 
CTI_WLAN_AdapterAPI::GetTrafficIntensityThresholds ( OS_802_11_TRAFFIC_INTENSITY_THRESHOLD_PARAMS* pTrafficThresholds )
{
    tiUINT32 dwRetValue = TI_RESULT_FAILED;
    tiUINT32 dwRetSize;
    
    dwRetValue = tiIoCtrl(TIWLN_802_11_GET_TRAFFIC_INTENSITY_THRESHOLDS, pTrafficThresholds , sizeof(OS_802_11_TRAFFIC_INTENSITY_THRESHOLD_PARAMS), pTrafficThresholds , sizeof(OS_802_11_TRAFFIC_INTENSITY_THRESHOLD_PARAMS),&dwRetSize);
    
    return dwRetValue;
}
/********************************************************************/
tiINT32 
CTI_WLAN_AdapterAPI::ToggleTrafficIntensityEvents ( tiUINT32 NewStatus )
{
    tiUINT32 dwRetValue = TI_RESULT_FAILED;
    tiUINT32 dwRetSize;
    tiUINT32 localVal = NewStatus;
    
    dwRetValue = tiIoCtrl(TIWLN_802_11_TOGGLE_TRAFFIC_INTENSITY_EVENTS, &localVal , sizeof(tiUINT32),NULL, 0,&dwRetSize);
    return dwRetValue;
}

/********************************************************************/
tiINT32
CTI_WLAN_AdapterAPI::SetDTagToAcMappingTable( acTrfcType_e* pDtagToAcTable )
{
    tiUINT32 dwRetValue = TI_RESULT_FAILED;
    tiUINT32 dwRetSize;
    txDataQosParams_t	txDataQosParams;
    
    if (CheckObjectMemory(pDtagToAcTable, sizeof(acTrfcType_e)))
    {
        for (int i=0; i<MAX_NUM_OF_802_1d_TAGS; i++)
        {
            if (pDtagToAcTable[i] < MAX_NUM_OF_AC)
            {
                txDataQosParams.qosParams.tag_ToAcClsfrTable[i] = pDtagToAcTable[i];
            }
            else
            {
                return dwRetValue;
            }
	}

        dwRetValue = tiIoCtrl(TIWLN_802_11_SET_DTAG_TO_AC_MAPPING_TABLE, &txDataQosParams, sizeof(txDataQosParams_t), NULL, 0,&dwRetSize);
    }
    return dwRetValue;
}

/********************************************************************/
tiINT32
CTI_WLAN_AdapterAPI::SetVAD( txDataVadTimerParams_t* pVadTimer )
{
    tiUINT32 dwRetValue = TI_RESULT_FAILED;
    tiUINT32 dwRetSize;
    
    if (CheckObjectMemory(pVadTimer, sizeof(txDataVadTimerParams_t)))
    {
        dwRetValue = tiIoCtrl(TIWLN_802_11_SET_VAD, pVadTimer, sizeof(txDataVadTimerParams_t), NULL, 0,&dwRetSize);
    }
    return dwRetValue;
}

/********************************************************************/
tiINT32
CTI_WLAN_AdapterAPI::GetVAD( txDataVadTimerParams_t* pVadTimer )
{
    tiUINT32 dwRetValue = TI_RESULT_FAILED;
    tiUINT32 dwRetSize;
    
    if (CheckObjectMemory(pVadTimer, sizeof(txDataVadTimerParams_t)))
    {
        dwRetValue = tiIoCtrl(TIWLN_802_11_GET_VAD, pVadTimer, sizeof(txDataVadTimerParams_t), pVadTimer, sizeof(txDataVadTimerParams_t),&dwRetSize);
    }
    return dwRetValue;	
}

/********************************************************************/
tiINT32
CTI_WLAN_AdapterAPI::SetQosParameters( OS_802_11_QOS_PARAMS* pQosParams )
{
    tiUINT32 dwRetValue = TI_RESULT_FAILED;
    tiUINT32 dwRetSize;
    
    if (CheckObjectMemory(pQosParams, sizeof(OS_802_11_QOS_PARAMS)))
    {
        dwRetValue = tiIoCtrl(TIWLN_802_11_SET_QOS_PARAMS, pQosParams, sizeof(OS_802_11_QOS_PARAMS),NULL, 0,&dwRetSize);
    }
    return dwRetValue;
}

/********************************************************************/
tiINT32
CTI_WLAN_AdapterAPI::SetRxTimeOut( OS_802_11_QOS_RX_TIMEOUT_PARAMS* pRxTimeOut )
{
    tiUINT32 dwRetValue = TI_RESULT_FAILED;
    tiUINT32 dwRetSize;
    
    if (CheckObjectMemory(pRxTimeOut, sizeof(OS_802_11_QOS_PARAMS)))
    {
        dwRetValue = tiIoCtrl(TIWLN_802_11_SET_RX_TIMEOUT, pRxTimeOut, sizeof(OS_802_11_QOS_RX_TIMEOUT_PARAMS),NULL, 0,&dwRetSize);
    }
    return dwRetValue;
}
/********************************************************************/
tiINT32
CTI_WLAN_AdapterAPI::GetAPQosParameters( OS_802_11_AC_QOS_PARAMS* pACQosParams)
{
    tiUINT32 dwRetValue = TI_RESULT_FAILED;
    tiUINT32 dwRetSize;
    
    if (CheckObjectMemory(pACQosParams, sizeof(OS_802_11_AC_QOS_PARAMS)))
    {
        dwRetValue = tiIoCtrl(TIWLN_802_11_GET_AP_QOS_PARAMS, pACQosParams, sizeof(OS_802_11_AC_QOS_PARAMS), pACQosParams, sizeof(OS_802_11_AC_QOS_PARAMS),&dwRetSize);
    }
    return dwRetValue;
}
/********************************************************************/
tiINT32
CTI_WLAN_AdapterAPI::GetUserPriorityOfStream( STREAM_TRAFFIC_PROPERTIES* streamProperties)
{
    tiUINT32 dwRetValue = TI_RESULT_FAILED;
    tiUINT32 dwRetSize;
    
    if (CheckObjectMemory(streamProperties, sizeof(STREAM_TRAFFIC_PROPERTIES)))
    {
        dwRetValue = tiIoCtrl(TIWLN_802_11_GET_USER_PRIORITY_OF_STREAM, streamProperties, sizeof(STREAM_TRAFFIC_PROPERTIES), streamProperties, sizeof(STREAM_TRAFFIC_PROPERTIES),&dwRetSize);
    }
    return dwRetValue;
}
/********************************************************************/
tiINT32
CTI_WLAN_AdapterAPI::GetAPQosCapabilitesParameters( OS_802_11_AP_QOS_CAPABILITIES_PARAMS* pAPQosCapabiltiesParams )
{
    tiUINT32 dwRetValue = TI_RESULT_FAILED;
    tiUINT32 dwRetSize;
    
    dwRetValue = tiIoCtrl(TIWLN_802_11_GET_AP_QOS_CAPABILITIES, NULL, 0, pAPQosCapabiltiesParams, sizeof(OS_802_11_AP_QOS_CAPABILITIES_PARAMS),&dwRetSize);
    return dwRetValue;
}

/********************************************************************/
tiINT32
CTI_WLAN_AdapterAPI::AddTspec ( OS_802_11_QOS_TSPEC_PARAMS* pTspecParams)
{
    tiUINT32 dwRetValue = TI_RESULT_FAILED;
    tiUINT32 dwRetSize;
    
    dwRetValue = tiIoCtrl(TIWLN_802_11_ADD_TSPEC, pTspecParams, sizeof(OS_802_11_QOS_TSPEC_PARAMS),NULL, 0,&dwRetSize);
    return dwRetValue;
}
/********************************************************************/
tiINT32
CTI_WLAN_AdapterAPI::GetTspecParameters( OS_802_11_QOS_TSPEC_PARAMS* pTspecParams)
{
    tiUINT32 dwRetValue = TI_RESULT_FAILED;
    tiUINT32 dwRetSize;
    
    dwRetValue = tiIoCtrl(TIWLN_802_11_GET_TSPEC_PARAMS, pTspecParams, sizeof(OS_802_11_QOS_TSPEC_PARAMS), pTspecParams, sizeof(OS_802_11_QOS_TSPEC_PARAMS),&dwRetSize);
    return dwRetValue;
}/********************************************************************/
tiINT32
CTI_WLAN_AdapterAPI::DeleteTspec( OS_802_11_QOS_DELETE_TSPEC_PARAMS* pDelTspecParams)
{
    tiUINT32 dwRetValue = TI_RESULT_FAILED;
    tiUINT32 dwRetSize;
    
    dwRetValue = tiIoCtrl(TIWLN_802_11_DELETE_TSPEC, pDelTspecParams, sizeof(OS_802_11_QOS_DELETE_TSPEC_PARAMS),NULL, 0,&dwRetSize);
    return dwRetValue;
}/********************************************************************/
tiINT32
CTI_WLAN_AdapterAPI:: GetCurrentACStatus( OS_802_11_AC_UPSD_STATUS_PARAMS *pAcStatusParams)
{
    tiUINT32 dwRetValue = TI_RESULT_FAILED;
    tiUINT32 dwRetSize;
    
    dwRetValue = tiIoCtrl(TIWLN_802_11_GET_CURRENT_AC_STATUS, pAcStatusParams, sizeof(OS_802_11_AC_UPSD_STATUS_PARAMS), pAcStatusParams, sizeof(OS_802_11_AC_UPSD_STATUS_PARAMS),&dwRetSize);
    return dwRetValue;
}/********************************************************************/
tiINT32
CTI_WLAN_AdapterAPI:: SetMediumUsageThreshold(OS_802_11_THRESHOLD_CROSS_PARAMS* pThresholdCrossParams)
{
    tiUINT32 dwRetValue = TI_RESULT_FAILED;
    tiUINT32 dwRetSize;
    
    dwRetValue = tiIoCtrl(TIWLN_802_11_SET_MEDIUM_USAGE_THRESHOLD, pThresholdCrossParams, sizeof(OS_802_11_THRESHOLD_CROSS_PARAMS),NULL, 0,&dwRetSize);
    return dwRetValue;
}/********************************************************************/
tiINT32
CTI_WLAN_AdapterAPI:: SetPhyRateThreshold(OS_802_11_THRESHOLD_CROSS_PARAMS* pThresholdCrossParams)
{
    tiUINT32 dwRetValue = TI_RESULT_FAILED;
    tiUINT32 dwRetSize;
    
    dwRetValue = tiIoCtrl(TIWLN_802_11_SET_PHY_RATE_THRESHOLD, pThresholdCrossParams, sizeof(OS_802_11_THRESHOLD_CROSS_PARAMS),NULL, 0,&dwRetSize);
    return dwRetValue;
}
/********************************************************************/
tiINT32
CTI_WLAN_AdapterAPI:: GetMediumUsageThreshold(OS_802_11_THRESHOLD_CROSS_PARAMS* pThresholdCrossParams)
{
    tiUINT32 dwRetValue = TI_RESULT_FAILED;
    tiUINT32 dwRetSize;
    
    dwRetValue = tiIoCtrl(TIWLN_802_11_GET_MEDIUM_USAGE_THRESHOLD, pThresholdCrossParams, sizeof(OS_802_11_THRESHOLD_CROSS_PARAMS), pThresholdCrossParams, sizeof(OS_802_11_THRESHOLD_CROSS_PARAMS),&dwRetSize);
    return dwRetValue;
}
/********************************************************************/
tiINT32
CTI_WLAN_AdapterAPI:: GetPhyRateThreshold(OS_802_11_THRESHOLD_CROSS_PARAMS* pThresholdCrossParams)
{
    tiUINT32 dwRetValue = TI_RESULT_FAILED;
    tiUINT32 dwRetSize;
    
    dwRetValue = tiIoCtrl(TIWLN_802_11_GET_PHY_RATE_THRESHOLD, pThresholdCrossParams, sizeof(OS_802_11_THRESHOLD_CROSS_PARAMS), pThresholdCrossParams, sizeof(OS_802_11_THRESHOLD_CROSS_PARAMS),&dwRetSize);
    return dwRetValue;
}
/********************************************************************/
tiINT32
CTI_WLAN_AdapterAPI:: GetDesiredPsMode(OS_802_11_QOS_DESIRED_PS_MODE* pDesiredPsMode)
{
    tiUINT32 dwRetValue = TI_RESULT_FAILED;
    tiUINT32 dwRetSize;
    
    dwRetValue = tiIoCtrl(TIWLN_802_11_GET_DESIRED_PS_MODE, NULL, 0, pDesiredPsMode, sizeof(OS_802_11_QOS_DESIRED_PS_MODE),&dwRetSize);
    
    return dwRetValue;
}
/********************************************************************/
tiINT32
CTI_WLAN_AdapterAPI::ConfigTxClassifier(tiUINT32 inParamsBuffLen, tiUINT8  *pInParamsBuff)
{
    tiUINT32 dwRetValue = TI_RESULT_FAILED;
    tiUINT32 dwRetSize;
    
    if ( pInParamsBuff && CheckObjectMemory(pInParamsBuff, inParamsBuffLen) )
    {
        dwRetValue = tiIoCtrl(TIWLN_802_11_CONFIG_TX_CLASS, pInParamsBuff, inParamsBuffLen,NULL, 0,&dwRetSize);
    }
    
    return dwRetValue;
}
/********************************************************************/
tiINT32
CTI_WLAN_AdapterAPI::RemoveClassifierEntry(clsfr_tableEntry_t *pClsfrEntry)
{
    tiUINT32 dwRetValue = TI_RESULT_FAILED;
    tiUINT32 dwRetSize;
    
    if (pClsfrEntry)
    {
        dwRetValue = tiIoCtrl(TIWLN_802_11_REMOVE_CLSFR_ENTRY, pClsfrEntry, sizeof(clsfr_tableEntry_t),NULL, 0,&dwRetSize);
    }
    
    return dwRetValue;
}
/**********************************************************************/
tiINT32
CTI_WLAN_AdapterAPI::GetClsfrType (clsfrTypeAndSupport *currClsfrType)
{
    tiUINT32 dwRetValue = TI_RESULT_FAILED;
    tiUINT32 dwRetSize;
    
    dwRetValue = tiIoCtrl(TIWLN_802_11_GET_CLSFR_TYPE, NULL, 0, currClsfrType, sizeof(clsfrTypeAndSupport),&dwRetSize);      
    return dwRetValue;
}
/********************************************************************/
tiINT32 
CTI_WLAN_AdapterAPI::GetDriverCapabilities (OS_802_11_DRIVER_CAPABILITIES* pDriverCapabilities )
{
    tiUINT32 dwRetValue = TI_RESULT_FAILED;
    tiUINT32 dwRetSize;
    
    dwRetValue = tiIoCtrl(TIWLN_802_11_GET_DRIVERS_CAPABILITIES, pDriverCapabilities, sizeof(OS_802_11_DRIVER_CAPABILITIES), pDriverCapabilities, sizeof(OS_802_11_DRIVER_CAPABILITIES),&dwRetSize);
    return dwRetValue;
}

/********************************************************************/
tiINT32
CTI_WLAN_AdapterAPI::GetSelectedBSSIDInfo(OS_802_11_BSSID_EX  *pSelectedBSSIDInfo)
{
    tiUINT32 dwRetValue = TI_RESULT_FAILED;
    tiUINT32 dwRetSize;
    
    dwRetValue = tiIoCtrl(TIWLN_802_11_GET_SELECTED_BSSID_INFO, pSelectedBSSIDInfo, sizeof(OS_802_11_BSSID_EX), pSelectedBSSIDInfo, sizeof(OS_802_11_BSSID_EX),&dwRetSize);
    return dwRetValue;
}

/********************************************************************/
tiINT32
CTI_WLAN_AdapterAPI::GetPrimaryBSSIDInfo(OS_802_11_BSSID_EX  *pSelectedBSSIDInfo)
{
	tiUINT32 dwRetValue = TI_RESULT_FAILED;
	tiUINT32 dwRetSize;
    tiUINT32 outBufLen;

    outBufLen = pSelectedBSSIDInfo->Length; //sizeof(OS_802_11_BSSID_EX) + sizeof(OS_802_11_FIXED_IEs) + 300;

   dwRetValue = tiIoCtrl(TIWLN_802_11_GET_PRIMARY_BSSID_INFO, pSelectedBSSIDInfo, outBufLen, pSelectedBSSIDInfo, outBufLen, &dwRetSize);
   return dwRetValue;
}

/********************************************************************/

tiINT32
CTI_WLAN_AdapterAPI::EnableDisableRxDataFilters(tiBOOL enabled)
{
    tiUINT32 dwRetSize;

    return tiIoCtrl(TIWLN_ENABLE_DISABLE_RX_DATA_FILTERS, &enabled, sizeof(enabled), NULL, 0, &dwRetSize);
}

/********************************************************************/

tiINT32
CTI_WLAN_AdapterAPI::GetRxDataFiltersStatistics(TIWLAN_DATA_FILTER_STATISTICS * pStatistics)
{
    tiUINT32 dwRetSize;

    return tiIoCtrl(TIWLN_GET_RX_DATA_FILTERS_STATISTICS, NULL, 0, pStatistics, sizeof(TIWLAN_DATA_FILTER_STATISTICS), &dwRetSize);
}

/********************************************************************/

tiINT32
CTI_WLAN_AdapterAPI::GetPowerConsumptionStatistics(PowerConsumptionTimeStat_t * pStatistics)
{
    tiUINT32 dwRetSize;

    return tiIoCtrl(TIWLN_GET_POWER_CONSUMPTION_STATISTICS, NULL, 0, pStatistics, sizeof(PowerConsumptionTimeStat_t), &dwRetSize);
}

/********************************************************************/

tiINT32
CTI_WLAN_AdapterAPI::AddRxDataFilter(TIWLAN_DATA_FILTER_REQUEST * pRequest)
{
    tiUINT32 dwRetValue = TI_RESULT_FAILED;
    tiUINT32 dwRetSize;

    if ( pRequest )
    {
        dwRetValue = tiIoCtrl(TIWLN_ADD_RX_DATA_FILTER, pRequest, sizeof(TIWLAN_DATA_FILTER_REQUEST), NULL, 0, &dwRetSize);
    }

    return dwRetValue;
}

/********************************************************************/
tiINT32
CTI_WLAN_AdapterAPI::RemoveRxDataFilter(TIWLAN_DATA_FILTER_REQUEST * pRequest)
{
    tiUINT32 dwRetValue = TI_RESULT_FAILED;
    tiUINT32 dwRetSize;

    if ( pRequest )
    {
        dwRetValue = tiIoCtrl(TIWLN_REMOVE_RX_DATA_FILTER, pRequest, sizeof(TIWLAN_DATA_FILTER_REQUEST), NULL, 0, &dwRetSize);
    }

    return dwRetValue;
}

/********************************************************************/
tiINT32
CTI_WLAN_AdapterAPI::SetTxPowerDbm(tiUINT8 uTxPower)
{
    tiUINT32 dwRetValue = TI_RESULT_FAILED;
    tiUINT32 dwRetSize;
    
    dwRetValue = tiIoCtrl(TIWLN_802_11_TX_POWER_DBM_SET, &uTxPower, sizeof(UINT8),NULL, 0,&dwRetSize);
    
    return dwRetValue;
}
/********************************************************************/
tiINT32
CTI_WLAN_AdapterAPI::SetPowerMode(OS_802_11_POWER_PROFILE uPower )
{
    tiUINT32 dwRetValue = TI_RESULT_FAILED;
    tiUINT32 dwRetSize;
    
    dwRetValue = tiIoCtrl(TIWLN_802_11_POWER_MODE_SET, &uPower, sizeof(OS_802_11_POWER_PROFILE),NULL, 0,&dwRetSize);
    return dwRetValue;
}
/********************************************************************/
tiINT32
CTI_WLAN_AdapterAPI::GetPowerMode(OS_802_11_POWER_PROFILE* puPower)
{
    tiUINT32 dwRetValue = TI_RESULT_FAILED;
    tiUINT32 dwRetSize;
    
    dwRetValue = tiIoCtrl(TIWLN_802_11_POWER_MODE_GET, NULL, 0, puPower, sizeof(OS_802_11_POWER_PROFILE),&dwRetSize);
    return dwRetValue;
}
/********************************************************************/
tiINT32
CTI_WLAN_AdapterAPI::SetPowerLevelPS(OS_802_11_POWER_LEVELS uPower )
{
    tiUINT32 dwRetValue = TI_RESULT_FAILED;
    tiUINT32 dwRetSize;
    
    dwRetValue = tiIoCtrl(TIWLN_802_11_POWER_LEVEL_PS_SET, &uPower, sizeof(OS_802_11_POWER_LEVELS),NULL, 0,&dwRetSize);
    return dwRetValue;
}
/********************************************************************/
tiINT32
CTI_WLAN_AdapterAPI::GetPowerLevelPS( OS_802_11_POWER_LEVELS* puPower)
{
    tiUINT32 dwRetValue = TI_RESULT_FAILED;
    tiUINT32 dwRetSize;
    
    dwRetValue = tiIoCtrl(TIWLN_802_11_POWER_LEVEL_PS_GET, NULL, 0, puPower, sizeof(OS_802_11_POWER_LEVELS),&dwRetSize);
    return dwRetValue;
}

/********************************************************************/
tiINT32
CTI_WLAN_AdapterAPI::SetPowerLevelDefault(OS_802_11_POWER_LEVELS uPower )
{
    tiUINT32 dwRetValue = TI_RESULT_FAILED;
    tiUINT32 dwRetSize;
    
    dwRetValue = tiIoCtrl(TIWLN_802_11_POWER_LEVEL_DEFAULT_SET, &uPower, sizeof(OS_802_11_POWER_LEVELS),NULL, 0,&dwRetSize);
    return dwRetValue;
}
/********************************************************************/
tiINT32
CTI_WLAN_AdapterAPI::GetPowerLevelDefault( OS_802_11_POWER_LEVELS* puPower)
{
    tiUINT32 dwRetValue = TI_RESULT_FAILED;
    tiUINT32 dwRetSize;
    
    dwRetValue = tiIoCtrl(TIWLN_802_11_POWER_LEVEL_DEFAULT_GET, NULL, 0, puPower, sizeof(OS_802_11_POWER_LEVELS),&dwRetSize);
    return dwRetValue;
}
/********************************************************************/
tiINT32
CTI_WLAN_AdapterAPI::SetPowerLevelDozeMode(OS_802_11_POWER_PROFILE uPower )
{
    tiUINT32 dwRetValue = TI_RESULT_FAILED;
    tiUINT32 dwRetSize;
    
    dwRetValue = tiIoCtrl(TIWLN_802_11_POWER_LEVEL_DOZE_MODE_SET, &uPower, sizeof(OS_802_11_POWER_PROFILE),NULL, 0,&dwRetSize);
    return dwRetValue;
}
/********************************************************************/
tiINT32
CTI_WLAN_AdapterAPI::GetPowerLevelDozeMode( OS_802_11_POWER_PROFILE* puPower)
{
    tiUINT32 dwRetValue = TI_RESULT_FAILED;
    tiUINT32 dwRetSize;
    
    dwRetValue = tiIoCtrl(TIWLN_802_11_POWER_LEVEL_DOZE_MODE_GET, NULL, 0, puPower, sizeof(OS_802_11_POWER_PROFILE),&dwRetSize);
    return dwRetValue;
}
/*********************…

Large files files are truncated, but you can click here to view the full file