CORE/SYS/legacy/src/utils/src/parserApi.c

/*
 * Copyright (c) 2012-2019 The Linux Foundation. All rights reserved.
 *
 * Previously licensed under the ISC license by Qualcomm Atheros, Inc.
 *
 *
 * Permission to use, copy, modify, and/or distribute this software for
 * any purpose with or without fee is hereby granted, provided that the
 * above copyright notice and this permission notice appear in all
 * copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
 * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
 * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
 * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
 * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
 * PERFORMANCE OF THIS SOFTWARE.
 */

/*
 * This file was originally distributed by Qualcomm Atheros, Inc.
 * under proprietary terms before Copyright ownership was assigned
 * to the Linux Foundation.
 */

/*
 * This file parserApi.cc contains the code for parsing
 * 802.11 messages.
 * Author:        Pierre Vandwalle
 * Date:          03/18/02
 * History:-
 * Date           Modified by    Modification Information
 * --------------------------------------------------------------------
 *
 */

#include "sirApi.h"
#include "aniGlobal.h"
#include "parserApi.h"
#include "cfgApi.h"
#include "limUtils.h"
#include "utilsParser.h"
#include "limSerDesUtils.h"
#include "schApi.h"
#include "palApi.h"
#include "wmmApsd.h"
#if defined WLAN_FEATURE_VOWIFI
#include "rrmApi.h"
#endif

#define DOT11F_RSN_VERSION 1    /* current supported version */
#define DOT11F_RSN_OUI_SIZE 4
#define DOT11F_RSN_CSE_NULL 0x00
#define DOT11F_RSN_CSE_WEP40 0x01
#define DOT11F_RSN_CSE_TKIP 0x02
#define DOT11F_RSN_CSE_WRAP 0x03
#define DOT11F_RSN_CSE_CCMP 0x04
#define DOT11F_RSN_CSE_WEP104 0x05
#define DOT11F_RSN_CSE_AES_CMAC 0x06

static const tANI_U8 sirRSNOui[][ DOT11F_RSN_OUI_SIZE ] = {
    { 0x00, 0x0F, 0xAC, 0x00 }, /* group cipher */
    { 0x00, 0x0F, 0xAC, 0x01 }, /* WEP-40 or RSN */
    { 0x00, 0x0F, 0xAC, 0x02 }, /* TKIP or RSN-PSK */
    { 0x00, 0x0F, 0xAC, 0x03 }, /* Reserved */
    { 0x00, 0x0F, 0xAC, 0x04 }, /* AES-CCMP */
    { 0x00, 0x0F, 0xAC, 0x05 }, /* WEP-104 */
    { 0x00, 0x40, 0x96, 0x00 }, /* CCKM */
    /* BIP (encryption type) or RSN-PSK-SHA256 (authentication type) */
    { 0x00, 0x0F, 0xAC, 0x06 },
    /* RSN-8021X-SHA256 (authentication type) */
    { 0x00, 0x0F, 0xAC, 0x05 }
};



////////////////////////////////////////////////////////////////////////
void dot11fLog(tpAniSirGlobal pMac, int loglevel, const char *pString,...) 
{
#ifdef WLAN_DEBUG
    if( (tANI_U32)loglevel > pMac->utils.gLogDbgLevel[LOG_INDEX_FOR_MODULE( SIR_DBG_MODULE_ID )] )
    {
        return;
    }
    else
    {
        va_list         marker;

        va_start( marker, pString );     /* Initialize variable arguments. */

        logDebug(pMac, SIR_DBG_MODULE_ID, loglevel, pString, marker);

        va_end( marker );              /* Reset variable arguments.      */
    }
#endif
}

void
swapBitField16(tANI_U16 in, tANI_U16 *out)
{
#   ifdef ANI_LITTLE_BIT_ENDIAN
    *out = in;
#   else // Big-Endian...
    *out = ( ( in & 0x8000 ) >> 15 ) |
           ( ( in & 0x4000 ) >> 13 ) |
           ( ( in & 0x2000 ) >> 11 ) |
           ( ( in & 0x1000 ) >>  9 ) |
           ( ( in & 0x0800 ) >>  7 ) |
           ( ( in & 0x0400 ) >>  5 ) |
           ( ( in & 0x0200 ) >>  3 ) |
           ( ( in & 0x0100 ) >>  1 ) |
           ( ( in & 0x0080 ) <<  1 ) |
           ( ( in & 0x0040 ) <<  3 ) |
           ( ( in & 0x0020 ) <<  5 ) |
           ( ( in & 0x0010 ) <<  7 ) |
           ( ( in & 0x0008 ) <<  9 ) |
           ( ( in & 0x0004 ) << 11 ) |
           ( ( in & 0x0002 ) << 13 ) |
           ( ( in & 0x0001 ) << 15 );
#   endif // ANI_LITTLE_BIT_ENDIAN
}

void
swapBitField32(tANI_U32 in, tANI_U32 *out)
{
#   ifdef ANI_LITTLE_BIT_ENDIAN
    *out = in;
#   else // Big-Endian...
    *out = ( ( in & 0x80000000 ) >> 31 ) |
           ( ( in & 0x40000000 ) >> 29 ) |
           ( ( in & 0x20000000 ) >> 27 ) |
           ( ( in & 0x10000000 ) >> 25 ) |
           ( ( in & 0x08000000 ) >> 23 ) |
           ( ( in & 0x04000000 ) >> 21 ) |
           ( ( in & 0x02000000 ) >> 19 ) |
           ( ( in & 0x01000000 ) >> 17 ) |
           ( ( in & 0x00800000 ) >> 15 ) |
           ( ( in & 0x00400000 ) >> 13 ) |
           ( ( in & 0x00200000 ) >> 11 ) |
           ( ( in & 0x00100000 ) >>  9 ) |
           ( ( in & 0x00080000 ) >>  7 ) |
           ( ( in & 0x00040000 ) >>  5 ) |
           ( ( in & 0x00020000 ) >>  3 ) |
           ( ( in & 0x00010000 ) >>  1 ) |
           ( ( in & 0x00008000 ) <<  1 ) |
           ( ( in & 0x00004000 ) <<  3 ) |
           ( ( in & 0x00002000 ) <<  5 ) |
           ( ( in & 0x00001000 ) <<  7 ) |
           ( ( in & 0x00000800 ) <<  9 ) |
           ( ( in & 0x00000400 ) << 11 ) |
           ( ( in & 0x00000200 ) << 13 ) |
           ( ( in & 0x00000100 ) << 15 ) |
           ( ( in & 0x00000080 ) << 17 ) |
           ( ( in & 0x00000040 ) << 19 ) |
           ( ( in & 0x00000020 ) << 21 ) |
           ( ( in & 0x00000010 ) << 23 ) |
           ( ( in & 0x00000008 ) << 25 ) |
           ( ( in & 0x00000004 ) << 27 ) |
           ( ( in & 0x00000002 ) << 29 ) |
           ( ( in & 0x00000001 ) << 31 );
#   endif // ANI_LITTLE_BIT_ENDIAN
}

inline static void __printWMMParams(tpAniSirGlobal  pMac, tDot11fIEWMMParams *pWmm)
{
    limLog(pMac, LOG1, FL("WMM Parameters Received: "));
    limLog(pMac, LOG1, FL("BE: aifsn %d, acm %d, aci %d, cwmin %d, cwmax %d, txop %d "),
           pWmm->acbe_aifsn, pWmm->acbe_acm, pWmm->acbe_aci, pWmm->acbe_acwmin, pWmm->acbe_acwmax, pWmm->acbe_txoplimit);

    limLog(pMac, LOG1, FL("BK: aifsn %d, acm %d, aci %d, cwmin %d, cwmax %d, txop %d "),
           pWmm->acbk_aifsn, pWmm->acbk_acm, pWmm->acbk_aci, pWmm->acbk_acwmin, pWmm->acbk_acwmax, pWmm->acbk_txoplimit);

    limLog(pMac, LOG1, FL("VI: aifsn %d, acm %d, aci %d, cwmin %d, cwmax %d, txop %d "),
           pWmm->acvi_aifsn, pWmm->acvi_acm, pWmm->acvi_aci, pWmm->acvi_acwmin, pWmm->acvi_acwmax, pWmm->acvi_txoplimit);

    limLog(pMac, LOG1, FL("VO: aifsn %d, acm %d, aci %d, cwmin %d, cwmax %d, txop %d "),
           pWmm->acvo_aifsn, pWmm->acvo_acm, pWmm->acvo_aci, pWmm->acvo_acwmin, pWmm->acvo_acwmax, pWmm->acvo_txoplimit);

    return;
}

////////////////////////////////////////////////////////////////////////
// Functions for populating "dot11f" style IEs


// return: >= 0, the starting location of the IE in rsnIEdata inside tSirRSNie
//         < 0, cannot find
int FindIELocation( tpAniSirGlobal pMac,
                           tpSirRSNie pRsnIe,
                           tANI_U8 EID)
{
    int idx, ieLen, bytesLeft;
    int ret_val = -1;

    // Here's what's going on: 'rsnIe' looks like this:

    //     typedef struct sSirRSNie
    //     {
    //         tANI_U16       length;
    //         tANI_U8        rsnIEdata[SIR_MAC_MAX_IE_LENGTH+2];
    //     } tSirRSNie, *tpSirRSNie;

    // other code records both the WPA & RSN IEs (including their EIDs &
    // lengths) into the array 'rsnIEdata'.  We may have:

    //     With WAPI support, there may be 3 IEs here
    //     It can be only WPA IE, or only RSN IE or only WAPI IE
    //     Or two or all three of them with no particular ordering

    // The if/then/else statements that follow are here to figure out
    // whether we have the WPA IE, and where it is if we *do* have it.

    //Save the first IE length 
    ieLen = pRsnIe->rsnIEdata[ 1 ] + 2;
    idx = 0;
    bytesLeft = pRsnIe->length;

    while( 1 )
    {
        if ( EID == pRsnIe->rsnIEdata[ idx ] )
        {
            //Found it
            return (idx);
        }
        else if ( EID != pRsnIe->rsnIEdata[ idx ] &&
             // & if no more IE, 
             bytesLeft <= (tANI_U16)( ieLen ) )
        {
            dot11fLog( pMac, LOG3, FL("No IE (%d) in FindIELocation."), EID );
            return ret_val;
        }
        bytesLeft -= ieLen;
        ieLen = pRsnIe->rsnIEdata[ idx + 1 ] + 2;
        idx += ieLen;
    }

    return ret_val;
}


tSirRetStatus
PopulateDot11fCapabilities(tpAniSirGlobal         pMac,
                           tDot11fFfCapabilities *pDot11f,
                           tpPESession            psessionEntry)
{
    tANI_U16           cfg;
    tSirRetStatus nSirStatus;

    nSirStatus = cfgGetCapabilityInfo( pMac, &cfg,psessionEntry );
    if ( eSIR_SUCCESS != nSirStatus )
    {
        dot11fLog( pMac, LOGP, FL("Failed to retrieve the Capabilities b"
                               "itfield from CFG (%d)."), nSirStatus );
        return nSirStatus;
    }

#if 0
    if ( sirIsPropCapabilityEnabled( pMac, SIR_MAC_PROP_CAPABILITY_11EQOS ) )
    {
        SIR_MAC_CLEAR_CAPABILITY( cfg, QOS );
    }
#endif
    swapBitField16( cfg, ( tANI_U16* )pDot11f );

    return eSIR_SUCCESS;
} // End PopulateDot11fCapabilities.

tSirRetStatus
PopulateDot11fCapabilities2(tpAniSirGlobal         pMac,
                            tDot11fFfCapabilities *pDot11f,
                            tpDphHashNode          pSta, 
                            tpPESession            psessionEntry)
{
    tANI_U16           cfg;
    tSirRetStatus nSirStatus;
    nSirStatus = cfgGetCapabilityInfo( pMac, &cfg ,psessionEntry);
    if ( eSIR_SUCCESS != nSirStatus )
    {
        dot11fLog( pMac, LOGP, FL("Failed to retrieve the Capabilities b"
                               "itfield from CFG (%d)."), nSirStatus );
        return nSirStatus;
    }

    if ( ( NULL != pSta ) && pSta->aniPeer &&
         PROP_CAPABILITY_GET( 11EQOS, pSta->propCapability ) )
    {
        SIR_MAC_CLEAR_CAPABILITY( cfg, QOS );
    }

    swapBitField16( cfg, ( tANI_U16* )pDot11f );

    return eSIR_SUCCESS;

} // End PopulateDot11fCapabilities2.

void populate_dot11f_ext_chann_switch_ann(tpAniSirGlobal mac_ctx,
            tDot11fIEext_chan_switch_ann *dot_11_ptr, tpPESession session_entry)
{
   offset_t ch_offset;

   if (session_entry->gLimChannelSwitch.secondarySubBand >=
       PHY_QUADRUPLE_CHANNEL_20MHZ_LOW_40MHZ_CENTERED)
         ch_offset = BW80;
   else
         ch_offset = session_entry->gLimChannelSwitch.secondarySubBand;

   dot_11_ptr->switch_mode = session_entry->gLimChannelSwitch.switchMode;
   dot_11_ptr->new_reg_class = limGetOPClassFromChannel(
         mac_ctx->scan.countryCodeCurrent,
         session_entry->gLimChannelSwitch.primaryChannel, ch_offset);
   dot_11_ptr->new_channel = session_entry->gLimChannelSwitch.primaryChannel;
   dot_11_ptr->switch_count = session_entry->gLimChannelSwitch.switchCount;
   dot_11_ptr->present = 1;

   limLog(mac_ctx, LOG1, FL("country:%s cb mode:%d width:%d reg:%d off:%d"),
          mac_ctx->scan.countryCodeCurrent,
          session_entry->gLimChannelSwitch.primaryChannel,
          session_entry->gLimChannelSwitch.secondarySubBand,
          dot_11_ptr->new_reg_class, ch_offset);
}

void
PopulateDot11fChanSwitchAnn(tpAniSirGlobal          pMac,
                            tDot11fIEChanSwitchAnn *pDot11f,
                            tpPESession psessionEntry)
{
    pDot11f->switchMode = psessionEntry->gLimChannelSwitch.switchMode;
    pDot11f->newChannel = psessionEntry->gLimChannelSwitch.primaryChannel;
    pDot11f->switchCount = ( tANI_U8 ) psessionEntry->gLimChannelSwitch.switchCount;

    pDot11f->present = 1;
} // End PopulateDot11fChanSwitchAnn.

void
PopulateDot11fsecChanOffset(tpAniSirGlobal pMac,
                               tDot11fIEsec_chan_offset *pDot11f,
                               tpPESession psessionEntry)
{
    //Has to be updated on the cb state basis
    pDot11f->secondaryChannelOffset = 
             psessionEntry->gLimChannelSwitch.secondarySubBand;

    pDot11f->present = 1;
}

#ifdef WLAN_FEATURE_11AC
void
PopulateDot11fWiderBWChanSwitchAnn(tpAniSirGlobal pMac,
                                   tDot11fIEWiderBWChanSwitchAnn *pDot11f,
                                   tpPESession psessionEntry)
{
    pDot11f->present = 1;
    pDot11f->newChanWidth = psessionEntry->gLimWiderBWChannelSwitch.newChanWidth;
    pDot11f->newCenterChanFreq0 = psessionEntry->gLimWiderBWChannelSwitch.newCenterChanFreq0;
    pDot11f->newCenterChanFreq1 = psessionEntry->gLimWiderBWChannelSwitch.newCenterChanFreq1;
    limLog(pMac, LOG1, FL("wrapper: width:%d f0:%d f1:%d"),
           pDot11f->newChanWidth, pDot11f->newCenterChanFreq0,
           pDot11f->newCenterChanFreq1);
}
#endif

tSirRetStatus
PopulateDot11fCountry(tpAniSirGlobal    pMac,
                      tDot11fIECountry *pDot11f,
                      tpPESession psessionEntry)
{
    tANI_U32           len, maxlen, codelen;
    tANI_U16           item;
    tSirRetStatus nSirStatus;
    tSirRFBand         rfBand;
    tANI_U8            temp[CFG_MAX_STR_LEN], code[3];

    if (psessionEntry->lim11dEnabled )
    {
        limGetRfBand(pMac, &rfBand, psessionEntry);
        if (rfBand == SIR_BAND_5_GHZ)
        {
            item   = WNI_CFG_MAX_TX_POWER_5;
            maxlen = WNI_CFG_MAX_TX_POWER_5_LEN;
        }
        else
        {
            item   = WNI_CFG_MAX_TX_POWER_2_4;
            maxlen = WNI_CFG_MAX_TX_POWER_2_4_LEN;
        }

        CFG_GET_STR( nSirStatus, pMac, item, temp, len, maxlen );

        if ( 3 > len )
        {
            // no limit on tx power, cannot include the IE because at least
            // one (channel,num,tx power) must be present
            return eSIR_SUCCESS;
        }

        CFG_GET_STR( nSirStatus, pMac, WNI_CFG_COUNTRY_CODE,
                     code, codelen, 3 );

        vos_mem_copy( pDot11f->country, code, codelen );

        if(len > MAX_SIZE_OF_TRIPLETS_IN_COUNTRY_IE)
        {
            dot11fLog( pMac, LOGE, FL("len:%d is out of bounds, resetting."), len);
            len = MAX_SIZE_OF_TRIPLETS_IN_COUNTRY_IE;
        }

        pDot11f->num_triplets = ( tANI_U8 ) ( len / 3 );
        vos_mem_copy( ( tANI_U8* )pDot11f->triplets, temp, len );

        pDot11f->present = 1;
    }

    return eSIR_SUCCESS;
} // End PopulateDot11fCountry.

tSirRetStatus
PopulateDot11fDSParams(tpAniSirGlobal     pMac,
                       tDot11fIEDSParams *pDot11f, tANI_U8 channel,
                       tpPESession psessionEntry)
{
    if (IS_24G_CH(channel))
    {
        // .11b/g mode PHY => Include the DS Parameter Set IE:
        pDot11f->curr_channel = channel;
        pDot11f->present = 1;
    }

    return eSIR_SUCCESS;
} // End PopulateDot11fDSParams.

#define SET_AIFSN(aifsn) (((aifsn) < 2) ? 2 : (aifsn))


void
PopulateDot11fEDCAParamSet(tpAniSirGlobal         pMac,
                           tDot11fIEEDCAParamSet *pDot11f, 
                           tpPESession psessionEntry)
{

    if (  psessionEntry->limQosEnabled )
    {
        //change to bitwise operation, after this is fixed in frames.
        pDot11f->qos = (tANI_U8)(0xf0 & (psessionEntry->gLimEdcaParamSetCount << 4) );

        // Fill each EDCA parameter set in order: be, bk, vi, vo
        pDot11f->acbe_aifsn     = ( 0xf & SET_AIFSN(psessionEntry->gLimEdcaParamsBC[0].aci.aifsn) );
        pDot11f->acbe_acm       = ( 0x1 & psessionEntry->gLimEdcaParamsBC[0].aci.acm );
        pDot11f->acbe_aci       = ( 0x3 & SIR_MAC_EDCAACI_BESTEFFORT );
        pDot11f->acbe_acwmin    = ( 0xf & psessionEntry->gLimEdcaParamsBC[0].cw.min );
        pDot11f->acbe_acwmax    = ( 0xf & psessionEntry->gLimEdcaParamsBC[0].cw.max );
        pDot11f->acbe_txoplimit = psessionEntry->gLimEdcaParamsBC[0].txoplimit;

        pDot11f->acbk_aifsn     = ( 0xf & SET_AIFSN(psessionEntry->gLimEdcaParamsBC[1].aci.aifsn) );
        pDot11f->acbk_acm       = ( 0x1 & psessionEntry->gLimEdcaParamsBC[1].aci.acm );
        pDot11f->acbk_aci       = ( 0x3 & SIR_MAC_EDCAACI_BACKGROUND );
        pDot11f->acbk_acwmin    = ( 0xf & psessionEntry->gLimEdcaParamsBC[1].cw.min );
        pDot11f->acbk_acwmax    = ( 0xf & psessionEntry->gLimEdcaParamsBC[1].cw.max );
        pDot11f->acbk_txoplimit = psessionEntry->gLimEdcaParamsBC[1].txoplimit;

        pDot11f->acvi_aifsn     = ( 0xf & SET_AIFSN(psessionEntry->gLimEdcaParamsBC[2].aci.aifsn) );
        pDot11f->acvi_acm       = ( 0x1 & psessionEntry->gLimEdcaParamsBC[2].aci.acm );
        pDot11f->acvi_aci       = ( 0x3 & SIR_MAC_EDCAACI_VIDEO );
        pDot11f->acvi_acwmin    = ( 0xf & psessionEntry->gLimEdcaParamsBC[2].cw.min );
        pDot11f->acvi_acwmax    = ( 0xf & psessionEntry->gLimEdcaParamsBC[2].cw.max );
        pDot11f->acvi_txoplimit = psessionEntry->gLimEdcaParamsBC[2].txoplimit;

        pDot11f->acvo_aifsn     = ( 0xf & SET_AIFSN(psessionEntry->gLimEdcaParamsBC[3].aci.aifsn) );
        pDot11f->acvo_acm       = ( 0x1 & psessionEntry->gLimEdcaParamsBC[3].aci.acm );
        pDot11f->acvo_aci       = ( 0x3 & SIR_MAC_EDCAACI_VOICE );
        pDot11f->acvo_acwmin    = ( 0xf & psessionEntry->gLimEdcaParamsBC[3].cw.min );
        pDot11f->acvo_acwmax    = ( 0xf & psessionEntry->gLimEdcaParamsBC[3].cw.max );
        pDot11f->acvo_txoplimit = psessionEntry->gLimEdcaParamsBC[3].txoplimit;

        pDot11f->present = 1;
    }

} // End PopluateDot11fEDCAParamSet.

tSirRetStatus
PopulateDot11fERPInfo(tpAniSirGlobal    pMac,
                      tDot11fIEERPInfo *pDot11f,
                      tpPESession    psessionEntry)
{
    tSirRetStatus nSirStatus;
    tANI_U32            val;
    tSirRFBand          rfBand = SIR_BAND_UNKNOWN;

    limGetRfBand(pMac, &rfBand, psessionEntry);
    if(SIR_BAND_2_4_GHZ == rfBand)
    {
        pDot11f->present = 1;

        val  = psessionEntry->cfgProtection.fromllb;
        if(!val ){
            dot11fLog( pMac, LOG1, FL("11B protection not enabled. Not populating ERP IE %d" ),val );
            return eSIR_SUCCESS;
        }

        if (psessionEntry->gLim11bParams.protectionEnabled)
        {
            pDot11f->non_erp_present = 1;
            pDot11f->use_prot        = 1;
        }

        if ( psessionEntry->gLimOlbcParams.protectionEnabled )
        {
            //FIXME_PROTECTION: we should be setting non_erp present also.
            //check the test plan first.
            pDot11f->use_prot = 1;
        }


        if((psessionEntry->gLimNoShortParams.numNonShortPreambleSta) 
                 || !psessionEntry->beaconParams.fShortPreamble){ 
                pDot11f->barker_preamble = 1;
         
        }
        // if protection always flag is set, advertise protection enabled
        // regardless of legacy stations presence
        CFG_GET_INT( nSirStatus, pMac, WNI_CFG_11G_PROTECTION_ALWAYS, val );

        if ( val )
        {
            pDot11f->use_prot = 1;
        }
    }

    return eSIR_SUCCESS;
} // End PopulateDot11fERPInfo.

tSirRetStatus
PopulateDot11fExtSuppRates(tpAniSirGlobal pMac, tANI_U8 nChannelNum,
                           tDot11fIEExtSuppRates *pDot11f, 
                           tpPESession psessionEntry)
{
    tSirRetStatus nSirStatus;
    tANI_U32           nRates = 0;
    tANI_U8            rates[SIR_MAC_RATESET_EID_MAX];

   /* Use the ext rates present in session entry whenever nChannelNum is set to OPERATIONAL
       else use the ext supported rate set from CFG, which is fixed and does not change dynamically and is used for
       sending mgmt frames (lile probe req) which need to go out before any session is present.
   */
    if(POPULATE_DOT11F_RATES_OPERATIONAL == nChannelNum )
    {
        if(psessionEntry != NULL)
        {
            nRates = psessionEntry->extRateSet.numRates;
            vos_mem_copy( rates, psessionEntry->extRateSet.rate,
                          nRates);
        }
        else
        {
            dot11fLog( pMac, LOGE, FL("no session context exists while"
                        " populating Operational Rate Set"));
        }
    }
    else if ( HIGHEST_24GHZ_CHANNEL_NUM >= nChannelNum )
    {
        CFG_GET_STR( nSirStatus, pMac, WNI_CFG_EXTENDED_OPERATIONAL_RATE_SET,
                     rates, nRates, WNI_CFG_EXTENDED_OPERATIONAL_RATE_SET_LEN );
    }

    if ( 0 != nRates )
    {
        pDot11f->num_rates = ( tANI_U8 )nRates;
        vos_mem_copy( pDot11f->rates, rates, nRates );
        pDot11f->present   = 1;
    }

    return eSIR_SUCCESS;

} // End PopulateDot11fExtSuppRates.

tSirRetStatus
PopulateDot11fExtSuppRates1(tpAniSirGlobal         pMac,
                            tANI_U8                     nChannelNum,
                            tDot11fIEExtSuppRates *pDot11f)
{
    tANI_U32           nRates;
    tSirRetStatus nSirStatus;
    tANI_U8            rates[SIR_MAC_MAX_NUMBER_OF_RATES];

    if ( 14 < nChannelNum )
    {
        pDot11f->present = 0;
        return eSIR_SUCCESS;
    }

    // N.B. I have *no* idea why we're calling 'wlan_cfgGetStr' with an argument
    // of WNI_CFG_SUPPORTED_RATES_11A here, but that's what was done
    // previously & I'm afraid to change it!
    CFG_GET_STR( nSirStatus, pMac, WNI_CFG_SUPPORTED_RATES_11A,
                 rates, nRates, SIR_MAC_MAX_NUMBER_OF_RATES );

    if ( 0 != nRates )
    {
        pDot11f->num_rates = ( tANI_U8 ) nRates;
        vos_mem_copy( pDot11f->rates, rates, nRates );
        pDot11f->present   = 1;
    }

    return eSIR_SUCCESS;
} // PopulateDot11fExtSuppRates1.

tSirRetStatus
PopulateDot11fHTCaps(tpAniSirGlobal           pMac,
                           tpPESession      psessionEntry,
                           tDot11fIEHTCaps *pDot11f)
{
    tANI_U32                         nCfgValue, nCfgLen;
    tANI_U8                          nCfgValue8;
    tSirRetStatus                    nSirStatus;
    tSirMacHTParametersInfo         *pHTParametersInfo;
    union {
        tANI_U16                        nCfgValue16;
        tSirMacHTCapabilityInfo         htCapInfo;
        tSirMacExtendedHTCapabilityInfo extHtCapInfo;
    } uHTCapabilityInfo;

    tSirMacTxBFCapabilityInfo       *pTxBFCapabilityInfo;
    tSirMacASCapabilityInfo         *pASCapabilityInfo;

    CFG_GET_INT( nSirStatus, pMac, WNI_CFG_HT_CAP_INFO, nCfgValue );

    uHTCapabilityInfo.nCfgValue16 = nCfgValue & 0xFFFF;

    pDot11f->advCodingCap             = uHTCapabilityInfo.htCapInfo.advCodingCap;
    pDot11f->mimoPowerSave            = uHTCapabilityInfo.htCapInfo.mimoPowerSave;
    pDot11f->greenField               = uHTCapabilityInfo.htCapInfo.greenField;
    pDot11f->shortGI20MHz             = uHTCapabilityInfo.htCapInfo.shortGI20MHz;
    pDot11f->shortGI40MHz             = uHTCapabilityInfo.htCapInfo.shortGI40MHz;
    pDot11f->txSTBC                   = uHTCapabilityInfo.htCapInfo.txSTBC;
    pDot11f->rxSTBC                   = uHTCapabilityInfo.htCapInfo.rxSTBC;
    pDot11f->delayedBA                = uHTCapabilityInfo.htCapInfo.delayedBA;
    pDot11f->maximalAMSDUsize         = uHTCapabilityInfo.htCapInfo.maximalAMSDUsize;
    pDot11f->dsssCckMode40MHz         = uHTCapabilityInfo.htCapInfo.dsssCckMode40MHz;
    pDot11f->psmp                     = uHTCapabilityInfo.htCapInfo.psmp;
    pDot11f->stbcControlFrame         = uHTCapabilityInfo.htCapInfo.stbcControlFrame;
    pDot11f->lsigTXOPProtection       = uHTCapabilityInfo.htCapInfo.lsigTXOPProtection;

    // All sessionized entries will need the check below
    if (psessionEntry == NULL) // Only in case of NO session
    {
        pDot11f->supportedChannelWidthSet = uHTCapabilityInfo.htCapInfo.supportedChannelWidthSet;
    }
    else
    {
        pDot11f->supportedChannelWidthSet = psessionEntry->htSupportedChannelWidthSet;
    }

    /* Ensure that shortGI40MHz is Disabled if supportedChannelWidthSet is
       eHT_CHANNEL_WIDTH_20MHZ */
    if(pDot11f->supportedChannelWidthSet == eHT_CHANNEL_WIDTH_20MHZ)
    {
       pDot11f->shortGI40MHz = 0;
    }



    CFG_GET_INT( nSirStatus, pMac, WNI_CFG_HT_AMPDU_PARAMS, nCfgValue );

    nCfgValue8 = ( tANI_U8 ) nCfgValue;
    pHTParametersInfo = ( tSirMacHTParametersInfo* ) &nCfgValue8;

    pDot11f->maxRxAMPDUFactor = pHTParametersInfo->maxRxAMPDUFactor;
    pDot11f->mpduDensity      = pHTParametersInfo->mpduDensity;
    pDot11f->reserved1        = pHTParametersInfo->reserved;

    CFG_GET_STR( nSirStatus, pMac, WNI_CFG_SUPPORTED_MCS_SET,
                 pDot11f->supportedMCSSet, nCfgLen,
                 SIZE_OF_SUPPORTED_MCS_SET );


    CFG_GET_INT( nSirStatus, pMac, WNI_CFG_EXT_HT_CAP_INFO, nCfgValue );

    uHTCapabilityInfo.nCfgValue16 = nCfgValue & 0xFFFF;

    pDot11f->pco            = uHTCapabilityInfo.extHtCapInfo.pco;
    pDot11f->transitionTime = uHTCapabilityInfo.extHtCapInfo.transitionTime;
    pDot11f->mcsFeedback    = uHTCapabilityInfo.extHtCapInfo.mcsFeedback;


    CFG_GET_INT( nSirStatus, pMac, WNI_CFG_TX_BF_CAP, nCfgValue );

    pTxBFCapabilityInfo = ( tSirMacTxBFCapabilityInfo* ) &nCfgValue;
    pDot11f->txBF                                       = pTxBFCapabilityInfo->txBF;
    pDot11f->rxStaggeredSounding                        = pTxBFCapabilityInfo->rxStaggeredSounding;
    pDot11f->txStaggeredSounding                        = pTxBFCapabilityInfo->txStaggeredSounding;
    pDot11f->rxZLF                                      = pTxBFCapabilityInfo->rxZLF;
    pDot11f->txZLF                                      = pTxBFCapabilityInfo->txZLF;
    pDot11f->implicitTxBF                               = pTxBFCapabilityInfo->implicitTxBF;
    pDot11f->calibration                                = pTxBFCapabilityInfo->calibration;
    pDot11f->explicitCSITxBF                            = pTxBFCapabilityInfo->explicitCSITxBF;
    pDot11f->explicitUncompressedSteeringMatrix         = pTxBFCapabilityInfo->explicitUncompressedSteeringMatrix;
    pDot11f->explicitBFCSIFeedback                      = pTxBFCapabilityInfo->explicitBFCSIFeedback;
    pDot11f->explicitUncompressedSteeringMatrixFeedback = pTxBFCapabilityInfo->explicitUncompressedSteeringMatrixFeedback;
    pDot11f->explicitCompressedSteeringMatrixFeedback   = pTxBFCapabilityInfo->explicitCompressedSteeringMatrixFeedback;
    pDot11f->csiNumBFAntennae                           = pTxBFCapabilityInfo->csiNumBFAntennae;
    pDot11f->uncompressedSteeringMatrixBFAntennae       = pTxBFCapabilityInfo->uncompressedSteeringMatrixBFAntennae;
    pDot11f->compressedSteeringMatrixBFAntennae         = pTxBFCapabilityInfo->compressedSteeringMatrixBFAntennae;

    CFG_GET_INT( nSirStatus, pMac, WNI_CFG_AS_CAP, nCfgValue );

    nCfgValue8 = ( tANI_U8 ) nCfgValue;

    pASCapabilityInfo = ( tSirMacASCapabilityInfo* ) &nCfgValue8;
    pDot11f->antennaSelection         = pASCapabilityInfo->antennaSelection;
    pDot11f->explicitCSIFeedbackTx    = pASCapabilityInfo->explicitCSIFeedbackTx;
    pDot11f->antennaIndicesFeedbackTx = pASCapabilityInfo->antennaIndicesFeedbackTx;
    pDot11f->explicitCSIFeedback      = pASCapabilityInfo->explicitCSIFeedback;
    pDot11f->antennaIndicesFeedback   = pASCapabilityInfo->antennaIndicesFeedback;
    pDot11f->rxAS                     = pASCapabilityInfo->rxAS;
    pDot11f->txSoundingPPDUs          = pASCapabilityInfo->txSoundingPPDUs;

    pDot11f->present = 1;

    return eSIR_SUCCESS;

} // End PopulateDot11fHTCaps.
#ifdef WLAN_FEATURE_11AC

void limLogVHTCap(tpAniSirGlobal pMac,
                              tDot11fIEVHTCaps *pDot11f)
{
#ifdef DUMP_MGMT_CNTNTS
    limLog(pMac, LOG1, FL("maxMPDULen (2): %d"), pDot11f->maxMPDULen);
    limLog(pMac, LOG1, FL("supportedChannelWidthSet (2): %d"), pDot11f->supportedChannelWidthSet);
    limLog(pMac, LOG1, FL("ldpcCodingCap (1): %d"), pDot11f->ldpcCodingCap);
    limLog(pMac, LOG1, FL("shortGI80MHz (1): %d"), pDot11f->shortGI80MHz);
    limLog(pMac, LOG1, FL("shortGI160and80plus80MHz (1): %d"), pDot11f->shortGI160and80plus80MHz);
    limLog(pMac, LOG1, FL("txSTBC (1): %d"), pDot11f->txSTBC);
    limLog(pMac, LOG1, FL("rxSTBC (3): %d"), pDot11f->rxSTBC);
    limLog(pMac, LOG1, FL("suBeamFormerCap (1): %d"), pDot11f->suBeamFormerCap);
    limLog(pMac, LOG1, FL("suBeamformeeCap (1): %d"), pDot11f->suBeamformeeCap);
    limLog(pMac, LOG1, FL("csnofBeamformerAntSup (3): %d"), pDot11f->csnofBeamformerAntSup);
    limLog(pMac, LOG1, FL("numSoundingDim (3): %d"), pDot11f->numSoundingDim);
    limLog(pMac, LOG1, FL("muBeamformerCap (1): %d"), pDot11f->muBeamformerCap);
    limLog(pMac, LOG1, FL("muBeamformeeCap (1): %d"), pDot11f->muBeamformeeCap);
    limLog(pMac, LOG1, FL("vhtTXOPPS (1): %d"), pDot11f->vhtTXOPPS);
    limLog(pMac, LOG1, FL("htcVHTCap (1): %d"), pDot11f->htcVHTCap);
    limLog(pMac, LOG1, FL("maxAMPDULenExp (3): %d"), pDot11f->maxAMPDULenExp);
    limLog(pMac, LOG1, FL("vhtLinkAdaptCap (2): %d"), pDot11f->vhtLinkAdaptCap);
    limLog(pMac, LOG1, FL("rxAntPattern (1): %d"), pDot11f->vhtLinkAdaptCap);
    limLog(pMac, LOG1, FL("txAntPattern (1): %d"), pDot11f->vhtLinkAdaptCap);
    limLog(pMac, LOG1, FL("reserved1 (2): %d"), pDot11f->reserved1);
    limLog(pMac, LOG1, FL("rxMCSMap (16): %d"), pDot11f->rxMCSMap);
    limLog(pMac, LOG1, FL("rxHighSupDataRate (13): %d"), pDot11f->rxHighSupDataRate);
    limLog(pMac, LOG1, FL("reserve (3): %d"), pDot11f->reserved2);
    limLog(pMac, LOG1, FL("txMCSMap (16): %d"), pDot11f->txMCSMap);
    limLog(pMac, LOG1, FL("txSupDataRate (13): %d"), pDot11f->txSupDataRate);
    limLog(pMac, LOG1, FL("reserv (3): %d"), pDot11f->reserved3);
#endif /* DUMP_MGMT_CNTNTS */
}

void limLogVHTOperation(tpAniSirGlobal pMac,
                              tDot11fIEVHTOperation *pDot11f)
{
#ifdef DUMP_MGMT_CNTNTS
    limLog(pMac, LOG1, FL("chanWidth : %d"), pDot11f->chanWidth);
    limLog(pMac, LOG1, FL("chanCenterFreqSeg1: %d"), pDot11f->chanCenterFreqSeg1);
    limLog(pMac, LOG1, FL("chanCenterFreqSeg2: %d"), pDot11f->chanCenterFreqSeg2);
    limLog(pMac, LOG1, FL("basicMCSSet: %d"), pDot11f->basicMCSSet);
#endif /* DUMP_MGMT_CNTNTS */
}

void limLogVHTExtBssLoad(tpAniSirGlobal pMac,
                              tDot11fIEVHTExtBssLoad *pDot11f)
{
#ifdef DUMP_MGMT_CNTNTS
    limLog(pMac, LOG1, FL("muMIMOCapStaCount : %d"), pDot11f->muMIMOCapStaCount);
    limLog(pMac, LOG1, FL("ssUnderUtil: %d"), pDot11f->ssUnderUtil);
    limLog(pMac, LOG1, FL("FortyMHzUtil: %d"), pDot11f->FortyMHzUtil);
    limLog(pMac, LOG1, FL("EightyMHzUtil: %d"), pDot11f->EightyMHzUtil);
    limLog(pMac, LOG1, FL("OneSixtyMHzUtil: %d"), pDot11f->OneSixtyMHzUtil);
#endif /* DUMP_MGMT_CNTNTS */
}


void limLogOperatingMode( tpAniSirGlobal pMac, 
                               tDot11fIEOperatingMode *pDot11f)
{
#ifdef DUMP_MGMT_CNTNTS
    limLog(pMac, LOG1, FL("ChanWidth : %d"), pDot11f->chanWidth);
    limLog(pMac, LOG1, FL("reserved: %d"), pDot11f->reserved);
    limLog(pMac, LOG1, FL("rxNSS: %d"), pDot11f->rxNSS);
    limLog(pMac, LOG1, FL("rxNSS Type: %d"), pDot11f->rxNSSType);
#endif /* DUMP_MGMT_CNTNTS */
}

void limLogQosMapSet(tpAniSirGlobal pMac, tSirQosMapSet *pQosMapSet)
{
    tANI_U8 i;
    if (pQosMapSet->num_dscp_exceptions > 21)
        pQosMapSet->num_dscp_exceptions = 21;
    limLog(pMac, LOG1, FL("num of dscp exceptions : %d"),
                                   pQosMapSet->num_dscp_exceptions);
    for (i=0; i < pQosMapSet->num_dscp_exceptions; i++)
    {
        limLog(pMac, LOG1, FL("dscp value: %d"),
                                 pQosMapSet->dscp_exceptions[i][0]);
        limLog(pMac, LOG1, FL("User priority value: %d"),
                                 pQosMapSet->dscp_exceptions[i][1]);
    }
    for (i=0;i<8;i++)
    {
        limLog(pMac, LOG1, FL("dscp low for up %d: %d"),i,
                                      pQosMapSet->dscp_range[i][0]);
        limLog(pMac, LOG1, FL("dscp high for up %d: %d"),i,
                                      pQosMapSet->dscp_range[i][1]);
    }
}

tSirRetStatus
PopulateDot11fVHTCaps(tpAniSirGlobal           pMac,
                      tDot11fIEVHTCaps *pDot11f,
                      tANI_U8 nChannelNum,
                      tAniBool isProbeRspAssocRspBeacon)
{
    tSirRetStatus        nStatus;
    tANI_U32             nCfgValue=0;
    tAniBool             disableMcs9 = eSIR_FALSE;

    if (nChannelNum <= SIR_11B_CHANNEL_END)
        disableMcs9 =  pMac->roam.configParam.channelBondingMode24GHz?
                       eSIR_FALSE:eSIR_TRUE;
    else
        disableMcs9 =
            pMac->roam.configParam.channelBondingMode5GHz?
                                      eSIR_FALSE: eSIR_TRUE;
    pDot11f->present = 1;

    CFG_GET_INT( nStatus, pMac, WNI_CFG_VHT_MAX_MPDU_LENGTH, nCfgValue );
    pDot11f->maxMPDULen =  (nCfgValue & 0x0003);

    nCfgValue = 0;
    CFG_GET_INT( nStatus, pMac, WNI_CFG_VHT_SUPPORTED_CHAN_WIDTH_SET,
                                                             nCfgValue );
    pDot11f->supportedChannelWidthSet = (nCfgValue & 0x0003);

    nCfgValue = 0;
    CFG_GET_INT( nStatus, pMac, WNI_CFG_VHT_LDPC_CODING_CAP, nCfgValue );
    pDot11f->ldpcCodingCap = (nCfgValue & 0x0001);

    nCfgValue = 0;
    CFG_GET_INT( nStatus, pMac, WNI_CFG_VHT_SHORT_GI_80MHZ, nCfgValue );
    pDot11f->shortGI80MHz= (nCfgValue & 0x0001);

    nCfgValue = 0;
    CFG_GET_INT( nStatus, pMac, WNI_CFG_VHT_SHORT_GI_160_AND_80_PLUS_80MHZ,
                                                                nCfgValue );
    pDot11f->shortGI160and80plus80MHz = (nCfgValue & 0x0001);

    if (nChannelNum && (SIR_BAND_2_4_GHZ == limGetRFBand(nChannelNum)))
    {
        pDot11f->shortGI80MHz = 0;
        pDot11f->shortGI160and80plus80MHz = 0;
    }

    nCfgValue = 0;
    CFG_GET_INT( nStatus, pMac, WNI_CFG_VHT_TXSTBC, nCfgValue );
    pDot11f->txSTBC = (nCfgValue & 0x0001);

    nCfgValue = 0;
    CFG_GET_INT( nStatus, pMac, WNI_CFG_VHT_RXSTBC, nCfgValue );
    pDot11f->rxSTBC = (nCfgValue & 0x0007);

    nCfgValue = 0;
    CFG_GET_INT( nStatus, pMac, WNI_CFG_VHT_SU_BEAMFORMER_CAP, nCfgValue );
    pDot11f->suBeamFormerCap = (nCfgValue & 0x0001);

    nCfgValue = 0;
    CFG_GET_INT( nStatus, pMac, WNI_CFG_VHT_SU_BEAMFORMEE_CAP, nCfgValue );
    pDot11f->suBeamformeeCap = (nCfgValue & 0x0001);

    nCfgValue = 0;
    CFG_GET_INT( nStatus, pMac, WNI_CFG_VHT_CSN_BEAMFORMEE_ANT_SUPPORTED,
                                                               nCfgValue );
    pDot11f->csnofBeamformerAntSup = (nCfgValue & 0x0007);

    nCfgValue = 0;
    CFG_GET_INT( nStatus, pMac, WNI_CFG_VHT_NUM_SOUNDING_DIMENSIONS,
                                                               nCfgValue );
    pDot11f->numSoundingDim = (nCfgValue & 0x0007);

    /* muBeamformerCap should be 0 for non AP and
     * muBeamformeeCap should be 0 for AP
     */
    if(eSIR_TRUE == isProbeRspAssocRspBeacon)
    {
       nCfgValue = 0;
       CFG_GET_INT( nStatus, pMac, WNI_CFG_VHT_MU_BEAMFORMER_CAP, nCfgValue );
       pDot11f->muBeamformerCap = (nCfgValue & 0x0001);
       pDot11f->muBeamformeeCap = 0;
    }
    else
    {
       pDot11f->muBeamformerCap = 0;
       nCfgValue = 0;
       CFG_GET_INT( nStatus, pMac, WNI_CFG_VHT_MU_BEAMFORMEE_CAP, nCfgValue );
       /* Enable only if FW and host both support the MU_MIMO feature
        */
       pDot11f->muBeamformeeCap = IS_MUMIMO_BFORMEE_CAPABLE ? (nCfgValue & 0x0001): 0;
    }

    nCfgValue = 0;
    CFG_GET_INT( nStatus, pMac, WNI_CFG_VHT_TXOP_PS, nCfgValue );
    pDot11f->vhtTXOPPS = (nCfgValue & 0x0001);

    nCfgValue = 0;
    CFG_GET_INT( nStatus, pMac, WNI_CFG_VHT_HTC_VHTC_CAP, nCfgValue );
    pDot11f->htcVHTCap = (nCfgValue & 0x0001);

    nCfgValue = 0;
    CFG_GET_INT( nStatus, pMac, WNI_CFG_VHT_AMPDU_LEN_EXPONENT, nCfgValue );
    pDot11f->maxAMPDULenExp = (nCfgValue & 0x0007);

    nCfgValue = 0;
    CFG_GET_INT( nStatus, pMac, WNI_CFG_VHT_LINK_ADAPTATION_CAP, nCfgValue );
    pDot11f->vhtLinkAdaptCap = (nCfgValue & 0x0003);

    nCfgValue = 0;
    CFG_GET_INT( nStatus, pMac, WNI_CFG_VHT_RX_ANT_PATTERN, nCfgValue );
    pDot11f->rxAntPattern = nCfgValue;

    nCfgValue = 0;
    CFG_GET_INT( nStatus, pMac, WNI_CFG_VHT_TX_ANT_PATTERN, nCfgValue );
    pDot11f->txAntPattern = nCfgValue;

    pDot11f->reserved1= 0;

    nCfgValue = 0;
    CFG_GET_INT( nStatus, pMac, WNI_CFG_VHT_RX_MCS_MAP, nCfgValue );

    if (eSIR_TRUE == disableMcs9)
       nCfgValue = (nCfgValue & 0xFFFC) | 0x1;
    pDot11f->rxMCSMap = (nCfgValue & 0x0000FFFF);

    nCfgValue = 0;
    CFG_GET_INT( nStatus, pMac, WNI_CFG_VHT_RX_HIGHEST_SUPPORTED_DATA_RATE,
                                                                  nCfgValue );
    pDot11f->rxHighSupDataRate = (nCfgValue & 0x00001FFF);

    pDot11f->reserved2= 0;

    nCfgValue = 0;
    CFG_GET_INT( nStatus, pMac, WNI_CFG_VHT_TX_MCS_MAP, nCfgValue );

    if (eSIR_TRUE == disableMcs9)
       nCfgValue = (nCfgValue & 0xFFFC) | 0x1;
    pDot11f->txMCSMap = (nCfgValue & 0x0000FFFF);

    nCfgValue = 0;
    CFG_GET_INT( nStatus, pMac, WNI_CFG_VHT_TX_HIGHEST_SUPPORTED_DATA_RATE,
                                                                  nCfgValue );
    pDot11f->txSupDataRate = (nCfgValue & 0x00001FFF);

    pDot11f->reserved3= 0;

    limLogVHTCap(pMac, pDot11f);

    return eSIR_SUCCESS;

}

tSirRetStatus
PopulateDot11fVHTOperation(tpAniSirGlobal   pMac,
                               tDot11fIEVHTOperation  *pDot11f,
                               tANI_U8 nChannelNum)
{
    tSirRetStatus        nStatus;
    tANI_U32             nCfgValue=0;
    tAniBool             disableMcs9 = eSIR_FALSE;

    if (nChannelNum <= SIR_11B_CHANNEL_END)
        disableMcs9 =  pMac->roam.configParam.channelBondingMode24GHz?
                       eSIR_FALSE:eSIR_TRUE;
    else
        disableMcs9 =
            pMac->roam.configParam.channelBondingMode5GHz?
                                      eSIR_FALSE: eSIR_TRUE;

    pDot11f->present = 1;

    CFG_GET_INT( nStatus, pMac, WNI_CFG_VHT_CHANNEL_WIDTH, nCfgValue );
    pDot11f->chanWidth = (tANI_U8)nCfgValue;

    nCfgValue = 0;
    CFG_GET_INT( nStatus, pMac, WNI_CFG_VHT_CHANNEL_CENTER_FREQ_SEGMENT1,
                                                               nCfgValue );
    pDot11f->chanCenterFreqSeg1 = (tANI_U8)nCfgValue;

    nCfgValue = 0;
    CFG_GET_INT( nStatus, pMac, WNI_CFG_VHT_CHANNEL_CENTER_FREQ_SEGMENT2,
                                                               nCfgValue );
    pDot11f->chanCenterFreqSeg2 = (tANI_U8)nCfgValue;

    nCfgValue = 0;
    CFG_GET_INT( nStatus, pMac, WNI_CFG_VHT_BASIC_MCS_SET,nCfgValue );

    if (eSIR_TRUE == disableMcs9)
       nCfgValue = (nCfgValue & 0xFFFC) | 0x1;
    pDot11f->basicMCSSet = (tANI_U16)nCfgValue;

    limLogVHTOperation(pMac,pDot11f);

    return eSIR_SUCCESS;

}

tSirRetStatus
PopulateDot11fVHTExtBssLoad(tpAniSirGlobal      pMac,
                           tDot11fIEVHTExtBssLoad   *pDot11f)
{
    tSirRetStatus    nStatus;
    tANI_U32         nCfgValue=0;

    pDot11f->present = 1;

    CFG_GET_INT( nStatus, pMac, WNI_CFG_VHT_MU_MIMO_CAP_STA_COUNT,
                                                         nCfgValue );
    pDot11f->muMIMOCapStaCount = (tANI_U8)nCfgValue;

    nCfgValue = 0;
    CFG_GET_INT( nStatus, pMac, WNI_CFG_VHT_SS_UNDER_UTIL,nCfgValue );
    pDot11f->ssUnderUtil = (tANI_U8)nCfgValue;

    nCfgValue=0;
    CFG_GET_INT( nStatus, pMac, WNI_CFG_VHT_40MHZ_UTILIZATION,nCfgValue );
    pDot11f->FortyMHzUtil = (tANI_U8)nCfgValue;

    nCfgValue=0;
    CFG_GET_INT( nStatus, pMac, WNI_CFG_VHT_80MHZ_UTILIZATION,nCfgValue );
    pDot11f->EightyMHzUtil = (tANI_U8)nCfgValue;

    nCfgValue=0;
    CFG_GET_INT( nStatus, pMac, WNI_CFG_VHT_160MHZ_UTILIZATION,nCfgValue );
    pDot11f->EightyMHzUtil = (tANI_U8)nCfgValue;

    limLogVHTExtBssLoad(pMac,pDot11f);

    return eSIR_SUCCESS;
}

#ifdef WLAN_FEATURE_AP_HT40_24G
tSirRetStatus
PopulateDot11fOBSSScanParameters(tpAniSirGlobal pMac,
                                 tDot11fIEOBSSScanParameters *pDot11f,
                                 tpPESession psessionEntry)
{
    pDot11f->present = 1;

    pDot11f->obssScanPassiveDwell =
          psessionEntry->obssHT40ScanParam.OBSSScanPassiveDwellTime;

    pDot11f->obssScanActiveDwell =
          psessionEntry->obssHT40ScanParam.OBSSScanActiveDwellTime;

    pDot11f->bssChannelWidthTriggerScanInterval =
          psessionEntry->obssHT40ScanParam.BSSChannelWidthTriggerScanInterval;

    pDot11f->obssScanPassiveTotalPerChannel =
          psessionEntry->obssHT40ScanParam.OBSSScanPassiveTotalPerChannel;

    pDot11f->obssScanActiveTotalPerChannel =
          psessionEntry->obssHT40ScanParam.OBSSScanActiveTotalPerChannel;

    pDot11f->bssWidthChannelTransitionDelayFactor =
          psessionEntry->obssHT40ScanParam.BSSWidthChannelTransitionDelayFactor;

    pDot11f->obssScanActivityThreshold =
          psessionEntry->obssHT40ScanParam.OBSSScanActivityThreshold;

    return eSIR_SUCCESS;
}
#endif

tSirRetStatus
PopulateDot11fExtCap(tpAniSirGlobal      pMac,
                           tDot11fIEExtCap  *pDot11f,
                           tpPESession   psessionEntry)
{
     struct s_ext_cap *p_ext_cap = (struct s_ext_cap *)pDot11f->bytes;

#ifdef WLAN_FEATURE_11AC
    if (psessionEntry->vhtCapability &&
        psessionEntry->limSystemRole != eLIM_STA_IN_IBSS_ROLE )
    {
        p_ext_cap->operModeNotification = 1;
        pDot11f->present = 1;
    }
#endif
       /* while operating in 2.4GHz only then STA need to advertize
               the bss co-ex capability*/
    if (psessionEntry->currentOperChannel <= RF_CHAN_14)
    {
#ifdef WLAN_FEATURE_AP_HT40_24G
       if(((IS_HT40_OBSS_SCAN_FEATURE_ENABLE)
         && pMac->roam.configParam.channelBondingMode24GHz)
         || pMac->roam.configParam.apHT40_24GEnabled)
#else
       if((IS_HT40_OBSS_SCAN_FEATURE_ENABLE)
         && pMac->roam.configParam.channelBondingMode24GHz)
#endif
       {
           p_ext_cap->bssCoexistMgmtSupport = 1;
           pDot11f->present = 1;
       }
    }

    p_ext_cap->fils_capability = 0;

    if (pDot11f->present)
    {
        /* Need to compute the num_bytes based on bits set */
        pDot11f->num_bytes = lim_compute_ext_cap_ie_length(pDot11f);
    }
    return eSIR_SUCCESS;
}

tSirRetStatus
PopulateDot11fOperatingMode(tpAniSirGlobal      pMac,
                           tDot11fIEOperatingMode  *pDot11f,
                           tpPESession   psessionEntry)
{
    pDot11f->present = 1;
    
    pDot11f->chanWidth = psessionEntry->gLimOperatingMode.chanWidth;
    pDot11f->rxNSS = psessionEntry->gLimOperatingMode.rxNSS;
    pDot11f->rxNSSType = psessionEntry->gLimOperatingMode.rxNSSType;
    
    return eSIR_SUCCESS;
}

#endif
tSirRetStatus
PopulateDot11fHTInfo(tpAniSirGlobal   pMac,
                     tDot11fIEHTInfo *pDot11f,
                     tpPESession      psessionEntry )
{
    tANI_U32             nCfgValue, nCfgLen;
    tANI_U8              htInfoField1;
    tANI_U16            htInfoField2;
    tSirRetStatus        nSirStatus;
    tSirMacHTInfoField1 *pHTInfoField1;
    tSirMacHTInfoField2 *pHTInfoField2;
    union {
        tANI_U16         nCfgValue16;
        tSirMacHTInfoField3 infoField3;
    }uHTInfoField;
    union {
        tANI_U16         nCfgValue16;
        tSirMacHTInfoField2 infoField2;
    }uHTInfoField2={0};


    #if 0
    CFG_GET_INT( nSirStatus, pMac, WNI_CFG_CURRENT_CHANNEL, nCfgValue );
    #endif // TO SUPPORT BT-AMP

    if (NULL == psessionEntry)
    {
        PELOGE(limLog(pMac, LOG1,
                FL("Invalid session entry in PopulateDot11fHTInfo()"));)
        return eSIR_FAILURE;
    }

    pDot11f->primaryChannel = psessionEntry->currentOperChannel;

    CFG_GET_INT( nSirStatus, pMac, WNI_CFG_HT_INFO_FIELD1, nCfgValue );

    htInfoField1 = ( tANI_U8 ) nCfgValue;

    pHTInfoField1 = ( tSirMacHTInfoField1* ) &htInfoField1;
    pHTInfoField1->rifsMode                   = psessionEntry->beaconParams.fRIFSMode;
    pHTInfoField1->serviceIntervalGranularity = pMac->lim.gHTServiceIntervalGranularity;

    if (psessionEntry == NULL)
    {
        PELOGE(limLog(pMac, LOG1,
            FL("Keep the value retrieved from cfg for secondary channel offset and recommended Tx Width set"));)
    }
    else
    {
        pHTInfoField1->secondaryChannelOffset     = psessionEntry->htSecondaryChannelOffset;
        pHTInfoField1->recommendedTxWidthSet      = psessionEntry->htRecommendedTxWidthSet;
    }

    if((psessionEntry) && (psessionEntry->limSystemRole == eLIM_AP_ROLE)){
    CFG_GET_INT( nSirStatus, pMac, WNI_CFG_HT_INFO_FIELD2, nCfgValue );

    uHTInfoField2.nCfgValue16 = nCfgValue & 0xFFFF; // this is added for fixing CRs on MDM9K platform - 257951, 259577

    uHTInfoField2.infoField2.opMode   =  psessionEntry->htOperMode;
    uHTInfoField2.infoField2.nonGFDevicesPresent = psessionEntry->beaconParams.llnNonGFCoexist;
    uHTInfoField2.infoField2.obssNonHTStaPresent = psessionEntry->beaconParams.gHTObssMode;   /*added for Obss  */

    uHTInfoField2.infoField2.reserved = 0;

   }else{
        CFG_GET_INT( nSirStatus, pMac, WNI_CFG_HT_INFO_FIELD2, nCfgValue );

        htInfoField2 = ( tANI_U16 ) nCfgValue;

        pHTInfoField2 = ( tSirMacHTInfoField2* ) &htInfoField2;
        pHTInfoField2->opMode   = pMac->lim.gHTOperMode;
        pHTInfoField2->nonGFDevicesPresent = pMac->lim.gHTNonGFDevicesPresent;
        pHTInfoField2->obssNonHTStaPresent = pMac->lim.gHTObssMode;   /*added for Obss  */

        pHTInfoField2->reserved = 0;
    }

    CFG_GET_INT( nSirStatus, pMac, WNI_CFG_HT_INFO_FIELD3, nCfgValue );


    uHTInfoField.nCfgValue16 = nCfgValue & 0xFFFF;


    uHTInfoField.infoField3.basicSTBCMCS                  = pMac->lim.gHTSTBCBasicMCS;
    uHTInfoField.infoField3.dualCTSProtection             = pMac->lim.gHTDualCTSProtection;
    uHTInfoField.infoField3.secondaryBeacon               = pMac->lim.gHTSecondaryBeacon;
    uHTInfoField.infoField3.lsigTXOPProtectionFullSupport = psessionEntry->beaconParams.fLsigTXOPProtectionFullSupport;
    uHTInfoField.infoField3.pcoActive                     = pMac->lim.gHTPCOActive;
    uHTInfoField.infoField3.pcoPhase                      = pMac->lim.gHTPCOPhase;
    uHTInfoField.infoField3.reserved                      = 0;


    pDot11f->secondaryChannelOffset        = pHTInfoField1->secondaryChannelOffset;
    pDot11f->recommendedTxWidthSet         = pHTInfoField1->recommendedTxWidthSet;
    pDot11f->rifsMode                      = pHTInfoField1->rifsMode;
    pDot11f->controlledAccessOnly          = pHTInfoField1->controlledAccessOnly;
    pDot11f->serviceIntervalGranularity    = pHTInfoField1->serviceIntervalGranularity;

    pDot11f->opMode                        = uHTInfoField2.infoField2.opMode;
    pDot11f->nonGFDevicesPresent           = uHTInfoField2.infoField2.nonGFDevicesPresent;
    pDot11f->obssNonHTStaPresent           = uHTInfoField2.infoField2.obssNonHTStaPresent;
    pDot11f->reserved                      = uHTInfoField2.infoField2.reserved;


    pDot11f->basicSTBCMCS                  = uHTInfoField.infoField3.basicSTBCMCS;
    pDot11f->dualCTSProtection             = uHTInfoField.infoField3.dualCTSProtection;
    pDot11f->secondaryBeacon               = uHTInfoField.infoField3.secondaryBeacon;
    pDot11f->lsigTXOPProtectionFullSupport = uHTInfoField.infoField3.lsigTXOPProtectionFullSupport;
    pDot11f->pcoActive                     = uHTInfoField.infoField3.pcoActive;
    pDot11f->pcoPhase                      = uHTInfoField.infoField3.pcoPhase;
    pDot11f->reserved2                     = uHTInfoField.infoField3.reserved;
    CFG_GET_STR( nSirStatus, pMac, WNI_CFG_BASIC_MCS_SET,
                 pDot11f->basicMCSSet, nCfgLen,
                 SIZE_OF_BASIC_MCS_SET );

    pDot11f->present = 1;

    return eSIR_SUCCESS;

} // End PopulateDot11fHTInfo.

void
PopulateDot11fIBSSParams(tpAniSirGlobal       pMac,
       tDot11fIEIBSSParams *pDot11f, tpPESession psessionEntry)
{
    if ( eLIM_STA_IN_IBSS_ROLE == psessionEntry->limSystemRole )
    {
        pDot11f->present = 1;
        // ATIM duration is always set to 0
        pDot11f->atim = 0;
    }

} // End PopulateDot11fIBSSParams.


#ifdef ANI_SUPPORT_11H
tSirRetStatus
PopulateDot11fMeasurementReport0(tpAniSirGlobal              pMac,
                                 tpSirMacMeasReqActionFrame  pReq,
                                 tDot11fIEMeasurementReport *pDot11f)
{
    pDot11f->token     = pReq->measReqIE.measToken;
    pDot11f->late      = 0;
    pDot11f->incapable = 0;
    pDot11f->refused   = 1;
    pDot11f->type      = SIR_MAC_BASIC_MEASUREMENT_TYPE;

    pDot11f->present   = 1;

    return eSIR_SUCCESS;

} // End PopulatedDot11fMeasurementReport0.

tSirRetStatus
PopulateDot11fMeasurementReport1(tpAniSirGlobal              pMac,
                                  tpSirMacMeasReqActionFrame  pReq,
                                  tDot11fIEMeasurementReport *pDot11f)
{
    pDot11f->token     = pReq->measReqIE.measToken;
    pDot11f->late      = 0;
    pDot11f->incapable = 0;
    pDot11f->refused   = 1;
    pDot11f->type      = SIR_MAC_CCA_MEASUREMENT_TYPE;

    pDot11f->present   = 1;

    return eSIR_SUCCESS;

} // End PopulatedDot11fMeasurementReport1.

tSirRetStatus
PopulateDot11fMeasurementReport2(tpAniSirGlobal              pMac,
                                 tpSirMacMeasReqActionFrame  pReq,
                                 tDot11fIEMeasurementReport *pDot11f)
{
    pDot11f->token     = pReq->measReqIE.measToken;
    pDot11f->late      = 0;
    pDot11f->incapable = 0;
    pDot11f->refused   = 1;
    pDot11f->type      = SIR_MAC_RPI_MEASUREMENT_TYPE;

    pDot11f->present   = 1;

    return eSIR_SUCCESS;

} // End PopulatedDot11fMeasurementReport2.
#endif

void
PopulateDot11fPowerCaps(tpAniSirGlobal      pMac,
                        tDot11fIEPowerCaps *pCaps,
                        tANI_U8 nAssocType,
                        tpPESession psessionEntry)
{
    if (nAssocType == LIM_REASSOC)
    {
        pCaps->minTxPower = psessionEntry->pLimReAssocReq->powerCap.minTxPower;
        pCaps->maxTxPower = psessionEntry->pLimReAssocReq->powerCap.maxTxPower;
    }else
    {
        pCaps->minTxPower = psessionEntry->pLimJoinReq->powerCap.minTxPower;
        pCaps->maxTxPower = psessionEntry->pLimJoinReq->powerCap.maxTxPower;

    }
    
    pCaps->present    = 1;
} // End PopulateDot11fPowerCaps.

tSirRetStatus
PopulateDot11fPowerConstraints(tpAniSirGlobal             pMac,
                               tDot11fIEPowerConstraints *pDot11f)
{
    tANI_U32           cfg;
    tSirRetStatus nSirStatus;

    CFG_GET_INT( nSirStatus, pMac, WNI_CFG_LOCAL_POWER_CONSTRAINT, cfg );

    pDot11f->localPowerConstraints = ( tANI_U8 )cfg;
    pDot11f->present = 1;

    return eSIR_SUCCESS;
} // End PopulateDot11fPowerConstraints.

void
PopulateDot11fQOSCapsAp(tpAniSirGlobal      pMac,
                        tDot11fIEQOSCapsAp *pDot11f, tpPESession psessionEntry)
{
    pDot11f->count    = psessionEntry->gLimEdcaParamSetCount;
    pDot11f->reserved = 0;
    pDot11f->txopreq  = 0;
    pDot11f->qreq     = 0;
    pDot11f->qack     = 0;
    pDot11f->present  = 1;
} // End PopulatedDot11fQOSCaps.

void
PopulateDot11fQOSCapsStation(tpAniSirGlobal    pMac,
                      tDot11fIEQOSCapsStation *pDot11f)
{
    tANI_U32  val = 0;

    if(wlan_cfgGetInt(pMac, WNI_CFG_MAX_SP_LENGTH, &val) != eSIR_SUCCESS) 
        PELOGE(limLog(pMac, LOGE, FL("could not retrieve Max SP Length "));)
   
    pDot11f->more_data_ack = 0;
    pDot11f->max_sp_length = (tANI_U8)val;
    pDot11f->qack    = 0;

    if (pMac->lim.gUapsdEnable)
    {
        pDot11f->acbe_uapsd = LIM_UAPSD_GET(ACBE, pMac->lim.gUapsdPerAcBitmask);
        pDot11f->acbk_uapsd = LIM_UAPSD_GET(ACBK, pMac->lim.gUapsdPerAcBitmask);
        pDot11f->acvi_uapsd = LIM_UAPSD_GET(ACVI, pMac->lim.gUapsdPerAcBitmask);
        pDot11f->acvo_uapsd = LIM_UAPSD_GET(ACVO, pMac->lim.gUapsdPerAcBitmask);
    }   
    pDot11f->present = 1;
} // End PopulatedDot11fQOSCaps.

tSirRetStatus
PopulateDot11fRSN(tpAniSirGlobal  pMac,
                  tpSirRSNie      pRsnIe,
                  tDot11fIERSN   *pDot11f)
{
    tANI_U32        status;
    int  idx;

    if ( pRsnIe->length )
    {
        if( 0 <= ( idx = FindIELocation( pMac, pRsnIe, DOT11F_EID_RSN ) ) )
            {
        status = dot11fUnpackIeRSN( pMac,
                                    pRsnIe->rsnIEdata + idx + 2, //EID, length
                                    pRsnIe->rsnIEdata[ idx + 1 ],
                                    pDot11f );
        if (!DOT11F_SUCCEEDED(status))
        {
            dot11fLog( pMac, LOGE, FL("Parse failure in PopulateDot11fRS"
                                   "N (0x%08x)."),
                    status );
            return eSIR_FAILURE;
        }
        dot11fLog( pMac, LOG2, FL("dot11fUnpackIeRSN returned 0x%08x in "
                               "PopulateDot11fRSN."), status );
        }

    }

    return eSIR_SUCCESS;
} // End PopulateDot11fRSN.

tSirRetStatus PopulateDot11fRSNOpaque( tpAniSirGlobal      pMac,
                                       tpSirRSNie          pRsnIe,
                                       tDot11fIERSNOpaque *pDot11f )
{
    int idx;

    if ( pRsnIe->length )
    {
        if( 0 <= ( idx = FindIELocation( pMac, pRsnIe, DOT11F_EID_RSN ) ) )
        {
            pDot11f->present  = 1;
            pDot11f->num_data = pRsnIe->rsnIEdata[ idx + 1 ];
            vos_mem_copy(  pDot11f->data,
                           pRsnIe->rsnIEdata + idx + 2,    // EID, len
                           pRsnIe->rsnIEdata[ idx + 1 ] );
        }
    }

    return eSIR_SUCCESS;

} // End PopulateDot11fRSNOpaque.



#if defined(FEATURE_WLAN_WAPI)

tSirRetStatus
PopulateDot11fWAPI(tpAniSirGlobal  pMac,
                  tpSirRSNie      pRsnIe,
                  tDot11fIEWAPI   *pDot11f)
        {
    tANI_U32        status;
    int  idx;

    if ( pRsnIe->length )
        {
        if( 0 <= ( idx = FindIELocation( pMac, pRsnIe, DOT11F_EID_WAPI ) ) )
        {
            status = dot11fUnpackIeWAPI( pMac,
                                        pRsnIe->rsnIEdata + idx + 2, //EID, length
                                        pRsnIe->rsnIEdata[ idx + 1 ],
                                        pDot11f );
            if ( DOT11F_FAILED( status ) )
            {
                dot11fLog( pMac, LOGE, FL("Parse failure in PopulateDot11fWAPI (0x%08x)."),
                        status );
                return eSIR_FAILURE;
            }
            dot11fLog( pMac, LOG2, FL("dot11fUnpackIeRSN returned 0x%08x in "
                               "PopulateDot11fWAPI."), status );
        }
    }

    return eSIR_SUCCESS;
} // End PopulateDot11fWAPI.

tSirRetStatus PopulateDot11fWAPIOpaque( tpAniSirGlobal      pMac,
                                       tpSirRSNie          pRsnIe,
                                       tDot11fIEWAPIOpaque *pDot11f )
{
    int idx;

    if ( pRsnIe->length )
    {
        if( 0 <= ( idx = FindIELocation( pMac, pRsnIe, DOT11F_EID_WAPI ) ) )
        {
        pDot11f->present  = 1;
        pDot11f->num_data = pRsnIe->rsnIEdata[ idx + 1 ];
        vos_mem_copy ( pDot11f->data,
                       pRsnIe->rsnIEdata + idx + 2,    // EID, len
                       pRsnIe->rsnIEdata[ idx + 1 ] );
    }
    }

    return eSIR_SUCCESS;

} // End PopulateDot11fWAPIOpaque.


#endif //defined(FEATURE_WLAN_WAPI)

void
PopulateDot11fSSID(tpAniSirGlobal pMac,
                   tSirMacSSid   *pInternal,
                   tDot11fIESSID *pDot11f)
{
    pDot11f->present = 1;
    pDot11f->num_ssid = pInternal->length;
    if ( pInternal->length )
    {
        vos_mem_copy( ( tANI_U8* )pDot11f->ssid, ( tANI_U8* )&pInternal->ssId,
                       pInternal->length );
    }
} // End PopulateDot11fSSID.

tSirRetStatus
PopulateDot11fSSID2(tpAniSirGlobal pMac,
                    tDot11fIESSID *pDot11f)
{
    tANI_U32           nCfg;
    tSirRetStatus nSirStatus;

    CFG_GET_STR( nSirStatus, pMac, WNI_CFG_SSID, pDot11f->ssid, nCfg, 32 );
    pDot11f->num_ssid = ( tANI_U8 )nCfg;
    pDot11f->present  = 1;
    return eSIR_SUCCESS;
} // End PopulateDot11fSSID2.

void
PopulateDot11fSchedule(tSirMacScheduleIE *pSchedule,
                       tDot11fIESchedule *pDot11f)
{
    pDot11f->aggregation        = pSchedule->info.aggregation;
    pDot11f->tsid               = pSchedule->info.tsid;
    pDot11f->direction          = pSchedule->info.direction;
    pDot11f->reserved           = pSchedule->info.rsvd;
    pDot11f->service_start_time = pSchedule->svcStartTime;
    pDot11f->service_interval   = pSchedule->svcInterval;
    pDot11f->max_service_dur    = pSchedule->maxSvcDuration;
    pDot11f->spec_interval      = pSchedule->specInterval;

    pDot11f->present = 1;
} // End PopulateDot11fSchedule.

void
PopulateDot11fSuppChannels(tpAniSirGlobal         pMac,
                           tDot11fIESuppChannels *pDot11f,
                           tANI_U8 nAssocType,
                           tpPESession psessionEntry)
{
    tANI_U8  i;
    tANI_U8 *p;

    if (nAssocType == LIM_REASSOC)
    {
        p = ( tANI_U8* )psessionEntry->pLimReAssocReq->supportedChannels.channelList;
        pDot11f->num_bands = psessionEntry->pLimReAssocReq->supportedChannels.numChnl;
    }else
    {
        p = ( tANI_U8* )psessionEntry->pLimJoinReq->supportedChannels.channelList;
        pDot11f->num_bands = psessionEntry->pLimJoinReq->supportedChannels.numChnl;
    }
    for ( i = 0U; i < pDot11f->num_bands; ++i, ++p)
    {
        pDot11f->bands[i][0] = *p;
        pDot11f->bands[i][1] = 1;
    }

    pDot11f->present = 1;

} // End PopulateDot11fSuppChannels.

tSirRetStatus
PopulateDot11fSuppRates(tpAniSirGlobal      pMac,
                        tANI_U8                  nChannelNum,
                        tDot11fIESuppRates *pDot11f,tpPESession psessionEntry)
{
    tSirRetStatus nSirStatus;
    tANI_U32           nRates;
    tANI_U8            rates[SIR_MAC_MAX_NUMBER_OF_RATES];

   /* Use the operational rates present in session entry whenever nChannelNum is set to OPERATIONAL
       else use the supported rate set from CFG, which is fixed and does not change dynamically and is used for
       sending mgmt frames (lile probe req) which need to go out before any session is present.
   */
    if(POPULATE_DOT11F_RATES_OPERATIONAL == nChannelNum )
    {
        #if 0
        CFG_GET_STR( nSirStatus, pMac, WNI_CFG_OPERATIONAL_RATE_SET,
                     rates, nRates, SIR_MAC_MAX_NUMBER_OF_RATES );
        #endif //TO SUPPORT BT-AMP
        if(psessionEntry != NULL)
        {
            nRates = psessionEntry->rateSet.numRates;
            vos_mem_copy( rates, psessionEntry->rateSet.rate,
                          nRates);
        }
        else
        {
            dot11fLog( pMac, LOGE, FL("no session context exists while populating Operational Rate Set"));
            nRates = 0;
        }
    }
    else if ( 14 >= nChannelNum )
    {
        CFG_GET_STR( nSirStatus, pMac, WNI_CFG_SUPPORTED_RATES_11B,
                     rates, nRates, SIR_MAC_MAX_NUMBER_OF_RATES );
    }
    else
    {
        CFG_GET_STR( nSirStatus, pMac, WNI_CFG_SUPPORTED_RATES_11A,
                     rates, nRates, SIR_MAC_MAX_NUMBER_OF_RATES );
    }

    if ( 0 != nRates )
    {
        pDot11f->num_rates = ( tANI_U8 )nRates;
        vos_mem_copy( pDot11f->rates, rates, nRates );
        pDot11f->present   = 1;
    }

    return eSIR_SUCCESS;

} // End PopulateDot11fSuppRates.

/**
 * PopulateDot11fRatesTdls() - populate supported rates and
 *                                extended supported rates IE.
 * @p_mac gloabl - header.
 * @p_supp_rates - pointer to supported rates IE
 * @p_ext_supp_rates - pointer to extended supported rates IE
 *
 * This function populates the supported rates and extended supported
 * rates IE based in the STA capability. If the number of rates
 * supported is less than MAX_NUM_SUPPORTED_RATES, only supported rates
 * IE is populated.
 *
 * Return: tSirRetStatus eSIR_SUCCESS on Success and eSIR_FAILURE
 *         on failure.
 */

tSirRetStatus
PopulateDot11fRatesTdls(tpAniSirGlobal p_mac,
                           tDot11fIESuppRates *p_supp_rates,
                           tDot11fIEExtSuppRates *p_ext_supp_rates,
                           tANI_U8 curr_oper_channel)
{
    tSirMacRateSet temp_rateset;
    tSirMacRateSet temp_rateset2;
    uint32_t val, i;
    uint32_t self_dot11mode = 0;

    wlan_cfgGetInt(p_mac, WNI_CFG_DOT11_MODE, &self_dot11mode);

    /**
     * Include 11b rates only when the device configured
     * in auto, 11a/b/g or 11b_only and also if current base
     * channel is 5 GHz then no need to advertise the 11b rates.
     * If devices to move 2.4GHz off-channel then they can communicate
     * in 11g rates i.e. (6, 9, 12, 18, 24, 36 and 54).
     */
    limLog(p_mac, LOG1, FL("Current operating channel %d self_dot11mode = %d"),
           curr_oper_channel, self_dot11mode);

    if ((curr_oper_channel <= SIR_11B_CHANNEL_END) &&
        ((self_dot11mode == WNI_CFG_DOT11_MODE_ALL) ||
        (self_dot11mode == WNI_CFG_DOT11_MODE_11A) ||
        (self_dot11mode == WNI_CFG_DOT11_MODE_11AC) ||
        (self_dot11mode == WNI_CFG_DOT11_MODE_11N) ||
        (self_dot11mode == WNI_CFG_DOT11_MODE_11G) ||
        (self_dot11mode == WNI_CFG_DOT11_MODE_11B)))
    {
            val = WNI_CFG_SUPPORTED_RATES_11B_LEN;
            wlan_cfgGetStr(p_mac, WNI_CFG_SUPPORTED_RATES_11B,
                            (tANI_U8 *)&temp_rateset.rate, &val);
            temp_rateset.numRates = (tANI_U8) val;
    }
    else
    {
            temp_rateset.numRates = 0;
    }

    /* Include 11a rates when the device configured in non-11b mode */
    if (!IS_DOT11_MODE_11B(self_dot11mode))
    {
            val = WNI_CFG_SUPPORTED_RATES_11A_LEN;
            wlan_cfgGetStr(p_mac, WNI_CFG_SUPPORTED_RATES_11A,
                    (tANI_U8 *)&temp_rateset2.rate, &val);
            temp_rateset2.numRates = (tANI_U8) val;
    }
    else
    {
            temp_rateset2.numRates = 0;
    }

    if ((temp_rateset.numRates + temp_rateset2.numRates) >
                                     SIR_MAC_MAX_NUMBER_OF_RATES)
    {
            limLog(p_mac, LOGP, FL("more than %d rates in CFG"),
                                SIR_MAC_MAX_NUMBER_OF_RATES);
            return eSIR_FAILURE;
    }

    /**
     * copy all rates in temp_rateset,
     * there are SIR_MAC_MAX_NUMBER_OF_RATES rates max
     */
    for (i = 0; i < temp_rateset2.numRates; i++)
            temp_rateset.rate[i + temp_rateset.numRates] =
                                          temp_rateset2.rate[i];

    temp_rateset.numRates += temp_rateset2.numRates;

    if (temp_rateset.numRates <= MAX_NUM_SUPPORTED_RATES)
    {
            p_supp_rates->num_rates = temp_rateset.numRates;
            vos_mem_copy(p_supp_rates->rates, temp_rateset.rate,
                         p_supp_rates->num_rates);
            p_supp_rates->present = 1;
    }
    else  /* Populate extended capability as well */
    {
            p_supp_rates->num_rates = MAX_NUM_SUPPORTED_RATES;
            vos_mem_copy(p_supp_rates->rates, temp_rateset.rate,
                         p_supp_rates->num_rates);
            p_supp_rates->present = 1;
            p_ext_supp_rates->num_rates = temp_rateset.numRates -
                                 MAX_NUM_SUPPORTED_RATES;
            vos_mem_copy(p_ext_supp_rates->rates,
                         (tANI_U8 *)temp_rateset.rate +
                         MAX_NUM_SUPPORTED_RATES,
                         p_ext_supp_rates->num_rates);
            p_ext_supp_rates->present = 1;
    }

    return eSIR_SUCCESS;

} /* End PopulateDot11fRatesTdls */

tSirRetStatus
PopulateDot11fTPCReport(tpAniSirGlobal      pMac,
                        tDot11fIETPCReport *pDot11f,
                        tpPESession psessionEntry)
{
    tANI_U16 staid, txPower;
    tSirRetStatus nSirStatus;

    nSirStatus = limGetMgmtStaid( pMac, &staid, psessionEntry);
    if ( eSIR_SUCCESS != nSirStatus )
    {
        dot11fLog( pMac, LOG1, FL("Failed to get the STAID in Populat"
                                  "eDot11fTPCReport; limGetMgmtStaid "
                                  "returned status %d."),
                   nSirStatus );
        return eSIR_FAILURE;
    }

    // FramesToDo: This function was "misplaced" in the move to Gen4_TVM...
    // txPower = halGetRateToPwrValue( pMac, staid, pMac->lim.gLimCurrentChannelId, isBeacon );
    txPower = 0;
    pDot11f->tx_power    = ( tANI_U8 )txPower;
    pDot11f->link_margin = 0;
    pDot11f->present     = 1;

    return eSIR_SUCCESS;
} // End PopulateDot11fTPCReport.


void PopulateDot11fTSInfo(tSirMacTSInfo   *pInfo,
                          tDot11fFfTSInfo *pDot11f)
{
    pDot11f->traffic_type   = pInfo->traffic.trafficType;
    pDot11f->tsid           = pInfo->traffic.tsid;
    pDot11f->direction      = pInfo->traffic.direction;
    pDot11f->access_policy  = pInfo->traffic.accessPolicy;
    pDot11f->aggregation    = pInfo->traffic.aggregation;
    pDot11f->psb            = pInfo->traffic.psb;
    pDot11f->user_priority  = pInfo->traffic.userPrio;
    pDot11f->tsinfo_ack_pol = pInfo->traffic.ackPolicy;
    pDot11f->schedule       = pInfo->schedule.schedule;
} // End PopulatedDot11fTSInfo.

void PopulateDot11fWMM(tpAniSirGlobal      pMac,
                       tDot11fIEWMMInfoAp  *pInfo,
                       tDot11fIEWMMParams *pParams,
                       tDot11fIEWMMCaps   *pCaps,
                       tpPESession        psessionEntry)
{
    if ( psessionEntry->limWmeEnabled )
    {
        if ( eLIM_STA_IN_IBSS_ROLE == psessionEntry->limSystemRole )
        {
            //if ( ! sirIsPropCapabilityEnabled( pMac, SIR_MAC_PROP_CAPABILITY_WME ) )
            {
                PopulateDot11fWMMInfoAp( pMac, pInfo, psessionEntry );
            }
        }
        else
        {
            {
                PopulateDot11fWMMParams( pMac, pParams, psessionEntry);
            }

           if ( psessionEntry->limWsmEnabled )
            {
                PopulateDot11fWMMCaps( pCaps );
            }
        }
    }
} // End PopulateDot11fWMM.

void PopulateDot11fWMMCaps(tDot11fIEWMMCaps *pCaps)
{
    pCaps->version       = SIR_MAC_OUI_VERSION_1;
    pCaps->qack          = 0;
    pCaps->queue_request = 1;
    pCaps->txop_request  = 0;
    pCaps->more_ack      = 0;
    pCaps->present       = 1;
} // End PopulateDot11fWmmCaps.

#ifdef FEATURE_WLAN_ESE
void PopulateDot11fReAssocTspec(tpAniSirGlobal pMac, tDot11fReAssocRequest *pReassoc, tpPESession psessionEntry)
{
    tANI_U8 numTspecs = 0, idx;
    tTspecInfo *pTspec = NULL;

    numTspecs = psessionEntry->pLimReAssocReq->eseTspecInfo.numTspecs;
    pTspec = &psessionEntry->pLimReAssocReq->eseTspecInfo.tspec[0];
    pReassoc->num_WMMTSPEC = numTspecs;
    if (numTspecs) {
        for (idx=0; idx<numTspecs; idx++) {
            PopulateDot11fWMMTSPEC(&pTspec->tspec, &pReassoc->WMMTSPEC[idx]);
            pTspec->tspec.mediumTime = 0;
            pTspec++;
        }
    }
}
#endif 

void PopulateDot11fWMMInfoAp(tpAniSirGlobal pMac, tDot11fIEWMMInfoAp *pInfo, 
                             tpPESession psessionEntry)
{
    pInfo->version = SIR_MAC_OUI_VERSION_1;

    /* WMM Specification 3.1.3, 3.2.3
     * An IBSS staion shall always use its default WMM parameters.
     */
    if ( eLIM_STA_IN_IBSS_ROLE == psessionEntry->limSystemRole )
    {
        pInfo->param_set_count = 0;
        pInfo->uapsd = 0;
    }
    else
    {
        pInfo->param_set_count = ( 0xf & psessionEntry->gLimEdcaParamSetCount );
        if(psessionEntry->limSystemRole == eLIM_AP_ROLE ){
            pInfo->uapsd = ( 0x1 & psessionEntry->apUapsdEnable );
        }
        else
            pInfo->uapsd = ( 0x1 & pMac->lim.gUapsdEnable );
    }
    pInfo->present = 1;
}

void PopulateDot11fWMMInfoStation(tpAniSirGlobal pMac, tDot11fIEWMMInfoStation *pInfo)
{
    tANI_U32  val = 0;

    limLog(pMac, LOG1, FL("populate WMM IE in Setup Request Frame"));
    pInfo->version = SIR_MAC_OUI_VERSION_1;
    pInfo->acvo_uapsd = LIM_UAPSD_GET(ACVO, pMac->lim.gUapsdPerAcBitmask);
    pInfo->acvi_uapsd = LIM_UAPSD_GET(ACVI, pMac->lim.gUapsdPerAcBitmask);
    pInfo->acbk_uapsd = LIM_UAPSD_GET(ACBK, pMac->lim.gUapsdPerAcBitmask);
    pInfo->acbe_uapsd = LIM_UAPSD_GET(ACBE, pMac->lim.gUapsdPerAcBitmask);

    if(wlan_cfgGetInt(pMac, WNI_CFG_MAX_SP_LENGTH, &val) != eSIR_SUCCESS) 
        PELOGE(limLog(pMac, LOGE, FL("could not retrieve Max SP Length "));)
    pInfo->max_sp_length = (tANI_U8)val;
    pInfo->present = 1;
}

void PopulateDot11fWMMParams(tpAniSirGlobal      pMac,
                             tDot11fIEWMMParams *pParams,
                             tpPESession        psessionEntry)
{
    pParams->version = SIR_MAC_OUI_VERSION_1;

    if(psessionEntry->limSystemRole == eLIM_AP_ROLE)
       pParams->qosInfo =
           (psessionEntry->apUapsdEnable << 7) | ((tANI_U8)(0x0f & psessionEntry->gLimEdcaParamSetCount));
    else 
       pParams->qosInfo =
           (pMac->lim.gUapsdEnable << 7) | ((tANI_U8)(0x0f & psessionEntry->gLimEdcaParamSetCount));

    // Fill each EDCA parameter set in order: be, bk, vi, vo
    pParams->acbe_aifsn     = ( 0xf & SET_AIFSN(psessionEntry->gLimEdcaParamsBC[0].aci.aifsn) );
    pParams->acbe_acm       = ( 0x1 & psessionEntry->gLimEdcaParamsBC[0].aci.acm );
    pParams->acbe_aci       = ( 0x3 & SIR_MAC_EDCAACI_BESTEFFORT );
    pParams->acbe_acwmin    = ( 0xf & psessionEntry->gLimEdcaParamsBC[0].cw.min );
    pParams->acbe_acwmax    = ( 0xf & psessionEntry->gLimEdcaParamsBC[0].cw.max );
    pParams->acbe_txoplimit = psessionEntry->gLimEdcaParamsBC[0].txoplimit;

    pParams->acbk_aifsn     = ( 0xf & SET_AIFSN(psessionEntry->gLimEdcaParamsBC[1].aci.aifsn) );
    pParams->acbk_acm       = ( 0x1 & psessionEntry->gLimEdcaParamsBC[1].aci.acm );
    pParams->acbk_aci       = ( 0x3 & SIR_MAC_EDCAACI_BACKGROUND );
    pParams->acbk_acwmin    = ( 0xf & psessionEntry->gLimEdcaParamsBC[1].cw.min );
    pParams->acbk_acwmax    = ( 0xf & psessionEntry->gLimEdcaParamsBC[1].cw.max );
    pParams->acbk_txoplimit = psessionEntry->gLimEdcaParamsBC[1].txoplimit;

    if(psessionEntry->limSystemRole == eLIM_AP_ROLE )
        pParams->acvi_aifsn     = ( 0xf & psessionEntry->gLimEdcaParamsBC[2].aci.aifsn );
    else
        pParams->acvi_aifsn     = ( 0xf & SET_AIFSN(psessionEntry->gLimEdcaParamsBC[2].aci.aifsn) );



    pParams->acvi_acm       = ( 0x1 & psessionEntry->gLimEdcaParamsBC[2].aci.acm );
    pParams->acvi_aci       = ( 0x3 & SIR_MAC_EDCAACI_VIDEO );
    pParams->acvi_acwmin    = ( 0xf & psessionEntry->gLimEdcaParamsBC[2].cw.min );
    pParams->acvi_acwmax    = ( 0xf & psessionEntry->gLimEdcaParamsBC[2].cw.max );
    pParams->acvi_txoplimit = psessionEntry->gLimEdcaParamsBC[2].txoplimit;

    if(psessionEntry->limSystemRole == eLIM_AP_ROLE )
        pParams->acvo_aifsn     = ( 0xf & psessionEntry->gLimEdcaParamsBC[3].aci.aifsn );
    else
        pParams->acvo_aifsn     = ( 0xf & SET_AIFSN(psessionEntry->gLimEdcaParamsBC[3].aci.aifsn) );

    pParams->acvo_acm       = ( 0x1 & psessionEntry->gLimEdcaParamsBC[3].aci.acm );
    pParams->acvo_aci       = ( 0x3 & SIR_MAC_EDCAACI_VOICE );
    pParams->acvo_acwmin    = ( 0xf & psessionEntry->gLimEdcaParamsBC[3].cw.min );
    pParams->acvo_acwmax    = ( 0xf & psessionEntry->gLimEdcaParamsBC[3].cw.max );
    pParams->acvo_txoplimit = psessionEntry->gLimEdcaParamsBC[3].txoplimit;

    pParams->present = 1;

} // End PopulateDot11fWMMParams.

void PopulateDot11fWMMSchedule(tSirMacScheduleIE    *pSchedule,
                               tDot11fIEWMMSchedule *pDot11f)
{
    pDot11f->version            = 1;
    pDot11f->aggregation        = pSchedule->info.aggregation;
    pDot11f->tsid               = pSchedule->info.tsid;
    pDot11f->direction          = pSchedule->info.direction;
    pDot11f->reserved           = pSchedule->info.rsvd;
    pDot11f->service_start_time = pSchedule->svcStartTime;
    pDot11f->service_interval   = pSchedule->svcInterval;
    pDot11f->max_service_dur    = pSchedule->maxSvcDuration;
    pDot11f->spec_interval      = pSchedule->specInterval;

    pDot11f->present = 1;
} // End PopulateDot11fWMMSchedule.

tSirRetStatus
PopulateDot11fWPA(tpAniSirGlobal  pMac,
                  tpSirRSNie      pRsnIe,
                  tDot11fIEWPA   *pDot11f)
{
    tANI_U32        status;
    int idx;

    if ( pRsnIe->length )
    {
        if( 0 <= ( idx = FindIELocation( pMac, pRsnIe, DOT11F_EID_WPA ) ) )
        {
        status = dot11fUnpackIeWPA( pMac,
                                    pRsnIe->rsnIEdata + idx + 2 + 4,  // EID, length, OUI
                                    pRsnIe->rsnIEdata[ idx + 1 ] - 4, // OUI
                                    pDot11f );
        if ( DOT11F_FAILED( status ) )
        {
            dot11fLog( pMac, LOGE, FL("Parse failure in PopulateDot11fWP"
                                   "A (0x%08x)."),
                    status );
            return eSIR_FAILURE;
        }
    }
    }

    return eSIR_SUCCESS;
} // End PopulateDot11fWPA.



tSirRetStatus PopulateDot11fWPAOpaque( tpAniSirGlobal      pMac,
                                       tpSirRSNie          pRsnIe,
                                       tDot11fIEWPAOpaque *pDot11f )
{
    int idx;

    if ( pRsnIe->length )
    {
        if( 0 <= ( idx = FindIELocation( pMac, pRsnIe, DOT11F_EID_WPA ) ) )
        {
        pDot11f->present  = 1;
        pDot11f->num_data = pRsnIe->rsnIEdata[ idx + 1 ] - 4;
        vos_mem_copy(  pDot11f->data,
                       pRsnIe->rsnIEdata + idx + 2 + 4,    // EID, len, OUI
                       pRsnIe->rsnIEdata[ idx + 1 ] - 4 ); // OUI
    }
    }

    return eSIR_SUCCESS;

} // End PopulateDot11fWPAOpaque.

////////////////////////////////////////////////////////////////////////

tSirRetStatus
sirGetCfgPropCaps(tpAniSirGlobal pMac, tANI_U16 *caps)
{
#if 0
    tANI_U32 val;

    *caps = 0;
    if (wlan_cfgGetInt(pMac, WNI_CFG_PROPRIETARY_ANI_FEATURES_ENABLED, &val)
        != eSIR_SUCCESS)
    {
        limLog(pMac, LOGP, FL("could not retrieve PropFeature enabled flag"));
        return eSIR_FAILURE;
    }
    if (wlan_cfgGetInt(pMac, WNI_CFG_PROP_CAPABILITY, &val) != eSIR_SUCCESS)
    {
        limLog(pMac, LOGP, FL("could not retrieve PROP_CAPABLITY flag"));
        return eSIR_FAILURE;
    }

    *caps = (tANI_U16) val;
#endif
    return eSIR_SUCCESS;
}

tSirRetStatus
sirConvertProbeReqFrame2Struct(tpAniSirGlobal  pMac,
                               tANI_U8             *pFrame,
                               tANI_U32             nFrame,
                               tpSirProbeReq   pProbeReq)
{
    tANI_U32 status;
    tDot11fProbeRequest pr;

    // Ok, zero-init our [out] parameter,
    vos_mem_set( (tANI_U8*)pProbeReq, sizeof(tSirProbeReq), 0);

    // delegate to the framesc-generated code,
    status = dot11fUnpackProbeRequest(pMac, pFrame, nFrame, &pr);
    if ( DOT11F_FAILED( status ) )
    {
        limLog(pMac, LOGE, FL("Failed to parse a Probe Request (0x%08x, %d bytes)"),
                  status, nFrame);
        PELOG2(sirDumpBuf(pMac, SIR_DBG_MODULE_ID, LOG2, pFrame, nFrame);)
        return eSIR_FAILURE;
    }
    else if ( DOT11F_WARNED( status ) )
    {
      limLog( pMac, LOGW, FL("There were warnings while unpacking a Probe Request (0x%08x, %d bytes)"),
                 status, nFrame );
        PELOG2(sirDumpBuf(pMac, SIR_DBG_MODULE_ID, LOG2, pFrame, nFrame);)
    }

    // & "transliterate" from a 'tDot11fProbeRequestto' a 'tSirProbeReq'...
    if ( ! pr.SSID.present )
    {
        PELOGW(limLog(pMac, LOGW, FL("Mandatory IE SSID not present!"));)
    }
    else
    {
        pProbeReq->ssidPresent = 1;
        ConvertSSID( pMac, &pProbeReq->ssId, &pr.SSID );
    }

    if ( ! pr.SuppRates.present )
    {
        PELOGW(limLog(pMac, LOGW, FL("Mandatory IE Supported Rates not present!"));)
        return eSIR_FAILURE;
    }
    else
    {
        pProbeReq->suppRatesPresent = 1;
        ConvertSuppRates( pMac, &pProbeReq->supportedRates, &pr.SuppRates );
    }

    if ( pr.ExtSuppRates.present )
    {
        pProbeReq->extendedRatesPresent = 1;
        ConvertExtSuppRates( pMac, &pProbeReq->extendedRates, &pr.ExtSuppRates );
    }

    if ( pr.HTCaps.present )
    {
        vos_mem_copy( &pProbeReq->HTCaps, &pr.HTCaps, sizeof( tDot11fIEHTCaps ) );
    }

    if ( pr.WscProbeReq.present )
    {
        pProbeReq->wscIePresent = 1;
        vos_mem_copy(&pProbeReq->probeReqWscIeInfo, &pr.WscProbeReq, sizeof(tDot11fIEWscProbeReq));
    }
#ifdef WLAN_FEATURE_11AC
    if ( pr.VHTCaps.present )
    {
        vos_mem_copy( &pProbeReq->VHTCaps, &pr.VHTCaps, sizeof( tDot11fIEVHTCaps ) );
    }
#endif


    if ( pr.P2PProbeReq.present )
    {
        pProbeReq->p2pIePresent = 1;
    }

    return eSIR_SUCCESS;

} // End sirConvertProbeReqFrame2Struct.

/* function ValidateAndRectifyIEs checks for the malformed frame.
 * The frame would contain fixed IEs of 12 bytes follwed by Variable IEs
 * (Tagged elements).
 * Every Tagged IE has tag number, tag length and data. Tag length indicates
 * the size of data in bytes.
 * This function checks for size of Frame recived with the sum of all IEs.
 * And also rectifies missing optional fields in IE.
 *
 * NOTE : Presently this function rectifies RSN capability in RSN IE, can
 * extended to rectify other optional fields in other IEs.
 *
 */
tSirRetStatus ValidateAndRectifyIEs(tpAniSirGlobal pMac,
                                    tANI_U8 *pMgmtFrame,
                                    tANI_U32 nFrameBytes,
                                    tANI_U32 *nMissingRsnBytes)
{
    tANI_U32 length = SIZE_OF_FIXED_PARAM;
    tANI_U8 *refFrame;

    // Frame contains atleast one IE
    if (nFrameBytes > (SIZE_OF_FIXED_PARAM + 2))
    {
        while (length < nFrameBytes)
        {
            /*refFrame points to next IE */
            refFrame = pMgmtFrame + length;
            length += (tANI_U32)(SIZE_OF_TAG_PARAM_NUM + SIZE_OF_TAG_PARAM_LEN
                                 + (*(refFrame + SIZE_OF_TAG_PARAM_NUM)));
        }
        if (length != nFrameBytes)
        {
            /* Workaround : Some APs may not include RSN Capability but
             * the length of which is included in RSN IE length.
             * this may cause in updating RSN Capability with junk value.
             * To avoid this, add RSN Capability value with default value.
             * Going further we can have such workaround for other IEs
             */
            if ((*refFrame == RSNIEID) &&
                (length == (nFrameBytes + RSNIE_CAPABILITY_LEN)))
            {
                //Assume RSN Capability as 00
                vos_mem_set( ( tANI_U8* ) (pMgmtFrame + (nFrameBytes)),
                             RSNIE_CAPABILITY_LEN, DEFAULT_RSNIE_CAP_VAL );
                *nMissingRsnBytes = RSNIE_CAPABILITY_LEN;
                limLog(pMac, LOG1,
                       FL("Added RSN Capability to the RSNIE as 0x00 0x00"));

                return eHAL_STATUS_SUCCESS;
            } else {
                /* Workaround: Some APs may add extra 0x00 padding after IEs.
                 * Return true to allow these probe response frames proceed.
                 */
                if (nFrameBytes - length > 0) {
                    tANI_U32 i;
                    tANI_BOOLEAN zero_padding = VOS_TRUE;

                    for (i = length; i < nFrameBytes; i ++) {
                        if (pMgmtFrame[i-1] != 0x0) {
                            zero_padding = VOS_FALSE;
                            break;
                        }
                    }

                    if (zero_padding) {
                        return eHAL_STATUS_SUCCESS;
                    }
                }
            }

            return eSIR_FAILURE;
        }
    }
    return eHAL_STATUS_SUCCESS;
}

tSirRetStatus sirConvertProbeFrame2Struct(tpAniSirGlobal       pMac,
                                          tANI_U8             *pFrame,
                                          tANI_U32             nFrame,
                                          tpSirProbeRespBeacon pProbeResp)
{
    tANI_U32             status;
    tDot11fProbeResponse *pr;

    // Ok, zero-init our [out] parameter,
    vos_mem_set( ( tANI_U8* )pProbeResp, sizeof(tSirProbeRespBeacon), 0 );

    pr = vos_mem_vmalloc(sizeof(tDot11fProbeResponse));
    if ( NULL == pr )
        status = eHAL_STATUS_FAILURE;
    else
        status = eHAL_STATUS_SUCCESS;
    if (!HAL_STATUS_SUCCESS(status))
    {
        limLog(pMac, LOGE, FL("Failed to allocate memory") );
        return eSIR_FAILURE;
    }

    vos_mem_set( ( tANI_U8* )pr, sizeof(tDot11fProbeResponse), 0 );

    // delegate to the framesc-generated code,
    status = dot11fUnpackProbeResponse( pMac, pFrame, nFrame, pr );
    if ( DOT11F_FAILED( status ) )
    {
        limLog(pMac, LOGE, FL("Failed to parse a Probe Response (0x%08x, %d bytes)"),
                  status, nFrame);
        PELOG2(sirDumpBuf(pMac, SIR_DBG_MODULE_ID, LOG2, pFrame, nFrame);)
        vos_mem_vfree(pr);
        return eSIR_FAILURE;
    }

    // & "transliterate" from a 'tDot11fProbeResponse' to a 'tSirProbeRespBeacon'...

    // Timestamp
    vos_mem_copy( ( tANI_U8* )pProbeResp->timeStamp, ( tANI_U8* )&pr->TimeStamp,
                  sizeof(tSirMacTimeStamp) );

    // Beacon Interval
    pProbeResp->beaconInterval = pr->BeaconInterval.interval;

    // Capabilities
    pProbeResp->capabilityInfo.ess            = pr->Capabilities.ess;
    pProbeResp->capabilityInfo.ibss           = pr->Capabilities.ibss;
    pProbeResp->capabilityInfo.cfPollable     = pr->Capabilities.cfPollable;
    pProbeResp->capabilityInfo.cfPollReq      = pr->Capabilities.cfPollReq;
    pProbeResp->capabilityInfo.privacy        = pr->Capabilities.privacy;
    pProbeResp->capabilityInfo.shortPreamble  = pr->Capabilities.shortPreamble;
    pProbeResp->capabilityInfo.pbcc           = pr->Capabilities.pbcc;
    pProbeResp->capabilityInfo.channelAgility = pr->Capabilities.channelAgility;
    pProbeResp->capabilityInfo.spectrumMgt    = pr->Capabilities.spectrumMgt;
    pProbeResp->capabilityInfo.qos            = pr->Capabilities.qos;
    pProbeResp->capabilityInfo.shortSlotTime  = pr->Capabilities.shortSlotTime;
    pProbeResp->capabilityInfo.apsd           = pr->Capabilities.apsd;
    pProbeResp->capabilityInfo.rrm            = pr->Capabilities.rrm;
    pProbeResp->capabilityInfo.dsssOfdm       = pr->Capabilities.dsssOfdm;
    pProbeResp->capabilityInfo.delayedBA       = pr->Capabilities.delayedBA;
    pProbeResp->capabilityInfo.immediateBA    = pr->Capabilities.immediateBA;

    if ( ! pr->SSID.present )
    {
        PELOGW(limLog(pMac, LOGW, FL("Mandatory IE SSID not present!"));)
    }
    else
    {
        pProbeResp->ssidPresent = 1;
        ConvertSSID( pMac, &pProbeResp->ssId, &pr->SSID );
    }

    if ( ! pr->SuppRates.present )
    {
        PELOGW(limLog(pMac, LOGW, FL("Mandatory IE Supported Rates not present!"));)
    }
    else
    {
        pProbeResp->suppRatesPresent = 1;
        ConvertSuppRates( pMac, &pProbeResp->supportedRates, &pr->SuppRates );
    }

    if ( pr->ExtSuppRates.present )
    {
        pProbeResp->extendedRatesPresent = 1;
        ConvertExtSuppRates( pMac, &pProbeResp->extendedRates, &pr->ExtSuppRates );
    }


    if ( pr->CFParams.present )
    {
        pProbeResp->cfPresent = 1;
        ConvertCFParams( pMac, &pProbeResp->cfParamSet, &pr->CFParams );
    }

    if ( pr->Country.present )
    {
        pProbeResp->countryInfoPresent = 1;
        ConvertCountry( pMac, &pProbeResp->countryInfoParam, &pr->Country );
    }

    if ( pr->EDCAParamSet.present )
    {
        pProbeResp->edcaPresent = 1;
        ConvertEDCAParam( pMac, &pProbeResp->edcaParams, &pr->EDCAParamSet );
    }

    if ( pr->ChanSwitchAnn.present )
    {
        pProbeResp->channelSwitchPresent = 1;
        vos_mem_copy( &pProbeResp->channelSwitchIE, &pr->ChanSwitchAnn,
                       sizeof(tDot11fIEChanSwitchAnn) );
    }

       if ( pr->sec_chan_offset.present )
    {
        pProbeResp->sec_chan_offset_present = 1;
        vos_mem_copy ( &pProbeResp->sec_chan_offset, &pr->sec_chan_offset,
                       sizeof(tDot11fIEsec_chan_offset) );
    }
    if (pr->ext_chan_switch_ann.present)
    {
        pProbeResp->ecsa_present = 1;
        vos_mem_copy(&pProbeResp->ext_chan_switch_ann,
                     &pr->ext_chan_switch_ann,
                     sizeof(tDot11fIEext_chan_switch_ann));
    }

    if( pr->TPCReport.present)
    {
        pProbeResp->tpcReportPresent = 1;
        vos_mem_copy( &pProbeResp->tpcReport, &pr->TPCReport, sizeof(tDot11fIETPCReport));
    }

    if( pr->PowerConstraints.present)
    {
        pProbeResp->powerConstraintPresent = 1;
        vos_mem_copy( &pProbeResp->localPowerConstraint, &pr->PowerConstraints,
                      sizeof(tDot11fIEPowerConstraints));
    }

    if ( pr->Quiet.present )
    {
        pProbeResp->quietIEPresent = 1;
        vos_mem_copy( &pProbeResp->quietIE, &pr->Quiet, sizeof(tDot11fIEQuiet) );
    }

    if ( pr->HTCaps.present )
    {
        vos_mem_copy( &pProbeResp->HTCaps, &pr->HTCaps, sizeof( tDot11fIEHTCaps ) );
    }

    if ( pr->HTInfo.present )
    {
        vos_mem_copy( &pProbeResp->HTInfo, &pr->HTInfo, sizeof( tDot11fIEHTInfo ) );
    }

    if ( pr->DSParams.present )
    {
        pProbeResp->dsParamsPresent = 1;
        pProbeResp->channelNumber = pr->DSParams.curr_channel;
    }
    else if(pr->HTInfo.present)
    {
        pProbeResp->channelNumber = pr->HTInfo.primaryChannel;
    }

    if ( pr->RSNOpaque.present )
    {
        pProbeResp->rsnPresent = 1;
        ConvertRSNOpaque( pMac, &pProbeResp->rsn, &pr->RSNOpaque );
    }

    if ( pr->WPA.present )
    {
        pProbeResp->wpaPresent = 1;
        ConvertWPA( pMac, &pProbeResp->wpa, &pr->WPA );
    }

    if ( pr->WMMParams.present )
    {
        pProbeResp->wmeEdcaPresent = 1;
        ConvertWMMParams( pMac, &pProbeResp->edcaParams, &pr->WMMParams );
        PELOG1(limLog(pMac, LOG1, FL("WMM Parameter present in Probe Response Frame!"));
                                __printWMMParams(pMac, &pr->WMMParams);)
    }

    if ( pr->WMMInfoAp.present )
    {
        pProbeResp->wmeInfoPresent = 1;
        PELOG1(limLog(pMac, LOG1, FL("WMM Information Element present in Probe Response Frame!"));)
    }

    if ( pr->WMMCaps.present )
    {
        pProbeResp->wsmCapablePresent = 1;
    }


    if ( pr->ERPInfo.present )
    {
        pProbeResp->erpPresent = 1;
        ConvertERPInfo( pMac, &pProbeResp->erpIEInfo, &pr->ERPInfo );
    }

#ifdef WLAN_FEATURE_VOWIFI_11R
    if (pr->MobilityDomain.present)
    {
        // MobilityDomain
        pProbeResp->mdiePresent = 1;
        vos_mem_copy( (tANI_U8 *)&(pProbeResp->mdie[0]), (tANI_U8 *)&(pr->MobilityDomain.MDID),
                       sizeof(tANI_U16) );
        pProbeResp->mdie[2] = ((pr->MobilityDomain.overDSCap << 0) | (pr->MobilityDomain.resourceReqCap << 1));
#ifdef WLAN_FEATURE_VOWIFI_11R_DEBUG
        limLog(pMac, LOG2, FL("mdie=%02x%02x%02x"), (unsigned int)pProbeResp->mdie[0],
               (unsigned int)pProbeResp->mdie[1], (unsigned int)pProbeResp->mdie[2]);
#endif
    }
#endif

#if defined(FEATURE_WLAN_ESE) || defined(WLAN_FEATURE_ROAM_SCAN_OFFLOAD)
    if (pr->QBSSLoad.present)
    {
        vos_mem_copy(&pProbeResp->QBSSLoad, &pr->QBSSLoad, sizeof(tDot11fIEQBSSLoad));
    }
#endif
    if (pr->P2PProbeRes.present)
    {
       vos_mem_copy( &pProbeResp->P2PProbeRes, &pr->P2PProbeRes,
                                                sizeof(tDot11fIEP2PProbeRes) );
    }
#ifdef WLAN_FEATURE_11AC
    if ( pr->VHTCaps.present )
    {
       vos_mem_copy( &pProbeResp->VHTCaps, &pr->VHTCaps, sizeof( tDot11fIEVHTCaps ) );
    }
    if ( pr->VHTOperation.present )
    {
        vos_mem_copy( &pProbeResp->VHTOperation, &pr->VHTOperation, sizeof( tDot11fIEVHTOperation) );
    }
    if ( pr->VHTExtBssLoad.present )
    {
        vos_mem_copy( &pProbeResp->VHTExtBssLoad, &pr->VHTExtBssLoad, sizeof( tDot11fIEVHTExtBssLoad) );
    }
#endif
    sir_copy_hs20_ie(&pProbeResp->hs20vendor_ie, &pr->hs20vendor_ie);

    vos_mem_vfree(pr);
    return eSIR_SUCCESS;

} // End sirConvertProbeFrame2Struct.

tSirRetStatus
sirConvertAssocReqFrame2Struct(tpAniSirGlobal pMac,
                               tANI_U8            *pFrame,
                               tANI_U32            nFrame,
                               tpSirAssocReq  pAssocReq)
{
    tDot11fAssocRequest *ar;
    tANI_U32                 status;

    ar = vos_mem_malloc(sizeof(tDot11fAssocRequest));
    if ( NULL == ar )
        status = eHAL_STATUS_FAILURE;
    else
        status = eHAL_STATUS_SUCCESS;
    if (!HAL_STATUS_SUCCESS(status))
    {
        limLog(pMac, LOGE, FL("Failed to allocate memory") );
        return eSIR_FAILURE;
    }
        // Zero-init our [out] parameter,
    vos_mem_set( ( tANI_U8* )pAssocReq, sizeof(tSirAssocReq), 0 );
    vos_mem_set( ( tANI_U8* )ar, sizeof( tDot11fAssocRequest ), 0 );

    // delegate to the framesc-generated code,
    status = dot11fUnpackAssocRequest( pMac, pFrame, nFrame, ar );
    if ( DOT11F_FAILED( status ) )
    {
        limLog(pMac, LOGE, FL("Failed to parse an Association Request (0x%08x, %d bytes):"),
                  status, nFrame);
        PELOG2(sirDumpBuf(pMac, SIR_DBG_MODULE_ID, LOG2, pFrame, nFrame);)
        vos_mem_free(ar);
        return eSIR_FAILURE;
    }
    else if ( DOT11F_WARNED( status ) )
    {
      limLog( pMac, LOGW, FL("There were warnings while unpacking an Assoication Request (0x%08x, %d bytes):"),
                 status, nFrame );
        PELOG2(sirDumpBuf(pMac, SIR_DBG_MODULE_ID, LOG2, pFrame, nFrame);)
    }

    // & "transliterate" from a 'tDot11fAssocRequest' to a 'tSirAssocReq'...

    // make sure this is seen as an assoc request
    pAssocReq->reassocRequest = 0;

    // Capabilities
    pAssocReq->capabilityInfo.ess            = ar->Capabilities.ess;
    pAssocReq->capabilityInfo.ibss           = ar->Capabilities.ibss;
    pAssocReq->capabilityInfo.cfPollable     = ar->Capabilities.cfPollable;
    pAssocReq->capabilityInfo.cfPollReq      = ar->Capabilities.cfPollReq;
    pAssocReq->capabilityInfo.privacy        = ar->Capabilities.privacy;
    pAssocReq->capabilityInfo.shortPreamble  = ar->Capabilities.shortPreamble;
    pAssocReq->capabilityInfo.pbcc           = ar->Capabilities.pbcc;
    pAssocReq->capabilityInfo.channelAgility = ar->Capabilities.channelAgility;
    pAssocReq->capabilityInfo.spectrumMgt    = ar->Capabilities.spectrumMgt;
    pAssocReq->capabilityInfo.qos            = ar->Capabilities.qos;
    pAssocReq->capabilityInfo.shortSlotTime  = ar->Capabilities.shortSlotTime;
    pAssocReq->capabilityInfo.apsd           = ar->Capabilities.apsd;
    pAssocReq->capabilityInfo.rrm            = ar->Capabilities.rrm;
    pAssocReq->capabilityInfo.dsssOfdm       = ar->Capabilities.dsssOfdm;
    pAssocReq->capabilityInfo.delayedBA       = ar->Capabilities.delayedBA;
    pAssocReq->capabilityInfo.immediateBA    = ar->Capabilities.immediateBA;

    // Listen Interval
    pAssocReq->listenInterval = ar->ListenInterval.interval;

    // SSID
    if ( ar->SSID.present )
    {
        pAssocReq->ssidPresent = 1;
        ConvertSSID( pMac, &pAssocReq->ssId, &ar->SSID );
    }

    // Supported Rates
    if ( ar->SuppRates.present )
    {
        pAssocReq->suppRatesPresent = 1;
        ConvertSuppRates( pMac, &pAssocReq->supportedRates, &ar->SuppRates );
    }

    // Extended Supported Rates
    if ( ar->ExtSuppRates.present )
    {
        pAssocReq->extendedRatesPresent = 1;
        ConvertExtSuppRates( pMac, &pAssocReq->extendedRates, &ar->ExtSuppRates );
    }

    // QOS Capabilities:
    if ( ar->QOSCapsStation.present )
    {
        pAssocReq->qosCapabilityPresent = 1;
        ConvertQOSCapsStation( pMac, &pAssocReq->qosCapability, &ar->QOSCapsStation );
    }

    // WPA
    if ( ar->WPAOpaque.present )
    {
        pAssocReq->wpaPresent = 1;
        ConvertWPAOpaque( pMac, &pAssocReq->wpa, &ar->WPAOpaque );
    }

    // RSN
    if ( ar->RSNOpaque.present )
    {
        pAssocReq->rsnPresent = 1;
        ConvertRSNOpaque( pMac, &pAssocReq->rsn, &ar->RSNOpaque );
    }

    // WSC IE
    if (ar->WscIEOpaque.present) 
    {
        pAssocReq->addIEPresent = 1;
        ConvertWscOpaque(pMac, &pAssocReq->addIE, &ar->WscIEOpaque);
    }
    

    if(ar->P2PIEOpaque.present)
    {
        pAssocReq->addIEPresent = 1;
        ConvertP2POpaque( pMac, &pAssocReq->addIE, &ar->P2PIEOpaque);
    }
#ifdef WLAN_FEATURE_WFD
    if(ar->WFDIEOpaque.present)
    {
        pAssocReq->addIEPresent = 1;
        ConvertWFDOpaque( pMac, &pAssocReq->addIE, &ar->WFDIEOpaque);
    }
#endif

    // Power Capabilities
    if ( ar->PowerCaps.present )
    {
        pAssocReq->powerCapabilityPresent     = 1;
        ConvertPowerCaps( pMac, &pAssocReq->powerCapability, &ar->PowerCaps );
    }

    // Supported Channels
    if ( ar->SuppChannels.present )
    {
        pAssocReq->supportedChannelsPresent = 1;
        ConvertSuppChannels( pMac, &pAssocReq->supportedChannels, &ar->SuppChannels );
    }

    if ( ar->HTCaps.present )
    {
        vos_mem_copy( &pAssocReq->HTCaps, &ar->HTCaps, sizeof( tDot11fIEHTCaps ) );
    }

    if ( ar->WMMInfoStation.present )
    {
        pAssocReq->wmeInfoPresent = 1;
        vos_mem_copy( &pAssocReq->WMMInfoStation, &ar->WMMInfoStation,
                      sizeof( tDot11fIEWMMInfoStation ) );

    }


    if ( ar->WMMCaps.present ) pAssocReq->wsmCapablePresent = 1;

    if ( ! pAssocReq->ssidPresent )
    {
        PELOG2(limLog(pMac, LOG2, FL("Received Assoc without SSID IE."));)
        vos_mem_free(ar);
        return eSIR_FAILURE;
    }

    if ( !pAssocReq->suppRatesPresent && !pAssocReq->extendedRatesPresent )
    {
        PELOG2(limLog(pMac, LOG2, FL("Received Assoc without supp rate IE."));)
        vos_mem_free(ar);
        return eSIR_FAILURE;
    }

#ifdef WLAN_FEATURE_11AC
    if ( ar->VHTCaps.present )
    {
        vos_mem_copy( &pAssocReq->VHTCaps, &ar->VHTCaps, sizeof( tDot11fIEVHTCaps ) );
        limLog( pMac, LOGW, FL("Received Assoc Req with VHT Cap"));
        limLogVHTCap( pMac, &pAssocReq->VHTCaps);
    }
    if ( ar->OperatingMode.present )
    {
        vos_mem_copy( &pAssocReq->operMode, &ar->OperatingMode, sizeof (tDot11fIEOperatingMode));
        limLog( pMac, LOGW, FL("Received Assoc Req with Operating Mode IE"));
        limLogOperatingMode( pMac, &pAssocReq->operMode);
    }
#endif
    vos_mem_free(ar);
    return eSIR_SUCCESS;

} // End sirConvertAssocReqFrame2Struct.

tSirRetStatus
sirConvertAssocRespFrame2Struct(tpAniSirGlobal pMac,
                                tANI_U8            *pFrame,
                                tANI_U32            nFrame,
                                tpSirAssocRsp  pAssocRsp)
{
    static tDot11fAssocResponse ar;
    tANI_U32                  status;
    tANI_U8  cnt =0;

    // Zero-init our [out] parameter,
    vos_mem_set( ( tANI_U8* )pAssocRsp, sizeof(tSirAssocRsp), 0 );

    // delegate to the framesc-generated code,
    status = dot11fUnpackAssocResponse( pMac, pFrame, nFrame, &ar);
    if ( DOT11F_FAILED( status ) )
    {
        limLog(pMac, LOGE, FL("Failed to parse an Association Response (0x%08x, %d bytes)"),
                  status, nFrame);
        PELOG2(sirDumpBuf(pMac, SIR_DBG_MODULE_ID, LOG2, pFrame, nFrame);)
        return eSIR_FAILURE;
    }
    else if ( DOT11F_WARNED( status ) )
    {
        limLog( pMac, LOGW, FL("There were warnings while unpacking an Association Response (0x%08x, %d bytes)"),
                   status, nFrame );
        PELOG2(sirDumpBuf(pMac, SIR_DBG_MODULE_ID, LOG2, pFrame, nFrame);)
    }

    // & "transliterate" from a 'tDot11fAssocResponse' a 'tSirAssocRsp'...

    // Capabilities
    pAssocRsp->capabilityInfo.ess            = ar.Capabilities.ess;
    pAssocRsp->capabilityInfo.ibss           = ar.Capabilities.ibss;
    pAssocRsp->capabilityInfo.cfPollable     = ar.Capabilities.cfPollable;
    pAssocRsp->capabilityInfo.cfPollReq      = ar.Capabilities.cfPollReq;
    pAssocRsp->capabilityInfo.privacy        = ar.Capabilities.privacy;
    pAssocRsp->capabilityInfo.shortPreamble  = ar.Capabilities.shortPreamble;
    pAssocRsp->capabilityInfo.pbcc           = ar.Capabilities.pbcc;
    pAssocRsp->capabilityInfo.channelAgility = ar.Capabilities.channelAgility;
    pAssocRsp->capabilityInfo.spectrumMgt    = ar.Capabilities.spectrumMgt;
    pAssocRsp->capabilityInfo.qos            = ar.Capabilities.qos;
    pAssocRsp->capabilityInfo.shortSlotTime  = ar.Capabilities.shortSlotTime;
    pAssocRsp->capabilityInfo.apsd           = ar.Capabilities.apsd;
    pAssocRsp->capabilityInfo.rrm            = ar.Capabilities.rrm;
    pAssocRsp->capabilityInfo.dsssOfdm       = ar.Capabilities.dsssOfdm;
    pAssocRsp->capabilityInfo.delayedBA       = ar.Capabilities.delayedBA;
    pAssocRsp->capabilityInfo.immediateBA    = ar.Capabilities.immediateBA;

    pAssocRsp->statusCode = ar.Status.status;
    pAssocRsp->aid        = ar.AID.associd;

    if ( ! ar.SuppRates.present )
    {
        pAssocRsp->suppRatesPresent = 0;
        PELOGW(limLog(pMac, LOGW, FL("Mandatory IE Supported Rates not present!"));)
    }
    else
    {
        pAssocRsp->suppRatesPresent = 1;
        ConvertSuppRates( pMac, &pAssocRsp->supportedRates, &ar.SuppRates );
    }

    if ( ar.ExtSuppRates.present )
    {
        pAssocRsp->extendedRatesPresent = 1;
        ConvertExtSuppRates( pMac, &pAssocRsp->extendedRates, &ar.ExtSuppRates );
    }

    if ( ar.EDCAParamSet.present )
    {
        pAssocRsp->edcaPresent = 1;
        ConvertEDCAParam( pMac, &pAssocRsp->edca, &ar.EDCAParamSet );
    }
    if (ar.ExtCap.present)
    {
        struct s_ext_cap *p_ext_cap;
        vos_mem_copy(&pAssocRsp->ExtCap, &ar.ExtCap, sizeof(tDot11fIEExtCap));

        p_ext_cap = (struct s_ext_cap *)&pAssocRsp->ExtCap.bytes;
        limLog(pMac, LOG1,
               FL("ExtCap is present, TDLSChanSwitProhibited: %d"),
               p_ext_cap->TDLSChanSwitProhibited);
    }
    if ( ar.WMMParams.present )
    {
        pAssocRsp->wmeEdcaPresent = 1;
        ConvertWMMParams( pMac, &pAssocRsp->edca, &ar.WMMParams);
        limLog(pMac, LOG1, FL("WMM Parameter Element present in Association Response Frame!"));
        __printWMMParams(pMac, &ar.WMMParams);
    }

    if ( ar.HTCaps.present )
    {
        limLog(pMac, LOG1, FL("Received Assoc Response with HT Cap"));
        vos_mem_copy( &pAssocRsp->HTCaps, &ar.HTCaps, sizeof( tDot11fIEHTCaps ) );
    }

    if ( ar.HTInfo.present )
    {   limLog(pMac, LOG1, FL("Received Assoc Response with HT Info"));
        vos_mem_copy( &pAssocRsp->HTInfo, &ar.HTInfo, sizeof( tDot11fIEHTInfo ) );
    }

#ifdef WLAN_FEATURE_VOWIFI_11R
    if (ar.MobilityDomain.present)
    {
        // MobilityDomain
        pAssocRsp->mdiePresent = 1;
        vos_mem_copy( (tANI_U8 *)&(pAssocRsp->mdie[0]), (tANI_U8 *)&(ar.MobilityDomain.MDID),
                       sizeof(tANI_U16) );
        pAssocRsp->mdie[2] = ((ar.MobilityDomain.overDSCap << 0) | (ar.MobilityDomain.resourceReqCap << 1));
#ifdef WLAN_FEATURE_VOWIFI_11R_DEBUG
        limLog(pMac, LOG1, FL("new mdie=%02x%02x%02x"), (unsigned int)pAssocRsp->mdie[0],
               (unsigned int)pAssocRsp->mdie[1], (unsigned int)pAssocRsp->mdie[2]);
#endif
    }

    if ( ar.FTInfo.present )
    {
#ifdef WLAN_FEATURE_VOWIFI_11R_DEBUG
        limLog(pMac, LOG1, FL("FT Info present %d %d %d"), ar.FTInfo.R0KH_ID.num_PMK_R0_ID,
                ar.FTInfo.R0KH_ID.present,
                ar.FTInfo.R1KH_ID.present);
#endif
        pAssocRsp->ftinfoPresent = 1;
        vos_mem_copy( &pAssocRsp->FTInfo, &ar.FTInfo, sizeof(tDot11fIEFTInfo) );
    }
#endif

#ifdef WLAN_FEATURE_VOWIFI_11R
    if (ar.num_RICDataDesc && ar.num_RICDataDesc <= 2) {
        for (cnt=0; cnt < ar.num_RICDataDesc; cnt++) {
            if (ar.RICDataDesc[cnt].present) {
                vos_mem_copy( &pAssocRsp->RICData[cnt], &ar.RICDataDesc[cnt],
                              sizeof(tDot11fIERICDataDesc));
            }
        }
        pAssocRsp->num_RICData = ar.num_RICDataDesc;
        pAssocRsp->ricPresent = TRUE;
    }
#endif    

#ifdef FEATURE_WLAN_ESE
    if (ar.num_WMMTSPEC) {
        pAssocRsp->num_tspecs = ar.num_WMMTSPEC;
        for (cnt=0; cnt < ar.num_WMMTSPEC; cnt++) {
            vos_mem_copy( &pAssocRsp->TSPECInfo[cnt], &ar.WMMTSPEC[cnt],
                          (sizeof(tDot11fIEWMMTSPEC)*ar.num_WMMTSPEC));
        }
        pAssocRsp->tspecPresent = TRUE;
    }
   
    if(ar.ESETrafStrmMet.present)
    {
        pAssocRsp->tsmPresent = 1;
        vos_mem_copy(&pAssocRsp->tsmIE.tsid,
                &ar.ESETrafStrmMet.tsid,sizeof(tSirMacESETSMIE));
    }    
#endif

#ifdef WLAN_FEATURE_11AC
    if ( ar.VHTCaps.present )
    {
        vos_mem_copy( &pAssocRsp->VHTCaps, &ar.VHTCaps, sizeof( tDot11fIEVHTCaps ) );
        limLog( pMac, LOG1, FL("Received Assoc Response with VHT Cap"));
        limLogVHTCap(pMac, &pAssocRsp->VHTCaps);
    }
    if ( ar.VHTOperation.present )
    {
        vos_mem_copy( &pAssocRsp->VHTOperation, &ar.VHTOperation, sizeof( tDot11fIEVHTOperation) );
        limLog( pMac, LOG1, FL("Received Assoc Response with VHT Operation"));
        limLogVHTOperation(pMac, &pAssocRsp->VHTOperation);
    }
#endif
    if(ar.OBSSScanParameters.present)
    {
       vos_mem_copy( &pAssocRsp->OBSSScanParameters, &ar.OBSSScanParameters,
                      sizeof( tDot11fIEOBSSScanParameters));
    }
    if ( ar.QosMapSet.present )
    {
        pAssocRsp->QosMapSet.present = 1;
        ConvertQosMapsetFrame( pMac, &pAssocRsp->QosMapSet, &ar.QosMapSet);
        limLog( pMac, LOG1, FL("Received Assoc Response with Qos Map Set"));
        limLogQosMapSet(pMac, &pAssocRsp->QosMapSet);
    }
    return eSIR_SUCCESS;
} // End sirConvertAssocRespFrame2Struct.

tSirRetStatus
sirConvertReassocReqFrame2Struct(tpAniSirGlobal pMac,
                                 tANI_U8            *pFrame,
                                 tANI_U32            nFrame,
                                 tpSirAssocReq  pAssocReq)
{
    static tDot11fReAssocRequest ar;
    tANI_U32                   status;

    // Zero-init our [out] parameter,
    vos_mem_set( ( tANI_U8* )pAssocReq, sizeof(tSirAssocReq), 0 );

    // delegate to the framesc-generated code,
    status = dot11fUnpackReAssocRequest( pMac, pFrame, nFrame, &ar );
    if ( DOT11F_FAILED( status ) )
    {
        limLog(pMac, LOGE, FL("Failed to parse a Re-association Request (0x%08x, %d bytes)"),
                  status, nFrame);
        PELOG2(sirDumpBuf(pMac, SIR_DBG_MODULE_ID, LOG2, pFrame, nFrame);)
        return eSIR_FAILURE;
    }
    else if ( DOT11F_WARNED( status ) )
    {
      limLog( pMac, LOGW, FL("There were warnings while unpacking a Re-association Request (0x%08x, %d bytes)"),
                 status, nFrame );
        PELOG2(sirDumpBuf(pMac, SIR_DBG_MODULE_ID, LOG2, pFrame, nFrame);)
    }

    // & "transliterate" from a 'tDot11fReAssocRequest' to a 'tSirAssocReq'...

    // make sure this is seen as a re-assoc request
    pAssocReq->reassocRequest = 1;

    // Capabilities
    pAssocReq->capabilityInfo.ess            = ar.Capabilities.ess;
    pAssocReq->capabilityInfo.ibss           = ar.Capabilities.ibss;
    pAssocReq->capabilityInfo.cfPollable     = ar.Capabilities.cfPollable;
    pAssocReq->capabilityInfo.cfPollReq      = ar.Capabilities.cfPollReq;
    pAssocReq->capabilityInfo.privacy        = ar.Capabilities.privacy;
    pAssocReq->capabilityInfo.shortPreamble  = ar.Capabilities.shortPreamble;
    pAssocReq->capabilityInfo.pbcc           = ar.Capabilities.pbcc;
    pAssocReq->capabilityInfo.channelAgility = ar.Capabilities.channelAgility;
    pAssocReq->capabilityInfo.spectrumMgt    = ar.Capabilities.spectrumMgt;
    pAssocReq->capabilityInfo.qos            = ar.Capabilities.qos;
    pAssocReq->capabilityInfo.shortSlotTime  = ar.Capabilities.shortSlotTime;
    pAssocReq->capabilityInfo.apsd           = ar.Capabilities.apsd;
    pAssocReq->capabilityInfo.rrm            = ar.Capabilities.rrm;
    pAssocReq->capabilityInfo.dsssOfdm      = ar.Capabilities.dsssOfdm;
    pAssocReq->capabilityInfo.delayedBA       = ar.Capabilities.delayedBA;
    pAssocReq->capabilityInfo.immediateBA    = ar.Capabilities.immediateBA;

    // Listen Interval
    pAssocReq->listenInterval = ar.ListenInterval.interval;

    // SSID
    if ( ar.SSID.present )
    {
        pAssocReq->ssidPresent = 1;
        ConvertSSID( pMac, &pAssocReq->ssId, &ar.SSID );
    }

    // Supported Rates
    if ( ar.SuppRates.present )
    {
        pAssocReq->suppRatesPresent = 1;
        ConvertSuppRates( pMac, &pAssocReq->supportedRates, &ar.SuppRates );
    }

    // Extended Supported Rates
    if ( ar.ExtSuppRates.present )
    {
        pAssocReq->extendedRatesPresent = 1;
        ConvertExtSuppRates( pMac, &pAssocReq->extendedRates,
                             &ar.ExtSuppRates );
    }

    // QOS Capabilities:
    if ( ar.QOSCapsStation.present )
    {
        pAssocReq->qosCapabilityPresent = 1;
        ConvertQOSCapsStation( pMac, &pAssocReq->qosCapability, &ar.QOSCapsStation );
    }

    // WPA
    if ( ar.WPAOpaque.present )
    {
        pAssocReq->wpaPresent = 1;
        ConvertWPAOpaque( pMac, &pAssocReq->wpa, &ar.WPAOpaque );
    }

    // RSN
    if ( ar.RSNOpaque.present )
    {
        pAssocReq->rsnPresent = 1;
        ConvertRSNOpaque( pMac, &pAssocReq->rsn, &ar.RSNOpaque );
    }


    // Power Capabilities
    if ( ar.PowerCaps.present )
    {
        pAssocReq->powerCapabilityPresent     = 1;
        ConvertPowerCaps( pMac, &pAssocReq->powerCapability, &ar.PowerCaps );
    }

    // Supported Channels
    if ( ar.SuppChannels.present )
    {
        pAssocReq->supportedChannelsPresent = 1;
        ConvertSuppChannels( pMac, &pAssocReq->supportedChannels, &ar.SuppChannels );
    }

    if ( ar.HTCaps.present )
    {
        vos_mem_copy( &pAssocReq->HTCaps, &ar.HTCaps, sizeof( tDot11fIEHTCaps ) );
    }

    if ( ar.WMMInfoStation.present )
    {
        pAssocReq->wmeInfoPresent = 1;
        vos_mem_copy( &pAssocReq->WMMInfoStation, &ar.WMMInfoStation,
                      sizeof( tDot11fIEWMMInfoStation ) );

    }

    if ( ar.WMMCaps.present ) pAssocReq->wsmCapablePresent = 1;

    if ( ! pAssocReq->ssidPresent )
    {
        PELOG2(limLog(pMac, LOG2, FL("Received Assoc without SSID IE."));)
        return eSIR_FAILURE;
    }

    if ( ! pAssocReq->suppRatesPresent && ! pAssocReq->extendedRatesPresent )
    {
        PELOG2(limLog(pMac, LOG2, FL("Received Assoc without supp rate IE."));)
        return eSIR_FAILURE;
    }

    // Why no call to 'updateAssocReqFromPropCapability' here, like
    // there is in 'sirConvertAssocReqFrame2Struct'?

    // WSC IE
    if (ar.WscIEOpaque.present) 
    {
        pAssocReq->addIEPresent = 1;
        ConvertWscOpaque(pMac, &pAssocReq->addIE, &ar.WscIEOpaque);
    }
    
    if(ar.P2PIEOpaque.present)
    {
        pAssocReq->addIEPresent = 1;
        ConvertP2POpaque( pMac, &pAssocReq->addIE, &ar.P2PIEOpaque);
    }

#ifdef WLAN_FEATURE_WFD
    if(ar.WFDIEOpaque.present)
    {
        pAssocReq->addIEPresent = 1;
        ConvertWFDOpaque( pMac, &pAssocReq->addIE, &ar.WFDIEOpaque);
    }
#endif

#ifdef WLAN_FEATURE_11AC
    if ( ar.VHTCaps.present )
    {
        vos_mem_copy( &pAssocReq->VHTCaps, &ar.VHTCaps, sizeof( tDot11fIEVHTCaps ) );
    }
    if ( ar.OperatingMode.present )
    {
        vos_mem_copy( &pAssocReq->operMode, &ar.OperatingMode, sizeof( tDot11fIEOperatingMode  ) );
        limLog( pMac, LOGW, FL("Received Assoc Req with Operating Mode IE"));
        limLogOperatingMode( pMac, &pAssocReq->operMode);
    }
#endif
    return eSIR_SUCCESS;

} // End sirConvertReassocReqFrame2Struct.


#if defined(FEATURE_WLAN_ESE_UPLOAD)
tSirRetStatus
sirFillBeaconMandatoryIEforEseBcnReport(tpAniSirGlobal   pMac,
                                        tANI_U8         *pPayload,
                                        const tANI_U32   nPayload,
                                        tANI_U8        **outIeBuf,
                                        tANI_U32        *pOutIeLen)
{
    tDot11fBeaconIEs            *pBies = NULL;
    tANI_U32                    status = eHAL_STATUS_SUCCESS;
    tSirRetStatus               retStatus = eSIR_SUCCESS;
    tSirEseBcnReportMandatoryIe eseBcnReportMandatoryIe;

    /* To store how many bytes are required to be allocated
           for Bcn report mandatory Ies */
    tANI_U16 numBytes = 0, freeBytes = 0;
    tANI_U8  *pos = NULL;

    // Zero-init our [out] parameter,
    vos_mem_set( (tANI_U8*)&eseBcnReportMandatoryIe, sizeof(eseBcnReportMandatoryIe), 0 );
    pBies = vos_mem_malloc(sizeof(tDot11fBeaconIEs));
    if ( NULL == pBies )
        status = eHAL_STATUS_FAILURE;
    else
        status = eHAL_STATUS_SUCCESS;
    if (!HAL_STATUS_SUCCESS(status))
    {
        limLog(pMac, LOGE, FL("Failed to allocate memory") );
        return eSIR_FAILURE;
    }
    vos_mem_zero(pBies, sizeof(tDot11fBeaconIEs));

    // delegate to the framesc-generated code,
    status = dot11fUnpackBeaconIEs( pMac, pPayload, nPayload, pBies );

    if ( DOT11F_FAILED( status ) )
    {
        limLog(pMac, LOGE, FL("Failed to parse Beacon IEs (0x%08x, %d bytes)"),
                  status, nPayload);
        vos_mem_free(pBies);
        return eSIR_FAILURE;
    }
    else if ( DOT11F_WARNED( status ) )
    {
      limLog( pMac, LOGW, FL("There were warnings while unpacking Beacon IEs (0x%08x, %d bytes)"),
                 status, nPayload );
        PELOG2(sirDumpBuf(pMac, SIR_DBG_MODULE_ID, LOG2, pPayload, nPayload);)
    }

    // & "transliterate" from a 'tDot11fBeaconIEs' to a 'eseBcnReportMandatoryIe'...
    if ( !pBies->SSID.present )
    {
        PELOGW(limLog(pMac, LOGW, FL("Mandatory IE SSID not present!"));)
    }
    else
    {
        eseBcnReportMandatoryIe.ssidPresent = 1;
        ConvertSSID( pMac, &eseBcnReportMandatoryIe.ssId, &pBies->SSID );
        /* 1 for EID, 1 for length and length bytes */
        numBytes += 1 + 1 + eseBcnReportMandatoryIe.ssId.length;
    }

    if ( !pBies->SuppRates.present )
    {
        PELOGW(limLog(pMac, LOGW, FL("Mandatory IE Supported Rates not present!"));)
    }
    else
    {
        eseBcnReportMandatoryIe.suppRatesPresent = 1;
        ConvertSuppRates( pMac, &eseBcnReportMandatoryIe.supportedRates, &pBies->SuppRates );
        numBytes += 1 + 1 + eseBcnReportMandatoryIe.supportedRates.numRates;
    }

    if ( pBies->FHParamSet.present)
    {
        eseBcnReportMandatoryIe.fhParamPresent = 1;
        ConvertFHParams( pMac, &eseBcnReportMandatoryIe.fhParamSet, &pBies->FHParamSet );
        numBytes += 1 + 1 + SIR_MAC_FH_PARAM_SET_EID_MAX;
    }

    if ( pBies->DSParams.present )
    {
        eseBcnReportMandatoryIe.dsParamsPresent = 1;
        eseBcnReportMandatoryIe.dsParamSet.channelNumber = pBies->DSParams.curr_channel;
        numBytes += 1 + 1 + SIR_MAC_DS_PARAM_SET_EID_MAX;
    }

    if ( pBies->CFParams.present )
    {
        eseBcnReportMandatoryIe.cfPresent = 1;
        ConvertCFParams( pMac, &eseBcnReportMandatoryIe.cfParamSet, &pBies->CFParams );
        numBytes += 1 + 1 + SIR_MAC_CF_PARAM_SET_EID_MAX;
    }

    if ( pBies->IBSSParams.present )
    {
        eseBcnReportMandatoryIe.ibssParamPresent = 1;
        eseBcnReportMandatoryIe.ibssParamSet.atim = pBies->IBSSParams.atim;
        numBytes += 1 + 1 + SIR_MAC_IBSS_PARAM_SET_EID_MAX;
    }

    if ( pBies->TIM.present )
    {
        eseBcnReportMandatoryIe.timPresent = 1;
        eseBcnReportMandatoryIe.tim.dtimCount     = pBies->TIM.dtim_count;
        eseBcnReportMandatoryIe.tim.dtimPeriod    = pBies->TIM.dtim_period;
        eseBcnReportMandatoryIe.tim.bitmapControl = pBies->TIM.bmpctl;
        /* As per the ESE spec, May truncate and report first 4 octets only */
        numBytes += 1 + 1 + SIR_MAC_TIM_EID_MIN;
    }

    if ( pBies->RRMEnabledCap.present )
    {
        eseBcnReportMandatoryIe.rrmPresent = 1;
        vos_mem_copy( &eseBcnReportMandatoryIe.rmEnabledCapabilities, &pBies->RRMEnabledCap, sizeof( tDot11fIERRMEnabledCap ) );
        numBytes += 1 + 1 + SIR_MAC_RM_ENABLED_CAPABILITY_EID_MAX;
    }

    *outIeBuf = vos_mem_malloc(numBytes);
    if (NULL == *outIeBuf)
    {
        limLog(pMac, LOGP, FL("Memory Allocation failure"));
        vos_mem_free(pBies);
        return eSIR_FAILURE;
    }
    pos = *outIeBuf;
    *pOutIeLen = numBytes;
    freeBytes = numBytes;

    /* Start filling the output Ie with Mandatory IE information */
    /* Fill SSID IE */
    if (eseBcnReportMandatoryIe.ssidPresent)
    {
       if (freeBytes < (1 + 1 + eseBcnReportMandatoryIe.ssId.length))
       {
           limLog(pMac, LOGP, FL("Insufficient memory to copy SSID"));
           retStatus = eSIR_FAILURE;
           goto err_bcnrep;
       }
       *pos = SIR_MAC_SSID_EID;
       pos++;
       *pos = eseBcnReportMandatoryIe.ssId.length;
       pos++;
       vos_mem_copy(pos, (tANI_U8*)eseBcnReportMandatoryIe.ssId.ssId,
                    eseBcnReportMandatoryIe.ssId.length);
       pos += eseBcnReportMandatoryIe.ssId.length;
       freeBytes -= (1 + 1 + eseBcnReportMandatoryIe.ssId.length);
    }

    /* Fill Supported Rates IE */
    if (eseBcnReportMandatoryIe.suppRatesPresent)
    {
       if (freeBytes < (1 + 1 + eseBcnReportMandatoryIe.supportedRates.numRates))
       {
           limLog(pMac, LOGP, FL("Insufficient memory to copy Rates IE"));
           retStatus = eSIR_FAILURE;
           goto err_bcnrep;
       }
       if (eseBcnReportMandatoryIe.supportedRates.numRates <=
             SIR_MAC_RATESET_EID_MAX) {
           *pos = SIR_MAC_RATESET_EID;
           pos++;
           *pos = eseBcnReportMandatoryIe.supportedRates.numRates;
           pos++;
           vos_mem_copy(pos,
                        (tANI_U8*)eseBcnReportMandatoryIe.supportedRates.rate,
                        eseBcnReportMandatoryIe.supportedRates.numRates);
           pos += eseBcnReportMandatoryIe.supportedRates.numRates;
           freeBytes -= (1 + 1 +
                         eseBcnReportMandatoryIe.supportedRates.numRates);
       }
    }

    /* Fill FH Parameter set IE */
    if (eseBcnReportMandatoryIe.fhParamPresent)
    {
       if (freeBytes < (1 + 1 + SIR_MAC_FH_PARAM_SET_EID_MAX))
       {
           limLog(pMac, LOGP, FL("Insufficient memory to copy FHIE"));
           retStatus = eSIR_FAILURE;
           goto err_bcnrep;
       }
       *pos = SIR_MAC_FH_PARAM_SET_EID;
       pos++;
       *pos = SIR_MAC_FH_PARAM_SET_EID_MAX;
       pos++;
       vos_mem_copy(pos, (tANI_U8*)&eseBcnReportMandatoryIe.fhParamSet,
                    SIR_MAC_FH_PARAM_SET_EID_MAX);
       pos += SIR_MAC_FH_PARAM_SET_EID_MAX;
       freeBytes -= (1 + 1 + SIR_MAC_FH_PARAM_SET_EID_MAX);
    }

    /* Fill DS Parameter set IE */
    if (eseBcnReportMandatoryIe.dsParamsPresent)
    {
       if (freeBytes < (1 + 1 + SIR_MAC_DS_PARAM_SET_EID_MAX))
       {
           limLog(pMac, LOGP, FL("Insufficient memory to copy DS IE"));
           retStatus = eSIR_FAILURE;
           goto err_bcnrep;
       }
       *pos = SIR_MAC_DS_PARAM_SET_EID;
       pos++;
       *pos = SIR_MAC_DS_PARAM_SET_EID_MAX;
       pos++;
       *pos = eseBcnReportMandatoryIe.dsParamSet.channelNumber;
       pos += SIR_MAC_DS_PARAM_SET_EID_MAX;
       freeBytes -= (1 + 1 + SIR_MAC_DS_PARAM_SET_EID_MAX);
    }

    /* Fill CF Parameter set */
    if (eseBcnReportMandatoryIe.cfPresent)
    {
       if (freeBytes < (1 + 1 + SIR_MAC_CF_PARAM_SET_EID_MAX))
       {
           limLog(pMac, LOGP, FL("Insufficient memory to copy CF IE"));
           retStatus = eSIR_FAILURE;
           goto err_bcnrep;
       }
       *pos = SIR_MAC_CF_PARAM_SET_EID;
       pos++;
       *pos = SIR_MAC_CF_PARAM_SET_EID_MAX;
       pos++;
       vos_mem_copy(pos, (tANI_U8*)&eseBcnReportMandatoryIe.cfParamSet,
                    SIR_MAC_CF_PARAM_SET_EID_MAX);
       pos += SIR_MAC_CF_PARAM_SET_EID_MAX;
       freeBytes -= (1 + 1 + SIR_MAC_CF_PARAM_SET_EID_MAX);
    }

    /* Fill IBSS Parameter set IE */
    if (eseBcnReportMandatoryIe.ibssParamPresent)
    {
       if (freeBytes < (1 + 1 + SIR_MAC_IBSS_PARAM_SET_EID_MAX))
       {
           limLog(pMac, LOGP, FL("Insufficient memory to copy IBSS IE"));
           retStatus = eSIR_FAILURE;
           goto err_bcnrep;
       }
       *pos = SIR_MAC_IBSS_PARAM_SET_EID;
       pos++;
       *pos = SIR_MAC_IBSS_PARAM_SET_EID_MAX;
       pos++;
       vos_mem_copy(pos, (tANI_U8*)&eseBcnReportMandatoryIe.ibssParamSet.atim,
                    SIR_MAC_IBSS_PARAM_SET_EID_MAX);
       pos += SIR_MAC_IBSS_PARAM_SET_EID_MAX;
       freeBytes -= (1 + 1 + SIR_MAC_IBSS_PARAM_SET_EID_MAX);
    }

    /* Fill TIM IE */
    if (eseBcnReportMandatoryIe.timPresent)
    {
       if (freeBytes < (1 + 1 + SIR_MAC_TIM_EID_MIN))
       {
           limLog(pMac, LOGP, FL("Insufficient memory to copy TIM IE"));
           retStatus = eSIR_FAILURE;
           goto err_bcnrep;
       }
       *pos = SIR_MAC_TIM_EID;
       pos++;
       *pos = SIR_MAC_TIM_EID_MIN;
       pos++;
       vos_mem_copy(pos, (tANI_U8*)&eseBcnReportMandatoryIe.tim,
                    SIR_MAC_TIM_EID_MIN);
       pos += SIR_MAC_TIM_EID_MIN;
       freeBytes -= (1 + 1 + SIR_MAC_TIM_EID_MIN);
    }

    /* Fill RM Capability IE */
    if (eseBcnReportMandatoryIe.rrmPresent)
    {
       if (freeBytes < (1 + 1 + SIR_MAC_RM_ENABLED_CAPABILITY_EID_MAX))
       {
           limLog(pMac, LOGP, FL("Insufficient memory to copy RRM IE"));
           retStatus = eSIR_FAILURE;
           goto err_bcnrep;
       }
       *pos = SIR_MAC_RM_ENABLED_CAPABILITY_EID;
       pos++;
       *pos = SIR_MAC_RM_ENABLED_CAPABILITY_EID_MAX;
       pos++;
       vos_mem_copy(pos, (tANI_U8*)&eseBcnReportMandatoryIe.rmEnabledCapabilities,
                    SIR_MAC_RM_ENABLED_CAPABILITY_EID_MAX);
       freeBytes -= (1 + 1 + SIR_MAC_RM_ENABLED_CAPABILITY_EID_MAX);
    }

    if (freeBytes != 0)
    {
       limLog(pMac, LOGP, FL("Mismatch in allocation and copying of IE in Bcn Rep"));
       retStatus = eSIR_FAILURE;
    }

err_bcnrep:
    /* The message counter would not be incremented in case of
     * returning failure and hence next time, this function gets
     * called, it would be using the same msg ctr for a different
     * BSS.So, it is good to clear the memory allocated for a BSS
     * that is returning failure.On success, the caller would take
     * care of freeing up the memory*/
    if (retStatus == eSIR_FAILURE)
    {
       vos_mem_free(*outIeBuf);
       *outIeBuf = NULL;
    }
    vos_mem_free(pBies);
    return retStatus;
}

#endif /* FEATURE_WLAN_ESE_UPLOAD */

tSirRetStatus
sirParseBeaconIE(tpAniSirGlobal        pMac,
                 tpSirProbeRespBeacon  pBeaconStruct,
                 tANI_U8                   *pPayload,
                 tANI_U32                   nPayload)
{
    tDot11fBeaconIEs *pBies;
    tANI_U32              status;

    // Zero-init our [out] parameter,
    vos_mem_set( ( tANI_U8* )pBeaconStruct, sizeof(tSirProbeRespBeacon), 0 );

    pBies = vos_mem_malloc(sizeof(tDot11fBeaconIEs));
    if ( NULL == pBies )
        status = eHAL_STATUS_FAILURE;
    else
        status = eHAL_STATUS_SUCCESS;
    if (!HAL_STATUS_SUCCESS(status))
    {
        limLog(pMac, LOGE, FL("Failed to allocate memory") );
        return eSIR_FAILURE;
    }
    vos_mem_zero(pBies, sizeof(tDot11fBeaconIEs));

    // delegate to the framesc-generated code,
    status = dot11fUnpackBeaconIEs( pMac, pPayload, nPayload, pBies );

    if ( DOT11F_FAILED( status ) )
    {
        limLog(pMac, LOGE, FL("Failed to parse Beacon IEs (0x%08x, %d bytes)"),
                  status, nPayload);
        PELOG2(sirDumpBuf(pMac, SIR_DBG_MODULE_ID, LOG2, pPayload, nPayload);)
        vos_mem_free(pBies);
        return eSIR_FAILURE;
    }
    else if ( DOT11F_WARNED( status ) )
    {
      limLog( pMac, LOGW, FL("There were warnings while unpacking Beacon IEs (0x%08x, %d bytes)"),
                 status, nPayload );
        PELOG2(sirDumpBuf(pMac, SIR_DBG_MODULE_ID, LOG2, pPayload, nPayload);)
    }

    // & "transliterate" from a 'tDot11fBeaconIEs' to a 'tSirProbeRespBeacon'...
    if ( ! pBies->SSID.present )
    {
        PELOGW(limLog(pMac, LOGW, FL("Mandatory IE SSID not present!"));)
    }
    else
    {
        pBeaconStruct->ssidPresent = 1;
        ConvertSSID( pMac, &pBeaconStruct->ssId, &pBies->SSID );
    }

    if ( ! pBies->SuppRates.present )
    {
        PELOGW(limLog(pMac, LOGW, FL("Mandatory IE Supported Rates not present!"));)
    }
    else
    {
        pBeaconStruct->suppRatesPresent = 1;
        ConvertSuppRates( pMac, &pBeaconStruct->supportedRates, &pBies->SuppRates );
    }

    if ( pBies->ExtSuppRates.present )
    {
        pBeaconStruct->extendedRatesPresent = 1;
        ConvertExtSuppRates( pMac, &pBeaconStruct->extendedRates, &pBies->ExtSuppRates );
    }

    if ( pBies->CFParams.present )
    {
        pBeaconStruct->cfPresent = 1;
        ConvertCFParams( pMac, &pBeaconStruct->cfParamSet, &pBies->CFParams );
    }

    if ( pBies->TIM.present )
    {
        pBeaconStruct->timPresent = 1;
        ConvertTIM( pMac, &pBeaconStruct->tim, &pBies->TIM );
    }

    if ( pBies->Country.present )
    {
        pBeaconStruct->countryInfoPresent = 1;
        ConvertCountry( pMac, &pBeaconStruct->countryInfoParam, &pBies->Country );
    }

    // 11h IEs
    if(pBies->TPCReport.present)
    {
        pBeaconStruct->tpcReportPresent = 1;
        vos_mem_copy( &pBeaconStruct->tpcReport,
                      &pBies->TPCReport,
                      sizeof( tDot11fIETPCReport));
    }

    if(pBies->PowerConstraints.present)
    {
        pBeaconStruct->powerConstraintPresent = 1;
        vos_mem_copy( &pBeaconStruct->localPowerConstraint,
                      &pBies->PowerConstraints,
                      sizeof(tDot11fIEPowerConstraints));
    }
#ifdef FEATURE_WLAN_ESE
    if(pBies->ESETxmitPower.present)
    {
        pBeaconStruct->eseTxPwr.present = 1;
        pBeaconStruct->eseTxPwr.power_limit = pBies->ESETxmitPower.power_limit;
    }
    if (pBies->QBSSLoad.present)
    {
        vos_mem_copy( &pBeaconStruct->QBSSLoad, &pBies->QBSSLoad, sizeof(tDot11fIEQBSSLoad));
    }
#endif

    if ( pBies->EDCAParamSet.present )
    {
        pBeaconStruct->edcaPresent = 1;
        ConvertEDCAParam( pMac, &pBeaconStruct->edcaParams, &pBies->EDCAParamSet );
    }

    // QOS Capabilities:
    if ( pBies->QOSCapsAp.present )
    {
        pBeaconStruct->qosCapabilityPresent = 1;
        ConvertQOSCaps( pMac, &pBeaconStruct->qosCapability, &pBies->QOSCapsAp );
    }



    if ( pBies->ChanSwitchAnn.present )
    {
        pBeaconStruct->channelSwitchPresent = 1;
        vos_mem_copy( &pBeaconStruct->channelSwitchIE, &pBies->ChanSwitchAnn,
                      sizeof(tDot11fIEChanSwitchAnn));
    }

    if ( pBies->sec_chan_offset.present)
    {
        pBeaconStruct->sec_chan_offset_present= 1;
        vos_mem_copy( &pBeaconStruct->sec_chan_offset, &pBies->sec_chan_offset,
                      sizeof(tDot11fIEsec_chan_offset));
    }
    if (pBies->ext_chan_switch_ann.present)
    {
        pBeaconStruct->ecsa_present = 1;
        vos_mem_copy(&pBeaconStruct->ext_chan_switch_ann,
                     &pBies->ext_chan_switch_ann,
                     sizeof(tDot11fIEext_chan_switch_ann));
    }

    if ( pBies->Quiet.present )
    {
        pBeaconStruct->quietIEPresent = 1;
        vos_mem_copy( &pBeaconStruct->quietIE, &pBies->Quiet, sizeof(tDot11fIEQuiet) );
    }

    if ( pBies->HTCaps.present )
    {
        vos_mem_copy( &pBeaconStruct->HTCaps, &pBies->HTCaps, sizeof( tDot11fIEHTCaps ) );
    }

    if ( pBies->HTInfo.present )
    {
        vos_mem_copy( &pBeaconStruct->HTInfo, &pBies->HTInfo, sizeof( tDot11fIEHTInfo ) );
    }

    if ( pBies->DSParams.present )
    {
        pBeaconStruct->dsParamsPresent = 1;
        pBeaconStruct->channelNumber = pBies->DSParams.curr_channel;
    }
    else if(pBies->HTInfo.present)
    {
        pBeaconStruct->channelNumber = pBies->HTInfo.primaryChannel;
    }
    
    if ( pBies->RSN.present )
    {
        pBeaconStruct->rsnPresent = 1;
        ConvertRSN( pMac, &pBeaconStruct->rsn, &pBies->RSN );
    }

    if ( pBies->WPA.present )
    {
        pBeaconStruct->wpaPresent = 1;
        ConvertWPA( pMac, &pBeaconStruct->wpa, &pBies->WPA );
    }

    if ( pBies->WMMParams.present )
    {
        pBeaconStruct->wmeEdcaPresent = 1;
        ConvertWMMParams( pMac, &pBeaconStruct->edcaParams, &pBies->WMMParams );
    }

    if ( pBies->WMMInfoAp.present )
    {
        pBeaconStruct->wmeInfoPresent = 1;
    }

    if ( pBies->WMMCaps.present )
    {
        pBeaconStruct->wsmCapablePresent = 1;
    }


    if ( pBies->ERPInfo.present )
    {
        pBeaconStruct->erpPresent = 1;
        ConvertERPInfo( pMac, &pBeaconStruct->erpIEInfo, &pBies->ERPInfo );
    }

#ifdef WLAN_FEATURE_11AC
    if ( pBies->VHTCaps.present )
    {
         pBeaconStruct->VHTCaps.present = 1;
         vos_mem_copy( &pBeaconStruct->VHTCaps, &pBies->VHTCaps, sizeof( tDot11fIEVHTCaps ) );
    }
    if ( pBies->VHTOperation.present )
    {
         pBeaconStruct->VHTOperation.present = 1;
         vos_mem_copy( &pBeaconStruct->VHTOperation, &pBies->VHTOperation,
                       sizeof( tDot11fIEVHTOperation) );
    }
    if ( pBies->VHTExtBssLoad.present )
    {
         pBeaconStruct->VHTExtBssLoad.present = 1;
         vos_mem_copy( &pBeaconStruct->VHTExtBssLoad, &pBies->VHTExtBssLoad,
                       sizeof( tDot11fIEVHTExtBssLoad) );
    }
    if( pBies->OperatingMode.present)
    {
        pBeaconStruct->OperatingMode.present = 1;
        vos_mem_copy( &pBeaconStruct->OperatingMode, &pBies->OperatingMode,
                      sizeof( tDot11fIEOperatingMode) );
    }

#endif
    if (pBies->ExtCap.present )
    {
        pBeaconStruct->ExtCap.present = 1;
        vos_mem_copy( &pBeaconStruct->ExtCap, &pBies->ExtCap,
                        sizeof(tDot11fIEExtCap));
    }
    sir_copy_hs20_ie(&pBeaconStruct->hs20vendor_ie, &pBies->hs20vendor_ie);

    vos_mem_free(pBies);


    return eSIR_SUCCESS;

} // End sirParseBeaconIE.

tSirRetStatus
sirConvertBeaconFrame2Struct(tpAniSirGlobal       pMac,
                             tANI_U8             *pFrame,
                             tpSirProbeRespBeacon pBeaconStruct)
{
    tDot11fBeacon  *pBeacon;
    tANI_U32        status, nPayload;
    tANI_U8        *pPayload;
    tpSirMacMgmtHdr pHdr;
    tANI_U8         mappedRXCh;
    tANI_U8         rfBand;

    pPayload = WDA_GET_RX_MPDU_DATA( pFrame );
    nPayload = WDA_GET_RX_PAYLOAD_LEN( pFrame );
    pHdr     = WDA_GET_RX_MAC_HEADER( pFrame );
    mappedRXCh = WDA_GET_RX_CH( pFrame );
    rfBand = WDA_GET_RX_RFBAND( pFrame );
    
    // Zero-init our [out] parameter,
    vos_mem_set( ( tANI_U8* )pBeaconStruct, sizeof(tSirProbeRespBeacon), 0 );

    pBeacon = vos_mem_vmalloc(sizeof(tDot11fBeacon));
    if ( NULL == pBeacon )
        status = eHAL_STATUS_FAILURE;
    else
        status = eHAL_STATUS_SUCCESS;
    if (!HAL_STATUS_SUCCESS(status))
    {
        limLog(pMac, LOGE, FL("Failed to allocate memory") );
        return eSIR_FAILURE;
    }

    vos_mem_set( ( tANI_U8* )pBeacon, sizeof(tDot11fBeacon), 0 );

    // get the MAC address out of the BD,
    vos_mem_copy( pBeaconStruct->bssid, pHdr->sa, 6 );

    // delegate to the framesc-generated code,
    status = dot11fUnpackBeacon( pMac, pPayload, nPayload, pBeacon );
    if ( DOT11F_FAILED( status ) )
    {
        limLog(pMac, LOGE, FL("Failed to parse Beacon IEs (0x%08x, %d bytes)"),
                  status, nPayload);
        PELOG2(sirDumpBuf(pMac, SIR_DBG_MODULE_ID, LOG2, pPayload, nPayload);)
        vos_mem_vfree(pBeacon);
        return eSIR_FAILURE;
    }

    // & "transliterate" from a 'tDot11fBeacon' to a 'tSirProbeRespBeacon'...
    // Timestamp
    vos_mem_copy( ( tANI_U8* )pBeaconStruct->timeStamp, ( tANI_U8* )&pBeacon->TimeStamp,
                   sizeof(tSirMacTimeStamp) );

    // Beacon Interval
    pBeaconStruct->beaconInterval = pBeacon->BeaconInterval.interval;

    // Capabilities
    pBeaconStruct->capabilityInfo.ess            = pBeacon->Capabilities.ess;
    pBeaconStruct->capabilityInfo.ibss           = pBeacon->Capabilities.ibss;
    pBeaconStruct->capabilityInfo.cfPollable     = pBeacon->Capabilities.cfPollable;
    pBeaconStruct->capabilityInfo.cfPollReq      = pBeacon->Capabilities.cfPollReq;
    pBeaconStruct->capabilityInfo.privacy        = pBeacon->Capabilities.privacy;
    pBeaconStruct->capabilityInfo.shortPreamble  = pBeacon->Capabilities.shortPreamble;
    pBeaconStruct->capabilityInfo.pbcc           = pBeacon->Capabilities.pbcc;
    pBeaconStruct->capabilityInfo.channelAgility = pBeacon->Capabilities.channelAgility;
    pBeaconStruct->capabilityInfo.spectrumMgt    = pBeacon->Capabilities.spectrumMgt;
    pBeaconStruct->capabilityInfo.qos            = pBeacon->Capabilities.qos;
    pBeaconStruct->capabilityInfo.shortSlotTime  = pBeacon->Capabilities.shortSlotTime;
    pBeaconStruct->capabilityInfo.apsd           = pBeacon->Capabilities.apsd;
    pBeaconStruct->capabilityInfo.rrm            = pBeacon->Capabilities.rrm;
    pBeaconStruct->capabilityInfo.dsssOfdm      = pBeacon->Capabilities.dsssOfdm;
    pBeaconStruct->capabilityInfo.delayedBA     = pBeacon->Capabilities.delayedBA;
    pBeaconStruct->capabilityInfo.immediateBA    = pBeacon->Capabilities.immediateBA;
 
    if ( ! pBeacon->SSID.present )
    {
        PELOGW(limLog(pMac, LOGW, FL("Mandatory IE SSID not present!"));)
    }
    else
    {
        pBeaconStruct->ssidPresent = 1;
        ConvertSSID( pMac, &pBeaconStruct->ssId, &pBeacon->SSID );
    }

    if ( ! pBeacon->SuppRates.present )
    {
        PELOGW(limLog(pMac, LOGW, FL("Mandatory IE Supported Rates not present!"));)
    }
    else
    {
        pBeaconStruct->suppRatesPresent = 1;
        ConvertSuppRates( pMac, &pBeaconStruct->supportedRates, &pBeacon->SuppRates );
    }

    if ( pBeacon->ExtSuppRates.present )
    {
        pBeaconStruct->extendedRatesPresent = 1;
        ConvertExtSuppRates( pMac, &pBeaconStruct->extendedRates, &pBeacon->ExtSuppRates );
    }


    if ( pBeacon->CFParams.present )
    {
        pBeaconStruct->cfPresent = 1;
        ConvertCFParams( pMac, &pBeaconStruct->cfParamSet, &pBeacon->CFParams );
    }

    if ( pBeacon->TIM.present )
    {
        pBeaconStruct->timPresent = 1;
        ConvertTIM( pMac, &pBeaconStruct->tim, &pBeacon->TIM );
    }

    if ( pBeacon->Country.present )
    {
        pBeaconStruct->countryInfoPresent = 1;
        ConvertCountry( pMac, &pBeaconStruct->countryInfoParam, &pBeacon->Country );
    }

    // QOS Capabilities:
    if ( pBeacon->QOSCapsAp.present )
    {
        pBeaconStruct->qosCapabilityPresent = 1;
        ConvertQOSCaps( pMac, &pBeaconStruct->qosCapability, &pBeacon->QOSCapsAp );
    }

    if ( pBeacon->EDCAParamSet.present )
    {
        pBeaconStruct->edcaPresent = 1;
        ConvertEDCAParam( pMac, &pBeaconStruct->edcaParams, &pBeacon->EDCAParamSet );
    }

    if ( pBeacon->ChanSwitchAnn.present )
    {
        pBeaconStruct->channelSwitchPresent = 1;
        vos_mem_copy( &pBeaconStruct->channelSwitchIE, &pBeacon->ChanSwitchAnn,
                                                       sizeof(tDot11fIEChanSwitchAnn) );
    }
    if ( pBeacon->sec_chan_offset.present )
    {
        pBeaconStruct->sec_chan_offset_present = 1;
        vos_mem_copy(&pBeaconStruct->sec_chan_offset, &pBeacon->sec_chan_offset,
                      sizeof(tDot11fIEsec_chan_offset));
    }
    if (pBeacon->ext_chan_switch_ann.present)
    {
        pBeaconStruct->ecsa_present = 1;
        vos_mem_copy(&pBeaconStruct->ext_chan_switch_ann,
                     &pBeacon->ext_chan_switch_ann,
                     sizeof(tDot11fIEext_chan_switch_ann));
    }

    if( pBeacon->TPCReport.present)
    {
        pBeaconStruct->tpcReportPresent = 1;
        vos_mem_copy( &pBeaconStruct->tpcReport, &pBeacon->TPCReport,
                                                     sizeof(tDot11fIETPCReport));
    }

    if( pBeacon->PowerConstraints.present)
    {
        pBeaconStruct->powerConstraintPresent = 1;
        vos_mem_copy( &pBeaconStruct->localPowerConstraint, &pBeacon->PowerConstraints,
                                                               sizeof(tDot11fIEPowerConstraints));
    }

    if ( pBeacon->Quiet.present )
    {
        pBeaconStruct->quietIEPresent = 1;
        vos_mem_copy( &pBeaconStruct->quietIE, &pBeacon->Quiet, sizeof(tDot11fIEQuiet));
    }

    if ( pBeacon->HTCaps.present )
    {
        vos_mem_copy( &pBeaconStruct->HTCaps, &pBeacon->HTCaps, sizeof( tDot11fIEHTCaps ) );
    }

    if ( pBeacon->HTInfo.present )
    {
        vos_mem_copy( &pBeaconStruct->HTInfo, &pBeacon->HTInfo, sizeof( tDot11fIEHTInfo) );

    }

    if ( pBeacon->DSParams.present )
    {
        pBeaconStruct->dsParamsPresent = 1;
        pBeaconStruct->channelNumber = pBeacon->DSParams.curr_channel;
    }
    else if(pBeacon->HTInfo.present)
    {
        pBeaconStruct->channelNumber = pBeacon->HTInfo.primaryChannel;
    }
    else
    {
       if ((!rfBand) || IS_5G_BAND(rfBand))
           pBeaconStruct->channelNumber = limUnmapChannel(mappedRXCh);
       else if (IS_24G_BAND(rfBand))
           pBeaconStruct->channelNumber = mappedRXCh;
       else
       {
           /*Only 0, 1, 2 are expected values for RF band from FW
            * if FW fixes are not present then rf band value will
            * be 0, else either 1 or 2 are expected from FW, 3 is
            * not expected from FW */
           PELOGE(limLog(pMac, LOGE,
           FL("Channel info is not present in Beacon and"
                   " mapping is not done correctly"));)
           pBeaconStruct->channelNumber = mappedRXCh;
       }
    }

    if ( pBeacon->RSN.present )
    {
        pBeaconStruct->rsnPresent = 1;
        ConvertRSN( pMac, &pBeaconStruct->rsn, &pBeacon->RSN );
    }

    if ( pBeacon->WPA.present )
    {
        pBeaconStruct->wpaPresent = 1;
        ConvertWPA( pMac, &pBeaconStruct->wpa, &pBeacon->WPA );
    }

    if ( pBeacon->WMMParams.present )
    {
        pBeaconStruct->wmeEdcaPresent = 1;
        ConvertWMMParams( pMac, &pBeaconStruct->edcaParams, &pBeacon->WMMParams );
        PELOG1(limLog(pMac, LOG1, FL("WMM Parameter present in Beacon Frame!"));
        __printWMMParams(pMac, &pBeacon->WMMParams); )
    }

    if ( pBeacon->WMMInfoAp.present )
    {
        pBeaconStruct->wmeInfoPresent = 1;
        PELOG1(limLog(pMac, LOG1, FL("WMM Info present in Beacon Frame!"));)
    }

    if ( pBeacon->WMMCaps.present )
    {
        pBeaconStruct->wsmCapablePresent = 1;
    }

    if ( pBeacon->ERPInfo.present )
    {
        pBeaconStruct->erpPresent = 1;
        ConvertERPInfo( pMac, &pBeaconStruct->erpIEInfo, &pBeacon->ERPInfo );
    }

#ifdef WLAN_FEATURE_VOWIFI_11R
    if (pBeacon->MobilityDomain.present)
    {
        // MobilityDomain
        pBeaconStruct->mdiePresent = 1;
        vos_mem_copy( (tANI_U8 *)&(pBeaconStruct->mdie[0]),
                      (tANI_U8 *)&(pBeacon->MobilityDomain.MDID), sizeof(tANI_U16) );
        pBeaconStruct->mdie[2] = ((pBeacon->MobilityDomain.overDSCap << 0) | (pBeacon->MobilityDomain.resourceReqCap << 1));

    }
#endif

#ifdef FEATURE_WLAN_ESE
    if (pBeacon->ESETxmitPower.present)
    {
        //ESE Tx Power
        pBeaconStruct->eseTxPwr.present = 1;
        vos_mem_copy(&pBeaconStruct->eseTxPwr,
                                   &pBeacon->ESETxmitPower,
                                   sizeof(tDot11fIEESETxmitPower));
    }
#endif

#ifdef WLAN_FEATURE_11AC
    if ( pBeacon->VHTCaps.present )
    {
        vos_mem_copy( &pBeaconStruct->VHTCaps, &pBeacon->VHTCaps, sizeof( tDot11fIEVHTCaps ) );
    }
    if ( pBeacon->VHTOperation.present )
    {
        vos_mem_copy( &pBeaconStruct->VHTOperation, &pBeacon->VHTOperation,
                      sizeof( tDot11fIEVHTOperation) );
    }
    if ( pBeacon->VHTExtBssLoad.present )
    {
        vos_mem_copy( &pBeaconStruct->VHTExtBssLoad, &pBeacon->VHTExtBssLoad,
                      sizeof( tDot11fIEVHTExtBssLoad) );
    }
    if(pBeacon->OperatingMode.present)
    {
        vos_mem_copy( &pBeaconStruct->OperatingMode, &pBeacon->OperatingMode,
                      sizeof( tDot11fIEOperatingMode) );
    }
    if(pBeacon->WiderBWChanSwitchAnn.present)
    {
        pBeaconStruct->WiderBWChanSwitchAnnPresent = 1;
        vos_mem_copy( &pBeaconStruct->WiderBWChanSwitchAnn, &pBeacon->WiderBWChanSwitchAnn,
                      sizeof( tDot11fIEWiderBWChanSwitchAnn));
    }      
#endif
    if(pBeacon->OBSSScanParameters.present)
    {
       vos_mem_copy( &pBeaconStruct->OBSSScanParameters,
                     &pBeacon->OBSSScanParameters,
                     sizeof( tDot11fIEOBSSScanParameters));
    }
    sir_copy_hs20_ie(&pBeaconStruct->hs20vendor_ie, &pBeacon->hs20vendor_ie);

    vos_mem_vfree(pBeacon);
    return eSIR_SUCCESS;

} // End sirConvertBeaconFrame2Struct.

tSirRetStatus
sirConvertAuthFrame2Struct(tpAniSirGlobal        pMac,
                           tANI_U8                   *pFrame,
                           tANI_U32                   nFrame,
                           tpSirMacAuthFrameBody pAuth)
{
    static tDot11fAuthentication auth;
    tANI_U32                   status;

    // Zero-init our [out] parameter,
    vos_mem_set( ( tANI_U8* )pAuth, sizeof(tSirMacAuthFrameBody), 0 );

    // delegate to the framesc-generated code,
    status = dot11fUnpackAuthentication( pMac, pFrame, nFrame, &auth );
    if ( DOT11F_FAILED( status ) )
    {
        limLog(pMac, LOGE, FL("Failed to parse an Authentication frame (0x%08x, %d bytes)"),
                  status, nFrame);
        PELOG2(sirDumpBuf(pMac, SIR_DBG_MODULE_ID, LOG2, pFrame, nFrame);)
        return eSIR_FAILURE;
    }
    else if ( DOT11F_WARNED( status ) )
    {
      limLog( pMac, LOGW, FL("There were warnings while unpacking an Authentication frame (0x%08x, %d bytes)"),
                 status, nFrame );
        PELOG2(sirDumpBuf(pMac, SIR_DBG_MODULE_ID, LOG2, pFrame, nFrame);)
    }

    // & "transliterate" from a 'tDot11fAuthentication' to a 'tSirMacAuthFrameBody'...
    pAuth->authAlgoNumber           = auth.AuthAlgo.algo;
    pAuth->authTransactionSeqNumber = auth.AuthSeqNo.no;
    pAuth->authStatusCode           = auth.Status.status;

    if ( auth.ChallengeText.present )
    {
        pAuth->type   = SIR_MAC_CHALLENGE_TEXT_EID;
        pAuth->length = auth.ChallengeText.num_text;
        vos_mem_copy( pAuth->challengeText, auth.ChallengeText.text, auth.ChallengeText.num_text );
    }

    return eSIR_SUCCESS;

} // End sirConvertAuthFrame2Struct.

tSirRetStatus
sirConvertAddtsReq2Struct(tpAniSirGlobal    pMac,
                          tANI_U8               *pFrame,
                          tANI_U32               nFrame,
                          tSirAddtsReqInfo *pAddTs)
{
    tDot11fAddTSRequest    addts = {{0}};
    tDot11fWMMAddTSRequest wmmaddts = {{0}};
    tANI_U8                     j;
    tANI_U16                    i;
    tANI_U32                    status;

    if ( SIR_MAC_QOS_ADD_TS_REQ != *( pFrame + 1 ) )
    {
        limLog( pMac, LOGE, FL("sirConvertAddtsReq2Struct invoked "
                                  "with an Action of %d; this is not "
                                  "supported & is probably an error."),
                   *( pFrame + 1 ) );
        return eSIR_FAILURE;
    }

    // Zero-init our [out] parameter,
    vos_mem_set( ( tANI_U8* )pAddTs, sizeof(tSirAddtsReqInfo), 0 );

    // delegate to the framesc-generated code,
    switch ( *pFrame )
    {
    case SIR_MAC_ACTION_QOS_MGMT:
        status = dot11fUnpackAddTSRequest( pMac, pFrame, nFrame, &addts );
        break;
    case SIR_MAC_ACTION_WME:
        status = dot11fUnpackWMMAddTSRequest( pMac, pFrame, nFrame, &wmmaddts );
        break;
    default:
        limLog( pMac, LOGE, FL("sirConvertAddtsReq2Struct invoked "
                                  "with a Category of %d; this is not"
                                  " supported & is probably an error."),
                   *pFrame );
        return eSIR_FAILURE;
    }

    if ( DOT11F_FAILED( status ) )
    {
        limLog(pMac, LOGE, FL("Failed to parse an Add TS Request f"
                                 "rame (0x%08x, %d bytes)"),
                  status, nFrame);
        PELOG2(sirDumpBuf(pMac, SIR_DBG_MODULE_ID, LOG2, pFrame, nFrame);)
        return eSIR_FAILURE;
    }
    else if ( DOT11F_WARNED( status ) )
    {
        limLog( pMac, LOGW, FL("There were warnings while unpackin"
                                  "g an Add TS Request frame (0x%08x,"
                                  "%d bytes)"),
                   status, nFrame );
        PELOG2(sirDumpBuf(pMac, SIR_DBG_MODULE_ID, LOG2, pFrame, nFrame);)
    }

    // & "transliterate" from a 'tDot11fAddTSRequest' or a
    // 'tDot11WMMAddTSRequest' to a 'tSirMacAddtsReqInfo'...
    if ( SIR_MAC_ACTION_QOS_MGMT == *pFrame )
    {
        pAddTs->dialogToken = addts.DialogToken.token;

        if ( addts.TSPEC.present )
        {
            ConvertTSPEC( pMac, &pAddTs->tspec, &addts.TSPEC );
        }
        else
        {
            limLog( pMac, LOGE, FL("Mandatory TSPEC element missing in Add TS Request.") );
            return eSIR_FAILURE;
        }

        if ( addts.num_TCLAS )
        {
            pAddTs->numTclas = (tANI_U8)addts.num_TCLAS;

            for ( i = 0U; i < addts.num_TCLAS; ++i )
            {
                if ( eSIR_SUCCESS != ConvertTCLAS( pMac, &( pAddTs->tclasInfo[i] ), &( addts.TCLAS[i] ) ) )
                {
                    limLog( pMac, LOGE, FL("Failed to convert a TCLAS IE.") );
                    return eSIR_FAILURE;
                }
            }
        }

        if ( addts.TCLASSPROC.present )
        {
            pAddTs->tclasProcPresent = 1;
            pAddTs->tclasProc = addts.TCLASSPROC.processing;
        }

        if ( addts.WMMTSPEC.present )
        {
            pAddTs->wsmTspecPresent = 1;
            ConvertWMMTSPEC( pMac, &pAddTs->tspec, &addts.WMMTSPEC );
        }

        if ( addts.num_WMMTCLAS )
        {
            j = (tANI_U8)(pAddTs->numTclas + addts.num_WMMTCLAS);
            if ( SIR_MAC_TCLASIE_MAXNUM < j ) j = SIR_MAC_TCLASIE_MAXNUM;

            for ( i = pAddTs->numTclas; i < j; ++i )
            {
                if ( eSIR_SUCCESS != ConvertWMMTCLAS( pMac, &( pAddTs->tclasInfo[i] ), &( addts.WMMTCLAS[i] ) ) )
                {
                    limLog( pMac, LOGE, FL("Failed to convert a TCLAS IE.") );
                    return eSIR_FAILURE;
                }
            }
        }

        if ( addts.WMMTCLASPROC.present )
        {
            pAddTs->tclasProcPresent = 1;
            pAddTs->tclasProc = addts.WMMTCLASPROC.processing;
        }

        if ( 1 < pAddTs->numTclas && ( ! pAddTs->tclasProcPresent ) )
        {
            limLog( pMac, LOGE, FL("%d TCLAS IE but not TCLASPROC IE."),
                       pAddTs->numTclas );
            return eSIR_FAILURE;
        }
    }
    else
    {
        pAddTs->dialogToken = wmmaddts.DialogToken.token;

        if ( wmmaddts.WMMTSPEC.present )
        {
            pAddTs->wmeTspecPresent = 1;
            ConvertWMMTSPEC( pMac, &pAddTs->tspec, &wmmaddts.WMMTSPEC );
        }
        else
        {
            limLog( pMac, LOGE, FL("Mandatory WME TSPEC element missing!") );
            return eSIR_FAILURE;
        }
    }

    return eSIR_SUCCESS;

} // End sirConvertAddtsReq2Struct.

tSirRetStatus
sirConvertAddtsRsp2Struct(tpAniSirGlobal    pMac,
                          tANI_U8               *pFrame,
                          tANI_U32               nFrame,
                          tSirAddtsRspInfo *pAddTs)
{
    tDot11fAddTSResponse    addts = {{0}};
    tDot11fWMMAddTSResponse wmmaddts = {{0}};
    tANI_U8                      j;
    tANI_U16                     i;
    tANI_U32                     status;

    if ( SIR_MAC_QOS_ADD_TS_RSP != *( pFrame + 1 ) )
    {
        limLog( pMac, LOGE, FL("sirConvertAddtsRsp2Struct invoked "
                                  "with an Action of %d; this is not "
                                  "supported & is probably an error."),
                   *( pFrame + 1 ) );
        return eSIR_FAILURE;
    }

    // Zero-init our [out] parameter,
    vos_mem_set( ( tANI_U8* )pAddTs, sizeof(tSirAddtsRspInfo), 0 );
    vos_mem_set( ( tANI_U8* )&addts, sizeof(tDot11fAddTSResponse), 0 );
    vos_mem_set( ( tANI_U8* )&wmmaddts, sizeof(tDot11fWMMAddTSResponse), 0 );


    // delegate to the framesc-generated code,
    switch ( *pFrame )
    {
    case SIR_MAC_ACTION_QOS_MGMT:
        status = dot11fUnpackAddTSResponse( pMac, pFrame, nFrame, &addts );
        break;
    case SIR_MAC_ACTION_WME:
        status = dot11fUnpackWMMAddTSResponse( pMac, pFrame, nFrame, &wmmaddts );
        break;
    default:
        limLog( pMac, LOGE, FL("sirConvertAddtsRsp2Struct invoked "
                                  "with a Category of %d; this is not"
                                  " supported & is probably an error."),
                   *pFrame );
        return eSIR_FAILURE;
    }

    if ( DOT11F_FAILED( status ) )
    {
        limLog(pMac, LOGE, FL("Failed to parse an Add TS Response f"
                                 "rame (0x%08x, %d bytes)"),
                  status, nFrame);
        PELOG2(sirDumpBuf(pMac, SIR_DBG_MODULE_ID, LOG2, pFrame, nFrame);)
        return eSIR_FAILURE;
    }
    else if ( DOT11F_WARNED( status ) )
    {
        limLog( pMac, LOGW, FL("There were warnings while unpackin"
                                  "g an Add TS Response frame (0x%08x,"
                                  "%d bytes)"),
                   status, nFrame );
        PELOG2(sirDumpBuf(pMac, SIR_DBG_MODULE_ID, LOG2, pFrame, nFrame);)
    }

    // & "transliterate" from a 'tDot11fAddTSResponse' or a
    // 'tDot11WMMAddTSResponse' to a 'tSirMacAddtsRspInfo'...
    if ( SIR_MAC_ACTION_QOS_MGMT == *pFrame )
    {
        pAddTs->dialogToken = addts.DialogToken.token;
        pAddTs->status      = ( tSirMacStatusCodes )addts.Status.status;

        if ( addts.TSDelay.present )
        {
            ConvertTSDelay( pMac, &pAddTs->delay, &addts.TSDelay );
        }

        // TS Delay is present iff status indicates its presence
        if ( eSIR_MAC_TS_NOT_CREATED_STATUS == pAddTs->status && ! addts.TSDelay.present )
        {
            limLog( pMac, LOGW, FL("Missing TSDelay IE.") );
        }

        if ( addts.TSPEC.present )
        {
            ConvertTSPEC( pMac, &pAddTs->tspec, &addts.TSPEC );
        }
        else
        {
            limLog( pMac, LOGE, FL("Mandatory TSPEC element missing in Add TS Response.") );
            return eSIR_FAILURE;
        }

        if ( addts.num_TCLAS )
        {
            pAddTs->numTclas = (tANI_U8)addts.num_TCLAS;

            for ( i = 0U; i < addts.num_TCLAS; ++i )
            {
                if ( eSIR_SUCCESS != ConvertTCLAS( pMac, &( pAddTs->tclasInfo[i] ), &( addts.TCLAS[i] ) ) )
                {
                    limLog( pMac, LOGE, FL("Failed to convert a TCLAS IE.") );
                    return eSIR_FAILURE;
                }
            }
        }

        if ( addts.TCLASSPROC.present )
        {
            pAddTs->tclasProcPresent = 1;
            pAddTs->tclasProc = addts.TCLASSPROC.processing;
        }
#ifdef FEATURE_WLAN_ESE
        if(addts.ESETrafStrmMet.present)
        {
            pAddTs->tsmPresent = 1;
            vos_mem_copy(&pAddTs->tsmIE.tsid,
                      &addts.ESETrafStrmMet.tsid,sizeof(tSirMacESETSMIE));
        }
#endif
        if ( addts.Schedule.present )
        {
            pAddTs->schedulePresent = 1;
            ConvertSchedule( pMac, &pAddTs->schedule, &addts.Schedule );
        }

        if ( addts.WMMSchedule.present )
        {
            pAddTs->schedulePresent = 1;
            ConvertWMMSchedule( pMac, &pAddTs->schedule, &addts.WMMSchedule );
        }

        if ( addts.WMMTSPEC.present )
        {
            pAddTs->wsmTspecPresent = 1;
            ConvertWMMTSPEC( pMac, &pAddTs->tspec, &addts.WMMTSPEC );
        }

        if ( addts.num_WMMTCLAS )
        {
            j = (tANI_U8)(pAddTs->numTclas + addts.num_WMMTCLAS);
            if ( SIR_MAC_TCLASIE_MAXNUM < j ) j = SIR_MAC_TCLASIE_MAXNUM;

            for ( i = pAddTs->numTclas; i < j; ++i )
            {
                if ( eSIR_SUCCESS != ConvertWMMTCLAS( pMac, &( pAddTs->tclasInfo[i] ), &( addts.WMMTCLAS[i] ) ) )
                {
                    limLog( pMac, LOGE, FL("Failed to convert a TCLAS IE.") );
                    return eSIR_FAILURE;
                }
            }
        }

        if ( addts.WMMTCLASPROC.present )
        {
            pAddTs->tclasProcPresent = 1;
            pAddTs->tclasProc = addts.WMMTCLASPROC.processing;
        }

        if ( 1 < pAddTs->numTclas && ( ! pAddTs->tclasProcPresent ) )
        {
            limLog( pMac, LOGE, FL("%d TCLAS IE but not TCLASPROC IE."),
                       pAddTs->numTclas );
            return eSIR_FAILURE;
        }
    }
    else
    {
        pAddTs->dialogToken = wmmaddts.DialogToken.token;
        pAddTs->status      = ( tSirMacStatusCodes )wmmaddts.StatusCode.statusCode;

        if ( wmmaddts.WMMTSPEC.present )
        {
            pAddTs->wmeTspecPresent = 1;
            ConvertWMMTSPEC( pMac, &pAddTs->tspec, &wmmaddts.WMMTSPEC );
        }
        else
        {
            limLog( pMac, LOGE, FL("Mandatory WME TSPEC element missing!") );
            return eSIR_FAILURE;
        }

#ifdef FEATURE_WLAN_ESE
        if(wmmaddts.ESETrafStrmMet.present)
        {
            pAddTs->tsmPresent = 1;
            vos_mem_copy(&pAddTs->tsmIE.tsid,
                         &wmmaddts.ESETrafStrmMet.tsid,sizeof(tSirMacESETSMIE));
        }
#endif

    }

    return eSIR_SUCCESS;

} // End sirConvertAddtsRsp2Struct.

tSirRetStatus
sirConvertDeltsReq2Struct(tpAniSirGlobal    pMac,
                          tANI_U8               *pFrame,
                          tANI_U32               nFrame,
                          tSirDeltsReqInfo *pDelTs)
{
    tDot11fDelTS    delts = {{0}};
    tDot11fWMMDelTS wmmdelts = {{0}};
    tANI_U32             status;

    if ( SIR_MAC_QOS_DEL_TS_REQ != *( pFrame + 1 ) )
    {
        limLog( pMac, LOGE, FL("sirConvertDeltsRsp2Struct invoked "
                                  "with an Action of %d; this is not "
                                  "supported & is probably an error."),
                   *( pFrame + 1 ) );
        return eSIR_FAILURE;
    }

    // Zero-init our [out] parameter,
    vos_mem_set( ( tANI_U8* )pDelTs, sizeof(tSirDeltsReqInfo), 0 );

    // delegate to the framesc-generated code,
    switch ( *pFrame )
    {
    case SIR_MAC_ACTION_QOS_MGMT:
        status = dot11fUnpackDelTS( pMac, pFrame, nFrame, &delts );
        break;
    case SIR_MAC_ACTION_WME:
        status = dot11fUnpackWMMDelTS( pMac, pFrame, nFrame, &wmmdelts );
        break;
    default:
        limLog( pMac, LOGE, FL("sirConvertDeltsRsp2Struct invoked "
                                  "with a Category of %d; this is not"
                                  " supported & is probably an error."),
                   *pFrame );
        return eSIR_FAILURE;
    }

    if ( DOT11F_FAILED( status ) )
    {
        limLog(pMac, LOGE, FL("Failed to parse an Del TS Request f"
                                 "rame (0x%08x, %d bytes)"),
                  status, nFrame);
        PELOG2(sirDumpBuf(pMac, SIR_DBG_MODULE_ID, LOG2, pFrame, nFrame);)
        return eSIR_FAILURE;
    }
    else if ( DOT11F_WARNED( status ) )
    {
        dot11fLog( pMac, LOGW, FL("There were warnings while unpackin"
                                  "g an Del TS Request frame (0x%08x,"
                                  "%d bytes):"),
                   status, nFrame );
        PELOG2(sirDumpBuf(pMac, SIR_DBG_MODULE_ID, LOG2, pFrame, nFrame);)
    }

    // & "transliterate" from a 'tDot11fDelTSResponse' or a
    // 'tDot11WMMDelTSResponse' to a 'tSirMacDeltsReqInfo'...
    if ( SIR_MAC_ACTION_QOS_MGMT == *pFrame )
    {
        pDelTs->tsinfo.traffic.trafficType  = (tANI_U16)delts.TSInfo.traffic_type;
        pDelTs->tsinfo.traffic.tsid         = (tANI_U16)delts.TSInfo.tsid;
        pDelTs->tsinfo.traffic.direction    = (tANI_U16)delts.TSInfo.direction;
        pDelTs->tsinfo.traffic.accessPolicy = (tANI_U16)delts.TSInfo.access_policy;
        pDelTs->tsinfo.traffic.aggregation  = (tANI_U16)delts.TSInfo.aggregation;
        pDelTs->tsinfo.traffic.psb          = (tANI_U16)delts.TSInfo.psb;
        pDelTs->tsinfo.traffic.userPrio     = (tANI_U16)delts.TSInfo.user_priority;
        pDelTs->tsinfo.traffic.ackPolicy    = (tANI_U16)delts.TSInfo.tsinfo_ack_pol;

        pDelTs->tsinfo.schedule.schedule    = (tANI_U8)delts.TSInfo.schedule;
    }
    else
    {
        if ( wmmdelts.WMMTSPEC.present )
        {
            pDelTs->wmeTspecPresent = 1;
            ConvertWMMTSPEC( pMac, &pDelTs->tspec, &wmmdelts.WMMTSPEC );
        }
        else
        {
            dot11fLog( pMac, LOGE, FL("Mandatory WME TSPEC element missing!") );
            return eSIR_FAILURE;
        }
    }

    return eSIR_SUCCESS;

} // End sirConvertDeltsReq2Struct.

tSirRetStatus
sirConvertQosMapConfigureFrame2Struct(tpAniSirGlobal    pMac,
                          tANI_U8               *pFrame,
                          tANI_U32               nFrame,
                          tSirQosMapSet      *pQosMapSet)
{
    tDot11fQosMapConfigure mapConfigure;
    tANI_U32 status;
    status = dot11fUnpackQosMapConfigure(pMac, pFrame, nFrame, &mapConfigure);
    if ( DOT11F_FAILED( status ) || !mapConfigure.QosMapSet.present )
    {
        dot11fLog(pMac, LOGE, FL("Failed to parse or QosMapSet not present(0x%08x, %d bytes):"),
                  status, nFrame);
        PELOG2(sirDumpBuf(pMac, SIR_DBG_MODULE_ID, LOG2, pFrame, nFrame);)
        return eSIR_FAILURE;
    }
    else if ( DOT11F_WARNED( status ) )
    {
      dot11fLog( pMac, LOGW, FL("There were warnings while unpacking Qos Map Configure frame (0x%08x, %d bytes):"),
                 status, nFrame );
        PELOG2(sirDumpBuf(pMac, SIR_DBG_MODULE_ID, LOG2, pFrame, nFrame);)
    }
    pQosMapSet->present = mapConfigure.QosMapSet.present;
    ConvertQosMapsetFrame(pMac->hHdd, pQosMapSet, &mapConfigure.QosMapSet);
    limLogQosMapSet(pMac, pQosMapSet);
    return eSIR_SUCCESS;
}

#ifdef ANI_SUPPORT_11H
tSirRetStatus
sirConvertTpcReqFrame2Struct(tpAniSirGlobal            pMac,
                             tANI_U8                       *pFrame,
                             tpSirMacTpcReqActionFrame pTpcReqFrame,
                             tANI_U32                       nFrame)
{
    tDot11fTPCRequest     req;
    tANI_U32                   status;

    // Zero-init our [out] parameter,
    vos_mem_set( ( tANI_U8* )pTpcReqFrame, sizeof(tSirMacTpcReqActionFrame), 0 );

    // delegate to the framesc-generated code,
    status = dot11fUnpackTPCRequest( pMac, pFrame, nFrame, &req );
    if ( DOT11F_FAILED( status ) )
    {
        dot11fLog(pMac, LOGE, FL("Failed to parse a TPC Request frame (0x%08x, %d bytes):"),
                  status, nFrame);
        PELOG2(sirDumpBuf(pMac, SIR_DBG_MODULE_ID, LOG2, pFrame, nFrame);)
        return eSIR_FAILURE;
    }
    else if ( DOT11F_WARNED( status ) )
    {
      dot11fLog( pMac, LOGW, FL("There were warnings while unpacking a TPC Request frame (0x%08x, %d bytes):"),
                 status, nFrame );
        PELOG2(sirDumpBuf(pMac, SIR_DBG_MODULE_ID, LOG2, pFrame, nFrame);)
    }

    // & "transliterate" from a 'tDot11fTPCRequest' to a
    // 'tSirMacTpcReqActionFrame'...
    pTpcReqFrame->actionHeader.category    = req.Category.category;
    pTpcReqFrame->actionHeader.actionID    = req.Action.action;
    pTpcReqFrame->actionHeader.dialogToken = req.DialogToken.token;
    if ( req.TPCRequest.present )
    {
        pTpcReqFrame->type   = DOT11F_EID_TPCREQUEST;
        pTpcReqFrame->length = 0;
    }
    else
    {
        dot11fLog( pMac, LOGW, FL("!!!Rcv TPC Req of inalid type!") );
        return eSIR_FAILURE;
    }

    return eSIR_SUCCESS;

} // End sirConvertTpcReqFrame2Struct.


tSirRetStatus
sirConvertMeasReqFrame2Struct(tpAniSirGlobal             pMac,
                              tANI_U8                        *pFrame,
                              tpSirMacMeasReqActionFrame pMeasReqFrame,
                              tANI_U32                        nFrame)
{
    tDot11fMeasurementRequest mr;
    tANI_U32                       status;

    // Zero-init our [out] parameter,
    vos_mem_set( ( tANI_U8* )pMeasReqFrame, sizeof(*pMeasReqFrame), 0 );

    // delegate to the framesc-generated code,
    status = dot11fUnpackMeasurementRequest( pMac, pFrame, nFrame, &mr );
    if ( DOT11F_FAILED( status ) )
    {
        dot11fLog(pMac, LOGE, FL("Failed to parse a Measurement Request frame (0x%08x, %d bytes):"),
                  status, nFrame);
        PELOG2(sirDumpBuf(pMac, SIR_DBG_MODULE_ID, LOG2, pFrame, nFrame);)
        return eSIR_FAILURE;
    }
    else if ( DOT11F_WARNED( status ) )
    {
      dot11fLog( pMac, LOGW, FL("There were warnings while unpacking a Measurement Request frame (0x%08x, %d bytes)"),
                 status, nFrame );
        PELOG2(sirDumpBuf(pMac, SIR_DBG_MODULE_ID, LOG2, pFrame, nFrame);)
    }

    // & "transliterate" from a 'tDot11fMeasurementRequest' to a
    // 'tpSirMacMeasReqActionFrame'...
    pMeasReqFrame->actionHeader.category    = mr.Category.category;
    pMeasReqFrame->actionHeader.actionID    = mr.Action.action;
    pMeasReqFrame->actionHeader.dialogToken = mr.DialogToken.token;

    if ( 0 == mr.num_MeasurementRequest )
    {
        dot11fLog( pMac, LOGE, FL("Missing mandatory IE in Measurement Request Frame.") );
        return eSIR_FAILURE;
    }
    else if ( 1 < mr.num_MeasurementRequest )
    {
        limLog( pMac, LOGW, FL("Warning: dropping extra Measurement Request IEs!") );
    }

    pMeasReqFrame->measReqIE.type        = DOT11F_EID_MEASUREMENTREQUEST;
    pMeasReqFrame->measReqIE.length      = DOT11F_IE_MEASUREMENTREQUEST_MIN_LEN;
    pMeasReqFrame->measReqIE.measToken   = mr.MeasurementRequest[0].measurement_token;
    pMeasReqFrame->measReqIE.measReqMode = ( mr.MeasurementRequest[0].reserved << 3 ) |
                                           ( mr.MeasurementRequest[0].enable   << 2 ) |
                                           ( mr.MeasurementRequest[0].request  << 1 ) |
                                           ( mr.MeasurementRequest[0].report /*<< 0*/ );
    pMeasReqFrame->measReqIE.measType    = mr.MeasurementRequest[0].measurement_type;

    pMeasReqFrame->measReqIE.measReqField.channelNumber = mr.MeasurementRequest[0].channel_no;

    vos_mem_copy(  pMeasReqFrame->measReqIE.measReqField.measStartTime,
                   mr.MeasurementRequest[0].meas_start_time, 8 );

    pMeasReqFrame->measReqIE.measReqField.measDuration = mr.MeasurementRequest[0].meas_duration;

    return eSIR_SUCCESS;

} // End sirConvertMeasReqFrame2Struct.
#endif


void
PopulateDot11fTSPEC(tSirMacTspecIE  *pOld,
                    tDot11fIETSPEC  *pDot11f)
{
    pDot11f->traffic_type         = pOld->tsinfo.traffic.trafficType;
    pDot11f->tsid                 = pOld->tsinfo.traffic.tsid;
    pDot11f->direction            = pOld->tsinfo.traffic.direction;
    pDot11f->access_policy        = pOld->tsinfo.traffic.accessPolicy;
    pDot11f->aggregation          = pOld->tsinfo.traffic.aggregation;
    pDot11f->psb                  = pOld->tsinfo.traffic.psb;
    pDot11f->user_priority        = pOld->tsinfo.traffic.userPrio;
    pDot11f->tsinfo_ack_pol       = pOld->tsinfo.traffic.ackPolicy;
    pDot11f->schedule             = pOld->tsinfo.schedule.schedule;
    /* As defined in IEEE 802.11-2007, section 7.3.2.30
     * Nominal MSDU size: Bit[0:14]=Size, Bit[15]=Fixed
     */
    pDot11f->size                 = ( pOld->nomMsduSz & 0x7fff );
    pDot11f->fixed                = ( pOld->nomMsduSz & 0x8000 ) ? 1 : 0;
    pDot11f->max_msdu_size        = pOld->maxMsduSz;
    pDot11f->min_service_int      = pOld->minSvcInterval;
    pDot11f->max_service_int      = pOld->maxSvcInterval;
    pDot11f->inactivity_int       = pOld->inactInterval;
    pDot11f->suspension_int       = pOld->suspendInterval;
    pDot11f->service_start_time   = pOld->svcStartTime;
    pDot11f->min_data_rate        = pOld->minDataRate;
    pDot11f->mean_data_rate       = pOld->meanDataRate;
    pDot11f->peak_data_rate       = pOld->peakDataRate;
    pDot11f->burst_size           = pOld->maxBurstSz;
    pDot11f->delay_bound          = pOld->delayBound;
    pDot11f->min_phy_rate         = pOld->minPhyRate;
    pDot11f->surplus_bw_allowance = pOld->surplusBw;
    pDot11f->medium_time          = pOld->mediumTime;

    pDot11f->present = 1;

} // End PopulateDot11fTSPEC.

void
PopulateDot11fWMMTSPEC(tSirMacTspecIE     *pOld,
                       tDot11fIEWMMTSPEC  *pDot11f)
{
    pDot11f->traffic_type         = pOld->tsinfo.traffic.trafficType;
    pDot11f->tsid                 = pOld->tsinfo.traffic.tsid;
    pDot11f->direction            = pOld->tsinfo.traffic.direction;
    pDot11f->access_policy        = pOld->tsinfo.traffic.accessPolicy;
    pDot11f->aggregation          = pOld->tsinfo.traffic.aggregation;
    pDot11f->psb                  = pOld->tsinfo.traffic.psb;
    pDot11f->user_priority        = pOld->tsinfo.traffic.userPrio;
    pDot11f->tsinfo_ack_pol       = pOld->tsinfo.traffic.ackPolicy;
    pDot11f->burst_size_defn      = pOld->tsinfo.traffic.burstSizeDefn;
    /* As defined in IEEE 802.11-2007, section 7.3.2.30
     * Nominal MSDU size: Bit[0:14]=Size, Bit[15]=Fixed
     */
    pDot11f->size                 = ( pOld->nomMsduSz & 0x7fff );
    pDot11f->fixed                = ( pOld->nomMsduSz & 0x8000 ) ? 1 : 0;
    pDot11f->max_msdu_size        = pOld->maxMsduSz;
    pDot11f->min_service_int      = pOld->minSvcInterval;
    pDot11f->max_service_int      = pOld->maxSvcInterval;
    pDot11f->inactivity_int       = pOld->inactInterval;
    pDot11f->suspension_int       = pOld->suspendInterval;
    pDot11f->service_start_time   = pOld->svcStartTime;
    pDot11f->min_data_rate        = pOld->minDataRate;
    pDot11f->mean_data_rate       = pOld->meanDataRate;
    pDot11f->peak_data_rate       = pOld->peakDataRate;
    pDot11f->burst_size           = pOld->maxBurstSz;
    pDot11f->delay_bound          = pOld->delayBound;
    pDot11f->min_phy_rate         = pOld->minPhyRate;
    pDot11f->surplus_bw_allowance = pOld->surplusBw;
    pDot11f->medium_time          = pOld->mediumTime;

    pDot11f->version = 1;
    pDot11f->present = 1;

} // End PopulateDot11fWMMTSPEC.

#if defined(FEATURE_WLAN_ESE)

// Fill the ESE version currently supported
void PopulateDot11fESEVersion(tDot11fIEESEVersion *pESEVersion)
{
    pESEVersion->present = 1;
    pESEVersion->version = ESE_VERSION_SUPPORTED;
}

// Fill the ESE ie for the station.
// The State is Normal (1)
// The MBSSID for station is set to 0.
void PopulateDot11fESERadMgmtCap(tDot11fIEESERadMgmtCap *pESERadMgmtCap)
{
    pESERadMgmtCap->present = 1;
    pESERadMgmtCap->mgmt_state = RM_STATE_NORMAL;
    pESERadMgmtCap->mbssid_mask = 0;
    pESERadMgmtCap->reserved = 0;
}

tSirRetStatus PopulateDot11fESECckmOpaque( tpAniSirGlobal pMac,
                                           tpSirCCKMie    pCCKMie,
                                           tDot11fIEESECckmOpaque *pDot11f )
{
    int idx;

    if ( pCCKMie->length )
    {
        if( 0 <= ( idx = FindIELocation( pMac, (tpSirRSNie)pCCKMie, DOT11F_EID_ESECCKMOPAQUE ) ) )
        {
            pDot11f->present  = 1;
            pDot11f->num_data = pCCKMie->cckmIEdata[ idx + 1 ] - 4; // Dont include OUI
            vos_mem_copy(pDot11f->data,
                           pCCKMie->cckmIEdata + idx + 2 + 4,    // EID, len, OUI
                           pCCKMie->cckmIEdata[ idx + 1 ] - 4 ); // Skip OUI
        }
    }

    return eSIR_SUCCESS;

} // End PopulateDot11fESECckmOpaque.

void PopulateDot11TSRSIE(tpAniSirGlobal  pMac,
                               tSirMacESETSRSIE     *pOld,
                               tDot11fIEESETrafStrmRateSet  *pDot11f,
                               tANI_U8 rate_length)
{
    pDot11f->tsid = pOld->tsid;
    vos_mem_copy(pDot11f->tsrates, pOld->rates,rate_length);
    pDot11f->num_tsrates = rate_length;
    pDot11f->present = 1;
}
#endif


tSirRetStatus
PopulateDot11fTCLAS(tpAniSirGlobal  pMac,
                    tSirTclasInfo  *pOld,
                    tDot11fIETCLAS *pDot11f)
{
    pDot11f->user_priority   = pOld->tclas.userPrio;
    pDot11f->classifier_type = pOld->tclas.classifierType;
    pDot11f->classifier_mask = pOld->tclas.classifierMask;

    switch ( pDot11f->classifier_type )
    {
    case SIR_MAC_TCLASTYPE_ETHERNET:
        vos_mem_copy( ( tANI_U8* )&pDot11f->info.EthParams.source,
                      ( tANI_U8* )&pOld->tclasParams.eth.srcAddr, 6 );
        vos_mem_copy( ( tANI_U8* )&pDot11f->info.EthParams.dest,
                      ( tANI_U8* )&pOld->tclasParams.eth.dstAddr, 6 );
        pDot11f->info.EthParams.type = pOld->tclasParams.eth.type;
        break;
    case SIR_MAC_TCLASTYPE_TCPUDPIP:
        pDot11f->info.IpParams.version = pOld->version;
        if ( SIR_MAC_TCLAS_IPV4 == pDot11f->info.IpParams.version )
        {
            vos_mem_copy( pDot11f->info.IpParams.params.
                          IpV4Params.source,
                          pOld->tclasParams.ipv4.srcIpAddr, 4 );
            vos_mem_copy( pDot11f->info.IpParams.params.
                          IpV4Params.dest,
                          pOld->tclasParams.ipv4.dstIpAddr, 4 );
            pDot11f->info.IpParams.params.IpV4Params.src_port  =
              pOld->tclasParams.ipv4.srcPort;
            pDot11f->info.IpParams.params.IpV4Params.dest_port =
              pOld->tclasParams.ipv4.dstPort;
            pDot11f->info.IpParams.params.IpV4Params.DSCP      =
              pOld->tclasParams.ipv4.dscp;
            pDot11f->info.IpParams.params.IpV4Params.proto     =
              pOld->tclasParams.ipv4.protocol;
            pDot11f->info.IpParams.params.IpV4Params.reserved  =
              pOld->tclasParams.ipv4.rsvd;
        }
        else
        {
            vos_mem_copy(  ( tANI_U8* )&pDot11f->info.IpParams.params.
                           IpV6Params.source,
                           ( tANI_U8* )pOld->tclasParams.ipv6.srcIpAddr, 16 );
            vos_mem_copy(  ( tANI_U8* )&pDot11f->info.IpParams.params.
                           IpV6Params.dest,
                           ( tANI_U8* )pOld->tclasParams.ipv6.dstIpAddr, 16 );
            pDot11f->info.IpParams.params.IpV6Params.src_port  =
              pOld->tclasParams.ipv6.srcPort;
            pDot11f->info.IpParams.params.IpV6Params.dest_port =
              pOld->tclasParams.ipv6.dstPort;
            vos_mem_copy(  ( tANI_U8* )&pDot11f->info.IpParams.params.
                           IpV6Params.flow_label,
                           ( tANI_U8* )pOld->tclasParams.ipv6.flowLabel, 3 );
        }
        break;
    case SIR_MAC_TCLASTYPE_8021DQ:
        pDot11f->info.Params8021dq.tag_type = pOld->tclasParams.t8021dq.tag;
        break;
    default:
        limLog( pMac, LOGE, FL("Bad TCLAS type %d in PopulateDot11fTCLAS."),
                pDot11f->classifier_type );
        return eSIR_FAILURE;
    }

    pDot11f->present = 1;

    return eSIR_SUCCESS;

} // End PopulateDot11fTCLAS.

tSirRetStatus
PopulateDot11fWMMTCLAS(tpAniSirGlobal     pMac,
                       tSirTclasInfo     *pOld,
                       tDot11fIEWMMTCLAS *pDot11f)
{
    pDot11f->version         = 1;
    pDot11f->user_priority   = pOld->tclas.userPrio;
    pDot11f->classifier_type = pOld->tclas.classifierType;
    pDot11f->classifier_mask = pOld->tclas.classifierMask;

    switch ( pDot11f->classifier_type )
    {
    case SIR_MAC_TCLASTYPE_ETHERNET:
        vos_mem_copy(  ( tANI_U8* )&pDot11f->info.EthParams.source,
                       ( tANI_U8* )&pOld->tclasParams.eth.srcAddr, 6 );
        vos_mem_copy(  ( tANI_U8* )&pDot11f->info.EthParams.dest,
                       ( tANI_U8* )&pOld->tclasParams.eth.dstAddr, 6 );
        pDot11f->info.EthParams.type = pOld->tclasParams.eth.type;
        break;
    case SIR_MAC_TCLASTYPE_TCPUDPIP:
        pDot11f->info.IpParams.version = pOld->version;
        if ( SIR_MAC_TCLAS_IPV4 == pDot11f->info.IpParams.version )
        {
            vos_mem_copy(  ( tANI_U8* )&pDot11f->info.IpParams.params.
                           IpV4Params.source,
                           ( tANI_U8* )pOld->tclasParams.ipv4.srcIpAddr, 4 );
            vos_mem_copy(  ( tANI_U8* )&pDot11f->info.IpParams.params.
                           IpV4Params.dest,
                           ( tANI_U8* )pOld->tclasParams.ipv4.dstIpAddr, 4 );
            pDot11f->info.IpParams.params.IpV4Params.src_port  =
              pOld->tclasParams.ipv4.srcPort;
            pDot11f->info.IpParams.params.IpV4Params.dest_port =
              pOld->tclasParams.ipv4.dstPort;
            pDot11f->info.IpParams.params.IpV4Params.DSCP      =
              pOld->tclasParams.ipv4.dscp;
            pDot11f->info.IpParams.params.IpV4Params.proto     =
              pOld->tclasParams.ipv4.protocol;
            pDot11f->info.IpParams.params.IpV4Params.reserved  =
              pOld->tclasParams.ipv4.rsvd;
        }
        else
        {
            vos_mem_copy( ( tANI_U8* )&pDot11f->info.IpParams.params.
                           IpV6Params.source,
                           ( tANI_U8* )pOld->tclasParams.ipv6.srcIpAddr, 16 );
            vos_mem_copy(  ( tANI_U8* )&pDot11f->info.IpParams.params.
                           IpV6Params.dest,
                           ( tANI_U8* )pOld->tclasParams.ipv6.dstIpAddr, 16 );
            pDot11f->info.IpParams.params.IpV6Params.src_port  =
              pOld->tclasParams.ipv6.srcPort;
            pDot11f->info.IpParams.params.IpV6Params.dest_port =
              pOld->tclasParams.ipv6.dstPort;
            vos_mem_copy(  ( tANI_U8* )&pDot11f->info.IpParams.params.
                           IpV6Params.flow_label,
                           ( tANI_U8* )pOld->tclasParams.ipv6.flowLabel, 3 );
        }
        break;
    case SIR_MAC_TCLASTYPE_8021DQ:
        pDot11f->info.Params8021dq.tag_type = pOld->tclasParams.t8021dq.tag;
        break;
    default:
        limLog( pMac, LOGE, FL("Bad TCLAS type %d in PopulateDot11fTCLAS."),
                pDot11f->classifier_type );
        return eSIR_FAILURE;
    }

    pDot11f->present = 1;

    return eSIR_SUCCESS;

} // End PopulateDot11fWMMTCLAS.


tSirRetStatus PopulateDot11fWsc(tpAniSirGlobal pMac,
                                tDot11fIEWscBeacon *pDot11f)
{

    tANI_U32 wpsState;

    pDot11f->Version.present = 1;
    pDot11f->Version.major = 0x01;
    pDot11f->Version.minor = 0x00;

    if (wlan_cfgGetInt(pMac, (tANI_U16) WNI_CFG_WPS_STATE, &wpsState) != eSIR_SUCCESS)
        limLog(pMac, LOGP,"Failed to cfg get id %d", WNI_CFG_WPS_STATE );

    pDot11f->WPSState.present = 1;
    pDot11f->WPSState.state = (tANI_U8) wpsState;

    pDot11f->APSetupLocked.present = 0;

    pDot11f->SelectedRegistrar.present = 0;

    pDot11f->DevicePasswordID.present = 0;

    pDot11f->SelectedRegistrarConfigMethods.present = 0;

    pDot11f->UUID_E.present = 0;

    pDot11f->RFBands.present = 0;

    pDot11f->present = 1;
    return eSIR_SUCCESS;
}

tSirRetStatus PopulateDot11fWscRegistrarInfo(tpAniSirGlobal pMac,
                                             tDot11fIEWscBeacon *pDot11f)
{
    const struct sLimWscIeInfo *const pWscIeInfo = &(pMac->lim.wscIeInfo);
    tANI_U32 devicepasswdId;


    pDot11f->APSetupLocked.present = 1;
    pDot11f->APSetupLocked.fLocked = pWscIeInfo->apSetupLocked;

    pDot11f->SelectedRegistrar.present = 1;
    pDot11f->SelectedRegistrar.selected = pWscIeInfo->selectedRegistrar;

    if (wlan_cfgGetInt(pMac, (tANI_U16) WNI_CFG_WPS_DEVICE_PASSWORD_ID, &devicepasswdId) != eSIR_SUCCESS)
        limLog(pMac, LOGP,"Failed to cfg get id %d", WNI_CFG_WPS_DEVICE_PASSWORD_ID );

    pDot11f->DevicePasswordID.present = 1;
    pDot11f->DevicePasswordID.id = (tANI_U16) devicepasswdId;

    pDot11f->SelectedRegistrarConfigMethods.present = 1;
    pDot11f->SelectedRegistrarConfigMethods.methods = pWscIeInfo->selectedRegistrarConfigMethods;

    // UUID_E and RF Bands are applicable only for dual band AP

    return eSIR_SUCCESS;
}

tSirRetStatus DePopulateDot11fWscRegistrarInfo(tpAniSirGlobal pMac,
                                               tDot11fIEWscBeacon *pDot11f)
{
    pDot11f->APSetupLocked.present = 0;
    pDot11f->SelectedRegistrar.present = 0;
    pDot11f->DevicePasswordID.present = 0;
    pDot11f->SelectedRegistrarConfigMethods.present = 0;

    return eSIR_SUCCESS;
}
tSirRetStatus PopulateDot11fProbeResWPSIEs(tpAniSirGlobal pMac, tDot11fIEWscProbeRes *pDot11f, tpPESession psessionEntry)
{
 
   tSirWPSProbeRspIE *pSirWPSProbeRspIE;

   pSirWPSProbeRspIE = &psessionEntry->APWPSIEs.SirWPSProbeRspIE;
   
    
    if(pSirWPSProbeRspIE->FieldPresent & SIR_WPS_PROBRSP_VER_PRESENT)
    {
        pDot11f->present = 1;
        pDot11f->Version.present = 1;
        pDot11f->Version.major = (tANI_U8) ((pSirWPSProbeRspIE->Version & 0xF0)>>4);
        pDot11f->Version.minor = (tANI_U8) (pSirWPSProbeRspIE->Version & 0x0F);
    }
    else
    {
        pDot11f->present = 0;
        pDot11f->Version.present = 0;
    }

    if(pSirWPSProbeRspIE->FieldPresent & SIR_WPS_PROBRSP_STATE_PRESENT)
    {
        
        pDot11f->WPSState.present = 1;
        pDot11f->WPSState.state = (tANI_U8)pSirWPSProbeRspIE->wpsState;
    }
    else
        pDot11f->WPSState.present = 0;
        
    if(pSirWPSProbeRspIE->FieldPresent & SIR_WPS_PROBRSP_APSETUPLOCK_PRESENT)
    {
        pDot11f->APSetupLocked.present = 1;
        pDot11f->APSetupLocked.fLocked = pSirWPSProbeRspIE->APSetupLocked;
    }
    else
        pDot11f->APSetupLocked.present = 0;
        
    if(pSirWPSProbeRspIE->FieldPresent & SIR_WPS_PROBRSP_SELECTEDREGISTRA_PRESENT)
    {
        pDot11f->SelectedRegistrar.present = 1;
        pDot11f->SelectedRegistrar.selected = pSirWPSProbeRspIE->SelectedRegistra;
    }
    else
         pDot11f->SelectedRegistrar.present = 0;
    
    if(pSirWPSProbeRspIE->FieldPresent & SIR_WPS_PROBRSP_DEVICEPASSWORDID_PRESENT)
    {
        pDot11f->DevicePasswordID.present = 1;
        pDot11f->DevicePasswordID.id = pSirWPSProbeRspIE->DevicePasswordID;
    }
    else
        pDot11f->DevicePasswordID.present = 0;
        
    if(pSirWPSProbeRspIE->FieldPresent & SIR_WPS_PROBRSP_SELECTEDREGISTRACFGMETHOD_PRESENT)
    {
        pDot11f->SelectedRegistrarConfigMethods.present = 1;
        pDot11f->SelectedRegistrarConfigMethods.methods = pSirWPSProbeRspIE->SelectedRegistraCfgMethod;
    }
    else
        pDot11f->SelectedRegistrarConfigMethods.present = 0;
        
    if(pSirWPSProbeRspIE->FieldPresent & SIR_WPS_PROBRSP_RESPONSETYPE_PRESENT)
    {
        pDot11f->ResponseType.present = 1;
        pDot11f->ResponseType.resType = pSirWPSProbeRspIE->ResponseType;
    }
    else
        pDot11f->ResponseType.present = 0;
        
    if(pSirWPSProbeRspIE->FieldPresent & SIR_WPS_PROBRSP_UUIDE_PRESENT)
    {
        pDot11f->UUID_E.present = 1;
        vos_mem_copy(pDot11f->UUID_E.uuid, pSirWPSProbeRspIE->UUID_E, WNI_CFG_WPS_UUID_LEN);
    }
    else
        pDot11f->UUID_E.present = 0;
    
    if(pSirWPSProbeRspIE->FieldPresent & SIR_WPS_PROBRSP_MANUFACTURE_PRESENT)
    {
        pDot11f->Manufacturer.present = 1;
        pDot11f->Manufacturer.num_name = pSirWPSProbeRspIE->Manufacture.num_name;
        vos_mem_copy(pDot11f->Manufacturer.name, pSirWPSProbeRspIE->Manufacture.name,
                     pSirWPSProbeRspIE->Manufacture.num_name);
    } 
    else
        pDot11f->Manufacturer.present = 0;
        
    if(pSirWPSProbeRspIE->FieldPresent & SIR_WPS_PROBRSP_MODELNUMBER_PRESENT)
    {
        pDot11f->ModelName.present = 1;
        pDot11f->ModelName.num_text = pSirWPSProbeRspIE->ModelName.num_text;
        vos_mem_copy(pDot11f->ModelName.text, pSirWPSProbeRspIE->ModelName.text,
                     pDot11f->ModelName.num_text);
    }
    else
      pDot11f->ModelName.present = 0;
    
    if(pSirWPSProbeRspIE->FieldPresent & SIR_WPS_PROBRSP_MODELNUMBER_PRESENT)
    {
        pDot11f->ModelNumber.present = 1;
        pDot11f->ModelNumber.num_text = pSirWPSProbeRspIE->ModelNumber.num_text;
        vos_mem_copy(pDot11f->ModelNumber.text, pSirWPSProbeRspIE->ModelNumber.text,
                     pDot11f->ModelNumber.num_text);
    }
    else
        pDot11f->ModelNumber.present = 0;
    
    if(pSirWPSProbeRspIE->FieldPresent & SIR_WPS_PROBRSP_SERIALNUMBER_PRESENT)
    {
        pDot11f->SerialNumber.present = 1;
        pDot11f->SerialNumber.num_text = pSirWPSProbeRspIE->SerialNumber.num_text;
        vos_mem_copy(pDot11f->SerialNumber.text, pSirWPSProbeRspIE->SerialNumber.text,
                     pDot11f->SerialNumber.num_text);
    }
    else
        pDot11f->SerialNumber.present = 0;
    
    if(pSirWPSProbeRspIE->FieldPresent & SIR_WPS_PROBRSP_PRIMARYDEVICETYPE_PRESENT)
    {
        pDot11f->PrimaryDeviceType.present = 1;
        vos_mem_copy(pDot11f->PrimaryDeviceType.oui, pSirWPSProbeRspIE->PrimaryDeviceOUI,
                     sizeof(pSirWPSProbeRspIE->PrimaryDeviceOUI));
        pDot11f->PrimaryDeviceType.primary_category = (tANI_U16)pSirWPSProbeRspIE->PrimaryDeviceCategory;
        pDot11f->PrimaryDeviceType.sub_category = (tANI_U16)pSirWPSProbeRspIE->DeviceSubCategory;
    }
    else
        pDot11f->PrimaryDeviceType.present = 0;
    
    if(pSirWPSProbeRspIE->FieldPresent & SIR_WPS_PROBRSP_DEVICENAME_PRESENT)
    {
        pDot11f->DeviceName.present = 1;
        pDot11f->DeviceName.num_text = pSirWPSProbeRspIE->DeviceName.num_text;
        vos_mem_copy(pDot11f->DeviceName.text, pSirWPSProbeRspIE->DeviceName.text,
                     pDot11f->DeviceName.num_text);
    }
    else
        pDot11f->DeviceName.present = 0;
    
    if(pSirWPSProbeRspIE->FieldPresent & SIR_WPS_PROBRSP_CONFIGMETHODS_PRESENT)
    {
        pDot11f->ConfigMethods.present = 1;
        pDot11f->ConfigMethods.methods = pSirWPSProbeRspIE->ConfigMethod;
    }
    else
        pDot11f->ConfigMethods.present = 0;
    
    
    if(pSirWPSProbeRspIE->FieldPresent & SIR_WPS_PROBRSP_RF_BANDS_PRESENT)
    {
        pDot11f->RFBands.present = 1;
        pDot11f->RFBands.bands = pSirWPSProbeRspIE->RFBand;
    }
    else
       pDot11f->RFBands.present = 0;      
       
    return eSIR_SUCCESS;
}
tSirRetStatus PopulateDot11fAssocResWPSIEs(tpAniSirGlobal pMac, tDot11fIEWscAssocRes *pDot11f, tpPESession psessionEntry)
{
   tSirWPSProbeRspIE *pSirWPSProbeRspIE;

   pSirWPSProbeRspIE = &psessionEntry->APWPSIEs.SirWPSProbeRspIE;
   
    if(pSirWPSProbeRspIE->FieldPresent & SIR_WPS_PROBRSP_VER_PRESENT)
    {
        pDot11f->present = 1;
        pDot11f->Version.present = 1;
        pDot11f->Version.major = (tANI_U8) ((pSirWPSProbeRspIE->Version & 0xF0)>>4);
        pDot11f->Version.minor = (tANI_U8) (pSirWPSProbeRspIE->Version & 0x0F);
    }
    else
    {
        pDot11f->present = 0;
        pDot11f->Version.present = 0;
    }
    
    if(pSirWPSProbeRspIE->FieldPresent & SIR_WPS_PROBRSP_RESPONSETYPE_PRESENT)
    {
        pDot11f->ResponseType.present = 1;
        pDot11f->ResponseType.resType = pSirWPSProbeRspIE->ResponseType;
    }
    else
        pDot11f->ResponseType.present = 0;    

    return eSIR_SUCCESS;
}

tSirRetStatus PopulateDot11fBeaconWPSIEs(tpAniSirGlobal pMac, tDot11fIEWscBeacon *pDot11f, tpPESession psessionEntry)
{
 
   tSirWPSBeaconIE *pSirWPSBeaconIE;

   pSirWPSBeaconIE = &psessionEntry->APWPSIEs.SirWPSBeaconIE;
   
    
    if(pSirWPSBeaconIE->FieldPresent & SIR_WPS_PROBRSP_VER_PRESENT)
    {
        pDot11f->present = 1;
        pDot11f->Version.present = 1;
        pDot11f->Version.major = (tANI_U8) ((pSirWPSBeaconIE->Version & 0xF0)>>4);
        pDot11f->Version.minor = (tANI_U8) (pSirWPSBeaconIE->Version & 0x0F);
    }
    else
    {
        pDot11f->present = 0;
        pDot11f->Version.present = 0;
    }
    
    if(pSirWPSBeaconIE->FieldPresent & SIR_WPS_BEACON_STATE_PRESENT)
    {
        
        pDot11f->WPSState.present = 1;
        pDot11f->WPSState.state = (tANI_U8)pSirWPSBeaconIE->wpsState;
    }
    else
        pDot11f->WPSState.present = 0;
        
    if(pSirWPSBeaconIE->FieldPresent & SIR_WPS_BEACON_APSETUPLOCK_PRESENT)
    {
        pDot11f->APSetupLocked.present = 1;
        pDot11f->APSetupLocked.fLocked = pSirWPSBeaconIE->APSetupLocked;
    }
    else
        pDot11f->APSetupLocked.present = 0;
        
    if(pSirWPSBeaconIE->FieldPresent & SIR_WPS_BEACON_SELECTEDREGISTRA_PRESENT)
    {
        pDot11f->SelectedRegistrar.present = 1;
        pDot11f->SelectedRegistrar.selected = pSirWPSBeaconIE->SelectedRegistra;
    }
    else
         pDot11f->SelectedRegistrar.present = 0;
    
    if(pSirWPSBeaconIE->FieldPresent & SIR_WPS_BEACON_DEVICEPASSWORDID_PRESENT)
    {
        pDot11f->DevicePasswordID.present = 1;
        pDot11f->DevicePasswordID.id = pSirWPSBeaconIE->DevicePasswordID;
    }
    else
        pDot11f->DevicePasswordID.present = 0;
        
    if(pSirWPSBeaconIE->FieldPresent & SIR_WPS_BEACON_SELECTEDREGISTRACFGMETHOD_PRESENT)
    {
        pDot11f->SelectedRegistrarConfigMethods.present = 1;
        pDot11f->SelectedRegistrarConfigMethods.methods = pSirWPSBeaconIE->SelectedRegistraCfgMethod;
    }
    else
        pDot11f->SelectedRegistrarConfigMethods.present = 0;
        
    if(pSirWPSBeaconIE->FieldPresent & SIR_WPS_BEACON_UUIDE_PRESENT)
    {
        pDot11f->UUID_E.present = 1;
        vos_mem_copy(pDot11f->UUID_E.uuid, pSirWPSBeaconIE->UUID_E, WNI_CFG_WPS_UUID_LEN);
    }
    else
        pDot11f->UUID_E.present = 0;
    
       
    if(pSirWPSBeaconIE->FieldPresent & SIR_WPS_BEACON_RF_BANDS_PRESENT)
    {
        pDot11f->RFBands.present = 1;
        pDot11f->RFBands.bands = pSirWPSBeaconIE->RFBand;
    }
    else
       pDot11f->RFBands.present = 0;      
       
    return eSIR_SUCCESS;
}
tSirRetStatus PopulateDot11fWscInProbeRes(tpAniSirGlobal pMac,
                                          tDot11fIEWscProbeRes *pDot11f)
{
    tANI_U32 cfgMethods;
    tANI_U32 cfgStrLen;
    tANI_U32 val;
    tANI_U32 wpsVersion, wpsState;


    if (wlan_cfgGetInt(pMac, (tANI_U16) WNI_CFG_WPS_VERSION, &wpsVersion) != eSIR_SUCCESS)
        limLog(pMac, LOGP,"Failed to cfg get id %d", WNI_CFG_WPS_VERSION );

    pDot11f->Version.present = 1;
    pDot11f->Version.major = (tANI_U8) ((wpsVersion & 0xF0)>>4);
    pDot11f->Version.minor = (tANI_U8) (wpsVersion & 0x0F);

    if (wlan_cfgGetInt(pMac, (tANI_U16) WNI_CFG_WPS_STATE, &wpsState) != eSIR_SUCCESS)
        limLog(pMac, LOGP,"Failed to cfg get id %d", WNI_CFG_WPS_STATE );

    pDot11f->WPSState.present = 1;
    pDot11f->WPSState.state = (tANI_U8) wpsState;

    pDot11f->APSetupLocked.present = 0;

    pDot11f->SelectedRegistrar.present = 0;

    pDot11f->DevicePasswordID.present = 0;

    pDot11f->SelectedRegistrarConfigMethods.present = 0;

    pDot11f->ResponseType.present = 1;
    if ((pMac->lim.wscIeInfo.reqType == REQ_TYPE_REGISTRAR) ||
        (pMac->lim.wscIeInfo.reqType == REQ_TYPE_WLAN_MANAGER_REGISTRAR)){
        pDot11f->ResponseType.resType = RESP_TYPE_ENROLLEE_OPEN_8021X;
    }
    else{
         pDot11f->ResponseType.resType = RESP_TYPE_AP;
    }

    /* UUID is a 16 byte long binary. Still use wlan_cfgGetStr to get it. */
    pDot11f->UUID_E.present = 1;
    cfgStrLen = WNI_CFG_WPS_UUID_LEN;
    if (wlan_cfgGetStr(pMac,
                  WNI_CFG_WPS_UUID,
                  pDot11f->UUID_E.uuid,
                  &cfgStrLen) != eSIR_SUCCESS)
    {
        *(pDot11f->UUID_E.uuid) = '\0';
    }

    pDot11f->Manufacturer.present = 1;
    cfgStrLen = WNI_CFG_MANUFACTURER_NAME_LEN - 1;
    if (wlan_cfgGetStr(pMac,
                  WNI_CFG_MANUFACTURER_NAME,
                  pDot11f->Manufacturer.name,
                  &cfgStrLen) != eSIR_SUCCESS)
    {
        pDot11f->Manufacturer.num_name = 0;
        *(pDot11f->Manufacturer.name) = '\0';
    }
    else
    {
        pDot11f->Manufacturer.num_name = (tANI_U8) (cfgStrLen & 0x000000FF);
        pDot11f->Manufacturer.name[cfgStrLen - 1] = '\0';
    }

    pDot11f->ModelName.present = 1;
    cfgStrLen = WNI_CFG_MODEL_NAME_LEN - 1;
    if (wlan_cfgGetStr(pMac,
                  WNI_CFG_MODEL_NAME,
                  pDot11f->ModelName.text,
                  &cfgStrLen) != eSIR_SUCCESS)
    {
        pDot11f->ModelName.num_text = 0;
        *(pDot11f->ModelName.text) = '\0';
    }
    else
    {
        pDot11f->ModelName.num_text = (tANI_U8) (cfgStrLen & 0x000000FF);
        pDot11f->ModelName.text[cfgStrLen - 1] = '\0';
    }

    pDot11f->ModelNumber.present = 1;
    cfgStrLen = WNI_CFG_MODEL_NUMBER_LEN - 1;
    if (wlan_cfgGetStr(pMac,
                  WNI_CFG_MODEL_NUMBER,
                  pDot11f->ModelNumber.text,
                  &cfgStrLen) != eSIR_SUCCESS)
    {
        pDot11f->ModelNumber.num_text = 0;
        *(pDot11f->ModelNumber.text) = '\0';
    }
    else
    {
        pDot11f->ModelNumber.num_text = (tANI_U8) (cfgStrLen & 0x000000FF);
        pDot11f->ModelNumber.text[cfgStrLen - 1] = '\0';
    }

    pDot11f->SerialNumber.present = 1;
    cfgStrLen = WNI_CFG_MANUFACTURER_PRODUCT_VERSION_LEN - 1;
    if (wlan_cfgGetStr(pMac,
                  WNI_CFG_MANUFACTURER_PRODUCT_VERSION,
                  pDot11f->SerialNumber.text,
                  &cfgStrLen) != eSIR_SUCCESS)
    {
        pDot11f->SerialNumber.num_text = 0;
        *(pDot11f->SerialNumber.text) = '\0';
    }
    else
    {
        pDot11f->SerialNumber.num_text = (tANI_U8) (cfgStrLen & 0x000000FF);
        pDot11f->SerialNumber.text[cfgStrLen - 1] = '\0';
    }

    pDot11f->PrimaryDeviceType.present = 1;

    if (wlan_cfgGetInt(pMac, WNI_CFG_WPS_PRIMARY_DEVICE_CATEGORY, &val) != eSIR_SUCCESS)
    {
       limLog(pMac, LOGP, FL("cfg get prim device category failed"));
    }
    else
       pDot11f->PrimaryDeviceType.primary_category = (tANI_U16) val;

    if (wlan_cfgGetInt(pMac, WNI_CFG_WPS_PIMARY_DEVICE_OUI, &val) != eSIR_SUCCESS)
    {
       limLog(pMac, LOGP, FL("cfg get prim device OUI failed"));
    }
    else
    {
       *(pDot11f->PrimaryDeviceType.oui) = (tANI_U8)((val >> 24)& 0xff);
       *(pDot11f->PrimaryDeviceType.oui+1) = (tANI_U8)((val >> 16)& 0xff);
       *(pDot11f->PrimaryDeviceType.oui+2) = (tANI_U8)((val >> 8)& 0xff);
       *(pDot11f->PrimaryDeviceType.oui+3) = (tANI_U8)((val & 0xff));
    }

    if (wlan_cfgGetInt(pMac, WNI_CFG_WPS_DEVICE_SUB_CATEGORY, &val) != eSIR_SUCCESS)
    {
       limLog(pMac, LOGP, FL("cfg get prim device sub category failed"));
    }
    else
       pDot11f->PrimaryDeviceType.sub_category = (tANI_U16) val;

    pDot11f->DeviceName.present = 1;
    cfgStrLen = WNI_CFG_MANUFACTURER_PRODUCT_NAME_LEN - 1;
    if (wlan_cfgGetStr(pMac,
                  WNI_CFG_MANUFACTURER_PRODUCT_NAME,
                  pDot11f->DeviceName.text,
                  &cfgStrLen) != eSIR_SUCCESS)
    {
        pDot11f->DeviceName.num_text = 0;
        *(pDot11f->DeviceName.text) = '\0';
    }
    else
    {
        pDot11f->DeviceName.num_text = (tANI_U8) (cfgStrLen & 0x000000FF);
        pDot11f->DeviceName.text[cfgStrLen - 1] = '\0';
    }

    if (wlan_cfgGetInt(pMac,
                  WNI_CFG_WPS_CFG_METHOD,
                  &cfgMethods) != eSIR_SUCCESS)
    {
        pDot11f->ConfigMethods.present = 0;
        pDot11f->ConfigMethods.methods = 0;
    }
    else
    {
        pDot11f->ConfigMethods.present = 1;
        pDot11f->ConfigMethods.methods = (tANI_U16) (cfgMethods & 0x0000FFFF);
    }

    pDot11f->RFBands.present = 0;

    pDot11f->present = 1;
    return eSIR_SUCCESS;
}

tSirRetStatus PopulateDot11fWscRegistrarInfoInProbeRes(tpAniSirGlobal pMac,
                                                       tDot11fIEWscProbeRes *pDot11f)
{
    const struct sLimWscIeInfo *const pWscIeInfo = &(pMac->lim.wscIeInfo);
    tANI_U32 devicepasswdId;

    pDot11f->APSetupLocked.present = 1;
    pDot11f->APSetupLocked.fLocked = pWscIeInfo->apSetupLocked;

    pDot11f->SelectedRegistrar.present = 1;
    pDot11f->SelectedRegistrar.selected = pWscIeInfo->selectedRegistrar;

    if (wlan_cfgGetInt(pMac, (tANI_U16) WNI_CFG_WPS_DEVICE_PASSWORD_ID, &devicepasswdId) != eSIR_SUCCESS)
       limLog(pMac, LOGP,"Failed to cfg get id %d", WNI_CFG_WPS_DEVICE_PASSWORD_ID );

    pDot11f->DevicePasswordID.present = 1;
    pDot11f->DevicePasswordID.id = (tANI_U16) devicepasswdId;

    pDot11f->SelectedRegistrarConfigMethods.present = 1;
    pDot11f->SelectedRegistrarConfigMethods.methods = pWscIeInfo->selectedRegistrarConfigMethods;

    // UUID_E and RF Bands are applicable only for dual band AP

    return eSIR_SUCCESS;
}

tSirRetStatus DePopulateDot11fWscRegistrarInfoInProbeRes(tpAniSirGlobal pMac,
                                                         tDot11fIEWscProbeRes *pDot11f)
{
    pDot11f->APSetupLocked.present = 0;
    pDot11f->SelectedRegistrar.present = 0;
    pDot11f->DevicePasswordID.present = 0;
    pDot11f->SelectedRegistrarConfigMethods.present = 0;

    return eSIR_SUCCESS;
}

tSirRetStatus PopulateDot11fAssocResWscIE(tpAniSirGlobal pMac, 
                                          tDot11fIEWscAssocRes *pDot11f, 
                                          tpSirAssocReq pRcvdAssocReq)
{
    tDot11fIEWscAssocReq parsedWscAssocReq = { 0, };
    tANI_U8         *wscIe;
    

    wscIe = limGetWscIEPtr(pMac, pRcvdAssocReq->addIE.addIEdata, pRcvdAssocReq->addIE.length);
    if(wscIe != NULL)
    {
        // retreive WSC IE from given AssocReq 
        dot11fUnpackIeWscAssocReq( pMac,
                                    wscIe + 2 + 4,  // EID, length, OUI
                                    wscIe[ 1 ] - 4, // length without OUI
                                    &parsedWscAssocReq );
        pDot11f->present = 1;
        // version has to be 0x10
        pDot11f->Version.present = 1;
        pDot11f->Version.major = 0x1;
        pDot11f->Version.minor = 0x0;

        pDot11f->ResponseType.present = 1;
        
        if ((parsedWscAssocReq.RequestType.reqType == REQ_TYPE_REGISTRAR) ||
            (parsedWscAssocReq.RequestType.reqType == REQ_TYPE_WLAN_MANAGER_REGISTRAR))
        {
            pDot11f->ResponseType.resType = RESP_TYPE_ENROLLEE_OPEN_8021X;
        }
        else
        {
             pDot11f->ResponseType.resType = RESP_TYPE_AP;
        }
        // Version infomration should be taken from our capability as well as peers
        // TODO: currently it takes from peers only
        if(parsedWscAssocReq.VendorExtension.present &&
           parsedWscAssocReq.VendorExtension.Version2.present)
        {   
            pDot11f->VendorExtension.present = 1;
            pDot11f->VendorExtension.vendorId[0] = 0x00;
            pDot11f->VendorExtension.vendorId[1] = 0x37;
            pDot11f->VendorExtension.vendorId[2] = 0x2A;
            pDot11f->VendorExtension.Version2.present = 1;
            pDot11f->VendorExtension.Version2.major = parsedWscAssocReq.VendorExtension.Version2.major;
            pDot11f->VendorExtension.Version2.minor = parsedWscAssocReq.VendorExtension.Version2.minor;
        }
    }
    return eSIR_SUCCESS;
}

tSirRetStatus PopulateDot11AssocResP2PIE(tpAniSirGlobal pMac, 
                                       tDot11fIEP2PAssocRes *pDot11f, 
                                       tpSirAssocReq pRcvdAssocReq)
{
    tANI_U8         *p2pIe;

    p2pIe = limGetP2pIEPtr(pMac, pRcvdAssocReq->addIE.addIEdata, pRcvdAssocReq->addIE.length);
    if(p2pIe != NULL)
    {
        pDot11f->present = 1;
        pDot11f->P2PStatus.present = 1;
        pDot11f->P2PStatus.status = eSIR_SUCCESS;
        pDot11f->ExtendedListenTiming.present = 0;
    }
    return eSIR_SUCCESS;
}

#if defined WLAN_FEATURE_VOWIFI

tSirRetStatus PopulateDot11fWFATPC( tpAniSirGlobal        pMac,
                                    tDot11fIEWFATPC *pDot11f, tANI_U8 txPower, tANI_U8 linkMargin )
{
     pDot11f->txPower = txPower;
     pDot11f->linkMargin = linkMargin;
     pDot11f->present = 1;

     return eSIR_SUCCESS;
}

tSirRetStatus PopulateDot11fBeaconReport( tpAniSirGlobal pMac, tDot11fIEMeasurementReport *pDot11f, tSirMacBeaconReport *pBeaconReport )
{

     pDot11f->report.Beacon.regClass = pBeaconReport->regClass;
     pDot11f->report.Beacon.channel = pBeaconReport->channel;
     vos_mem_copy( pDot11f->report.Beacon.meas_start_time, pBeaconReport->measStartTime,
                   sizeof(pDot11f->report.Beacon.meas_start_time) );
     pDot11f->report.Beacon.meas_duration = pBeaconReport->measDuration;
     pDot11f->report.Beacon.condensed_PHY = pBeaconReport->phyType;
     pDot11f->report.Beacon.reported_frame_type = !pBeaconReport->bcnProbeRsp;
     pDot11f->report.Beacon.RCPI = pBeaconReport->rcpi;
     pDot11f->report.Beacon.RSNI = pBeaconReport->rsni;
     vos_mem_copy( pDot11f->report.Beacon.BSSID, pBeaconReport->bssid, sizeof(tSirMacAddr));
     pDot11f->report.Beacon.antenna_id = pBeaconReport->antennaId;
     pDot11f->report.Beacon.parent_TSF = pBeaconReport->parentTSF;

     if( pBeaconReport->numIes )
     {
          pDot11f->report.Beacon.BeaconReportFrmBody.present = 1;
          vos_mem_copy( pDot11f->report.Beacon.BeaconReportFrmBody.reportedFields,
                        pBeaconReport->Ies, pBeaconReport->numIes );
          pDot11f->report.Beacon.BeaconReportFrmBody.num_reportedFields = pBeaconReport->numIes;
     }

     return eSIR_SUCCESS;

}

tSirRetStatus PopulateDot11fRRMIe( tpAniSirGlobal pMac, tDot11fIERRMEnabledCap *pDot11f, tpPESession    psessionEntry )
{  
   tpRRMCaps pRrmCaps;

   pRrmCaps = rrmGetCapabilities( pMac, psessionEntry );

   pDot11f->LinkMeasurement         = pRrmCaps->LinkMeasurement ;
   pDot11f->NeighborRpt             = pRrmCaps->NeighborRpt ;
   pDot11f->parallel                = pRrmCaps->parallel ;
   pDot11f->repeated                = pRrmCaps->repeated ;
   pDot11f->BeaconPassive           = pRrmCaps->BeaconPassive ;
   pDot11f->BeaconActive            = pRrmCaps->BeaconActive ;
   pDot11f->BeaconTable             = pRrmCaps->BeaconTable ;
   pDot11f->BeaconRepCond           = pRrmCaps->BeaconRepCond ;
   pDot11f->FrameMeasurement        = pRrmCaps->FrameMeasurement ;
   pDot11f->ChannelLoad             = pRrmCaps->ChannelLoad ;
   pDot11f->NoiseHistogram          = pRrmCaps->NoiseHistogram ;
   pDot11f->statistics              = pRrmCaps->statistics ;
   pDot11f->LCIMeasurement          = pRrmCaps->LCIMeasurement ;
   pDot11f->LCIAzimuth              = pRrmCaps->LCIAzimuth ;
   pDot11f->TCMCapability           = pRrmCaps->TCMCapability ;
   pDot11f->triggeredTCM            = pRrmCaps->triggeredTCM ;
   pDot11f->APChanReport            = pRrmCaps->APChanReport ;
   pDot11f->RRMMIBEnabled           = pRrmCaps->RRMMIBEnabled ;
   pDot11f->operatingChanMax        = pRrmCaps->operatingChanMax ;
   pDot11f->nonOperatinChanMax      = pRrmCaps->nonOperatingChanMax ;
   pDot11f->MeasurementPilot        = pRrmCaps->MeasurementPilot ;
   pDot11f->MeasurementPilotEnabled = pRrmCaps->MeasurementPilotEnabled ;
   pDot11f->NeighborTSFOffset       = pRrmCaps->NeighborTSFOffset ;
   pDot11f->RCPIMeasurement         = pRrmCaps->RCPIMeasurement ;
   pDot11f->RSNIMeasurement         = pRrmCaps->RSNIMeasurement ;
   pDot11f->BssAvgAccessDelay       = pRrmCaps->BssAvgAccessDelay ;
   pDot11f->BSSAvailAdmission       = pRrmCaps->BSSAvailAdmission ;
   pDot11f->AntennaInformation      = pRrmCaps->AntennaInformation ;

   pDot11f->present = 1;
   return eSIR_SUCCESS;
}
#endif

#if defined WLAN_FEATURE_VOWIFI_11R
void PopulateMDIE( tpAniSirGlobal        pMac,
                   tDot11fIEMobilityDomain *pDot11f, tANI_U8 mdie[SIR_MDIE_SIZE] )
{
   pDot11f->present = 1;
   pDot11f->MDID = (tANI_U16)((mdie[1] << 8) | (mdie[0]));

   // Plugfest fix
   pDot11f->overDSCap =   (mdie[2] & 0x01);
   pDot11f->resourceReqCap = ((mdie[2] >> 1) & 0x01);
   
}

void PopulateFTInfo( tpAniSirGlobal      pMac,
                     tDot11fIEFTInfo     *pDot11f )
{
   pDot11f->present = 1;
   pDot11f->IECount = 0; //TODO: put valid data during reassoc.
   //All other info is zero.

}
#endif

void PopulateDot11fAssocRspRates ( tpAniSirGlobal pMac, tDot11fIESuppRates *pSupp, 
      tDot11fIEExtSuppRates *pExt, tANI_U16 *_11bRates, tANI_U16 *_11aRates )
{
  tANI_U8 num_supp = 0, num_ext = 0;
  tANI_U8 i,j;

  for( i = 0 ; (i < SIR_NUM_11B_RATES && _11bRates[i]) ; i++, num_supp++ )
  {
      pSupp->rates[num_supp] = (tANI_U8)_11bRates[i];
  }  
  for( j = 0 ; (j < SIR_NUM_11A_RATES && _11aRates[j]) ; j++ )
  {
     if( num_supp < 8 )
         pSupp->rates[num_supp++] = (tANI_U8)_11aRates[j];
     else
         pExt->rates[num_ext++] =  (tANI_U8)_11aRates[j]; 
  }  

  if( num_supp )
  {
      pSupp->num_rates = num_supp;
      pSupp->present = 1;
  }
  if( num_ext )
  {
     pExt->num_rates = num_ext;
     pExt->present = 1;
  }
}

void PopulateDot11fTimeoutInterval( tpAniSirGlobal pMac,
                                    tDot11fIETimeoutInterval *pDot11f,
                                    tANI_U8 type, tANI_U32 value )
{
   pDot11f->present = 1;
   pDot11f->timeoutType = type;
   pDot11f->timeoutValue = value;
}
#ifdef SAP_AUTH_OFFLOAD
tSirRetStatus
sap_auth_offload_construct_rsn_opaque( tDot11fIERSN *pdot11f_rsn,
        tDot11fIERSNOpaque *pdot11f)
{
    tANI_U32 data_len=0;
    tANI_U8 *ptr;
    tANI_U32 element_len=0;
    tANI_U32 count=0;
    ptr = (tANI_U8 *)pdot11f->data;
    if (pdot11f_rsn->present)
    {
        pdot11f->present = pdot11f_rsn->present;
        element_len = sizeof(pdot11f_rsn->version);
        vos_mem_copy(ptr, &pdot11f_rsn->version, element_len);
        ptr += element_len;
        data_len += element_len;
        element_len = sizeof(pdot11f_rsn->gp_cipher_suite);
        vos_mem_copy(ptr, pdot11f_rsn->gp_cipher_suite, element_len);
        ptr += element_len;
        data_len += element_len;

        if (pdot11f_rsn->pwise_cipher_suite_count)
        {
            element_len = sizeof(pdot11f_rsn->pwise_cipher_suite_count);
            vos_mem_copy(ptr,
                    &pdot11f_rsn->pwise_cipher_suite_count,
                    element_len);
            ptr += element_len;
            data_len += element_len;
            for (count = 0; count < pdot11f_rsn->pwise_cipher_suite_count;
                    count++)
            {
                element_len = DOT11F_RSN_OUI_SIZE;
                vos_mem_copy(ptr,
                        &pdot11f_rsn->pwise_cipher_suites[count][0],
                        element_len);
                ptr += element_len;
                data_len += element_len;
            }
        }

        if (pdot11f_rsn->akm_suite_cnt)
        {
            element_len = sizeof(pdot11f_rsn->akm_suite_cnt);
            vos_mem_copy(ptr, &pdot11f_rsn->akm_suite_cnt, element_len);
            ptr += element_len;
            data_len += element_len;
            for (count = 0; count < pdot11f_rsn->akm_suite_cnt; count++)
            {
                element_len = DOT11F_RSN_OUI_SIZE;
                vos_mem_copy(ptr,
                        &pdot11f_rsn->akm_suite[count][0],
                        element_len);
                ptr += element_len;
                data_len += element_len;
            }
        }

        element_len = sizeof(pdot11f_rsn->RSN_Cap);
        vos_mem_copy(ptr, pdot11f_rsn->RSN_Cap, element_len);
        ptr += element_len;
        data_len += element_len;
    }
    pdot11f->num_data = data_len;
    return eSIR_SUCCESS;
}

void
sap_auth_offload_update_rsn_ie(tpAniSirGlobal pmac,
			tDot11fIERSNOpaque *pdot11f)
{
    tDot11fIERSN *pdot11f_rsn;
    pdot11f_rsn = vos_mem_malloc(sizeof(tDot11fIERSN));
    if (!pdot11f_rsn) {
           dot11fLog(pmac, LOGE,
           FL("Memory allocation failes for RSN IE"));
           return;
    }

    vos_mem_set(pdot11f_rsn, sizeof(tDot11fIERSN), 0);
    /* Assign RSN IE for Software AP Authentication offload security */
    if (pmac->sap_auth_offload && pmac->sap_auth_offload_sec_type)
    {
        switch (pmac->sap_auth_offload_sec_type)
        {
            case eSIR_OFFLOAD_WPA2PSK_CCMP:
                /* Only Support one kind of Cipher Suit for
                 * Software AP authentication offload
                 */
                pdot11f_rsn->present = 1;
                pdot11f_rsn->version = 1;
                vos_mem_copy(pdot11f_rsn->gp_cipher_suite,
                        &sirRSNOui[DOT11F_RSN_CSE_CCMP][0],
                        DOT11F_RSN_OUI_SIZE);
                pdot11f_rsn->pwise_cipher_suite_count = 1;
                vos_mem_copy(&(pdot11f_rsn->pwise_cipher_suites[0][0]),
                        &sirRSNOui[DOT11F_RSN_CSE_CCMP][0],
                        DOT11F_RSN_OUI_SIZE);
                pdot11f_rsn->akm_suite_cnt = 1;
                vos_mem_copy(&(pdot11f_rsn->akm_suite[0][0]),
                        &sirRSNOui[DOT11F_RSN_CSE_TKIP][0],
                        DOT11F_RSN_OUI_SIZE);
                pdot11f_rsn->pmkid_count = 0;
                /* Construct RSN IE into RSNOpaque*/
                sap_auth_offload_construct_rsn_opaque(pdot11f_rsn, pdot11f);
                break;
            default:
                dot11fLog( pmac, LOGE,
                        FL("The security type is not definied for "
                            "Software AP authentication offload!\n"));
                break;
        }
    }
    vos_mem_free(pdot11f_rsn);
}
#endif /* SAP_AUTH_OFFLOAD */

/**
 * sir_copy_hs20_ie() - Update HS 2.0 Information Element.
 * @dest: dest HS IE buffer to be updated
 * @src: src HS IE buffer
 *
 * Update HS2.0 IE info from src to dest
 *
 * Return: void
 */
void sir_copy_hs20_ie(tDot11fIEhs20vendor_ie *dest, tDot11fIEhs20vendor_ie *src)
{
   if (src->present) {
       vos_mem_copy(dest, src,
            sizeof(tDot11fIEhs20vendor_ie) -
            sizeof(src->hs_id));
       if (src->hs_id_present)
           vos_mem_copy(&dest->hs_id,
                   &src->hs_id,
                   sizeof(src->hs_id));
   }
}

// parserApi.c ends here.