Merge "Merge remote-tracking branch 'origin/caf/caf-wlan/master'"

15 files changed, 190 insertions, 148 deletions

diff --git a/CORE/CLD_TXRX/TXRX/ol_tx_queue.c b/CORE/CLD_TXRX/TXRX/ol_tx_queue.c
index a8141edf8485..cea3006b9b92 100644
--- a/CORE/CLD_TXRX/TXRX/ol_tx_queue.c
+++ b/CORE/CLD_TXRX/TXRX/ol_tx_queue.c
@@ -521,11 +521,8 @@ ol_txrx_vdev_unpause(ol_txrx_vdev_handle vdev)
         adf_os_spin_unlock(&pdev->tx_queue_spinlock);
 #endif /* defined(CONFIG_HL_SUPPORT) */
     } else {
-        if (vdev->ll_pause.is_paused)
-        {
-            vdev->ll_pause.is_paused = A_FALSE;
-            ol_tx_vdev_ll_pause_queue_send(vdev);
-        }
+        vdev->ll_pause.is_paused = A_FALSE;
+        ol_tx_vdev_ll_pause_queue_send(vdev);
     }
     TX_SCHED_DEBUG_PRINT("Leave %s\n", __func__);
 }
diff --git a/CORE/CLD_TXRX/TXRX/ol_txrx.c b/CORE/CLD_TXRX/TXRX/ol_txrx.c
index 6d632683966c..e8217c7f4813 100644
--- a/CORE/CLD_TXRX/TXRX/ol_txrx.c
+++ b/CORE/CLD_TXRX/TXRX/ol_txrx.c
@@ -827,7 +827,6 @@ ol_txrx_vdev_attach(
     }
     #endif /* defined(CONFIG_HL_SUPPORT) */
 
-    adf_os_spinlock_init(&vdev->ll_pause.mutex);
     vdev->ll_pause.is_paused = A_FALSE;
     vdev->ll_pause.txq.head = vdev->ll_pause.txq.tail = NULL;
     vdev->ll_pause.txq.depth = 0;
diff --git a/CORE/HDD/inc/wlan_hdd_hostapd.h b/CORE/HDD/inc/wlan_hdd_hostapd.h
index 40d3cb984cdb..c3e855a0cdda 100644
--- a/CORE/HDD/inc/wlan_hdd_hostapd.h
+++ b/CORE/HDD/inc/wlan_hdd_hostapd.h
@@ -53,7 +53,7 @@
   -------------------------------------------------------------------------*/
 
 /* max length of command string in hostapd ioctl */
-#define HOSTAPD_IOCTL_COMMAND_STRLEN_MAX   2048
+#define HOSTAPD_IOCTL_COMMAND_STRLEN_MAX   4096
 
 hdd_adapter_t* hdd_wlan_create_ap_dev( hdd_context_t *pHddCtx, tSirMacAddr macAddr, tANI_U8 *name);
 
diff --git a/CORE/HDD/src/wlan_hdd_cfg80211.c b/CORE/HDD/src/wlan_hdd_cfg80211.c
index bf04268a1afc..8da0c0bc3df9 100644
--- a/CORE/HDD/src/wlan_hdd_cfg80211.c
+++ b/CORE/HDD/src/wlan_hdd_cfg80211.c
@@ -8193,7 +8193,7 @@ static int wlan_hdd_cfg80211_flush_pmksa(struct wiphy *wiphy, struct net_device
     /*in case index is 0,no entry to delete*/
     if (0 == PMKIDCacheIndex)
     {
-       hddLog(VOS_TRACE_LEVEL_ERROR, "%s: Invalid entry to delete" ,
+       hddLog(VOS_TRACE_LEVEL_INFO, "%s: No entries to flush" ,
               __func__);
        return -EINVAL;
     }
@@ -8332,8 +8332,7 @@ void hdd_cfg80211_sched_scan_done_callback(void *callbackContext,
 
 /*
  * FUNCTION: wlan_hdd_is_pno_allowed
- * To check is there any P2P GO/SAP or P2P Client/STA
- * session is active
+ * Check if PNO is allowed or not.
  */
 static eHalStatus wlan_hdd_is_pno_allowed(hdd_adapter_t *pAdapter)
 {
@@ -8341,8 +8340,14 @@ static eHalStatus wlan_hdd_is_pno_allowed(hdd_adapter_t *pAdapter)
    hdd_adapter_t *pTempAdapter = NULL;
    hdd_context_t *pHddCtx = WLAN_HDD_GET_CTX(pAdapter);
    int status = 0;
+
    status = hdd_get_front_adapter(pHddCtx, &pAdapterNode);
 
+   /* Current firmware design for PNO does not consider concurrent
+    * active sessions. Hence , determine the concurrent active sessions
+    * and return a failure.
+    */
+
    while ((NULL != pAdapterNode) && (VOS_STATUS_SUCCESS == status))
    {
         pTempAdapter = pAdapterNode->pAdapter;
@@ -8355,13 +8360,13 @@ static eHalStatus wlan_hdd_is_pno_allowed(hdd_adapter_t *pAdapter)
                  (WLAN_HDD_P2P_GO == pTempAdapter->device_mode) ||
                  (WLAN_HDD_SOFTAP == pTempAdapter->device_mode))
             {
-                return eHAL_STATUS_SUCCESS;
+                return eHAL_STATUS_FAILURE;
             }
         }
         status = hdd_get_next_adapter ( pHddCtx, pAdapterNode, &pNext );
         pAdapterNode = pNext;
    }
-   return eHAL_STATUS_FAILURE;
+   return eHAL_STATUS_SUCCESS;
 }
 
 /*
@@ -8435,16 +8440,11 @@ static int wlan_hdd_cfg80211_sched_scan_start(struct wiphy *wiphy,
         }
     }
 
-    /* The current firmware design for PNO does not consider concurrent
-     * active sessions.Hence , determine the concurrent active sessions
-     * and return a failure to the framework on a request for schedule
-     * scan.
-     */
-    if (eHAL_STATUS_SUCCESS == wlan_hdd_is_pno_allowed(pAdapter))
+    if (eHAL_STATUS_FAILURE == wlan_hdd_is_pno_allowed(pAdapter))
     {
-        VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR,
-                  "%s: Cannot handle sched_scan as p2p session is active", __func__);
-        return -EBUSY;
+        VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO,
+                  "%s: pno is not allowed", __func__);
+        return -ENOTSUPP;
     }
 
     pPnoRequest = (tpSirPNOScanReq) vos_mem_malloc(sizeof (tSirPNOScanReq));
diff --git a/CORE/HDD/src/wlan_hdd_hostapd.c b/CORE/HDD/src/wlan_hdd_hostapd.c
index 409c79ae704a..2f03453046f4 100644
--- a/CORE/HDD/src/wlan_hdd_hostapd.c
+++ b/CORE/HDD/src/wlan_hdd_hostapd.c
@@ -236,7 +236,7 @@ int hdd_hostapd_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
          * To avoid addition overflow total_len should be
          * smaller than INT_MAX. */
         VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_FATAL,
-           "%s: integer out of range\n", __func__);
+           "%s: integer out of range len %d", __func__, priv_data.total_len);
         ret = -EFAULT;
         goto exit;
     }
diff --git a/CORE/HDD/src/wlan_hdd_ipa.c b/CORE/HDD/src/wlan_hdd_ipa.c
index 88da1e7337b0..7091aabee452 100644
--- a/CORE/HDD/src/wlan_hdd_ipa.c
+++ b/CORE/HDD/src/wlan_hdd_ipa.c
@@ -977,7 +977,7 @@ setup_sys_pipe_fail:
 
 	while (--i >= 0) {
 		ipa_teardown_sys_pipe(hdd_ipa->sys_pipe[i].conn_hdl);
-		vos_mem_zero(&hdd_ipa->sys_pipe[i],
+		adf_os_mem_zero(&hdd_ipa->sys_pipe[i],
 				sizeof(struct hdd_ipa_sys_pipe ));
 	}
 
@@ -1020,22 +1020,23 @@ static int hdd_ipa_register_interface(struct hdd_ipa_priv *hdd_ipa,
 		num_prop++;
 
 	/* Allocate TX properties for TOS categories, 1 each for IPv4 & IPv6 */
-	tx_prop = vos_mem_malloc(sizeof(struct ipa_ioc_tx_intf_prop) *
-			num_prop);
+	tx_prop = adf_os_mem_alloc(NULL,
+			sizeof(struct ipa_ioc_tx_intf_prop) * num_prop);
 	if (!tx_prop) {
 		HDD_IPA_LOG(VOS_TRACE_LEVEL_ERROR, "tx_prop allocation failed");
 		goto register_interface_fail;
 	}
 
 	/* Allocate RX properties, 1 each for IPv4 & IPv6 */
-	rx_prop = vos_mem_malloc(sizeof(struct ipa_ioc_rx_intf_prop) *
-			num_prop);
+	rx_prop = adf_os_mem_alloc(NULL,
+			sizeof(struct ipa_ioc_rx_intf_prop) * num_prop);
 	if (!rx_prop) {
 		HDD_IPA_LOG(VOS_TRACE_LEVEL_ERROR, "rx_prop allocation failed");
 		goto register_interface_fail;
 	}
-	vos_mem_zero(&tx_intf, sizeof(tx_intf));
-	vos_mem_zero(&rx_intf, sizeof(rx_intf));
+
+	adf_os_mem_zero(&tx_intf, sizeof(tx_intf));
+	adf_os_mem_zero(&rx_intf, sizeof(rx_intf));
 
 	snprintf(ipv4_hdr_name, IPA_RESOURCE_NAME_MAX, "%s%s",
 		ifname, HDD_IPA_IPV4_NAME_EXT);
@@ -1089,8 +1090,8 @@ static int hdd_ipa_register_interface(struct hdd_ipa_priv *hdd_ipa,
 	ret = ipa_register_intf(ifname, &tx_intf, &rx_intf);
 
 register_interface_fail:
-	vos_mem_free(tx_prop);
-	vos_mem_free(rx_prop);
+	adf_os_mem_free(tx_prop);
+	adf_os_mem_free(rx_prop);
 	return ret;
 }
 
@@ -1100,7 +1101,7 @@ static void hdd_remove_ipa_header(char *name)
 	int ret = 0, len;
 	struct ipa_ioc_del_hdr *ipa_hdr;
 
-	vos_mem_zero(&hdrlookup, sizeof(hdrlookup));
+	adf_os_mem_zero(&hdrlookup, sizeof(hdrlookup));
 	strlcpy(hdrlookup.name, name, sizeof(hdrlookup.name));
 	ret = ipa_get_hdr(&hdrlookup);
 	if (ret) {
@@ -1112,7 +1113,7 @@ static void hdd_remove_ipa_header(char *name)
 
 	HDD_IPA_LOG(VOS_TRACE_LEVEL_INFO, "hdl: 0x%x", hdrlookup.hdl);
 	len = sizeof(struct ipa_ioc_del_hdr) + sizeof(struct ipa_hdr_del)*1;
-	ipa_hdr = (struct ipa_ioc_del_hdr *) vos_mem_malloc(len);
+	ipa_hdr = (struct ipa_ioc_del_hdr *) adf_os_mem_alloc(NULL, len);
 	if (ipa_hdr == NULL) {
 		HDD_IPA_LOG(VOS_TRACE_LEVEL_ERROR, "ipa_hdr allocation failed");
 		return;
@@ -1126,7 +1127,7 @@ static void hdd_remove_ipa_header(char *name)
 		HDD_IPA_LOG(VOS_TRACE_LEVEL_ERROR, "Delete header failed: %d",
 				ret);
 
-	vos_mem_free(ipa_hdr);
+	adf_os_mem_free(ipa_hdr);
 }
 
 
@@ -1146,7 +1147,7 @@ static int hdd_ipa_add_header_info(struct hdd_ipa_priv *hdd_ipa,
 			ifname, mac_addr);
 
 	/* dynamically allocate the memory to add the hdrs */
-	ipa_hdr = vos_mem_malloc(sizeof(struct ipa_ioc_add_hdr)
+	ipa_hdr = adf_os_mem_alloc(NULL, sizeof(struct ipa_ioc_add_hdr)
 			+ sizeof(struct ipa_hdr_add));
 	if (!ipa_hdr) {
 		HDD_IPA_LOG(VOS_TRACE_LEVEL_ERROR,
@@ -1204,7 +1205,7 @@ static int hdd_ipa_add_header_info(struct hdd_ipa_priv *hdd_ipa,
 				ipa_hdr->hdr[0].name, ipa_hdr->hdr[0].hdr_hdl);
 	}
 
-	vos_mem_free(ipa_hdr);
+	adf_os_mem_free(ipa_hdr);
 
 	return ret;
 
@@ -1214,7 +1215,7 @@ clean_ipv4_hdr:
 	hdd_remove_ipa_header(ipa_hdr->hdr[0].name);
 end:
 	if(ipa_hdr)
-		vos_mem_free(ipa_hdr);
+		adf_os_mem_free(ipa_hdr);
 
 	return ret;
 }
@@ -1319,7 +1320,7 @@ static void hdd_ipa_msg_free_fn(void *buff, uint32_t len, uint32_t type)
 {
 	HDD_IPA_LOG(VOS_TRACE_LEVEL_INFO, "msg type:%d, len:%d", type, len);
 	ghdd_ipa->stats.free_msg++;
-	vos_mem_free(buff);
+	adf_os_mem_free(buff);
 }
 
 int hdd_ipa_wlan_evt(hdd_adapter_t *adapter, uint8_t sta_id,
@@ -1377,7 +1378,7 @@ int hdd_ipa_wlan_evt(hdd_adapter_t *adapter, uint8_t sta_id,
 		meta.msg_type = type;
 		meta.msg_len = (sizeof(struct ipa_wlan_msg_ex) +
 				sizeof(struct ipa_wlan_hdr_attrib_val));
-		msg_ex = vos_mem_malloc (meta.msg_len);
+		msg_ex = adf_os_mem_alloc (NULL, meta.msg_len);
 
 		if (msg_ex == NULL) {
 			HDD_IPA_LOG(VOS_TRACE_LEVEL_ERROR,
@@ -1397,7 +1398,7 @@ int hdd_ipa_wlan_evt(hdd_adapter_t *adapter, uint8_t sta_id,
 		if (ret) {
 			HDD_IPA_LOG(VOS_TRACE_LEVEL_INFO, "%s: Evt: %d : %d",
 					msg_ex->name, meta.msg_type,  ret);
-			vos_mem_free(msg_ex);
+			adf_os_mem_free(msg_ex);
 			return ret;
 		}
 		hdd_ipa->stats.send_msg++;
@@ -1411,7 +1412,7 @@ int hdd_ipa_wlan_evt(hdd_adapter_t *adapter, uint8_t sta_id,
 	}
 
 	meta.msg_len = sizeof(struct ipa_wlan_msg);
-	msg = vos_mem_malloc(meta.msg_len);
+	msg = adf_os_mem_alloc(NULL, meta.msg_len);
 	if (msg == NULL) {
 		HDD_IPA_LOG(VOS_TRACE_LEVEL_ERROR, "msg allocation failed");
 		return -ENOMEM;
@@ -1429,7 +1430,7 @@ int hdd_ipa_wlan_evt(hdd_adapter_t *adapter, uint8_t sta_id,
 	if (ret) {
 		HDD_IPA_LOG(VOS_TRACE_LEVEL_INFO, "%s: Evt: %d fail:%d",
 					msg->name, meta.msg_type,  ret);
-		vos_mem_free(msg);
+		adf_os_mem_free(msg);
 		return ret;
 	}
 
@@ -1452,7 +1453,7 @@ static void hdd_ipa_rx_pipe_desc_free(void)
 	list_for_each_entry_safe(desc, tmp, &hdd_ipa->free_desc_head, link) {
 		list_del(&desc->link);
 		spin_unlock_bh(&hdd_ipa->q_lock);
-		vos_mem_free(desc);
+		adf_os_mem_free(desc);
 		spin_lock_bh(&hdd_ipa->q_lock);
 		i++;
 	}
@@ -1481,8 +1482,8 @@ static int hdd_ipa_rx_pipe_desc_alloc(void)
 	INIT_LIST_HEAD(&hdd_ipa->pend_desc_head);
 	hdd_ipa->stats.freeq_cnt = max_desc_cnt;
 	for (i = 0; i < max_desc_cnt; i++) {
-		tmp_desc = vos_mem_malloc(sizeof(struct
-							ipa_tx_data_desc));
+		tmp_desc = adf_os_mem_alloc(NULL,
+				sizeof(struct ipa_tx_data_desc));
 		if (!tmp_desc) {
 			ret = -ENOMEM;
 
@@ -1651,11 +1652,12 @@ VOS_STATUS hdd_ipa_init(hdd_context_t *hdd_ctx)
 	if (!hdd_ipa_is_enabled(hdd_ctx))
 		return VOS_STATUS_SUCCESS;
 
-	hdd_ipa = vos_mem_malloc(sizeof(struct hdd_ipa_priv));
+	hdd_ipa = adf_os_mem_alloc(NULL, sizeof(struct hdd_ipa_priv));
 	if (!hdd_ipa) {
 		HDD_IPA_LOG(VOS_TRACE_LEVEL_FATAL, "hdd_ipa allocation failed");
 		goto fail_setup_rm;
 	}
+
 	hdd_ctx->hdd_ipa = hdd_ipa;
 	ghdd_ipa = hdd_ipa;
 	hdd_ipa->hdd_ctx = hdd_ctx;
@@ -1700,7 +1702,7 @@ fail_create_sys_pipe:
 	hdd_ipa_destory_rm_resource(hdd_ipa);
 fail_setup_rm:
 	if (hdd_ipa)
-		vos_mem_free(hdd_ipa);
+		adf_os_mem_free(hdd_ipa);
 
 	return VOS_STATUS_E_FAILURE;
 }
@@ -1725,7 +1727,7 @@ VOS_STATUS hdd_ipa_cleanup(hdd_context_t *hdd_ctx)
 	hdd_ipa_teardown_sys_pipe(hdd_ipa);
 	hdd_ipa_destory_rm_resource(hdd_ipa);
 
-	vos_mem_free(hdd_ipa);
+	adf_os_mem_free(hdd_ipa);
 	hdd_ctx->hdd_ipa = NULL;
 
 	return VOS_STATUS_SUCCESS;
diff --git a/CORE/HDD/src/wlan_hdd_main.c b/CORE/HDD/src/wlan_hdd_main.c
index 6421db20a0f3..a95f46f63069 100644
--- a/CORE/HDD/src/wlan_hdd_main.c
+++ b/CORE/HDD/src/wlan_hdd_main.c
@@ -6248,7 +6248,7 @@ tANI_U8* wlan_hdd_get_intf_addr(hdd_context_t* pHddCtx)
    int i;
    for ( i = 0; i < VOS_MAX_CONCURRENCY_PERSONA; i++)
    {
-      if( 0 == (pHddCtx->cfg_ini->intfAddrMask >> i))
+      if( 0 == ((pHddCtx->cfg_ini->intfAddrMask) & (1 << i)))
          break;
    }
 
@@ -7008,6 +7008,15 @@ hdd_adapter_t* hdd_open_adapter( hdd_context_t *pHddCtx, tANI_U8 session_type,
         return NULL;
    }
 
+   if(macAddr == NULL)
+   {
+         /* Not received valid macAddr */
+         VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR,
+                 "%s:Unable to add virtual intf: Not able to get"
+                             "valid mac address",__func__);
+         return NULL;
+   }
+
    /*
     * If Powersave Offload is enabled
     * Fw will take care incase of concurrency
@@ -8987,7 +8996,9 @@ int hdd_wlan_startup(struct device *dev, v_VOID_t *hif_sc)
 {
    VOS_STATUS status;
    hdd_adapter_t *pAdapter = NULL;
+#ifdef WLAN_OPEN_P2P_INTERFACE
    hdd_adapter_t *pP2pAdapter = NULL;
+#endif
    hdd_context_t *pHddCtx = NULL;
    v_CONTEXT_t pVosContext= NULL;
 #ifdef WLAN_BTAMP_FEATURE
@@ -9489,6 +9500,9 @@ int hdd_wlan_startup(struct device *dev, v_VOID_t *hif_sc)
    {
      pAdapter = hdd_open_adapter( pHddCtx, WLAN_HDD_INFRA_STATION, "wlan%d",
          wlan_hdd_get_intf_addr(pHddCtx), FALSE );
+
+#ifdef WLAN_OPEN_P2P_INTERFACE
+     /* Open P2P device interface */
      if (pAdapter != NULL)
      {
          if ( pHddCtx->cfg_ini->isP2pDeviceAddrAdministrated )
@@ -9529,6 +9543,7 @@ int hdd_wlan_startup(struct device *dev, v_VOID_t *hif_sc)
              goto err_close_adapter;
          }
      }
+#endif
    }
 
    if( pAdapter == NULL )
diff --git a/CORE/MAC/inc/qwlan_version.h b/CORE/MAC/inc/qwlan_version.h
index 9bd1045f26e2..2c360eea6554 100644
--- a/CORE/MAC/inc/qwlan_version.h
+++ b/CORE/MAC/inc/qwlan_version.h
@@ -42,9 +42,9 @@ BRIEF DESCRIPTION:
 #define QWLAN_VERSION_MINOR            0
 #define QWLAN_VERSION_PATCH            0
 #define QWLAN_VERSION_EXTRA            ""
-#define QWLAN_VERSION_BUILD            33
+#define QWLAN_VERSION_BUILD            34
 
-#define QWLAN_VERSIONSTR               "1.0.0.33"
+#define QWLAN_VERSIONSTR               "1.0.0.34"
 
 #ifdef QCA_WIFI_2_0
 
diff --git a/CORE/SERVICES/BMI/ol_fw.c b/CORE/SERVICES/BMI/ol_fw.c
index e98a9dcf6959..138806ab8ee6 100644
--- a/CORE/SERVICES/BMI/ol_fw.c
+++ b/CORE/SERVICES/BMI/ol_fw.c
@@ -190,7 +190,7 @@ static int ol_transfer_single_bin_file(struct ol_softc *scn,
 			if (binary_len < sizeof(SIGN_HEADER_T))
 			{
 				AR_DEBUG_PRINTF(ATH_DEBUG_ERR,
-					("%s: sign header size is error: bin id: %d, bin len: %d, sign header size: %d \n",
+					("%s: sign header size is error: bin id: %d, bin len: %d, sign header size: %zu \n",
 					__func__, one_bin_header->binary_id,
 					one_bin_header->binary_len,
 					sizeof(SIGN_HEADER_T)));
@@ -599,10 +599,8 @@ void ol_target_failure(void *instance, A_STATUS status)
 	A_UINT32 reg_dump_cnt = 0;
 	A_UINT32 i;
 	A_UINT32 dbglog_hdr_address;
-	struct dbglog_hdr_s dbglog_hdr;
-	struct dbglog_buf_s dbglog_buf;
-	struct dbglog_hdr_host dbglog_hdr_temp;
-	struct dbglog_buf_host dbglog_buf_temp;
+	struct dbglog_hdr_host dbglog_hdr;
+	struct dbglog_buf_host dbglog_buf;
 	A_UINT8 *dbglog_data;
 	void *vos_context = vos_get_global_context(VOS_MODULE_ID_WDA, NULL);
 	tp_wma_handle wma = vos_get_context(VOS_MODULE_ID_WDA, vos_context);
@@ -659,32 +657,22 @@ void ol_target_failure(void *instance, A_STATUS status)
 
 	if (HIFDiagReadMem(scn->hif_hdl,
 	            dbglog_hdr_address,
-	            (A_UCHAR *)&dbglog_hdr_temp,
-	            sizeof(dbglog_hdr_temp))!= A_OK)
+	            (A_UCHAR *)&dbglog_hdr,
+	            sizeof(dbglog_hdr))!= A_OK)
 	{
 	    printk("HifDiagReadiMem FW dbglog_hdr failed\n");
 	    return;
 	}
 
-	dbglog_hdr.dbuf = (struct dbglog_buf_s *)dbglog_hdr_temp.dbuf;
-	dbglog_hdr.dropped = dbglog_hdr_temp.dropped;
-
 	if (HIFDiagReadMem(scn->hif_hdl,
 	            (A_UINT32)dbglog_hdr.dbuf,
-	            (A_UCHAR *)&dbglog_buf_temp,
-	            sizeof(dbglog_buf_temp))!= A_OK)
+	            (A_UCHAR *)&dbglog_buf,
+	            sizeof(dbglog_buf))!= A_OK)
 	{
 	    printk("HifDiagReadiMem FW dbglog_buf failed\n");
 	    return;
 	}
 
-	dbglog_buf.next = (struct dbglog_buf_s *)dbglog_buf_temp.next;
-	dbglog_buf.buffer = (A_UINT8 *)dbglog_buf_temp.buffer;
-	dbglog_buf.bufsize = dbglog_buf_temp.bufsize;
-	dbglog_buf.length = dbglog_buf_temp.length;
-	dbglog_buf.count = dbglog_buf_temp.count;
-	dbglog_buf.free = dbglog_buf_temp.free;
-
 	dbglog_data = adf_os_mem_alloc(scn->adf_dev,  dbglog_buf.length + 4);
 	if (dbglog_data) {
 	    if (HIFDiagReadMem(scn->hif_hdl,
@@ -694,7 +682,7 @@ void ol_target_failure(void *instance, A_STATUS status)
 	    {
 	        printk("HifDiagReadiMem FW dbglog_data failed\n");
 	    } else {
-	        printk("dbglog_hdr.dbuf=%p dbglog_data=%p dbglog_buf.buffer=%p dbglog_buf.length=%u\n",
+	        printk("dbglog_hdr.dbuf=%u dbglog_data=%p dbglog_buf.buffer=%u dbglog_buf.length=%u\n",
 	                dbglog_hdr.dbuf, dbglog_data, dbglog_buf.buffer, dbglog_buf.length);
 
 
diff --git a/CORE/SERVICES/COMMON/wdi_in.h b/CORE/SERVICES/COMMON/wdi_in.h
index 8c266f0114df..69ae4d1b68f1 100644
--- a/CORE/SERVICES/COMMON/wdi_in.h
+++ b/CORE/SERVICES/COMMON/wdi_in.h
@@ -1199,12 +1199,19 @@ ol_tx_queue_log_display(ol_txrx_pdev_handle pdev);
 #define wdi_in_peer_attach ol_txrx_peer_attach
 #define wdi_in_peer_update ol_txrx_peer_update
 #define wdi_in_peer_pause ol_txrx_peer_pause
+#define wdi_in_peer_pause ol_txrx_peer_pause
+#define wdi_in_peer_tid_unpause ol_txrx_peer_tid_unpause
 #define wdi_in_peer_tid_unpause ol_txrx_peer_tid_unpause
 #define wdi_in_tx_release ol_txrx_tx_release
+#define wdi_in_tx_release ol_txrx_tx_release
+#define wdi_in_vdev_pause ol_txrx_vdev_pause
 #define wdi_in_vdev_pause ol_txrx_vdev_pause
 #define wdi_in_vdev_unpause ol_txrx_vdev_unpause
+#define wdi_in_vdev_unpause ol_txrx_vdev_unpause
+#define wdi_in_pdev_pause ol_txrx_pdev_pause
 #define wdi_in_pdev_pause ol_txrx_pdev_pause
 #define wdi_in_pdev_unpause ol_txrx_pdev_unpause
+#define wdi_in_pdev_unpause ol_txrx_pdev_unpause
 #define wdi_in_tx_sync ol_txrx_tx_sync
 #define wdi_in_peer_detach ol_txrx_peer_detach
 #define wdi_in_vdev_detach ol_txrx_vdev_detach
diff --git a/CORE/SERVICES/COMMON/wma_api.h b/CORE/SERVICES/COMMON/wma_api.h
index 4ded593e5cc8..0055a219dd42 100644
--- a/CORE/SERVICES/COMMON/wma_api.h
+++ b/CORE/SERVICES/COMMON/wma_api.h
@@ -99,6 +99,8 @@ VOS_STATUS wma_stop(v_VOID_t *vos_context, tANI_U8 reason);
 
 VOS_STATUS wma_close(v_VOID_t *vos_context);
 
+VOS_STATUS wma_wmi_service_close(v_VOID_t *vos_context);
+
 v_VOID_t wma_rx_ready_event(WMA_HANDLE handle, v_VOID_t *ev);
 
 v_VOID_t wma_rx_service_ready_event(WMA_HANDLE handle, 
diff --git a/CORE/SERVICES/WMA/wma.c b/CORE/SERVICES/WMA/wma.c
index 3d04929b472e..e8029e9fa767 100644
--- a/CORE/SERVICES/WMA/wma.c
+++ b/CORE/SERVICES/WMA/wma.c
@@ -2648,7 +2648,7 @@ void wma_vdev_detach_callback(void *ctx)
 			 __func__, param->sessionId);
 		vos_timer_stop(&req_msg->event_timeout);
 		vos_timer_destroy(&req_msg->event_timeout);
-		vos_mem_free(req_msg);
+		adf_os_mem_free(req_msg);
 	}
 	if(iface->addBssStaContext)
                 adf_os_mem_free(iface->addBssStaContext);
@@ -2721,11 +2721,10 @@ static VOS_STATUS wma_vdev_detach(tp_wma_handle wma_handle,
 
         adf_os_spin_lock_bh(&wma_handle->vdev_detach_lock);
         if(!iface->handle) {
-                status = VOS_STATUS_E_FAILURE;
                 WMA_LOGE("handle of vdev_id %d is NULL vdev is already freed",
                     vdev_id);
                 adf_os_spin_unlock_bh(&wma_handle->vdev_detach_lock);
-                goto out;
+		return status;
         }
 
         /* remove the interface from ath_dev */
@@ -3281,7 +3280,10 @@ static ol_txrx_vdev_handle wma_vdev_attach(tp_wma_handle wma_handle,
 						self_sta_req->selfMacAddr,
 						self_sta_req->sessionId,
 						txrx_vdev_type);
-	wma_handle->interfaces[self_sta_req->sessionId].pause_bitmap = 0;
+#ifdef QCA_SUPPORT_TXRX_VDEV_PAUSE_LL
+	WMA_LOGD("LL TX Pause Mutex init");
+	adf_os_spinlock_init(&txrx_vdev_handle->ll_pause.mutex);
+#endif /* QCA_SUPPORT_TXRX_VDEV_PAUSE_LL */
 
 	WMA_LOGA("vdev_id %hu, txrx_vdev_handle = %p", self_sta_req->sessionId,
 			txrx_vdev_handle);
@@ -3810,18 +3812,27 @@ VOS_STATUS wma_start_scan(tp_wma_handle wma_handle,
 		goto error1;
 	}
 
+	/* Start the timer for scan completion */
+	vos_status = vos_timer_start(&wma_handle->wma_scan_comp_timer,
+					WMA_HW_DEF_SCAN_MAX_DURATION);
+	if (vos_status != VOS_STATUS_SUCCESS ) {
+		WMA_LOGE("Failed to start the scan completion timer");
+		vos_status = VOS_STATUS_E_FAILURE;
+		goto error1;
+	}
+
 	/* Fill individual elements of wmi_start_scan_req and
 	 * TLV for channel list, bssid, ssid etc ... */
 	vos_status = wma_get_buf_start_scan_cmd(wma_handle, scan_req,
 			&buf, &len);
 	if (vos_status != VOS_STATUS_SUCCESS) {
 		WMA_LOGE("Failed to get buffer for start scan cmd");
-		goto error1;
+		goto error0;
 	}
 
 	if (NULL == buf) {
 		WMA_LOGE("Failed to get buffer for saving current scan info");
-		goto error1;
+		goto error0;
 	}
 
 	/* Save current scan info */
@@ -3847,14 +3858,6 @@ VOS_STATUS wma_start_scan(tp_wma_handle wma_handle,
 
 	WMA_LOGI("WMA --> WMI_START_SCAN_CMDID");
 
-	/* Start the timer for scan completion */
-	vos_status = vos_timer_start(&wma_handle->wma_scan_comp_timer,
-					WMA_HW_DEF_SCAN_MAX_DURATION);
-	if (vos_status != VOS_STATUS_SUCCESS ) {
-		WMA_LOGE("Failed to start the scan completion timer");
-		vos_status = VOS_STATUS_E_FAILURE;
-		goto error;
-	}
 	/* Update the scan parameters for handler */
 	wma_handle->wma_scan_timer_info.vdev_id = cmd->vdev_id;
 	wma_handle->wma_scan_timer_info.scan_id = cmd->scan_id;
@@ -3864,6 +3867,12 @@ error:
 	wma_reset_scan_info(wma_handle, cmd->vdev_id);
 	if (buf)
 		adf_nbuf_free(buf);
+error0:
+	/* Stop the timer for scan completion */
+	if (vos_timer_stop(&wma_handle->wma_scan_comp_timer)
+		!= VOS_STATUS_SUCCESS) {
+		WMA_LOGE("Failed to stop the scan completion timer");
+	}
 error1:
         /* Send completion event for only for start scan request */
         if (msg_type == WDA_START_SCAN_OFFLOAD_REQ) {
@@ -5612,7 +5621,7 @@ static struct wma_target_req *wma_fill_vdev_req(tp_wma_handle wma, u_int8_t vdev
 {
 	struct wma_target_req *req;
 
-	req = vos_mem_malloc(sizeof(*req));
+	req = adf_os_mem_alloc(NULL, sizeof(*req));
 	if (!req) {
 		WMA_LOGP("Failed to allocate memory for msg %d vdev %d\n",
 			 msg_type, vdev_id);
@@ -9408,6 +9417,8 @@ static int wmi_unified_bcn_tmpl_send(tp_wma_handle wma,
 	int ret;
 	u_int8_t *p2p_ie;
 	u_int16_t p2p_ie_len = 0;
+	u_int64_t adjusted_tsf_le;
+	struct ieee80211_frame *wh;
 
 
 	WMA_LOGD("Send beacon template for vdev %d", vdev_id);
@@ -9433,6 +9444,15 @@ static int wmi_unified_bcn_tmpl_send(tp_wma_handle wma,
 
 	frm = bcn_info->beacon + bytes_to_strip;
 	tmpl_len_aligned = roundup(tmpl_len, sizeof(A_UINT32));
+	/*
+	 * Make the TSF offset negative so beacons in the same
+	 * staggered batch have the same TSF.
+	 */
+	adjusted_tsf_le = cpu_to_le64(0ULL -
+				      wma->interfaces[vdev_id].tsfadjust);
+	/* Update the timstamp in the beacon buffer with adjusted TSF */
+	wh = (struct ieee80211_frame *)frm;
+	A_MEMCPY(&wh[1], &adjusted_tsf_le, sizeof(adjusted_tsf_le));
 
 	wmi_buf_len = sizeof(wmi_bcn_tmpl_cmd_fixed_param) +
 	          sizeof(wmi_bcn_prb_info) + WMI_TLV_HDR_SIZE +
@@ -9557,11 +9577,8 @@ static int wma_tbttoffset_update_event_handler(void *handle, u_int8_t *event,
 	WMI_TBTTOFFSET_UPDATE_EVENTID_param_tlvs *param_buf;
 	wmi_tbtt_offset_event_fixed_param *tbtt_offset_event;
 	struct wma_txrx_node *intf = wma->interfaces;
-	struct ieee80211_frame *wh;
 	struct beacon_info *bcn;
 	tSendbeaconParams bcn_info;
-	u_int8_t *bcn_payload;
-	u_int64_t adjusted_tsf_le;
 	u_int32_t *adjusted_tsf;
 	u_int32_t if_id = 0, vdev_map;
 
@@ -9585,19 +9602,10 @@ static int wma_tbttoffset_update_event_handler(void *handle, u_int8_t *event,
 		}
 		/* Save the adjusted TSF */
 		intf[if_id].tsfadjust = adjusted_tsf[if_id];
-		/*
-		 * Make the TSF offset negative so beacons in the same
-		 * staggered batch have the same TSF.
-		 */
-		adjusted_tsf_le = cpu_to_le64(0ULL - intf[if_id].tsfadjust);
 
-		/* Update the timstamp in the beacon buffer with adjusted TSF */
 		adf_os_spin_lock_bh(&bcn->lock);
-		bcn_payload = adf_nbuf_data(bcn->buf);
-		wh = (struct ieee80211_frame *) bcn_payload;
-		A_MEMCPY(&wh[1], &adjusted_tsf_le, sizeof(adjusted_tsf_le));
 		vos_mem_zero(&bcn_info, sizeof(bcn_info));
-		bcn_info.beacon = bcn_payload;
+		bcn_info.beacon = adf_nbuf_data(bcn->buf);
 		bcn_info.p2pIeOffset = bcn->p2p_ie_offset;
 		bcn_info.beaconLength = bcn->len;
 		bcn_info.timIeOffset = bcn->tim_ie_offset;
@@ -14899,12 +14907,12 @@ static int wma_mcc_vdev_tx_pause_evt_handler(void *handle, u_int8_t *event,
 	tp_wma_handle wma = (tp_wma_handle) handle;
 	WMI_TX_PAUSE_EVENTID_param_tlvs *param_buf;
 	wmi_tx_pause_event_fixed_param  *wmi_event;
+	ol_txrx_vdev_handle txrx_vdev;
 	u_int8_t vdev_id;
 	A_UINT32 vdev_map;
 
 	param_buf = (WMI_TX_PAUSE_EVENTID_param_tlvs *) event;
-	if (!param_buf)
-	{
+	if (!param_buf) {
 		WMA_LOGE("Invalid roam event buffer");
 		return -EINVAL;
 	}
@@ -14918,47 +14926,35 @@ static int wma_mcc_vdev_tx_pause_evt_handler(void *handle, u_int8_t *event,
 	{
 		if (!(vdev_map & 0x1))
 		{
-			/* No Vdev */
+			vdev_map >>= 1;
 		}
 		else
 		{
-			if (!wma->interfaces[vdev_id].handle)
-			{
-				WMA_LOGE("%s: invalid vdev ID %d", __func__, vdev_id);
-				/* Test Next VDEV */
-				vdev_map >>= 1;
-				continue;
-			}
+			WMA_LOGD("Found vdev %d\n", vdev_id);
+			break;
+		}
+	}
 
-			/* PAUSE action, add bitmap */
-			if (ACTION_PAUSE == wmi_event->action)
-			{
-				wma->interfaces[vdev_id].pause_bitmap |= (1 << wmi_event->pause_type);
-				wdi_in_vdev_pause(wma->interfaces[vdev_id].handle);
-			}
-			/* UNPAUSE action, clean bitmap */
-			else if (ACTION_UNPAUSE == wmi_event->action)
-			{
-				wma->interfaces[vdev_id].pause_bitmap &= ~(1 << wmi_event->pause_type);
+	WMA_LOGD("vdev_id %d, vdev_map 0x%x, tid_map 0x%x,"
+			" pause_type 0x%x, action 0x%x, peer_id 0x%x\n",
+			vdev_id, wmi_event->vdev_map, wmi_event->tid_map,
+			wmi_event->pause_type, wmi_event->action, wmi_event->peer_id);
 
-				if (!wma->interfaces[vdev_id].pause_bitmap)
-				{
-					/* PAUSE BIT MAP is cleared
-					 * UNPAUSE VDEV */
-					wdi_in_vdev_unpause(wma->interfaces[vdev_id].handle);
-				}
-			}
-			else
-			{
-				WMA_LOGE("Not Valid Action Type %d", wmi_event->action);
-			}
 
-			WMA_LOGD("vdev_id %d, pause_map 0x%x, pause type %d, action %d",
-				vdev_id, wma->interfaces[vdev_id].pause_bitmap,
-				wmi_event->pause_type, wmi_event->action);
+	txrx_vdev = wma->interfaces[vdev_id].handle;
+	if (txrx_vdev)
+	{
+		if ((PAUSE_TYPE_CHOP == wmi_event->pause_type) &&
+			(!wmi_event->action))
+		{
+			wdi_in_vdev_pause(txrx_vdev);
+		}
+		if ((PAUSE_TYPE_CHOP == wmi_event->pause_type) &&
+			(wmi_event->action))
+		{
+			wdi_in_vdev_unpause(txrx_vdev);
 		}
-		/* Test Next VDEV */
-		vdev_map >>= 1;
+		/* TODO, other types of pause should be added */
 	}
 
 	return 0;
@@ -15738,6 +15734,41 @@ static void wma_cleanup_vdev_resp(tp_wma_handle wma)
 	adf_os_spin_unlock_bh(&wma->vdev_respq_lock);
 }
 
+VOS_STATUS wma_wmi_service_close(v_VOID_t *vos_ctx)
+{
+	tp_wma_handle wma_handle;
+
+	WMA_LOGD("%s: Enter", __func__);
+
+	wma_handle = vos_get_context(VOS_MODULE_ID_WDA, vos_ctx);
+
+	/* validate the wma_handle */
+	if (NULL == wma_handle) {
+		WMA_LOGE("%s: Invalid wma handle", __func__);
+		return VOS_STATUS_E_INVAL;
+	}
+
+	/* validate the wmi handle */
+	if (NULL == wma_handle->wmi_handle) {
+		WMA_LOGE("%s: Invalid wmi handle", __func__);
+		return VOS_STATUS_E_INVAL;
+	}
+
+	/* dettach the wmi serice */
+	WMA_LOGD("calling wmi_unified_detach");
+	wmi_unified_detach(wma_handle->wmi_handle);
+	wma_handle->wmi_handle = NULL;
+
+	vos_mem_free(wma_handle->interfaces);
+	/* free the wma_handle */
+	vos_free_context(wma_handle->vos_context, VOS_MODULE_ID_WDA, wma_handle);
+
+	adf_os_mem_free(((pVosContextType) vos_ctx)->cfg_ctx);
+	WMA_LOGD("%s: Exit", __func__);
+	return VOS_STATUS_SUCCESS;
+}
+
+
 /* function   : wma_close
  * Descriptin :
  * Args       :
@@ -15813,18 +15844,6 @@ VOS_STATUS wma_close(v_VOID_t *vos_ctx)
 		wma_utf_detach(wma_handle);
 #endif
 
-	/* dettach the wmi serice */
-	if (wma_handle->wmi_handle) {
-		WMA_LOGD("calling wmi_unified_detach");
-		wmi_unified_detach(wma_handle->wmi_handle);
-		wma_handle->wmi_handle = NULL;
-	}
-	vos_mem_free(wma_handle->interfaces);
-	/* free the wma_handle */
-	vos_free_context(wma_handle->vos_context, VOS_MODULE_ID_WDA, wma_handle);
-
-	adf_os_mem_free(((pVosContextType) vos_ctx)->cfg_ctx);
-
 	WMA_LOGD("%s: Exit", __func__);
 	return VOS_STATUS_SUCCESS;
 }
diff --git a/CORE/SERVICES/WMA/wma.h b/CORE/SERVICES/WMA/wma.h
index 53501bc49003..3cda4a9d5c76 100644
--- a/CORE/SERVICES/WMA/wma.h
+++ b/CORE/SERVICES/WMA/wma.h
@@ -430,7 +430,6 @@ struct wma_txrx_node {
 	tANI_U8 rate_flags;
 	tANI_U8 nss;
 	v_BOOL_t is_channel_switch;
-	u_int16_t pause_bitmap;
 };
 
 #if defined(QCA_WIFI_FTM) && !defined(QCA_WIFI_ISOC)
diff --git a/CORE/VOSS/src/vos_api.c b/CORE/VOSS/src/vos_api.c
index 99173e7ae503..041a9e918a75 100644
--- a/CORE/VOSS/src/vos_api.c
+++ b/CORE/VOSS/src/vos_api.c
@@ -1116,6 +1116,15 @@ VOS_STATUS vos_close( v_CONTEXT_t vosContext )
   }
 #endif
 
+  vosStatus = wma_wmi_service_close( vosContext );
+  if (!VOS_IS_STATUS_SUCCESS(vosStatus))
+  {
+     VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
+         "%s: Failed to close wma_wmi_service", __func__);
+     VOS_ASSERT( VOS_IS_STATUS_SUCCESS( vosStatus ) );
+  }
+
+
 #ifndef QCA_WIFI_2_0
   /* Let DXE return packets in WDA_close and then free them here */
   vosStatus = vos_packet_close( vosContext );
diff --git a/Kbuild b/Kbuild
index d1a593f6fa12..87a97d4350fc 100644..100755
--- a/Kbuild
+++ b/Kbuild
@@ -1103,6 +1103,11 @@ CDEFINES += -DQCA_CONFIG_SMP
 endif
 endif
 
+#Open P2P device interface only for non-MDM9630 platform
+ifneq ($(CONFIG_ARCH_MDM9630), y)
+CDEFINES += -DWLAN_OPEN_P2P_INTERFACE
+endif
+
 # Fix build for GCC 4.7
 EXTRA_CFLAGS += -Wno-maybe-uninitialized -Wno-unused-function