diff --git a/CORE/SME/src/csr/csrApiRoam.c b/CORE/SME/src/csr/csrApiRoam.c
index 839ab2a..67b21b7 100644
--- a/CORE/SME/src/csr/csrApiRoam.c
+++ b/CORE/SME/src/csr/csrApiRoam.c
@@ -8538,6 +8538,12 @@
             vos_mem_copy(&pRoamInfo->bssid, pUpperLayerAssocCnf->bssId,
                          sizeof(tCsrBssid));
             pRoamInfo->wmmEnabledSta = pUpperLayerAssocCnf->wmmEnabledSta;
+#ifdef WLAN_FEATURE_AP_HT40_24G
+            pRoamInfo->HT40MHzIntoEnabledSta =
+                       pUpperLayerAssocCnf->HT40MHzIntoEnabledSta;
+            smsLog( pMac, LOGW, FL("HT40MHzIntoEnabledSta: %d \n"),
+                                    pRoamInfo->HT40MHzIntoEnabledSta);
+#endif
             if(CSR_IS_INFRA_AP(pRoamInfo->u.pConnectedProfile) )
             {
                 pMac->roam.roamSession[sessionId].connectState = eCSR_ASSOC_STATE_TYPE_INFRA_CONNECTED;
@@ -9489,6 +9495,12 @@
                     vos_mem_copy(&pRoamInfo->bssid, pAssocInd->bssId,
                                  sizeof(tCsrBssid));
                     pRoamInfo->wmmEnabledSta = pAssocInd->wmmEnabledSta;
+#ifdef WLAN_FEATURE_AP_HT40_24G
+                    pRoamInfo->HT40MHzIntoEnabledSta =
+                               pAssocInd->HT40MHzIntoEnabledSta;
+                    smsLog(pMac, LOGW, FL("HT40MHzIntoEnabledSta: %d \n"),
+                                       pRoamInfo->HT40MHzIntoEnabledSta);
+#endif
                     if(CSR_IS_WDS_AP( pRoamInfo->u.pConnectedProfile))
                         status = csrRoamCallCallback(pMac, sessionId, pRoamInfo, 0, eCSR_ROAM_WDS_IND, eCSR_ROAM_RESULT_WDS_ASSOCIATION_IND);//Sta
                     if(CSR_IS_INFRA_AP(pRoamInfo->u.pConnectedProfile))
@@ -13932,6 +13944,11 @@
         //reassocReq
         *pBuf = pAssocInd->reassocReq;
         pBuf += sizeof (tANI_U8);
+#ifdef WLAN_FEATURE_AP_HT40_24G
+        // 40 MHz Intolerant
+        *pBuf = pAssocInd->HT40MHzIntoEnabledSta;
+        pBuf += sizeof (tANI_U8);
+#endif
         msgQ.type = eWNI_SME_UPPER_LAYER_ASSOC_CNF;
         msgQ.bodyptr = pMsg;
         msgQ.bodyval = 0;
