| /* |
| * Copyright (c) 2012-2013, 2017 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 contains TSPEC and STA admit control related functions |
| * NOTE: applies only to AP builds |
| * |
| * Author: Sandesh Goel |
| * Date: 02/25/02 |
| * History:- |
| * Date Modified by Modification Information |
| * -------------------------------------------------------------------- |
| * |
| */ |
| #include "limDebug.h" |
| #include "sysDef.h" |
| #include "limApi.h" |
| #include "cfgApi.h" // wlan_cfgGetInt() |
| #include "limTrace.h" |
| #include "limSendSmeRspMessages.h" |
| #include "limTypes.h" |
| |
| |
| #define ADMIT_CONTROL_LOGLEVEL LOG1 |
| #define ADMIT_CONTROL_POLICY_LOGLEVEL LOG1 |
| #define ADMIT_CONTROL_MIN_INTERVAL 1000 // min acceptable service interval 1mSec |
| |
| /* total available bandwidth in bps in each phy mode |
| * these should be defined in hal or dph - replace these later |
| */ |
| #define LIM_TOTAL_BW_11A 54000000 |
| #define LIM_MIN_BW_11A 6000000 |
| #define LIM_TOTAL_BW_11B 11000000 |
| #define LIM_MIN_BW_11B 1000000 |
| #define LIM_TOTAL_BW_11G LIM_TOTAL_BW_11A |
| #define LIM_MIN_BW_11G LIM_MIN_BW_11B |
| |
| // conversion factors |
| #define LIM_CONVERT_SIZE_BITS(numBytes) ((numBytes) * 8) |
| #define LIM_CONVERT_RATE_MBPS(rate) ((rate)/1000000) |
| |
| /* ANI sta's support enhanced rates, so the effective medium time used is |
| * half that of other stations. This is the same as if they were requesting |
| * half the badnwidth - so we adjust ANI sta's accordingly for bandwidth |
| * calculations. Also enhanced rates apply only in case of non 11B mode. |
| */ |
| #define LIM_STA_BW_ADJUST(aniPeer, phyMode, bw) \ |
| (((aniPeer) && ((phyMode) != WNI_CFG_PHY_MODE_11B)) \ |
| ? ((bw)/2) : (bw)) |
| |
| |
| //------------------------------------------------------------------------------ |
| // local protos |
| |
| static tSirRetStatus |
| limCalculateSvcInt(tpAniSirGlobal, tSirMacTspecIE *, tANI_U32 *); |
| #if 0 //only EDCA is supported now |
| static tSirRetStatus |
| limValidateTspecHcca(tpAniSirGlobal, tSirMacTspecIE *); |
| #endif |
| static tSirRetStatus |
| limValidateTspecEdca(tpAniSirGlobal, tSirMacTspecIE *, tpPESession); |
| static tSirRetStatus |
| limValidateTspec(tpAniSirGlobal, tSirMacTspecIE *, tpPESession); |
| static void |
| limComputeMeanBwUsed(tpAniSirGlobal, tANI_U32 *, tANI_U32, tpLimTspecInfo, tpPESession); |
| static void |
| limGetAvailableBw(tpAniSirGlobal, tANI_U32 *, tANI_U32 *, tANI_U32, tANI_U32); |
| static tSirRetStatus |
| limAdmitPolicyOversubscription(tpAniSirGlobal, tSirMacTspecIE *, tpLimAdmitPolicyInfo, tpLimTspecInfo, tpPESession); |
| static tSirRetStatus |
| limTspecFindByStaAddr(tpAniSirGlobal, tANI_U8 *, tSirMacTspecIE*, tpLimTspecInfo, tpLimTspecInfo *); |
| static tSirRetStatus |
| limValidateAccessPolicy(tpAniSirGlobal, tANI_U8, tANI_U16, tpPESession); |
| |
| |
| /** ------------------------------------------------------------- |
| \fn limCalculateSvcInt |
| \brief TSPEC validation and servcie interval determination |
| \param tpAniSirGlobal pMac |
| \param tSirMacTspecIE *pTspec |
| \param tANI_U32 *pSvcInt |
| \return eSirRetStatus - status of the comparison |
| -------------------------------------------------------------*/ |
| |
| static tSirRetStatus |
| limCalculateSvcInt( |
| tpAniSirGlobal pMac, |
| tSirMacTspecIE *pTspec, |
| tANI_U32 *pSvcInt) |
| { |
| tANI_U32 msduSz, dataRate; |
| *pSvcInt = 0; |
| |
| // if a service interval is already specified, we are done |
| if ((pTspec->minSvcInterval != 0) || (pTspec->maxSvcInterval != 0)) |
| { |
| *pSvcInt = (pTspec->maxSvcInterval != 0) |
| ? pTspec->maxSvcInterval : pTspec->minSvcInterval; |
| return eSIR_SUCCESS; |
| } |
| |
| /* Masking off the fixed bits according to definition of MSDU size |
| * in IEEE 802.11-2007 spec (section 7.3.2.30). Nominal MSDU size |
| * is defined as: Bit[0:14]=Size, Bit[15]=Fixed |
| */ |
| if (pTspec->nomMsduSz != 0) |
| msduSz = (pTspec->nomMsduSz & 0x7fff); |
| else if (pTspec->maxMsduSz != 0) |
| msduSz = pTspec->maxMsduSz; |
| else |
| { |
| PELOGE(limLog(pMac, LOGE, FL("MsduSize not specified"));) |
| return eSIR_FAILURE; |
| } |
| |
| /* need to calculate a reasonable service interval |
| * this is simply the msduSz/meanDataRate |
| */ |
| if (pTspec->meanDataRate != 0) dataRate = pTspec->meanDataRate; |
| else if (pTspec->peakDataRate != 0) dataRate = pTspec->peakDataRate; |
| else if (pTspec->minDataRate != 0) dataRate = pTspec->minDataRate; |
| else |
| { |
| PELOGE(limLog(pMac, LOGE, FL("DataRate not specified"));) |
| return eSIR_FAILURE; |
| } |
| |
| *pSvcInt = LIM_CONVERT_SIZE_BITS(msduSz) / LIM_CONVERT_RATE_MBPS(dataRate); |
| return eSIR_FAILURE; |
| } |
| |
| #if 0 //only EDCA is supported now |
| /** ------------------------------------------------------------- |
| \fn limValidateTspecHcca |
| \brief validate the parameters in the hcca tspec |
| mandatory fields are derived from 11e Annex I (Table I.1) |
| \param tpAniSirGlobal pMac |
| \param tSirMacTspecIE *pTspec |
| \return eSirRetStatus - status |
| -------------------------------------------------------------*/ |
| static tSirRetStatus |
| limValidateTspecHcca( |
| tpAniSirGlobal pMac, |
| tSirMacTspecIE *pTspec) |
| { |
| tANI_U32 maxPhyRate, minPhyRate; |
| tANI_U32 phyMode; |
| |
| tSirRetStatus retval = eSIR_SUCCESS; |
| /* make sure a TSID is being requested */ |
| if (pTspec->tsinfo.traffic.tsid < SIR_MAC_HCCA_TSID_MIN) |
| { |
| limLog(pMac, LOGW, FL("tsid %d must be >%d)"), |
| pTspec->tsinfo.traffic.tsid, SIR_MAC_HCCA_TSID_MIN); |
| retval = eSIR_FAILURE; |
| } |
| /* |
| * With Polaris, there is a limitation in that the tsid cannot be arbitary |
| * but is based on the qid. Thus, we cannot have a tspec which requests |
| * a tsid of 13 and userPrio of 7, the bottom three bits of the tsid must |
| * correspond to the userPrio |
| */ |
| if (pTspec->tsinfo.traffic.userPrio != |
| (pTspec->tsinfo.traffic.tsid - SIR_MAC_HCCA_TSID_MIN)) |
| { |
| limLog(pMac, LOGE, FL("TSid=0x%x, userPrio=%d: is not allowed"), |
| pTspec->tsinfo.traffic.tsid, pTspec->tsinfo.traffic.userPrio); |
| retval = eSIR_FAILURE; |
| } |
| // an inactivity interval is mandatory |
| if (pTspec->inactInterval == 0) |
| { |
| PELOGW(limLog(pMac, LOGW, FL("inactInterval unspecified!"));) |
| retval = eSIR_FAILURE; |
| } |
| // surplus BW must be specified if a delay Bound is specified |
| if ((pTspec->delayBound != 0) && (pTspec->surplusBw == 0)) |
| { |
| limLog(pMac, LOGW, FL("delayBound %d, but surplusBw unspecified!"), |
| pTspec->delayBound); |
| retval = eSIR_FAILURE; |
| } |
| // minPhyRate must always be specified and cannot exceed maximum supported |
| limGetPhyMode(pMac, &phyMode); |
| //limGetAvailableBw(pMac, &maxPhyRate, &minPhyRate, pMac->dph.gDphPhyMode, |
| // 1 /* bandwidth mult factor */); |
| limGetAvailableBw(pMac, &maxPhyRate, &minPhyRate, phyMode, |
| 1 /* bandwidth mult factor */); |
| if ((pTspec->minPhyRate == 0) |
| || (pTspec->minPhyRate > maxPhyRate) |
| || (pTspec->minPhyRate < minPhyRate)) |
| { |
| limLog(pMac, LOGW, FL("minPhyRate (%d) invalid"), |
| pTspec->minPhyRate); |
| retval = eSIR_FAILURE; |
| } |
| /* NOTE: we will require all Tspec's to specify a mean data rate (and so |
| * also the min and peak data rates) |
| */ |
| if ((pTspec->minDataRate == 0) || |
| (pTspec->meanDataRate == 0) || |
| (pTspec->peakDataRate == 0)) |
| { |
| limLog(pMac, LOGW, FL("DataRate must be specified (min %d, mean %d, peak %d)"), |
| pTspec->minDataRate, pTspec->meanDataRate, pTspec->peakDataRate); |
| retval = eSIR_FAILURE; |
| } |
| |
| // mean data rate can't be more than the min phy rate |
| if (pTspec->meanDataRate > pTspec->minPhyRate) |
| { |
| limLog(pMac, LOGW, FL("Data rate (%d) is more than Phyrate %d"), |
| pTspec->meanDataRate, pTspec->minPhyRate); |
| return eSIR_FAILURE; |
| } |
| |
| /* if the tspec specifies a service interval, we won't accept tspec's |
| * with service interval less than our allowed minimum, also either both |
| * min and max must be specified or neither should be specified (in which |
| * case, HC determines the appropriate service interval |
| */ |
| if ((pTspec->minSvcInterval != 0) || (pTspec->maxSvcInterval != 0)) |
| { |
| // max < min is ridiculous |
| if (pTspec->maxSvcInterval < pTspec->minSvcInterval) |
| { |
| limLog(pMac, LOGW, FL("maxSvcInt %d > minSvcInterval %d!!"), |
| pTspec->maxSvcInterval, pTspec->minSvcInterval); |
| retval = eSIR_FAILURE; |
| } |
| if (pTspec->maxSvcInterval < ADMIT_CONTROL_MIN_INTERVAL) |
| { |
| limLog(pMac, LOGW, FL("maxSvcInt %d must be >%d"), |
| pTspec->maxSvcInterval, ADMIT_CONTROL_MIN_INTERVAL); |
| retval = eSIR_FAILURE; |
| } |
| } |
| else // min and max both unspecified |
| { |
| /* no service interval is specified, so make sure the parameters |
| * needed to determine one are specified in the tspec |
| * minPhyRate, meanDataRate and nomMsduSz are needed, only nomMsduSz |
| * must be checked here since the other two are already validated |
| */ |
| if (pTspec->nomMsduSz == 0) |
| { |
| PELOGW(limLog(pMac, LOGW, FL("No svcInt and no MsduSize specified"));) |
| retval = eSIR_FAILURE; |
| } |
| } |
| |
| limLog(pMac, ADMIT_CONTROL_LOGLEVEL, FL("return status %d"), retval); |
| return retval; |
| } |
| |
| #endif //only edca is supported now. |
| |
| /** ------------------------------------------------------------- |
| \fn limValidateTspecEdca |
| \brief validate the parameters in the edca tspec |
| mandatory fields are derived from 11e Annex I (Table I.1) |
| \param tpAniSirGlobal pMac |
| \param tSirMacTspecIE *pTspec |
| \return eSirRetStatus - status |
| -------------------------------------------------------------*/ |
| static tSirRetStatus |
| limValidateTspecEdca( |
| tpAniSirGlobal pMac, |
| tSirMacTspecIE *pTspec, |
| tpPESession psessionEntry) |
| { |
| tANI_U32 maxPhyRate, minPhyRate; |
| tANI_U32 phyMode; |
| tSirRetStatus retval = eSIR_SUCCESS; |
| |
| limGetPhyMode(pMac, &phyMode, psessionEntry); |
| |
| //limGetAvailableBw(pMac, &maxPhyRate, &minPhyRate, pMac->dph.gDphPhyMode, |
| // 1 /* bandwidth mult factor */); |
| limGetAvailableBw(pMac, &maxPhyRate, &minPhyRate, phyMode, |
| 1 /* bandwidth mult factor */); |
| // mandatory fields are derived from 11e Annex I (Table I.1) |
| if ((pTspec->nomMsduSz == 0) || |
| (pTspec->meanDataRate == 0) || |
| (pTspec->surplusBw == 0) || |
| (pTspec->minPhyRate == 0) || |
| (pTspec->minPhyRate > maxPhyRate)) |
| { |
| limLog(pMac, LOGW, FL("Invalid EDCA Tspec: NomMsdu %d, meanDataRate %d, surplusBw %d, minPhyRate %d"), |
| pTspec->nomMsduSz, pTspec->meanDataRate, pTspec->surplusBw, pTspec->minPhyRate); |
| retval = eSIR_FAILURE; |
| } |
| |
| limLog(pMac, ADMIT_CONTROL_LOGLEVEL, FL("return status %d"), retval); |
| return retval; |
| } |
| |
| /** ------------------------------------------------------------- |
| \fn limValidateTspec |
| \brief validate the offered tspec |
| \param tpAniSirGlobal pMac |
| \param tSirMacTspecIE *pTspec |
| \return eSirRetStatus - status |
| -------------------------------------------------------------*/ |
| |
| static tSirRetStatus |
| limValidateTspec( |
| tpAniSirGlobal pMac, |
| tSirMacTspecIE *pTspec, |
| tpPESession psessionEntry) |
| { |
| tSirRetStatus retval = eSIR_SUCCESS; |
| switch (pTspec->tsinfo.traffic.accessPolicy) |
| { |
| case SIR_MAC_ACCESSPOLICY_EDCA: |
| if ((retval = limValidateTspecEdca(pMac, pTspec, psessionEntry)) != eSIR_SUCCESS) |
| PELOGW(limLog(pMac, LOGW, FL("EDCA tspec invalid"));) |
| break; |
| |
| case SIR_MAC_ACCESSPOLICY_HCCA: |
| #if 0 //Not supported right now. |
| if ((retval = limValidateTspecHcca(pMac, pTspec)) != eSIR_SUCCESS) |
| PELOGW(limLog(pMac, LOGW, FL("HCCA tspec invalid"));) |
| break; |
| #endif |
| case SIR_MAC_ACCESSPOLICY_BOTH: |
| // TBD: should we support hybrid tspec as well?? for now, just fall through |
| default: |
| limLog(pMac, LOGW, FL("AccessType %d not supported"), |
| pTspec->tsinfo.traffic.accessPolicy); |
| retval = eSIR_FAILURE; |
| break; |
| } |
| return retval; |
| } |
| |
| //----------------------------------------------------------------------------- |
| // Admit Control Policy |
| |
| |
| /** ------------------------------------------------------------- |
| \fn limComputeMeanBwUsed |
| \brief determime the used/allocated bandwidth |
| \param tpAniSirGlobal pMac |
| \param tANI_U32 *pBw |
| \param tANI_U32 phyMode |
| \param tpLimTspecInfo pTspecInfo |
| \return eSirRetStatus - status |
| -------------------------------------------------------------*/ |
| |
| static void |
| limComputeMeanBwUsed( |
| tpAniSirGlobal pMac, |
| tANI_U32 *pBw, |
| tANI_U32 phyMode, |
| tpLimTspecInfo pTspecInfo, |
| tpPESession psessionEntry) |
| { |
| tANI_U32 ctspec; |
| *pBw = 0; |
| for (ctspec = 0; ctspec < LIM_NUM_TSPEC_MAX; ctspec++, pTspecInfo++) |
| { |
| if (pTspecInfo->inuse) |
| { |
| tpDphHashNode pSta = dphGetHashEntry(pMac, pTspecInfo->assocId, &psessionEntry->dph.dphHashTable); |
| if (pSta == NULL) |
| { |
| // maybe we should delete the tspec?? |
| limLog(pMac, LOGE, FL("Tspec %d (assocId %d): dphNode not found"), |
| ctspec, pTspecInfo->assocId); |
| continue; |
| } |
| //FIXME: need to take care of taurusPeer, titanPeer, 11npeer too. |
| *pBw += LIM_STA_BW_ADJUST(pSta->aniPeer, phyMode, pTspecInfo->tspec.meanDataRate); |
| } |
| } |
| } |
| |
| /** ------------------------------------------------------------- |
| \fn limGetAvailableBw |
| \brief based on the phy mode and the bw_factor, determine the total bandwidth that |
| can be supported |
| \param tpAniSirGlobal pMac |
| \param tANI_U32 *pMaxBw |
| \param tANI_U32 *pMinBw |
| \param tANI_U32 phyMode |
| \param tANI_U32 bw_factor |
| \return eSirRetStatus - status |
| -------------------------------------------------------------*/ |
| |
| static void |
| limGetAvailableBw( |
| tpAniSirGlobal pMac, |
| tANI_U32 *pMaxBw, |
| tANI_U32 *pMinBw, |
| tANI_U32 phyMode, |
| tANI_U32 bw_factor) |
| { |
| switch (phyMode) |
| { |
| case WNI_CFG_PHY_MODE_11B: |
| *pMaxBw = LIM_TOTAL_BW_11B; |
| *pMinBw = LIM_MIN_BW_11B; |
| break; |
| |
| case WNI_CFG_PHY_MODE_11A: |
| *pMaxBw = LIM_TOTAL_BW_11A; |
| *pMinBw = LIM_MIN_BW_11A; |
| break; |
| |
| case WNI_CFG_PHY_MODE_11G: |
| case WNI_CFG_PHY_MODE_NONE: |
| default: |
| *pMaxBw = LIM_TOTAL_BW_11G; |
| *pMinBw = LIM_MIN_BW_11G; |
| break; |
| } |
| *pMaxBw *= bw_factor; |
| } |
| |
| /** ------------------------------------------------------------- |
| \fn limAdmitPolicyOversubscription |
| \brief simple admission control policy based on oversubscription |
| if the total bandwidth of all admitted tspec's exceeds (factor * phy-bw) then |
| reject the tspec, else admit it. The phy-bw is the peak available bw in the |
| current phy mode. The 'factor' is the configured oversubscription factor. |
| \param tpAniSirGlobal pMac |
| \param tSirMacTspecIE *pTspec |
| \param tpLimAdmitPolicyInfo pAdmitPolicy |
| \param tpLimTspecInfo pTspecInfo |
| \return eSirRetStatus - status |
| -------------------------------------------------------------*/ |
| |
| /* |
| * simple admission control policy based on oversubscription |
| * if the total bandwidth of all admitted tspec's exceeds (factor * phy-bw) then |
| * reject the tspec, else admit it. The phy-bw is the peak available bw in the |
| * current phy mode. The 'factor' is the configured oversubscription factor. |
| */ |
| static tSirRetStatus |
| limAdmitPolicyOversubscription( |
| tpAniSirGlobal pMac, |
| tSirMacTspecIE *pTspec, |
| tpLimAdmitPolicyInfo pAdmitPolicy, |
| tpLimTspecInfo pTspecInfo, |
| tpPESession psessionEntry) |
| { |
| tANI_U32 totalbw, minbw, usedbw; |
| tANI_U32 phyMode; |
| |
| // determine total bandwidth used so far |
| limGetPhyMode(pMac, &phyMode, psessionEntry); |
| |
| //limComputeMeanBwUsed(pMac, &usedbw, pMac->dph.gDphPhyMode, pTspecInfo); |
| limComputeMeanBwUsed(pMac, &usedbw, phyMode, pTspecInfo, psessionEntry); |
| |
| // determine how much bandwidth is available based on the current phy mode |
| //limGetAvailableBw(pMac, &totalbw, &minbw, pMac->dph.gDphPhyMode, pAdmitPolicy->bw_factor); |
| limGetAvailableBw(pMac, &totalbw, &minbw, phyMode, pAdmitPolicy->bw_factor); |
| |
| if (usedbw > totalbw) // this can't possibly happen |
| return eSIR_FAILURE; |
| |
| if ((totalbw - usedbw) < pTspec->meanDataRate) |
| { |
| limLog(pMac, ADMIT_CONTROL_POLICY_LOGLEVEL, |
| FL("Total BW %d, Used %d, Tspec request %d not possible"), |
| totalbw, usedbw, pTspec->meanDataRate); |
| return eSIR_FAILURE; |
| } |
| return eSIR_SUCCESS; |
| } |
| |
| /** ------------------------------------------------------------- |
| \fn limAdmitPolicy |
| \brief determine the current admit control policy and apply it for the offered tspec |
| \param tpAniSirGlobal pMac |
| \param tSirMacTspecIE *pTspec |
| \return eSirRetStatus - status |
| -------------------------------------------------------------*/ |
| |
| tSirRetStatus limAdmitPolicy( |
| tpAniSirGlobal pMac, |
| tSirMacTspecIE *pTspec, |
| tpPESession psessionEntry) |
| { |
| tSirRetStatus retval = eSIR_FAILURE; |
| tpLimAdmitPolicyInfo pAdmitPolicy = &pMac->lim.admitPolicyInfo; |
| |
| switch (pAdmitPolicy->type) |
| { |
| case WNI_CFG_ADMIT_POLICY_ADMIT_ALL: |
| retval = eSIR_SUCCESS; |
| break; |
| |
| case WNI_CFG_ADMIT_POLICY_BW_FACTOR: |
| retval = limAdmitPolicyOversubscription(pMac, pTspec, |
| &pMac->lim.admitPolicyInfo, &pMac->lim.tspecInfo[0], psessionEntry); |
| if (retval != eSIR_SUCCESS) |
| PELOGE(limLog(pMac, LOGE, FL("rejected by BWFactor policy"));) |
| break; |
| |
| case WNI_CFG_ADMIT_POLICY_REJECT_ALL: |
| retval = eSIR_FAILURE; |
| break; |
| |
| default: |
| retval = eSIR_SUCCESS; |
| limLog(pMac, LOGE, FL("Admit Policy %d unknown, admitting all traffic"), |
| pAdmitPolicy->type); |
| break; |
| } |
| return retval; |
| } |
| |
| /** ------------------------------------------------------------- |
| \fn limTspecDelete |
| \brief delete the specified tspec |
| \param tpAniSirGlobal pMac |
| \param tpLimTspecInfo pInfo |
| \return eSirRetStatus - status |
| -------------------------------------------------------------*/ |
| |
| //----------------------------------------------------------------------------- |
| // delete the specified tspec |
| void limTspecDelete(tpAniSirGlobal pMac, tpLimTspecInfo pInfo) |
| { |
| if (pInfo == NULL) |
| return; |
| //pierre |
| limLog(pMac, ADMIT_CONTROL_LOGLEVEL, FL("tspec entry = %d"), pInfo->idx); |
| limLog(pMac, ADMIT_CONTROL_LOGLEVEL, FL("delete tspec %pK"), pInfo); |
| pInfo->inuse = 0; |
| |
| // clear the hcca/parameterized queue indicator |
| #if 0 |
| if ((pInfo->tspec.tsinfo.traffic.direction == SIR_MAC_DIRECTION_UPLINK) || |
| (pInfo->tspec.tsinfo.traffic.direction == SIR_MAC_DIRECTION_BIDIR)) |
| queue[pInfo->staid][pInfo->tspec.tsinfo.traffic.userPrio][SCH_UL_QUEUE].ts = 0; |
| #endif |
| |
| return; |
| } |
| |
| /** ------------------------------------------------------------- |
| \fn limTspecFindByStaAddr |
| \brief Send halMsg_AddTs to HAL |
| \param tpAniSirGlobal pMac |
| \param \param tANI_U8 *pAddr |
| \param tSirMacTspecIE *pTspecIE |
| \param tpLimTspecInfo pTspecList |
| \param tpLimTspecInfo *ppInfo |
| \return eSirRetStatus - status |
| -------------------------------------------------------------*/ |
| |
| // find the specified tspec in the list |
| static tSirRetStatus |
| limTspecFindByStaAddr( |
| tpAniSirGlobal pMac, |
| tANI_U8 *pAddr, |
| tSirMacTspecIE *pTspecIE, |
| tpLimTspecInfo pTspecList, |
| tpLimTspecInfo *ppInfo) |
| { |
| int ctspec; |
| |
| *ppInfo = NULL; |
| |
| for (ctspec = 0; ctspec < LIM_NUM_TSPEC_MAX; ctspec++, pTspecList++) |
| { |
| if ((pTspecList->inuse) |
| && (vos_mem_compare(pAddr, pTspecList->staAddr, sizeof(pTspecList->staAddr))) |
| && (vos_mem_compare((tANI_U8 *) pTspecIE, (tANI_U8 *) &pTspecList->tspec, |
| sizeof(tSirMacTspecIE)))) |
| { |
| *ppInfo = pTspecList; |
| return eSIR_SUCCESS; |
| } |
| } |
| return eSIR_FAILURE; |
| } |
| |
| /** ------------------------------------------------------------- |
| \fn limTspecFindByAssocId |
| \brief find tspec with matchin staid and Tspec |
| \param tpAniSirGlobal pMac |
| \param tANI_U32 staid |
| \param tSirMacTspecIE *pTspecIE |
| \param tpLimTspecInfo pTspecList |
| \param tpLimTspecInfo *ppInfo |
| \return eSirRetStatus - status |
| -------------------------------------------------------------*/ |
| |
| tSirRetStatus |
| limTspecFindByAssocId( |
| tpAniSirGlobal pMac, |
| tANI_U16 assocId, |
| tSirMacTspecIE *pTspecIE, |
| tpLimTspecInfo pTspecList, |
| tpLimTspecInfo *ppInfo) |
| { |
| int ctspec; |
| |
| *ppInfo = NULL; |
| |
| limLog(pMac, ADMIT_CONTROL_LOGLEVEL, FL("Trying to find tspec entry for assocId = %d"), assocId); |
| limLog(pMac, ADMIT_CONTROL_LOGLEVEL, FL("pTsInfo->traffic.direction = %d, pTsInfo->traffic.tsid = %d"), |
| pTspecIE->tsinfo.traffic.direction, pTspecIE->tsinfo.traffic.tsid); |
| |
| for (ctspec = 0; ctspec < LIM_NUM_TSPEC_MAX; ctspec++, pTspecList++) |
| { |
| if ((pTspecList->inuse) |
| && (assocId == pTspecList->assocId) |
| && (vos_mem_compare((tANI_U8 *)pTspecIE, (tANI_U8 *)&pTspecList->tspec, |
| sizeof(tSirMacTspecIE)))) |
| { |
| *ppInfo = pTspecList; |
| return eSIR_SUCCESS; |
| } |
| } |
| return eSIR_FAILURE; |
| } |
| |
| /** ------------------------------------------------------------- |
| \fn limFindTspec |
| \brief finding a TSPEC entry with assocId, tsinfo.direction and tsinfo.tsid |
| \param tANI_U16 assocId |
| \param tpAniSirGlobal pMac |
| \param tSirMacTSInfo *pTsInfo |
| \param tpLimTspecInfo pTspecList |
| \param tpLimTspecInfo *ppInfo |
| \return eSirRetStatus - status of the comparison |
| -------------------------------------------------------------*/ |
| |
| tSirRetStatus |
| limFindTspec( |
| tpAniSirGlobal pMac, |
| tANI_U16 assocId, |
| tSirMacTSInfo *pTsInfo, |
| tpLimTspecInfo pTspecList, |
| tpLimTspecInfo *ppInfo) |
| { |
| int ctspec; |
| |
| *ppInfo = NULL; |
| |
| limLog(pMac, ADMIT_CONTROL_LOGLEVEL, FL("Trying to find tspec entry for assocId = %d"), assocId); |
| limLog(pMac, ADMIT_CONTROL_LOGLEVEL, FL("pTsInfo->traffic.direction = %d, pTsInfo->traffic.tsid = %d"), |
| pTsInfo->traffic.direction, pTsInfo->traffic.tsid); |
| |
| for (ctspec = 0; ctspec < LIM_NUM_TSPEC_MAX; ctspec++, pTspecList++) |
| { |
| if ((pTspecList->inuse) |
| && (assocId == pTspecList->assocId) |
| && (pTsInfo->traffic.direction == pTspecList->tspec.tsinfo.traffic.direction) |
| && (pTsInfo->traffic.tsid == pTspecList->tspec.tsinfo.traffic.tsid)) |
| { |
| *ppInfo = pTspecList; |
| return eSIR_SUCCESS; |
| } |
| } |
| return eSIR_FAILURE; |
| } |
| |
| /** ------------------------------------------------------------- |
| \fn limTspecAdd |
| \brief add or update the specified tspec to the tspec list |
| \param tpAniSirGlobal pMac |
| \param tANI_U8 *pAddr |
| \param tANI_U16 assocId |
| \param tSirMacTspecIE *pTspec |
| \param tANI_U32 interval |
| \param tpLimTspecInfo *ppInfo |
| |
| \return eSirRetStatus - status of the comparison |
| -------------------------------------------------------------*/ |
| |
| tSirRetStatus limTspecAdd( |
| tpAniSirGlobal pMac, |
| tANI_U8 *pAddr, |
| tANI_U16 assocId, |
| tSirMacTspecIE *pTspec, |
| tANI_U32 interval, |
| tpLimTspecInfo *ppInfo) |
| { |
| tpLimTspecInfo pTspecList = &pMac->lim.tspecInfo[0]; |
| *ppInfo = NULL; |
| |
| // validate the assocId |
| if (assocId >= pMac->lim.maxStation) |
| { |
| PELOGE(limLog(pMac, LOGE, FL("Invalid assocId 0x%x"), assocId);) |
| return eSIR_FAILURE; |
| } |
| |
| //decide whether to add/update |
| { |
| *ppInfo = NULL; |
| |
| if(eSIR_SUCCESS == limFindTspec(pMac, assocId, &pTspec->tsinfo, pTspecList, ppInfo)) |
| { |
| //update this entry. |
| limLog(pMac, ADMIT_CONTROL_LOGLEVEL, FL("updating TSPEC table entry = %d"), |
| (*ppInfo)->idx); |
| } |
| else |
| { |
| /* We didn't find one to update. So find a free slot in the |
| * LIM TSPEC list and add this new entry |
| */ |
| tANI_U8 ctspec = 0; |
| for (ctspec = 0 , pTspecList = &pMac->lim.tspecInfo[0]; ctspec < LIM_NUM_TSPEC_MAX; ctspec++, pTspecList++) |
| { |
| if (! pTspecList->inuse) |
| { |
| limLog(pMac, LOG1, FL("Found free slot in TSPEC list. Add to TSPEC table entry %d"), ctspec); |
| break; |
| } |
| } |
| |
| if (ctspec >= LIM_NUM_TSPEC_MAX) |
| return eSIR_FAILURE; |
| |
| //Record the new index entry |
| pTspecList->idx = ctspec; |
| } |
| } |
| |
| // update the tspec info |
| pTspecList->tspec = *pTspec; |
| pTspecList->assocId = assocId; |
| vos_mem_copy(pTspecList->staAddr, pAddr, sizeof(pTspecList->staAddr)); |
| |
| // for edca tspec's, we are all done |
| if (pTspec->tsinfo.traffic.accessPolicy == SIR_MAC_ACCESSPOLICY_EDCA) |
| { |
| pTspecList->inuse = 1; |
| *ppInfo = pTspecList; |
| limLog(pMac, ADMIT_CONTROL_LOGLEVEL, FL("added entry for EDCA AccessPolicy")); |
| return eSIR_SUCCESS; |
| } |
| |
| /* |
| * for hcca tspec's, must set the parameterized bit in the queues |
| * the 'ts' bit in the queue data structure indicates that the queue is |
| * parameterized (hcca). When the schedule is written this bit is used |
| * in the tsid field (bit 3) and the other three bits (0-2) are simply |
| * filled in as the user priority (or qid). This applies only to uplink |
| * polls where the qos control field must contain the tsid specified in the |
| * tspec. |
| */ |
| #if 0 |
| if ((pTspec->tsinfo.traffic.direction == SIR_MAC_DIRECTION_UPLINK) || |
| (pTspec->tsinfo.traffic.direction == SIR_MAC_DIRECTION_BIDIR)) |
| queue[staid][pTspec->tsinfo.traffic.userPrio][SCH_UL_QUEUE].ts = 1; |
| #endif |
| pTspecList->inuse = 1; |
| *ppInfo = pTspecList; |
| limLog(pMac, ADMIT_CONTROL_LOGLEVEL, FL("added entry for HCCA AccessPolicy")); |
| return eSIR_SUCCESS; |
| } |
| |
| /** ------------------------------------------------------------- |
| \fn limValidateAccessPolicy |
| \brief Validates Access policy |
| \param tpAniSirGlobal pMac |
| \param tANI_U8 accessPolicy |
| \param tANI_U16 assocId |
| \return eSirRetStatus - status |
| -------------------------------------------------------------*/ |
| |
| static tSirRetStatus |
| limValidateAccessPolicy( |
| tpAniSirGlobal pMac, |
| tANI_U8 accessPolicy, |
| tANI_U16 assocId, |
| tpPESession psessionEntry) |
| { |
| tSirRetStatus retval = eSIR_FAILURE; |
| tpDphHashNode pSta = dphGetHashEntry(pMac, assocId, &psessionEntry->dph.dphHashTable); |
| |
| if ((pSta == NULL) || (! pSta->valid)) |
| { |
| PELOGE(limLog(pMac, LOGE, FL("invalid station address passed"));) |
| return eSIR_FAILURE; |
| } |
| |
| switch (accessPolicy) |
| { |
| case SIR_MAC_ACCESSPOLICY_EDCA: |
| if (pSta->wmeEnabled || pSta->lleEnabled) |
| retval = eSIR_SUCCESS; |
| break; |
| |
| case SIR_MAC_ACCESSPOLICY_HCCA: |
| case SIR_MAC_ACCESSPOLICY_BOTH: |
| #if 0 //only EDCA supported for now. |
| // TBD: check wsm doesn't support the hybrid access policy |
| if (pSta->wsmEnabled || pSta->lleEnabled) |
| retval = eSIR_SUCCESS; |
| break; |
| #endif //only EDCA supported for now. |
| default: |
| PELOGE(limLog(pMac, LOGE, FL("Invalid accessPolicy %d"), accessPolicy);) |
| break; |
| } |
| |
| if (retval != eSIR_SUCCESS) |
| limLog(pMac, LOGW, FL("failed (accPol %d, staId %d, lle %d, wme %d, wsm %d)"), |
| accessPolicy, pSta->staIndex, pSta->lleEnabled, pSta->wmeEnabled, pSta->wsmEnabled); |
| |
| return retval; |
| } |
| |
| /** ------------------------------------------------------------- |
| \fn limAdmitControlAddTS |
| \brief Determine if STA with the specified TSPEC can be admitted. If it can, |
| a schedule element is provided |
| \param tpAniSirGlobal pMac |
| \param tANI_U8 *pAddr, |
| \param tSirAddtsReqInfo *pAddts, |
| \param tSirMacQosCapabilityIE *pQos, |
| \param tANI_U16 assocId, // assocId, valid only if alloc==true |
| \param tANI_U8 alloc, // true=>allocate bw for this tspec, |
| // else determine only if space is available |
| \param tSirMacScheduleIE *pSch, |
| \param tANI_U8 *pTspecIdx //index to the lim tspec table. |
| \return eSirRetStatus - status |
| -------------------------------------------------------------*/ |
| |
| tSirRetStatus limAdmitControlAddTS( |
| tpAniSirGlobal pMac, |
| tANI_U8 *pAddr, |
| tSirAddtsReqInfo *pAddts, |
| tSirMacQosCapabilityStaIE *pQos, |
| tANI_U16 assocId, // assocId, valid only if alloc==true |
| tANI_U8 alloc, // true=>allocate bw for this tspec, |
| // else determine only if space is available |
| tSirMacScheduleIE *pSch, |
| tANI_U8 *pTspecIdx, //index to the lim tspec table. |
| tpPESession psessionEntry |
| ) |
| { |
| tpLimTspecInfo pTspecInfo; |
| tSirRetStatus retval; |
| tANI_U32 svcInterval; |
| (void) pQos; |
| |
| // TBD: modify tspec as needed |
| // EDCA: need to fill in the medium time and the minimum phy rate |
| // to be consistent with the desired traffic parameters. |
| |
| limLog(pMac, ADMIT_CONTROL_LOGLEVEL, FL("tsid %d, directn %d, start %d, intvl %d, accPolicy %d, up %d"), |
| pAddts->tspec.tsinfo.traffic.tsid, pAddts->tspec.tsinfo.traffic.direction, |
| pAddts->tspec.svcStartTime, pAddts->tspec.minSvcInterval, |
| pAddts->tspec.tsinfo.traffic.accessPolicy, pAddts->tspec.tsinfo.traffic.userPrio); |
| |
| // check for duplicate tspec |
| retval = (alloc) |
| ? limTspecFindByAssocId(pMac, assocId, &pAddts->tspec, &pMac->lim.tspecInfo[0], &pTspecInfo) |
| : limTspecFindByStaAddr(pMac, pAddr, &pAddts->tspec, &pMac->lim.tspecInfo[0], &pTspecInfo); |
| |
| if (retval == eSIR_SUCCESS) |
| { |
| limLog(pMac, ADMIT_CONTROL_LOGLEVEL, FL("duplicate tspec (index %d)!"), pTspecInfo->idx); |
| return eSIR_FAILURE; |
| } |
| |
| // check that the tspec's are well formed and acceptable |
| if (limValidateTspec(pMac, &pAddts->tspec, psessionEntry) != eSIR_SUCCESS) |
| { |
| PELOGW(limLog(pMac, LOGW, FL("tspec validation failed"));) |
| return eSIR_FAILURE; |
| } |
| |
| // determine a service interval for the tspec |
| if (limCalculateSvcInt(pMac, &pAddts->tspec, &svcInterval) != eSIR_SUCCESS) |
| { |
| PELOGW(limLog(pMac, LOGW, FL("SvcInt calculate failed"));) |
| return eSIR_FAILURE; |
| } |
| |
| // determine if the tspec can be admitted or not based on current policy |
| if (limAdmitPolicy(pMac, &pAddts->tspec, psessionEntry) != eSIR_SUCCESS) |
| { |
| PELOGW(limLog(pMac, LOGW, FL("tspec rejected by admit control policy"));) |
| return eSIR_FAILURE; |
| } |
| |
| // fill in a schedule if requested |
| if (pSch != NULL) |
| { |
| vos_mem_set((tANI_U8 *) pSch, sizeof(*pSch), 0); |
| pSch->svcStartTime = pAddts->tspec.svcStartTime; |
| pSch->svcInterval = svcInterval; |
| pSch->maxSvcDuration = (tANI_U16) pSch->svcInterval; // use SP = SI |
| pSch->specInterval = 0x1000; // fixed for now: TBD |
| |
| pSch->info.direction = pAddts->tspec.tsinfo.traffic.direction; |
| pSch->info.tsid = pAddts->tspec.tsinfo.traffic.tsid; |
| pSch->info.aggregation = 0; // no support for aggregation for now: TBD |
| } |
| |
| // if no allocation is requested, done |
| if (! alloc) |
| return eSIR_SUCCESS; |
| |
| // check that we are in the proper mode to deal with the tspec type |
| if (limValidateAccessPolicy(pMac, (tANI_U8) pAddts->tspec.tsinfo.traffic.accessPolicy, assocId, psessionEntry) != eSIR_SUCCESS) |
| { |
| limLog(pMac, LOGW, FL("AccessPolicy %d is not valid in current mode"), |
| pAddts->tspec.tsinfo.traffic.accessPolicy); |
| return eSIR_FAILURE; |
| } |
| |
| // add tspec to list |
| if (limTspecAdd(pMac, pAddr, assocId, &pAddts->tspec, svcInterval, &pTspecInfo) |
| != eSIR_SUCCESS) |
| { |
| PELOGE(limLog(pMac, LOGE, FL("no space in tspec list"));) |
| return eSIR_FAILURE; |
| } |
| |
| //passing lim tspec table index to the caller |
| *pTspecIdx = pTspecInfo->idx; |
| |
| return eSIR_SUCCESS; |
| } |
| |
| /** ------------------------------------------------------------- |
| \fn limAdmitControlDeleteTS |
| \brief Delete the specified Tspec for the specified STA |
| \param tpAniSirGlobal pMac |
| \param tANI_U16 assocId |
| \param tSirMacTSInfo *pTsInfo |
| \param tANI_U8 *pTsStatus |
| \param tANI_U8 *ptspecIdx |
| \return eSirRetStatus - status |
| -------------------------------------------------------------*/ |
| |
| tSirRetStatus |
| limAdmitControlDeleteTS( |
| tpAniSirGlobal pMac, |
| tANI_U16 assocId, |
| tSirMacTSInfo *pTsInfo, |
| tANI_U8 *pTsStatus, |
| tANI_U8 *ptspecIdx) |
| { |
| tpLimTspecInfo pTspecInfo = NULL; |
| |
| if (pTsStatus != NULL) |
| *pTsStatus = 0; |
| |
| if (limFindTspec(pMac, assocId, pTsInfo, &pMac->lim.tspecInfo[0], &pTspecInfo) == eSIR_SUCCESS) |
| { |
| if(pTspecInfo != NULL) |
| { |
| limLog(pMac, ADMIT_CONTROL_LOGLEVEL, FL("Tspec entry %d found"), pTspecInfo->idx); |
| |
| *ptspecIdx = pTspecInfo->idx; |
| limTspecDelete(pMac, pTspecInfo); |
| return eSIR_SUCCESS; |
| } |
| } |
| return eSIR_FAILURE; |
| } |
| |
| /** ------------------------------------------------------------- |
| \fn limAdmitControlDeleteSta |
| \brief Delete all TSPEC for the specified STA |
| \param tpAniSirGlobal pMac |
| \param tANI_U16 assocId |
| \return eSirRetStatus - status |
| -------------------------------------------------------------*/ |
| |
| tSirRetStatus |
| limAdmitControlDeleteSta( |
| tpAniSirGlobal pMac, |
| tANI_U16 assocId) |
| { |
| tpLimTspecInfo pTspecInfo = &pMac->lim.tspecInfo[0]; |
| int ctspec; |
| |
| for (ctspec = 0; ctspec < LIM_NUM_TSPEC_MAX; ctspec++, pTspecInfo++) |
| { |
| if (assocId == pTspecInfo->assocId) |
| { |
| limTspecDelete(pMac, pTspecInfo); |
| limLog(pMac, ADMIT_CONTROL_LOGLEVEL, FL("Deleting TSPEC %d for assocId %d"), |
| ctspec, assocId); |
| } |
| } |
| limLog(pMac, ADMIT_CONTROL_LOGLEVEL, FL("assocId %d done"), assocId); |
| |
| return eSIR_SUCCESS; |
| } |
| |
| /** ------------------------------------------------------------- |
| \fn limAdmitControlInit |
| \brief init tspec table |
| \param tpAniSirGlobal pMac |
| \return eSirRetStatus - status |
| -------------------------------------------------------------*/ |
| tSirRetStatus limAdmitControlInit(tpAniSirGlobal pMac) |
| { |
| vos_mem_set(pMac->lim.tspecInfo, LIM_NUM_TSPEC_MAX * sizeof(tLimTspecInfo), 0); |
| return eSIR_SUCCESS; |
| } |
| |
| /** ------------------------------------------------------------- |
| \fn limUpdateAdmitPolicy |
| \brief Set the admit control policy based on CFG parameters |
| \param tpAniSirGlobal pMac |
| \return eSirRetStatus - status |
| -------------------------------------------------------------*/ |
| |
| tSirRetStatus limUpdateAdmitPolicy(tpAniSirGlobal pMac) |
| { |
| tANI_U32 val; |
| if (wlan_cfgGetInt(pMac, WNI_CFG_ADMIT_POLICY, &val) != eSIR_SUCCESS) |
| { |
| limLog(pMac, LOGP, FL("Unable to get CFG_ADMIT_POLICY")); |
| return eSIR_FAILURE; |
| } |
| pMac->lim.admitPolicyInfo.type = (tANI_U8) val; |
| if (wlan_cfgGetInt(pMac, WNI_CFG_ADMIT_BWFACTOR, &val) != eSIR_SUCCESS) |
| { |
| limLog(pMac, LOGP, FL("Unable to get CFG_ADMIT_BWFACTOR")); |
| return eSIR_FAILURE; |
| } |
| pMac->lim.admitPolicyInfo.bw_factor = (tANI_U8) val; |
| |
| PELOG1(limLog(pMac, LOG1, FL("LIM: AdmitPolicy %d, bw_factor %d"), |
| pMac->lim.admitPolicyInfo.type, pMac->lim.admitPolicyInfo.bw_factor);) |
| |
| return eSIR_SUCCESS; |
| } |
| |
| |
| /** ------------------------------------------------------------- |
| \fn limSendHalMsgAddTs |
| \brief Send halMsg_AddTs to HAL |
| \param tpAniSirGlobal pMac |
| \param tANI_U16 staIdx |
| \param tANI_U8 tspecIdx |
| \param tSirMacTspecIE tspecIE |
| \param tSirTclasInfo *tclasInfo |
| \param tANI_U8 tclasProc |
| \return eSirRetStatus - status |
| -------------------------------------------------------------*/ |
| |
| tSirRetStatus |
| limSendHalMsgAddTs( |
| tpAniSirGlobal pMac, |
| tANI_U16 staIdx, |
| tANI_U8 tspecIdx, |
| tSirMacTspecIE tspecIE, |
| tANI_U8 sessionId) |
| { |
| tSirMsgQ msg; |
| tpAddTsParams pAddTsParam; |
| |
| pAddTsParam = vos_mem_malloc(sizeof(tAddTsParams)); |
| if (NULL == pAddTsParam) |
| { |
| PELOGW(limLog(pMac, LOGW, FL("AllocateMemory() failed"));) |
| return eSIR_MEM_ALLOC_FAILED; |
| } |
| |
| vos_mem_set((tANI_U8 *)pAddTsParam, sizeof(tAddTsParams), 0); |
| pAddTsParam->staIdx = staIdx; |
| pAddTsParam->tspecIdx = tspecIdx; |
| vos_mem_copy(&pAddTsParam->tspec, &tspecIE, sizeof(tSirMacTspecIE)); |
| pAddTsParam->sessionId = sessionId; |
| |
| msg.type = WDA_ADD_TS_REQ; |
| msg.bodyptr = pAddTsParam; |
| msg.bodyval = 0; |
| |
| /* We need to defer any incoming messages until we get a |
| * WDA_ADD_TS_RSP from HAL. |
| */ |
| SET_LIM_PROCESS_DEFD_MESGS(pMac, false); |
| MTRACE(macTraceMsgTx(pMac, sessionId, msg.type)); |
| |
| if(eSIR_SUCCESS != wdaPostCtrlMsg(pMac, &msg)) |
| { |
| PELOGW(limLog(pMac, LOGW, FL("wdaPostCtrlMsg() failed"));) |
| SET_LIM_PROCESS_DEFD_MESGS(pMac, true); |
| vos_mem_free(pAddTsParam); |
| return eSIR_FAILURE; |
| } |
| return eSIR_SUCCESS; |
| } |
| |
| /** ------------------------------------------------------------- |
| \fn limSendHalMsgDelTs |
| \brief Send halMsg_AddTs to HAL |
| \param tpAniSirGlobal pMac |
| \param tANI_U16 staIdx |
| \param tANI_U8 tspecIdx |
| \param tSirAddtsReqInfo addts |
| \return eSirRetStatus - status |
| -------------------------------------------------------------*/ |
| |
| tSirRetStatus |
| limSendHalMsgDelTs( |
| tpAniSirGlobal pMac, |
| tANI_U16 staIdx, |
| tANI_U8 tspecIdx, |
| tSirDeltsReqInfo delts, |
| tANI_U8 sessionId, |
| tANI_U8 *bssId) |
| { |
| tSirMsgQ msg; |
| tpDelTsParams pDelTsParam; |
| |
| pDelTsParam = vos_mem_malloc(sizeof(tDelTsParams)); |
| if (NULL == pDelTsParam) |
| { |
| limLog(pMac, LOGP, FL("AllocateMemory() failed")); |
| return eSIR_MEM_ALLOC_FAILED; |
| } |
| |
| msg.type = WDA_DEL_TS_REQ; |
| msg.bodyptr = pDelTsParam; |
| msg.bodyval = 0; |
| vos_mem_set((tANI_U8 *)pDelTsParam, sizeof(tDelTsParams), 0); |
| |
| //filling message parameters. |
| pDelTsParam->staIdx = staIdx; |
| pDelTsParam->tspecIdx = tspecIdx; |
| vos_mem_copy(&pDelTsParam->bssId, bssId, sizeof(tSirMacAddr)); |
| |
| PELOGW(limLog(pMac, LOGW, FL("calling wdaPostCtrlMsg()"));) |
| MTRACE(macTraceMsgTx(pMac, sessionId, msg.type)); |
| |
| if(eSIR_SUCCESS != wdaPostCtrlMsg(pMac, &msg)) |
| { |
| PELOGW(limLog(pMac, LOGW, FL("wdaPostCtrlMsg() failed"));) |
| vos_mem_free(pDelTsParam); |
| return eSIR_FAILURE; |
| } |
| return eSIR_SUCCESS; |
| } |
| |
| /** ------------------------------------------------------------- |
| \fn limProcessHalAddTsRsp |
| \brief This function process the WDA_ADD_TS_RSP from HAL. |
| \ If response is successful, then send back SME_ADDTS_RSP. |
| \ Otherwise, send DELTS action frame to peer and then |
| \ then send back SME_ADDTS_RSP. |
| \ |
| \param tpAniSirGlobal pMac |
| \param tpSirMsgQ limMsg |
| -------------------------------------------------------------*/ |
| void limProcessHalAddTsRsp(tpAniSirGlobal pMac, tpSirMsgQ limMsg) |
| { |
| tpAddTsParams pAddTsRspMsg = NULL; |
| tpDphHashNode pSta = NULL; |
| tANI_U16 assocId =0; |
| tSirMacAddr peerMacAddr; |
| tANI_U8 rspReqd = 1; |
| tpPESession psessionEntry = NULL; |
| |
| |
| /* Need to process all the deferred messages enqueued |
| * since sending the WDA_ADD_TS_REQ. |
| */ |
| SET_LIM_PROCESS_DEFD_MESGS(pMac, true); |
| |
| if (NULL == limMsg->bodyptr) |
| { |
| limLog(pMac, LOGP, FL("Received WDA_ADD_TS_RSP with NULL ")); |
| goto end; |
| } |
| |
| pAddTsRspMsg = (tpAddTsParams) (limMsg->bodyptr); |
| |
| // 090803: Use peFindSessionBySessionId() to obtain the PE session context |
| // from the sessionId in the Rsp Msg from HAL |
| psessionEntry = peFindSessionBySessionId(pMac, pAddTsRspMsg->sessionId); |
| |
| if(psessionEntry == NULL) |
| { |
| PELOGE(limLog(pMac, LOGE,FL("Session does Not exist with given sessionId :%d "), pAddTsRspMsg->sessionId);) |
| limSendSmeAddtsRsp(pMac, rspReqd, eSIR_SME_ADDTS_RSP_FAILED, psessionEntry, pAddTsRspMsg->tspec, |
| pMac->lim.gLimAddtsReq.sessionId, pMac->lim.gLimAddtsReq.transactionId); |
| goto end; |
| } |
| |
| if(pAddTsRspMsg->status == eHAL_STATUS_SUCCESS) |
| { |
| limLog(pMac, LOG1, FL("Received successful ADDTS response from HAL ")); |
| // Use the smesessionId and smetransactionId from the PE session context |
| limSendSmeAddtsRsp(pMac, rspReqd, eSIR_SME_SUCCESS, psessionEntry, pAddTsRspMsg->tspec, |
| psessionEntry->smeSessionId, psessionEntry->transactionId); |
| goto end; |
| } |
| else |
| { |
| limLog(pMac, LOG1, FL("Received failure ADDTS response from HAL ")); |
| |
| // Send DELTS action frame to AP |
| // 090803: Get peer MAC addr from session |
| #if 0 |
| cfgLen = sizeof(tSirMacAddr); |
| if (wlan_cfgGetStr(pMac, WNI_CFG_BSSID, peerMacAddr, &cfgLen) != eSIR_SUCCESS) |
| { |
| limLog(pMac, LOGP, FL("Fail to retrieve BSSID ")); |
| goto end; |
| } |
| #endif //TO SUPPORT BT-AMP |
| sirCopyMacAddr(peerMacAddr,psessionEntry->bssId); |
| |
| // 090803: Add the SME Session ID |
| limSendDeltsReqActionFrame(pMac, peerMacAddr, rspReqd, &pAddTsRspMsg->tspec.tsinfo, &pAddTsRspMsg->tspec, |
| //psessionEntry->smeSessionId); |
| psessionEntry); |
| |
| // Delete TSPEC |
| // 090803: Pull the hash table from the session |
| pSta = dphLookupAssocId(pMac, pAddTsRspMsg->staIdx, &assocId, |
| &psessionEntry->dph.dphHashTable); |
| if (pSta != NULL) |
| limAdmitControlDeleteTS(pMac, assocId, &pAddTsRspMsg->tspec.tsinfo, NULL, (tANI_U8 *)&pAddTsRspMsg->tspecIdx); |
| |
| // Send SME_ADDTS_RSP |
| // 090803: Use the smesessionId and smetransactionId from the PE session context |
| limSendSmeAddtsRsp(pMac, rspReqd, eSIR_SME_ADDTS_RSP_FAILED, psessionEntry, pAddTsRspMsg->tspec, |
| psessionEntry->smeSessionId, psessionEntry->transactionId); |
| goto end; |
| } |
| |
| end: |
| if( pAddTsRspMsg != NULL ) |
| vos_mem_free(pAddTsRspMsg); |
| return; |
| } |
| |