qcacld: SME: Support Software Authentication Offload

For SAP Auth Offload, Sta assoc/disassoc state will be finish by
target FW. So we need the wmi events (Sta connect/disconnect) to
get station Info and keep station peer information maintain well
(add peer/remove peer) on host side. Station assoc req frame will
append on WMI_SAP_OFL_ADD_STA_EVENTID event, and this modification
will parse the frame and create station node and peer for host driver.

Change-Id: I8ab0cc906be97be6f1f61de3e2ac9359cb7d17b0
CRs-Fixed: 753731

9 files changed, 703 insertions, 0 deletions

diff --git a/CORE/MAC/src/cfg/cfgApi.c b/CORE/MAC/src/cfg/cfgApi.c
index 343fd6e41540..5008619b78c1 100644
--- a/CORE/MAC/src/cfg/cfgApi.c
+++ b/CORE/MAC/src/cfg/cfgApi.c
@@ -856,6 +856,15 @@ cfgGetCapabilityInfo(tpAniSirGlobal pMac, tANI_U16 *pCap,tpPESession sessionEntr
 
     if (LIM_IS_AP_ROLE(sessionEntry)) {
         val = sessionEntry->privacy;
+#ifdef SAP_AUTH_OFFLOAD
+         /* Support software AP Authentication Offload feature,
+          * If Auth offload security Type is not disabled
+          * We need to enable privacy bit in beacon
+          */
+        if (pMac->sap_auth_offload && pMac->sap_auth_offload_sec_type) {
+            val = 1;
+        }
+#endif
     } else {
         // PRIVACY bit
         if (wlan_cfgGetInt(pMac, WNI_CFG_PRIVACY_ENABLED, &val) != eSIR_SUCCESS)
diff --git a/CORE/MAC/src/include/parserApi.h b/CORE/MAC/src/include/parserApi.h
index 0e1a88d6c169..8876dd50d249 100644
--- a/CORE/MAC/src/include/parserApi.h
+++ b/CORE/MAC/src/include/parserApi.h
@@ -858,3 +858,10 @@ PopulateDot11fWiderBWChanSwitchAnn(tpAniSirGlobal pMac,
 void PopulateDot11fTimeoutInterval( tpAniSirGlobal pMac,
                                     tDot11fIETimeoutInterval *pDot11f,
                                     tANI_U8 type, tANI_U32 value );
+
+#ifdef SAP_AUTH_OFFLOAD
+void
+sap_auth_offload_update_rsn_ie(tpAniSirGlobal pmac,
+                            tDot11fIERSNOpaque *pdot11f);
+#endif /* SAP_AUTH_OFFLOAD */
+
diff --git a/CORE/MAC/src/pe/lim/limProcessMessageQueue.c b/CORE/MAC/src/pe/lim/limProcessMessageQueue.c
index 6bfe87f73110..e0abca44ee8c 100644
--- a/CORE/MAC/src/pe/lim/limProcessMessageQueue.c
+++ b/CORE/MAC/src/pe/lim/limProcessMessageQueue.c
@@ -2021,6 +2021,15 @@ limProcessMessages(tpAniSirGlobal pMac, tpSirMsgQ  limMsg)
         limMsg->bodyptr = NULL;
         break;
 #endif
+
+#ifdef SAP_AUTH_OFFLOAD
+    case WDA_SAP_OFL_ADD_STA:
+        lim_sap_offload_add_sta(pMac, limMsg);
+        break;
+    case WDA_SAP_OFL_DEL_STA:
+        lim_sap_offload_del_sta(pMac, limMsg);
+        break;
+#endif /* SAP_AUTH_OFFLOAD */
     default:
         vos_mem_free((v_VOID_t*)limMsg->bodyptr);
         limMsg->bodyptr = NULL;
diff --git a/CORE/MAC/src/pe/lim/limProcessSmeReqMessages.c b/CORE/MAC/src/pe/lim/limProcessSmeReqMessages.c
index 1e506cb139c8..96d8029ead4c 100644
--- a/CORE/MAC/src/pe/lim/limProcessSmeReqMessages.c
+++ b/CORE/MAC/src/pe/lim/limProcessSmeReqMessages.c
@@ -4016,8 +4016,85 @@ end:
 
 } /*** end __limProcessSmeAssocCnfNew() ***/
 
+#ifdef SAP_AUTH_OFFLOAD
+/**
+ * __lim_process_sme_assoc_offload_cnf() station connect confirm
+ * @pMac: SirGlobal handler
+ * @msgType: message type
+ * @pMsgBuf: message body
+ *
+ * This function handles the station connect confirm of
+ * Software AP authentication offload feature
+ *
+ * Return: None
+ */
+static void
+__lim_process_sme_assoc_offload_cnf(tpAniSirGlobal pmac,
+                               tANI_U32 msg_type,
+                               tANI_U32 *pmsg_buf)
+{
+    tSirSmeAssocCnf assoc_cnf;
+    tpDphHashNode sta_ds = NULL;
+    tpPESession psession_entry= NULL;
+    tANI_U8 session_id;
+    tANI_U16 aid=0;
+
+    if(pmsg_buf == NULL) {
+        limLog(pmac, LOGE, FL("pmsg_buf is NULL "));
+        goto end;
+    }
+
+    if ((limAssocCnfSerDes(pmac, &assoc_cnf, (tANI_U8 *) pmsg_buf) ==
+        eSIR_FAILURE) || !__limIsSmeAssocCnfValid(&assoc_cnf)) {
+        limLog(pmac, LOGE, FL("Received invalid SME_RE(ASSOC)_CNF message "));
+        goto end;
+    }
+
+    if((psession_entry =
+        peFindSessionByBssid(pmac, assoc_cnf.bssId, &session_id))== NULL) {
+        limLog(pmac, LOGE, FL("session does not exist for given bssId"));
+        goto end;
+    }
 
+    if ((!LIM_IS_AP_ROLE(psession_entry) &&
+         !LIM_IS_BT_AMP_AP_ROLE(psession_entry)) ||
+        ((psession_entry->limSmeState != eLIM_SME_NORMAL_STATE) &&
+        (psession_entry->limSmeState != eLIM_SME_NORMAL_CHANNEL_SCAN_STATE))) {
+        limLog(pmac, LOGE,
+               FL("Received unexpected message %X in state %X, in role %X"),
+               msg_type, psession_entry->limSmeState,
+               GET_LIM_SYSTEM_ROLE(psession_entry));
+        goto end;
+    }
+
+    sta_ds = dphGetHashEntry(pmac,
+                             assoc_cnf.aid,
+                             &psession_entry->dph.dphHashTable);
+    if (sta_ds != NULL) {
+        aid = sta_ds->assocId;
+        limDeactivateAndChangePerStaIdTimer(pmac,
+                                            eLIM_CNF_WAIT_TIMER,
+                                            aid);
+    }
+
+end:
+    if((psession_entry != NULL) && (sta_ds != NULL)) {
+        if ( psession_entry->parsedAssocReq[aid] != NULL ) {
+            if ( ((tpSirAssocReq)
+                (psession_entry->parsedAssocReq[aid]))->assocReqFrame) {
+                vos_mem_free(((tpSirAssocReq)
+                    (psession_entry->parsedAssocReq[aid]))->assocReqFrame);
+                ((tpSirAssocReq)
+                    (psession_entry->parsedAssocReq[aid]))->assocReqFrame =
+                    NULL;
+            }
+            vos_mem_free(psession_entry->parsedAssocReq[aid]);
+            psession_entry->parsedAssocReq[aid] = NULL;
+        }
+    }
 
+} /*** end __lim_process_sme_assoc_offload_cnf() ***/
+#endif /* SAP_AUTH_OFFLOAD */
 
 static void
 __limProcessSmeAddtsReq(tpAniSirGlobal pMac, tANI_U32 *pMsgBuf)
@@ -5658,7 +5735,16 @@ limProcessSmeReqMessages(tpAniSirGlobal pMac, tpSirMsgQ pMsg)
                 PELOG1(limLog(pMac, LOG1, FL("Received ASSOC_CNF message"));)
             else
                 PELOG1(limLog(pMac, LOG1, FL("Received REASSOC_CNF message"));)
+
+#ifdef SAP_AUTH_OFFLOAD
+            if (pMac->sap_auth_offload) {
+                __lim_process_sme_assoc_offload_cnf(pMac, pMsg->type, pMsgBuf);
+            } else {
+                __limProcessSmeAssocCnfNew(pMac, pMsg->type, pMsgBuf);
+            }
+#else
             __limProcessSmeAssocCnfNew(pMac, pMsg->type, pMsgBuf);
+#endif /* SAP_AUTH_OFFLOAD */
             break;
 
         case eWNI_SME_ADDTS_REQ:
diff --git a/CORE/MAC/src/pe/lim/limUtils.c b/CORE/MAC/src/pe/lim/limUtils.c
index 3825ce5482f0..9eaff2c2fa94 100644
--- a/CORE/MAC/src/pe/lim/limUtils.c
+++ b/CORE/MAC/src/pe/lim/limUtils.c
@@ -64,6 +64,10 @@
 #include "wniCfgAp.h"
 #endif
 
+#ifdef SAP_AUTH_OFFLOAD
+#include "limAssocUtils.h"
+#endif
+
 /* Static global used to mark situations where pMac->lim.gLimTriggerBackgroundScanDuringQuietBss is SET
  * and limTriggerBackgroundScanDuringQuietBss() returned failure.  In this case, we will stop data
  * traffic instead of going into scan.  The recover function limProcessQuietBssTimeout() needs to have
@@ -7520,3 +7524,430 @@ void lim_set_ht_caps(tpAniSirGlobal p_mac, tpPESession p_session_entry,
         p_ht_cap->txSoundingPPDUs = dot11_ht_cap.txSoundingPPDUs;
     }
 }
+
+#ifdef SAP_AUTH_OFFLOAD
+static tpDphHashNode
+_sap_offload_parse_assoc_req(tpAniSirGlobal pmac,
+                    tpSirAssocReq assoc_req,
+                    struct sap_offload_add_sta_req *add_sta_req)
+{
+    tpSirMacAssocReqFrame mac_assoc_req = NULL;
+    tpSirAssocReq temp_assoc_req;
+    tSirRetStatus status;
+    tpSirMacMgmtHdr mac_hdr = NULL;
+    tpDphHashNode sta_ds = NULL;
+    uint8_t *frame_body;
+
+    tpPESession session_entry = limIsApSessionActive(pmac);
+    mac_hdr = (tpSirMacMgmtHdr)add_sta_req->conn_req;
+
+    /* Update Attribute and Remove IE for
+     * Software AP Authentication Offload
+     */
+    frame_body = (tANI_U8 *)add_sta_req->conn_req + sizeof(*mac_hdr);
+    mac_assoc_req = (tpSirMacAssocReqFrame)frame_body;
+    mac_assoc_req->capabilityInfo.privacy = 0;
+
+    status = sirConvertAssocReqFrame2Struct(pmac,
+                                            frame_body,
+                                            add_sta_req->conn_req_len,
+                                            assoc_req);
+    if (status != eSIR_SUCCESS) {
+        limLog(pmac, LOGW, FL("sap_offload_add_sta_req parse error\n"));
+        goto error;
+    }
+    /* For software AP Auth Offload feature
+     * Host will take it as none security station
+     * Force change to none security
+     */
+    assoc_req->rsnPresent = 0;
+    assoc_req->wpaPresent = 0;
+
+    sta_ds = dphAddHashEntry(pmac,
+                             mac_hdr->sa,
+                             add_sta_req->assoc_id,
+                             &session_entry->dph.dphHashTable);
+    if (sta_ds == NULL) {
+        /* Could not add hash table entry at DPH */
+        limLog(pmac, LOGE,
+           FL("could not add hash entry at DPH for aid=%d, MacAddr:"
+               MAC_ADDRESS_STR),
+           add_sta_req->assoc_id,MAC_ADDR_ARRAY(mac_hdr->sa));
+        goto error;
+    }
+
+    if (session_entry->parsedAssocReq != NULL) {
+        temp_assoc_req = session_entry->parsedAssocReq[sta_ds->assocId];
+        if (temp_assoc_req != NULL) {
+            if (temp_assoc_req->assocReqFrame) {
+                vos_mem_free(temp_assoc_req->assocReqFrame);
+                temp_assoc_req->assocReqFrame = NULL;
+                temp_assoc_req->assocReqFrameLength = 0;
+            }
+            vos_mem_free(temp_assoc_req);
+            temp_assoc_req = NULL;
+        }
+        session_entry->parsedAssocReq[sta_ds->assocId] = assoc_req;
+    }
+error:
+    return sta_ds;
+}
+
+static void
+_sap_offload_parse_sta_capability(tpDphHashNode sta_ds,
+                        tpSirAssocReq assoc_req,
+                        struct sap_offload_add_sta_req *add_sta_req)
+{
+    tpSirMacMgmtHdr mac_hdr = NULL;
+
+    mac_hdr = (tpSirMacMgmtHdr)add_sta_req->conn_req;
+
+    sta_ds->mlmStaContext.htCapability = assoc_req->HTCaps.present;
+#ifdef WLAN_FEATURE_11AC
+    sta_ds->mlmStaContext.vhtCapability = assoc_req->VHTCaps.present;
+#endif
+    sta_ds->qos.addtsPresent = (assoc_req->addtsPresent==0) ? false : true;
+    sta_ds->qos.addts        = assoc_req->addtsReq;
+    sta_ds->qos.capability   = assoc_req->qosCapability;
+    sta_ds->versionPresent   = 0;
+    /* short slot and short preamble should be
+     * updated before doing limaddsta
+     */
+    sta_ds->shortPreambleEnabled =
+        (tANI_U8)assoc_req->capabilityInfo.shortPreamble;
+    sta_ds->shortSlotTimeEnabled =
+        (tANI_U8)assoc_req->capabilityInfo.shortSlotTime;
+
+    sta_ds->valid = 0;
+    /* The Auth Type of Software AP Authentication Offload
+     * is always Open System is host side
+     */
+    sta_ds->mlmStaContext.authType = eSIR_OPEN_SYSTEM;
+    sta_ds->staType = STA_ENTRY_PEER;
+
+    /* Re/Assoc Response frame to requesting STA */
+    sta_ds->mlmStaContext.subType = mac_hdr->fc.subType;
+
+    sta_ds->mlmStaContext.listenInterval = assoc_req->listenInterval;
+    sta_ds->mlmStaContext.capabilityInfo = assoc_req->capabilityInfo;
+
+    /* The following count will be used to knock-off the station
+     * if it doesn't come back to receive the buffered data.
+     * The AP will wait for numTimSent number of beacons after
+     * sending TIM information for the station, before assuming that
+     * the station is no more associated and disassociates it
+     */
+
+    /* timWaitCount is used by PMM for monitoring the STA's in PS for LINK*/
+    sta_ds->timWaitCount =
+        (tANI_U8)GET_TIM_WAIT_COUNT(assoc_req->listenInterval);
+
+    /* Initialise the Current successful
+     * MPDU's tranfered to this STA count as 0
+     */
+    sta_ds->curTxMpduCnt = 0;
+}
+
+static tSirRetStatus
+_sap_offload_parse_sta_vht(tpAniSirGlobal pmac,
+                        tpDphHashNode sta_ds,
+                        tpSirAssocReq assoc_req)
+{
+    tpPESession session_entry = limIsApSessionActive(pmac);
+
+    if (IS_DOT11_MODE_HT(session_entry->dot11mode) &&
+        assoc_req->HTCaps.present && assoc_req->wmeInfoPresent) {
+        sta_ds->htGreenfield = (tANI_U8)assoc_req->HTCaps.greenField;
+        sta_ds->htAMpduDensity = assoc_req->HTCaps.mpduDensity;
+        sta_ds->htDsssCckRate40MHzSupport =
+            (tANI_U8)assoc_req->HTCaps.dsssCckMode40MHz;
+        sta_ds->htLsigTXOPProtection =
+            (tANI_U8)assoc_req->HTCaps.lsigTXOPProtection;
+        sta_ds->htMaxAmsduLength =
+            (tANI_U8)assoc_req->HTCaps.maximalAMSDUsize;
+        sta_ds->htMaxRxAMpduFactor = assoc_req->HTCaps.maxRxAMPDUFactor;
+        sta_ds->htMIMOPSState = assoc_req->HTCaps.mimoPowerSave;
+        sta_ds->htShortGI20Mhz = (tANI_U8)assoc_req->HTCaps.shortGI20MHz;
+        sta_ds->htShortGI40Mhz = (tANI_U8)assoc_req->HTCaps.shortGI40MHz;
+        sta_ds->htSupportedChannelWidthSet =
+            (tANI_U8)assoc_req->HTCaps.supportedChannelWidthSet;
+        /* peer just follows AP; so when we are softAP/GO,
+         * we just store our session entry's secondary channel offset here
+         * in peer INFRA STA. However, if peer's 40MHz channel width support
+         * is disabled then secondary channel will be zero
+         */
+        sta_ds->htSecondaryChannelOffset =
+            (sta_ds->htSupportedChannelWidthSet) ?
+            session_entry->htSecondaryChannelOffset : 0;
+#ifdef WLAN_FEATURE_11AC
+        if (assoc_req->operMode.present) {
+            sta_ds->vhtSupportedChannelWidthSet =
+                (tANI_U8)((assoc_req->operMode.chanWidth ==
+                eHT_CHANNEL_WIDTH_80MHZ) ?
+                    WNI_CFG_VHT_CHANNEL_WIDTH_80MHZ :
+                    WNI_CFG_VHT_CHANNEL_WIDTH_20_40MHZ);
+            sta_ds->htSupportedChannelWidthSet =
+                (tANI_U8)(assoc_req->operMode.chanWidth ?
+                    eHT_CHANNEL_WIDTH_40MHZ : eHT_CHANNEL_WIDTH_20MHZ);
+        } else if (assoc_req->VHTCaps.present) {
+            /* Check if STA has enabled it's channel bonding mode.
+             * If channel bonding mode is enabled, we decide based on
+             * SAP's current configuration else, we set it to VHT20.
+             */
+            sta_ds->vhtSupportedChannelWidthSet =
+                (tANI_U8)((sta_ds->htSupportedChannelWidthSet ==
+                eHT_CHANNEL_WIDTH_20MHZ) ?
+                WNI_CFG_VHT_CHANNEL_WIDTH_20_40MHZ :
+                session_entry->vhtTxChannelWidthSet );
+            sta_ds->htMaxRxAMpduFactor = assoc_req->VHTCaps.maxAMPDULenExp;
+        }
+
+        /* Lesser among the AP and STA bandwidth of operation. */
+        sta_ds->htSupportedChannelWidthSet =
+            (sta_ds->htSupportedChannelWidthSet <
+            session_entry->htSupportedChannelWidthSet) ?
+            sta_ds->htSupportedChannelWidthSet :
+            session_entry->htSupportedChannelWidthSet ;
+#endif
+        sta_ds->baPolicyFlag = 0xFF;
+        sta_ds->htLdpcCapable = (tANI_U8)assoc_req->HTCaps.advCodingCap;
+    }
+
+    if (assoc_req->VHTCaps.present && assoc_req->wmeInfoPresent) {
+        sta_ds->vhtLdpcCapable = (tANI_U8)assoc_req->VHTCaps.ldpcCodingCap;
+    }
+
+    if (!assoc_req->wmeInfoPresent) {
+        sta_ds->mlmStaContext.htCapability = 0;
+#ifdef WLAN_FEATURE_11AC
+        sta_ds->mlmStaContext.vhtCapability = 0;
+#endif
+    }
+#ifdef WLAN_FEATURE_11AC
+    if (limPopulateMatchingRateSet(pmac,
+                                   sta_ds,
+                                   &(assoc_req->supportedRates),
+                                   &(assoc_req->extendedRates),
+                                   assoc_req->HTCaps.supportedMCSSet,
+                                   session_entry , &assoc_req->VHTCaps)
+                                   != eSIR_SUCCESS) {
+#else
+    if (limPopulateMatchingRateSet(pmac,
+                                   sta_ds,
+                                   &(assoc_req->supportedRates),
+                                   &(assoc_req->extendedRates),
+                                   assoc_req->HTCaps.supportedMCSSet,
+                                   &(assoc_req->propIEinfo.propRates),
+                                   session_entry) != eSIR_SUCCESS) {
+#endif
+        limLog(pmac, LOGE,
+           FL("Rate set mismatched for aid=%d, MacAddr: "
+           MAC_ADDRESS_STR),
+           sta_ds->assocId, MAC_ADDR_ARRAY(sta_ds->staAddr));
+        goto error;
+    }
+
+#ifdef WLAN_FEATURE_11AC
+    if (assoc_req->operMode.present) {
+        sta_ds->vhtSupportedRxNss = assoc_req->operMode.rxNSS + 1;
+    } else {
+        sta_ds->vhtSupportedRxNss =
+            ((sta_ds->supportedRates.vhtRxMCSMap & MCSMAPMASK2x2)
+            == MCSMAPMASK2x2) ? 1 : 2;
+    }
+#endif
+
+    return eSIR_SUCCESS;
+error:
+    return eSIR_FAILURE;
+}
+
+static void
+_sap_offload_parse_sta_qos(tpAniSirGlobal pmac,
+                        tpDphHashNode sta_ds,
+                        tpSirAssocReq assoc_req)
+{
+    tHalBitVal qos_mode;
+    tHalBitVal wsm_mode, wme_mode;
+    tpPESession session_entry = limIsApSessionActive(pmac);
+
+    limGetQosMode(session_entry, &qos_mode);
+    sta_ds->qosMode    = eANI_BOOLEAN_FALSE;
+    sta_ds->lleEnabled = eANI_BOOLEAN_FALSE;
+
+    if (assoc_req->capabilityInfo.qos && (qos_mode == eHAL_SET)) {
+        sta_ds->lleEnabled = eANI_BOOLEAN_TRUE;
+        sta_ds->qosMode    = eANI_BOOLEAN_TRUE;
+    }
+
+    sta_ds->wmeEnabled = eANI_BOOLEAN_FALSE;
+    sta_ds->wsmEnabled = eANI_BOOLEAN_FALSE;
+    limGetWmeMode(session_entry, &wme_mode);
+    if ((!sta_ds->lleEnabled) && assoc_req->wmeInfoPresent &&
+        (wme_mode == eHAL_SET)) {
+        sta_ds->wmeEnabled = eANI_BOOLEAN_TRUE;
+        sta_ds->qosMode = eANI_BOOLEAN_TRUE;
+        limGetWsmMode(session_entry, &wsm_mode);
+        /* WMM_APSD - WMM_SA related processing should be
+         * separate; WMM_SA and WMM_APSD can coexist
+         */
+        if (assoc_req->WMMInfoStation.present) {
+            /* check whether AP supports or not */
+            if ((session_entry->limSystemRole == eLIM_AP_ROLE)
+                 && (session_entry->apUapsdEnable == 0) &&
+                    (assoc_req->WMMInfoStation.acbe_uapsd
+                    || assoc_req->WMMInfoStation.acbk_uapsd
+                    || assoc_req->WMMInfoStation.acvo_uapsd
+                    || assoc_req->WMMInfoStation.acvi_uapsd)) {
+                /*
+                 * Received Re/Association Request from
+                 * STA when UPASD is not supported
+                 */
+               limLog( pmac, LOGE, FL( "AP do not support UAPSD so reply "
+                                       "to STA accordingly" ));
+               /* update UAPSD and send it to LIM to add STA */
+               sta_ds->qos.capability.qosInfo.acbe_uapsd = 0;
+               sta_ds->qos.capability.qosInfo.acbk_uapsd = 0;
+               sta_ds->qos.capability.qosInfo.acvo_uapsd = 0;
+               sta_ds->qos.capability.qosInfo.acvi_uapsd = 0;
+               sta_ds->qos.capability.qosInfo.maxSpLen =   0;
+            } else {
+                /* update UAPSD and send it to LIM to add STA */
+                sta_ds->qos.capability.qosInfo.acbe_uapsd =
+                    assoc_req->WMMInfoStation.acbe_uapsd;
+                sta_ds->qos.capability.qosInfo.acbk_uapsd =
+                    assoc_req->WMMInfoStation.acbk_uapsd;
+                sta_ds->qos.capability.qosInfo.acvo_uapsd =
+                    assoc_req->WMMInfoStation.acvo_uapsd;
+                sta_ds->qos.capability.qosInfo.acvi_uapsd =
+                    assoc_req->WMMInfoStation.acvi_uapsd;
+                sta_ds->qos.capability.qosInfo.maxSpLen =
+                    assoc_req->WMMInfoStation.max_sp_length;
+            }
+        }
+        if (assoc_req->wsmCapablePresent && (wsm_mode == eHAL_SET))
+            sta_ds->wsmEnabled = eANI_BOOLEAN_TRUE;
+    }
+}
+
+void lim_sap_offload_add_sta(tpAniSirGlobal pmac, tpSirMsgQ lim_msgq)
+{
+    tpSirAssocReq assoc_req = NULL;
+    tpDphHashNode sta_ds = NULL;
+
+    struct sap_offload_add_sta_req  *add_sta_req = NULL;
+    tpPESession session_entry = limIsApSessionActive(pmac);
+
+     if (session_entry == NULL) {
+        PELOGE(limLog(pmac, LOGE, FL(" Session not found"));)
+        return;
+    }
+    add_sta_req = (struct sap_offload_add_sta_req *)lim_msgq->bodyptr;
+    assoc_req = vos_mem_malloc(sizeof(*assoc_req));
+    if (NULL == assoc_req) {
+        limLog(pmac, LOGP, FL("Allocate Memory failed in AssocReq"));
+        return;
+    }
+    vos_mem_set(assoc_req , sizeof(*assoc_req), 0);
+
+    /* parse Assoc req frame for station information */
+    sta_ds = _sap_offload_parse_assoc_req(pmac, assoc_req, add_sta_req);
+    if (sta_ds == NULL) {
+        vos_mem_free(assoc_req);
+        goto error;
+    }
+
+    /* Parse Station Capability */
+    _sap_offload_parse_sta_capability(sta_ds, assoc_req, add_sta_req);
+
+    /* Parse Station HT/VHT information */
+    if (_sap_offload_parse_sta_vht(pmac, sta_ds, assoc_req)
+            == eSIR_FAILURE) {
+            goto error;
+    }
+
+    /* Parse Station QOS information */
+    _sap_offload_parse_sta_qos(pmac, sta_ds, assoc_req);
+
+    if (assoc_req->ExtCap.present) {
+        sta_ds->timingMeasCap = 0;
+        sta_ds->timingMeasCap |= (assoc_req->ExtCap.timingMeas)?
+                                  RTT_TIMING_MEAS_CAPABILITY :
+                                  RTT_INVALID;
+        sta_ds->timingMeasCap |= (assoc_req->ExtCap.fineTimingMeas)?
+                                  RTT_FINE_TIMING_MEAS_CAPABILITY :
+                                  RTT_INVALID;
+        PELOG1(limLog(pmac, LOG1,
+               FL("ExtCap present, timingMeas: %d fineTimingMeas: %d"),
+               assoc_req->ExtCap.timingMeas,
+               assoc_req->ExtCap.fineTimingMeas);)
+    } else {
+        sta_ds->timingMeasCap = 0;
+        PELOG1(limLog(pmac, LOG1, FL("ExtCap not present"));)
+    }
+
+    session_entry->parsedAssocReq[sta_ds->assocId] = assoc_req;
+
+    if (limAddSta(pmac, sta_ds, false, session_entry) != eSIR_SUCCESS) {
+        limLog(pmac, LOGE, FL("could not Add STA with assocId=%d"),
+                              sta_ds->assocId);
+    }
+
+error:
+    vos_mem_free(add_sta_req);
+    return;
+}
+
+void
+lim_sap_offload_del_sta(tpAniSirGlobal pmac, tpSirMsgQ lim_msgq)
+{
+    struct sap_offload_del_sta_req *del_sta_req = NULL;
+    tpDphHashNode sta_ds = NULL;
+    tANI_U16 assoc_id = 0;
+    tpPESession psession_entry = limIsApSessionActive(pmac);
+
+    if (psession_entry == NULL) {
+        PELOGE(limLog(pmac, LOGE, FL(" Session not found"));)
+        goto error;
+    }
+
+    del_sta_req = ( struct sap_offload_del_sta_req *)lim_msgq->bodyptr;
+    sta_ds = dphLookupHashEntry(pmac,
+                                del_sta_req->sta_mac,
+                                &assoc_id,
+                                &psession_entry->dph.dphHashTable);
+    if (sta_ds == NULL) {
+        /*
+         * Disassociating STA is not associated.
+         * Log error
+         */
+        PELOGE(limLog(pmac, LOGE,
+           FL("received del sta event that sta not exist in table "
+           "reasonCode=%d, addr "MAC_ADDRESS_STR),
+           del_sta_req->reason_code,
+           MAC_ADDR_ARRAY(del_sta_req->sta_mac));)
+        goto error;
+    }
+
+    if (assoc_id != (tANI_U16)del_sta_req->assoc_id) {
+        /*
+         * Associate Id mismatch
+         * Log error
+         */
+        PELOGE(limLog(pmac, LOGE,
+           FL("received del sta event that sta assoc Id mismatch"));)
+        goto error;
+    }
+
+    sta_ds->mlmStaContext.cleanupTrigger = eLIM_PEER_ENTITY_DISASSOC;
+    sta_ds->mlmStaContext.disassocReason =
+        (tSirMacReasonCodes) del_sta_req->reason_code;
+    sta_ds->mlmStaContext.updateContext = 1;
+
+    limSendSmeDisassocInd(pmac, sta_ds, psession_entry);
+
+error:
+    vos_mem_free(del_sta_req);
+    return;
+}
+#endif /* SAP_AUTH_OFFLOAD */
diff --git a/CORE/MAC/src/pe/lim/limUtils.h b/CORE/MAC/src/pe/lim/limUtils.h
index 2ee20a5acf89..696ca6e62af3 100644
--- a/CORE/MAC/src/pe/lim/limUtils.h
+++ b/CORE/MAC/src/pe/lim/limUtils.h
@@ -587,4 +587,12 @@ void lim_set_ht_caps(tpAniSirGlobal p_mac,
 			tpPESession p_session_entry,
 			tANI_U8 *p_ie_start,
 			tANI_U32 num_bytes);
+
+#ifdef SAP_AUTH_OFFLOAD
+void lim_sap_offload_add_sta(tpAniSirGlobal pmac,
+                            tpSirMsgQ lim_msgq);
+void lim_sap_offload_del_sta(tpAniSirGlobal pmac,
+                            tpSirMsgQ lim_msgq);
+#endif /* SAP_AUTH_OFFLOAD */
+
 #endif /* __LIM_UTILS_H */
diff --git a/CORE/MAC/src/pe/sch/schBeaconGen.c b/CORE/MAC/src/pe/sch/schBeaconGen.c
index e7743bcb7586..558fbca08a86 100644
--- a/CORE/MAC/src/pe/sch/schBeaconGen.c
+++ b/CORE/MAC/src/pe/sch/schBeaconGen.c
@@ -386,6 +386,13 @@ tSirRetStatus schSetFixedBeaconFields(tpAniSirGlobal pMac,tpPESession psessionEn
                        &pBcn2->WPA );
           PopulateDot11fRSNOpaque( pMac, &psessionEntry->pLimStartBssReq->rsnIE,
                        &pBcn2->RSNOpaque );
+#ifdef SAP_AUTH_OFFLOAD
+        /* Software AP Authentication Offload feature
+         * only support WPA2-PSK AES and we
+         * need to update RSNIE for beacon
+         */
+        sap_auth_offload_update_rsn_ie(pMac, &pBcn2->RSNOpaque);
+#endif
     }
 
     if(psessionEntry->limWmeEnabled)
diff --git a/CORE/SYS/legacy/src/utils/src/parserApi.c b/CORE/SYS/legacy/src/utils/src/parserApi.c
index fdb12ee57ae1..8d4f238b2b3a 100644
--- a/CORE/SYS/legacy/src/utils/src/parserApi.c
+++ b/CORE/SYS/legacy/src/utils/src/parserApi.c
@@ -50,6 +50,29 @@
 #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 }
+};
 
 
 ////////////////////////////////////////////////////////////////////////
@@ -5134,4 +5157,108 @@ void PopulateDot11fTimeoutInterval( tpAniSirGlobal pMac,
    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_count) {
+            element_len = sizeof(pdot11f_rsn->akm_suite_count);
+            vos_mem_copy(ptr, &pdot11f_rsn->akm_suite_count, element_len);
+            ptr += element_len;
+            data_len += element_len;
+            for (count = 0; count < pdot11f_rsn->akm_suite_count; count++) {
+                element_len = DOT11F_RSN_OUI_SIZE;
+                vos_mem_copy(ptr,
+                             &pdot11f_rsn->akm_suites[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));
+    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_count = 1;
+            vos_mem_copy(&(pdot11f_rsn->akm_suites[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;
+        }
+    }
+}
+#endif /* SAP_AUTH_OFFLOAD */
 // parserApi.c ends here.
diff --git a/CORE/WDA/inc/legacy/halMsgApi.h b/CORE/WDA/inc/legacy/halMsgApi.h
index 3f60751440fa..253c523b4d76 100644
--- a/CORE/WDA/inc/legacy/halMsgApi.h
+++ b/CORE/WDA/inc/legacy/halMsgApi.h
@@ -80,6 +80,10 @@
  */
 #define BSSIDX_INVALID             254
 
+#ifdef SAP_AUTH_OFFLOAD
+#define MAX_CONNECT_REQ_LENGTH 512
+#endif
+
 #define HAL_IS_VALID_BSS_INDEX(pMac, bssIdx)  ((BSSIDX_INVALID != (bssIdx)) && ((bssIdx) < (pMac)->hal.memMap.maxBssids))
 
 // Beacon structure
@@ -1571,4 +1575,19 @@ typedef struct sNanRequest
 } tNanRequest, *tpNanRequest;
 #endif
 
+#ifdef SAP_AUTH_OFFLOAD
+struct sap_offload_add_sta_req
+{
+    tANI_U32 assoc_id;
+    tANI_U32 conn_req_len;
+    tANI_U8 conn_req[MAX_CONNECT_REQ_LENGTH];
+};
+struct sap_offload_del_sta_req
+{
+    tANI_U32 assoc_id;
+    tANI_U32 reason_code;
+    tSirMacAddr sta_mac;
+};
+#endif /* SAP_AUTH_OFFLOAD */
+
 #endif /* _HALMSGAPI_H_ */