wlan: add station and monitor mode concurrency
Currently sta interface cannot operate in parallel with monitor
interface, but, to monitor the traffic of access point to which sta is
connected, there is need of monitor interface operating in parallel and
on the same connected channel.
Therefore, add single channel concurrency for sta and monitor interfaces.
Change-Id: I5107e905d93a0e1b64077a3c189fa580f6fcab4d
CRs-Fixed: 2160352
diff --git a/CORE/HDD/inc/wlan_hdd_main.h b/CORE/HDD/inc/wlan_hdd_main.h
index 9d0a87e..2d65005 100644
--- a/CORE/HDD/inc/wlan_hdd_main.h
+++ b/CORE/HDD/inc/wlan_hdd_main.h
@@ -211,6 +211,9 @@
/* Maximum number of interfaces allowed(STA, P2P Device, P2P Interface) */
#define WLAN_MAX_INTERFACES 3
+/* station and monitor interface */
+#define WLAN_STA_AND_MON_INTERFACES 2
+
#ifdef WLAN_FEATURE_GTK_OFFLOAD
#define GTK_OFFLOAD_ENABLE 0
#define GTK_OFFLOAD_DISABLE 1
@@ -1814,6 +1817,9 @@
/* work queue ecsa channel change on SAP */
struct delayed_work ecsa_chan_change_work;
+ /* used to enable roaming back after monitor mode stop */
+ v_BOOL_t roaming_ini_original;
+
uint32_t track_arp_ip;
};
@@ -2229,4 +2235,49 @@
}
#endif
int hdd_dhcp_mdns_offload(hdd_adapter_t *adapter);
+
+/**
+ * wlan_hdd_stop_mon() - stop monitor mode
+ * @hdd_ctx: pointer to hdd context
+ * @wait: used to wait for completion event from firmware
+ *
+ * Return: 0 - success, negative value -failure
+ */
+int wlan_hdd_stop_mon(hdd_context_t *hdd_ctx, bool wait);
+
+/**
+ * wlan_hdd_check_monitor_state() - check monitor state
+ * @hdd_ctx: pointer to hdd context
+ *
+ * This function is used to check whether capture of monitor mode is ON/OFF
+ *
+ * Return: true - capture is ON, false - capture is OFF
+ */
+bool wlan_hdd_check_monitor_state(hdd_context_t *hdd_ctx);
+
+/**
+ * hdd_disable_roaming() - disable sme roaming
+ * @hdd_ctx: pointer to hdd context
+ *
+ * This function is used to disable FT roaming, one of the use-case
+ * is to disable when monitor mode starts
+ *
+ * Return: None
+ */
+void hdd_disable_roaming(hdd_context_t *hdd_ctx);
+
+/**
+ * hdd_disable_roaming() - enable sme roaming
+ * @hdd_ctx: pointer to hdd context
+ *
+ * This function is used to enable FT roaming, if roaming is enabled before
+ * invocation of hdd_disable_roaming(), one of the use-case is to re-enable
+ * roaming when monitor mode stops
+ *
+ * Return: None
+ */
+void hdd_restore_roaming(hdd_context_t *hdd_ctx);
+
+int wlan_hdd_check_and_stop_mon(hdd_adapter_t *sta_adapter, bool wait);
+
#endif // end #if !defined( WLAN_HDD_MAIN_H )
diff --git a/CORE/HDD/src/wlan_hdd_assoc.c b/CORE/HDD/src/wlan_hdd_assoc.c
index a07f460..71ec1b4 100644
--- a/CORE/HDD/src/wlan_hdd_assoc.c
+++ b/CORE/HDD/src/wlan_hdd_assoc.c
@@ -1537,6 +1537,8 @@
//TxTimeoutCount need to reset in case of disconnect handler
pAdapter->hdd_stats.hddTxRxStats.continuousTxTimeoutCount = 0;
+ wlan_hdd_check_and_stop_mon(pAdapter, false);
+
INIT_COMPLETION(pAdapter->disconnect_comp_var);
/* If only STA mode is on */
if((pHddCtx->concurrency_mode <= 1) &&
@@ -3929,6 +3931,12 @@
#endif
}
break;
+ case eCSR_ROAM_LOSTLINK_DETECTED:
+ {
+ if (wlan_hdd_check_and_stop_mon(pAdapter, false))
+ halStatus = eHAL_STATUS_FAILURE;
+ }
+ break;
case eCSR_ROAM_LOSTLINK:
case eCSR_ROAM_DISASSOCIATED:
{
@@ -4758,6 +4766,9 @@
return -EINVAL;
pRoamProfile = &pWextState->roamProfile;
+ if (wlan_hdd_check_and_stop_mon(pAdapter, true))
+ return -EINVAL;
+
/*Try disconnecting if already in connected state*/
status = wlan_hdd_try_disconnect(pAdapter);
if (0 > status)
diff --git a/CORE/HDD/src/wlan_hdd_cfg80211.c b/CORE/HDD/src/wlan_hdd_cfg80211.c
index f59eeb0..4a6ad59 100644
--- a/CORE/HDD/src/wlan_hdd_cfg80211.c
+++ b/CORE/HDD/src/wlan_hdd_cfg80211.c
@@ -421,24 +421,46 @@
},
};
+/* interface limits for sta + monitor SCC */
+static const struct ieee80211_iface_limit
+wlan_hdd_iface_sta_mon_limit[] = {
+ {
+ .max = 1,
+ .types = BIT(NL80211_IFTYPE_STATION),
+ },
+ {
+ .max = 1, /* Monitor interface */
+ .types = BIT(NL80211_IFTYPE_MONITOR),
+ },
+};
+
/* By default, only single channel concurrency is allowed */
static struct ieee80211_iface_combination
-wlan_hdd_iface_combination = {
- .limits = wlan_hdd_iface_limit,
- .num_different_channels = 1,
- /*
- * max = WLAN_MAX_INTERFACES ; JellyBean architecture creates wlan0
- * and p2p0 interfaces during driver init
- * Some vendors create separate interface for P2P operations.
- * wlan0: STA interface
- * p2p0: P2P Device interface, action frames goes
- * through this interface.
- * p2p-xx: P2P interface, After GO negotiation this interface is
- * created for p2p operations(GO/CLIENT interface).
- */
- .max_interfaces = WLAN_MAX_INTERFACES,
- .n_limits = ARRAY_SIZE(wlan_hdd_iface_limit),
- .beacon_int_infra_match = false,
+wlan_hdd_iface_combination[] = {
+ {
+ .limits = wlan_hdd_iface_limit,
+ .num_different_channels = 1,
+ /*
+ * max = WLAN_MAX_INTERFACES ; JellyBean architecture creates wlan0
+ * and p2p0 interfaces during driver init
+ * Some vendors create separate interface for P2P operations.
+ * wlan0: STA interface
+ * p2p0: P2P Device interface, action frames goes
+ * through this interface.
+ * p2p-xx: P2P interface, After GO negotiation this interface is
+ * created for p2p operations(GO/CLIENT interface).
+ */
+ .max_interfaces = WLAN_MAX_INTERFACES,
+ .n_limits = ARRAY_SIZE(wlan_hdd_iface_limit),
+ .beacon_int_infra_match = false,
+ },
+ {
+ .limits = wlan_hdd_iface_sta_mon_limit,
+ .num_different_channels = 1,
+ .max_interfaces = WLAN_STA_AND_MON_INTERFACES,
+ .n_limits = ARRAY_SIZE(wlan_hdd_iface_sta_mon_limit),
+ .beacon_int_infra_match = false,
+ }
};
#endif
@@ -8945,12 +8967,8 @@
| BIT(NL80211_IFTYPE_ADHOC)
| BIT(NL80211_IFTYPE_P2P_CLIENT)
| BIT(NL80211_IFTYPE_P2P_GO)
- | BIT(NL80211_IFTYPE_AP);
-
- if (VOS_MONITOR_MODE == hdd_get_conparam())
- {
- wiphy->interface_modes |= BIT(NL80211_IFTYPE_MONITOR);
- }
+ | BIT(NL80211_IFTYPE_AP)
+ | BIT(NL80211_IFTYPE_MONITOR);
if( pCfg->advertiseConcurrentOperation )
{
@@ -8958,14 +8976,14 @@
if( pCfg->enableMCC )
{
/* Currently, supports up to two channels */
- wlan_hdd_iface_combination.num_different_channels = 2;
+ wlan_hdd_iface_combination[0].num_different_channels = 2;
if( !pCfg->allowMCCGODiffBI )
- wlan_hdd_iface_combination.beacon_int_infra_match = true;
+ wlan_hdd_iface_combination[0].beacon_int_infra_match = true;
}
- wiphy->iface_combinations = &wlan_hdd_iface_combination;
- wiphy->n_iface_combinations = 1;
+ wiphy->iface_combinations = wlan_hdd_iface_combination;
+ wiphy->n_iface_combinations = ARRAY_SIZE(wlan_hdd_iface_combination);
#endif
}
@@ -11501,6 +11519,12 @@
__func__, hdd_device_modetoString(pAdapter->device_mode),
pAdapter->device_mode);
+ if (pHddCtx->concurrency_mode == VOS_STA_MON) {
+ hddLog(VOS_TRACE_LEVEL_FATAL,
+ "%s: STA + MON is in progress, cannot change interface",
+ __func__);
+ }
+
if (vos_max_concurrent_connections_reached()) {
hddLog(VOS_TRACE_LEVEL_INFO, FL("Reached max concurrent connections"));
return -EINVAL;
@@ -14350,6 +14374,11 @@
return -EOPNOTSUPP;
}
+ if (pAdapter->device_mode == WLAN_HDD_MONITOR) {
+ hddLog(LOGE, FL("Scan is not supported for monitor adapter"));
+ return -EOPNOTSUPP;
+ }
+
if (TRUE == pScanInfo->mScanPending)
{
if ( MAX_PENDING_LOG > pScanInfo->mScanPendingCounter++ )
@@ -16099,6 +16128,9 @@
return status;
}
+ if (wlan_hdd_check_and_stop_mon(pAdapter, true))
+ return -EINVAL;
+
status = wlan_hdd_reassoc_bssid_hint(pAdapter, req);
if (0 == status)
return status;
@@ -16266,6 +16298,8 @@
netif_tx_disable(pAdapter->dev);
netif_carrier_off(pAdapter->dev);
+ wlan_hdd_check_and_stop_mon(pAdapter, true);
+
/*issue disconnect*/
status = sme_RoamDisconnect( WLAN_HDD_GET_HAL_CTX(pAdapter),
pAdapter->sessionId, reason);
diff --git a/CORE/HDD/src/wlan_hdd_main.c b/CORE/HDD/src/wlan_hdd_main.c
index b5b4bd6..de3ccde 100644
--- a/CORE/HDD/src/wlan_hdd_main.c
+++ b/CORE/HDD/src/wlan_hdd_main.c
@@ -3622,6 +3622,13 @@
tANI_U8 *value = command;
tANI_BOOLEAN roamMode = CFG_LFR_FEATURE_ENABLED_DEFAULT;
+ if (pHddCtx->concurrency_mode == VOS_STA_MON) {
+ hddLog(LOGE,
+ FL("Roaming is always disabled in STA + MON concurrency"));
+ ret = -EINVAL;
+ goto exit;
+ }
+
ret = hdd_drv_cmd_validate(command, SIZE_OF_SETROAMMODE);
if (ret)
goto exit;
@@ -4513,6 +4520,13 @@
tANI_U8 *value = command;
tANI_U8 lfrMode = CFG_LFR_FEATURE_ENABLED_DEFAULT;
+ if (pHddCtx->concurrency_mode == VOS_STA_MON) {
+ hddLog(LOGE,
+ FL("Roaming is always disabled in STA + MON concurrency"));
+ ret = -EINVAL;
+ goto exit;
+ }
+
ret = hdd_drv_cmd_validate(command, 11);
if (ret)
goto exit;
@@ -7302,6 +7316,8 @@
int __hdd_mon_open (struct net_device *dev)
{
hdd_adapter_t *pAdapter = WLAN_HDD_GET_PRIV_PTR(dev);
+ hdd_adapter_t *sta_adapter;
+ hdd_context_t *hdd_ctx;
if(pAdapter == NULL) {
VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_FATAL,
@@ -7309,6 +7325,26 @@
return -EINVAL;
}
+ if (vos_get_concurrency_mode() != VOS_STA_MON)
+ return 0;
+
+ hdd_ctx = WLAN_HDD_GET_CTX(pAdapter);
+ if (wlan_hdd_validate_context(hdd_ctx))
+ return -EINVAL;
+
+ sta_adapter = hdd_get_adapter(hdd_ctx, WLAN_HDD_INFRA_STATION);
+ if (!sta_adapter) {
+ hddLog(LOGE, FL("No valid STA interface"));
+ return -EINVAL;
+ }
+
+ if (!test_bit(DEVICE_IFACE_OPENED, &sta_adapter->event_flags)) {
+ hddLog(LOGE, FL("STA Interface is not OPENED"));
+ return -EINVAL;
+ }
+
+ set_bit(DEVICE_IFACE_OPENED, &pAdapter->event_flags);
+
return 0;
}
@@ -7323,9 +7359,43 @@
return ret;
}
+int __hdd_mon_stop (struct net_device *dev)
+{
+ hdd_adapter_t *mon_adapter = WLAN_HDD_GET_PRIV_PTR(dev);
+ hdd_context_t *hdd_ctx;
+
+ if (vos_get_concurrency_mode() != VOS_STA_MON)
+ return 0;
+
+ if(!mon_adapter) {
+ hddLog(LOGE, FL("HDD adapter is Null"));
+ return -EINVAL;
+ }
+
+ hdd_ctx = WLAN_HDD_GET_CTX(mon_adapter);
+ if (wlan_hdd_validate_context(hdd_ctx))
+ return -EINVAL;
+
+ if (!test_bit(DEVICE_IFACE_OPENED, &mon_adapter->event_flags)) {
+ hddLog(LOGE, FL("NETDEV Interface is not OPENED"));
+ return -ENODEV;
+ }
+
+ clear_bit(DEVICE_IFACE_OPENED, &mon_adapter->event_flags);
+ hdd_stop_adapter(hdd_ctx, mon_adapter, VOS_FALSE);
+
+ return 0;
+}
+
int hdd_mon_stop(struct net_device *dev)
{
- return 0;
+ int ret;
+
+ vos_ssr_protect(__func__);
+ ret = __hdd_mon_stop(dev);
+ vos_ssr_unprotect(__func__);
+
+ return ret;
}
/**---------------------------------------------------------------------------
@@ -7372,6 +7442,26 @@
return -ENODEV;
}
+ if (pHddCtx->concurrency_mode == VOS_STA_MON) {
+ hdd_adapter_t *mon_adapter = hdd_get_adapter(pHddCtx, WLAN_HDD_MONITOR);
+ if (!mon_adapter) {
+ hddLog(LOGE,
+ FL("No valid monitor interface in STA + MON concurrency"));
+ return -EINVAL;
+ }
+
+ /*
+ * In STA + Monitor mode concurrency, no point in enabling
+ * monitor interface, when STA interface is stopped
+ */
+ ret = hdd_mon_stop(mon_adapter->dev);
+ if (ret) {
+ hddLog(LOGE,
+ FL("Failed to stop Monitor interface in STA + MON concurrency"));
+ return ret;
+ }
+ }
+
/* Make sure the interface is marked as closed */
clear_bit(DEVICE_IFACE_OPENED, &pAdapter->event_flags);
hddLog(VOS_TRACE_LEVEL_INFO, "%s: Disabling OS Tx queues", __func__);
@@ -7406,7 +7496,6 @@
/* SoftAP ifaces should never go in power save mode
making sure same here. */
if ( (WLAN_HDD_SOFTAP == pAdapter->device_mode )
- || (WLAN_HDD_MONITOR == pAdapter->device_mode )
|| (WLAN_HDD_P2P_GO == pAdapter->device_mode )
)
{
@@ -8663,6 +8752,12 @@
hddLog( LOGE, FL("Wlan Unload in progress"));
return VOS_STATUS_E_PERM;
}
+
+ if (wlan_hdd_check_monitor_state(pHddCtx)) {
+ hddLog(LOG1, FL("Monitor mode is started, cannot enable BMPS"));
+ return VOS_STATUS_SUCCESS;
+ }
+
if(pHddCtx->cfg_ini->fIsBmpsEnabled)
{
sme_EnablePowerSave(pHddCtx->hHal, ePMC_BEACON_MODE_POWER_SAVE);
@@ -8836,6 +8931,12 @@
hdd_adapter_list_node_t *pHddAdapterNode = NULL;
VOS_STATUS status = VOS_STATUS_E_FAILURE;
VOS_STATUS exitbmpsStatus;
+ v_CONTEXT_t pVosContext = NULL;
+
+ /* No need to check for NULL, reaching this step
+ * means vos context is initialized
+ */
+ pVosContext = vos_get_global_context(VOS_MODULE_ID_SYS, NULL);
hddLog(VOS_TRACE_LEVEL_INFO_HIGH, "%s iface =%s type = %d",__func__,iface_name,session_type);
@@ -8995,6 +9096,9 @@
return NULL;
}
+ pAdapter->device_mode = session_type;
+ pAdapter->wdev.iftype = NL80211_IFTYPE_MONITOR;
+
// Register wireless extensions
if( VOS_STATUS_SUCCESS != (status = hdd_register_wext(pAdapter->dev)))
{
@@ -9004,8 +9108,6 @@
status = VOS_STATUS_E_FAILURE;
}
- pAdapter->wdev.iftype = NL80211_IFTYPE_MONITOR;
- pAdapter->device_mode = session_type;
#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,29)
pAdapter->dev->netdev_ops = &wlan_mon_drv_ops;
#else
@@ -9014,11 +9116,15 @@
pAdapter->dev->stop = hdd_mon_stop;
pAdapter->dev->do_ioctl = hdd_mon_ioctl;
#endif
- status = hdd_register_interface( pAdapter, rtnl_held );
hdd_init_mon_mode( pAdapter );
hdd_initialize_adapter_common(pAdapter);
hdd_init_tx_rx( pAdapter );
+
+ if (VOS_MONITOR_MODE != hdd_get_conparam())
+ WLANTL_SetMonRxCbk( pVosContext, hdd_rx_packet_monitor_cbk );
+
set_bit(INIT_TX_RX_SUCCESS, &pAdapter->event_flags);
+ status = hdd_register_interface( pAdapter, rtnl_held );
//Stop the Interface TX queue.
netif_tx_disable(pAdapter->dev);
netif_carrier_off(pAdapter->dev);
@@ -9247,6 +9353,135 @@
return VOS_STATUS_SUCCESS;
}
+int wlan_hdd_stop_mon(hdd_context_t *hdd_ctx, bool wait)
+{
+ hdd_mon_ctx_t *mon_ctx;
+ long ret;
+ v_U32_t magic;
+ struct completion cmp_var;
+ void (*func_ptr)(tANI_U32 *magic, struct completion *cmpVar) = NULL;
+ hdd_adapter_t *adapter;
+
+ adapter = hdd_get_adapter(hdd_ctx, WLAN_HDD_MONITOR);
+ if (!adapter) {
+ hddLog(LOGE, FL("Invalid STA + MON mode"));
+ return -EINVAL;
+ }
+
+ mon_ctx = WLAN_HDD_GET_MONITOR_CTX_PTR(adapter);
+ if (!mon_ctx)
+ return 0;
+
+ if (mon_ctx->state != MON_MODE_START)
+ return 0;
+
+ mon_ctx->state = MON_MODE_STOP;
+ if (wait) {
+ func_ptr = hdd_monPostMsgCb;
+ magic = MON_MODE_MSG_MAGIC;
+ init_completion(&cmp_var);
+ }
+
+ if (VOS_STATUS_SUCCESS != wlan_hdd_mon_postMsg(&magic, &cmp_var,
+ mon_ctx,
+ hdd_monPostMsgCb)) {
+ hddLog(LOGE, FL("failed to stop MON MODE"));
+ mon_ctx->state = MON_MODE_START;
+ magic = 0;
+ return -EINVAL;
+ }
+
+ if (!wait)
+ goto bmps_roaming;
+
+ ret = wait_for_completion_timeout(&cmp_var, MON_MODE_MSG_TIMEOUT);
+ magic = 0;
+ if (ret <= 0 ) {
+ hddLog(LOGE,
+ FL("timeout on stop monitor mode completion %ld"), ret);
+ return -EINVAL;
+ }
+
+bmps_roaming:
+ hddLog(LOG1, FL("Enable BMPS"));
+ hdd_enable_bmps_imps(hdd_ctx);
+ hdd_restore_roaming(hdd_ctx);
+
+ return 0;
+}
+
+bool wlan_hdd_check_monitor_state(hdd_context_t *hdd_ctx)
+{
+ hdd_adapter_t *mon_adapter;
+ hdd_mon_ctx_t *mon_ctx;
+
+ if (hdd_ctx->concurrency_mode != VOS_STA_MON)
+ return false;
+
+ mon_adapter = hdd_get_adapter(hdd_ctx, WLAN_HDD_MONITOR);
+ if (!mon_adapter) {
+ hddLog(LOGE, FL("Invalid concurrency mode"));
+ return false;
+ }
+
+ mon_ctx = WLAN_HDD_GET_MONITOR_CTX_PTR(mon_adapter);
+ if (mon_ctx->state == MON_MODE_START)
+ return true;
+
+ return false;
+}
+
+int wlan_hdd_check_and_stop_mon(hdd_adapter_t *sta_adapter, bool wait)
+{
+ hdd_context_t *hdd_ctx = WLAN_HDD_GET_CTX(sta_adapter);
+
+ if ((sta_adapter->device_mode != WLAN_HDD_INFRA_STATION) ||
+ !wlan_hdd_check_monitor_state(hdd_ctx))
+ return 0;
+
+ if (wlan_hdd_stop_mon(hdd_ctx, wait))
+ return -EINVAL;
+
+ return 0;
+}
+
+void hdd_disable_roaming(hdd_context_t *hdd_ctx)
+{
+ if (!hdd_ctx)
+ return;
+
+ if (!hdd_ctx->cfg_ini->isFastRoamIniFeatureEnabled) {
+ hdd_ctx->roaming_ini_original = CFG_LFR_FEATURE_ENABLED_MIN;
+ return;
+ }
+
+ hddLog(LOG1, FL("Disable driver and firmware roaming"));
+
+ hdd_ctx->roaming_ini_original =
+ hdd_ctx->cfg_ini->isFastRoamIniFeatureEnabled;
+
+ hdd_ctx->cfg_ini->isFastRoamIniFeatureEnabled =
+ CFG_LFR_FEATURE_ENABLED_MIN;
+
+ sme_UpdateIsFastRoamIniFeatureEnabled(hdd_ctx->hHal,
+ CFG_LFR_FEATURE_ENABLED_MIN);
+}
+
+void hdd_restore_roaming(hdd_context_t *hdd_ctx)
+{
+ if (!hdd_ctx->roaming_ini_original)
+ return;
+
+ hddLog(LOG1, FL("Enable driver and firmware roaming"));
+
+ hdd_ctx->cfg_ini->isFastRoamIniFeatureEnabled =
+ CFG_LFR_FEATURE_ENABLED_MAX;
+
+ hdd_ctx->roaming_ini_original = CFG_LFR_FEATURE_ENABLED_MIN;
+
+ sme_UpdateIsFastRoamIniFeatureEnabled(hdd_ctx->hHal,
+ CFG_LFR_FEATURE_ENABLED_MAX);
+}
VOS_STATUS hdd_stop_adapter( hdd_context_t *pHddCtx, hdd_adapter_t *pAdapter,
const v_BOOL_t bCloseSession )
@@ -9504,7 +9739,9 @@
break;
case WLAN_HDD_MONITOR:
- break;
+ if (VOS_MONITOR_MODE != hdd_get_conparam())
+ wlan_hdd_stop_mon(pHddCtx, true);
+ break;
default:
break;
@@ -9821,6 +10058,7 @@
}
pAdapter->sessionCtx.station.hdd_ReassocScenario = VOS_FALSE;
+ pAdapter->sessionCtx.monitor.state = MON_MODE_STOP;
hdd_deinit_tx_rx(pAdapter);
@@ -10930,9 +11168,13 @@
wlan_hdd_init_deinit_defer_scan_context(&pHddCtx->scan_ctxt);
if (WLAN_HDD_INFRA_STATION == pAdapter->device_mode ||
- WLAN_HDD_P2P_CLIENT == pAdapter->device_mode)
+ WLAN_HDD_P2P_CLIENT == pAdapter->device_mode ||
+ WLAN_HDD_MONITOR == pAdapter->device_mode)
{
- wlan_hdd_cfg80211_deregister_frames(pAdapter);
+ if (WLAN_HDD_INFRA_STATION == pAdapter->device_mode ||
+ WLAN_HDD_P2P_CLIENT == pAdapter->device_mode)
+ wlan_hdd_cfg80211_deregister_frames(pAdapter);
+
hdd_UnregisterWext(pAdapter->dev);
}
@@ -13863,6 +14105,7 @@
case VOS_P2P_CLIENT_MODE:
case VOS_P2P_GO_MODE:
case VOS_STA_SAP_MODE:
+ case VOS_MONITOR_MODE:
pHddCtx->concurrency_mode |= (1 << mode);
pHddCtx->no_of_open_sessions[mode]++;
break;
@@ -13884,6 +14127,7 @@
case VOS_P2P_CLIENT_MODE:
case VOS_P2P_GO_MODE:
case VOS_STA_SAP_MODE:
+ case VOS_MONITOR_MODE:
pHddCtx->no_of_open_sessions[mode]--;
if (!(pHddCtx->no_of_open_sessions[mode]))
pHddCtx->concurrency_mode &= (~(1 << mode));
@@ -13918,6 +14162,7 @@
case VOS_P2P_CLIENT_MODE:
case VOS_P2P_GO_MODE:
case VOS_STA_SAP_MODE:
+ case VOS_MONITOR_MODE:
pHddCtx->no_of_active_sessions[mode]++;
break;
default:
@@ -13952,6 +14197,7 @@
case VOS_P2P_CLIENT_MODE:
case VOS_P2P_GO_MODE:
case VOS_STA_SAP_MODE:
+ case VOS_MONITOR_MODE:
if (pHddCtx->no_of_active_sessions[mode] > 0)
pHddCtx->no_of_active_sessions[mode]--;
else
diff --git a/CORE/HDD/src/wlan_hdd_p2p.c b/CORE/HDD/src/wlan_hdd_p2p.c
index 67c4820..eb2d98c 100644
--- a/CORE/HDD/src/wlan_hdd_p2p.c
+++ b/CORE/HDD/src/wlan_hdd_p2p.c
@@ -2140,6 +2140,119 @@
return sessionType;
}
+/**
+ * hdd_close_all_adapters_per_mode() - close all adapters per mode
+ * @hdd_ctx: pointer to hdd context
+ * @mode: all adapters to be deleted in this mode
+ *
+ * Return: None
+ */
+static void
+hdd_close_all_adapters_per_mode(hdd_context_t *hdd_ctx,
+ uint32_t mode)
+{
+ hdd_adapter_t *adapter = hdd_get_adapter(hdd_ctx, mode);
+
+ while (adapter) {
+ hdd_stop_adapter(hdd_ctx, adapter, VOS_TRUE);
+ hdd_deinit_adapter(hdd_ctx, adapter, TRUE);
+ hdd_close_adapter(hdd_ctx, adapter, VOS_TRUE);
+
+ adapter = hdd_get_adapter(hdd_ctx, mode);
+ }
+}
+
+static void wlan_hdd_create_p2p_adapter(hdd_context_t *hdd_ctx,
+ tANI_U8 rtnl_held)
+{
+ hdd_adapter_t *p2p_adapter;
+
+ p2p_adapter = hdd_open_adapter(hdd_ctx, WLAN_HDD_P2P_DEVICE, "p2p%d",
+ &hdd_ctx->p2pDeviceAddress.bytes[0],
+ rtnl_held);
+ if (!p2p_adapter)
+ hddLog(LOGE,
+ FL("Failed to do hdd_open_adapter for P2P Device Interface"));
+}
+
+/**
+ * wlan_hdd_add_monitor_check() - check for monitor intf and add if needed
+ * @hdd_ctx: pointer to hdd context
+ * @adapter: output pointer to hold created monitor adapter
+ * @type: type of the interface
+ * @name: name of the interface
+ *
+ * Return: 0 - on success
+ * 1 - on failure
+ */
+static int
+wlan_hdd_add_monitor_check(hdd_context_t *hdd_ctx, hdd_adapter_t **adapter,
+ enum nl80211_iftype type, const char *name)
+{
+ hdd_adapter_t *sta_adapter;
+ hdd_adapter_t *mon_adapter;
+ uint32_t i;
+
+ *adapter = NULL;
+
+ /*
+ * If add interface request is for monitor mode, then it can run in
+ * parallel with only one station interface.
+ * If there is no existing station interface return error
+ */
+ if (type != NL80211_IFTYPE_MONITOR)
+ return 0;
+
+ if (!sme_IsFeatureSupportedByFW(STA_MONITOR_SCC)) {
+ hddLog(LOGE, FL("No FW support for STA + MON SCC"));
+ return -EINVAL;
+ }
+
+ if (hdd_ctx->no_of_open_sessions[VOS_MONITOR_MODE]) {
+ hddLog(VOS_TRACE_LEVEL_ERROR,
+ "%s: monitor mode already exists, only one is possible",
+ __func__);
+
+ return -EBUSY;
+ }
+
+ /* Ensure there is only one station interface */
+ if (hdd_ctx->no_of_open_sessions[VOS_STA_MODE] != 1) {
+ hddLog(LOGE,
+ FL("cannot add monitor mode, due to %u sta interfaces"),
+ hdd_ctx->no_of_open_sessions[VOS_STA_MODE]);
+
+ return -EINVAL;
+ }
+
+ sta_adapter = hdd_get_adapter(hdd_ctx, WLAN_HDD_INFRA_STATION);
+ if (!sta_adapter) {
+ hddLog(LOGE, FL("No station adapter"));
+ return -EINVAL;
+ }
+
+ /* delete all the other interfaces */
+ for (i = VOS_STA_SAP_MODE; i <= VOS_P2P_DEVICE; i++) {
+ if (i == VOS_FTM_MODE || i == VOS_MONITOR_MODE)
+ continue;
+
+ hdd_close_all_adapters_per_mode(hdd_ctx, i);
+ }
+
+ mon_adapter = hdd_open_adapter(hdd_ctx, WLAN_HDD_MONITOR, name,
+ wlan_hdd_get_intf_addr(hdd_ctx),
+ VOS_TRUE);
+ if (!mon_adapter) {
+ hddLog(VOS_TRACE_LEVEL_ERROR,"%s: hdd_open_adapter failed",
+ __func__);
+ wlan_hdd_create_p2p_adapter(hdd_ctx, TRUE);
+ return -EINVAL;
+ }
+
+ *adapter = mon_adapter;
+ return 0;
+}
+
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,7,0))
struct wireless_dev* __wlan_hdd_add_virtual_intf(
struct wiphy *wiphy, const char *name,
@@ -2191,6 +2304,17 @@
#endif
}
+ if (pHddCtx->concurrency_mode == VOS_STA_MON) {
+ hddLog(VOS_TRACE_LEVEL_ERROR,
+ "%s: STA + MONITOR mode is in progress, cannot add new interface",
+ __func__);
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,38))
+ return ERR_PTR(-EINVAL);
+#else
+ return -EBUSY;
+#endif
+ }
+
pAdapter = hdd_get_adapter(pHddCtx, WLAN_HDD_INFRA_STATION);
pScanInfo = &pHddCtx->scan_info;
if ((pScanInfo != NULL) && (pAdapter != NULL) &&
@@ -2202,6 +2326,18 @@
"%s: Abort Scan while adding virtual interface",__func__);
}
+ ret = wlan_hdd_add_monitor_check(pHddCtx, &pAdapter, type, name);
+ if (ret) {
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,38))
+ return ERR_PTR(-EINVAL);
+#else
+ return ret;
+#endif
+ }
+
+ if (pAdapter)
+ goto return_adapter;
+
pAdapter = NULL;
if (pHddCtx->cfg_ini->isP2pDeviceAddrAdministrated &&
((NL80211_IFTYPE_P2P_GO == type) ||
@@ -2245,6 +2381,8 @@
hdd_tdls_notify_mode_change(pAdapter, pHddCtx);
}
+return_adapter:
+
EXIT();
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,6,0))
return pAdapter->dev->ieee80211_ptr;
@@ -2297,6 +2435,54 @@
#endif
}
+/**
+ * hdd_delete_adapter() - stop and close adapter
+ * @hdd_ctx: pointer to hdd context
+ * @adapter: adapter to be deleted
+ * @rtnl_held: rtnl lock held
+ *
+ * Rerurn: None
+ */
+static void
+hdd_delete_adapter(hdd_context_t *hdd_ctx, hdd_adapter_t *adapter,
+ tANI_U8 rtnl_held)
+{
+ wlan_hdd_release_intf_addr(hdd_ctx, adapter->macAddressCurrent.bytes);
+ hdd_stop_adapter(hdd_ctx, adapter, VOS_TRUE);
+ hdd_close_adapter(hdd_ctx, adapter, rtnl_held);
+}
+
+/**
+ * wlan_hdd_del_monitor() - delete monitor interface
+ * @hdd_ctx: pointer to hdd context
+ * @adapter: adapter to be deleted
+ * @rtnl_held: rtnl lock held
+ *
+ * This function is invoked to delete monitor interface and also
+ * station interface if needed.
+ *
+ * Return: None
+ */
+static void
+wlan_hdd_del_monitor(hdd_context_t *hdd_ctx, hdd_adapter_t *adapter,
+ tANI_U8 rtnl_held)
+{
+ hdd_adapter_t *monitor_adapter;
+ bool delete_station = false;
+
+ monitor_adapter = hdd_get_adapter(hdd_ctx, WLAN_HDD_MONITOR);
+ if (monitor_adapter != adapter)
+ delete_station = true;
+
+ /* delete the monitor adapter and re-create the p2p-dev adapter */
+ hdd_delete_adapter(hdd_ctx, monitor_adapter, rtnl_held);
+
+ wlan_hdd_create_p2p_adapter(hdd_ctx, rtnl_held);
+
+ if (delete_station)
+ hdd_delete_adapter(hdd_ctx, adapter, rtnl_held);
+}
+
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,6,0))
int __wlan_hdd_del_virtual_intf( struct wiphy *wiphy, struct wireless_dev *wdev )
#else
@@ -2308,7 +2494,6 @@
#endif
hdd_context_t *pHddCtx = (hdd_context_t*) wiphy_priv(wiphy);
hdd_adapter_t *pAdapter = WLAN_HDD_GET_PRIV_PTR( dev );
- hdd_adapter_t *pVirtAdapter = WLAN_HDD_GET_PRIV_PTR(dev);
int status;
ENTER();
@@ -2317,7 +2502,7 @@
TRACE_CODE_HDD_DEL_VIRTUAL_INTF,
pAdapter->sessionId, pAdapter->device_mode));
hddLog(VOS_TRACE_LEVEL_INFO, "%s: device_mode = %d",
- __func__,pVirtAdapter->device_mode);
+ __func__,pAdapter->device_mode);
status = wlan_hdd_validate_context(pHddCtx);
@@ -2326,11 +2511,11 @@
return status;
}
- wlan_hdd_release_intf_addr( pHddCtx,
- pVirtAdapter->macAddressCurrent.bytes );
+ if (pHddCtx->concurrency_mode == VOS_STA_MON)
+ wlan_hdd_del_monitor(pHddCtx, pAdapter, TRUE);
+ else
+ hdd_delete_adapter(pHddCtx, pAdapter, TRUE);
- hdd_stop_adapter( pHddCtx, pVirtAdapter, VOS_TRUE);
- hdd_close_adapter( pHddCtx, pVirtAdapter, TRUE );
EXIT();
return 0;
}
diff --git a/CORE/HDD/src/wlan_hdd_wext.c b/CORE/HDD/src/wlan_hdd_wext.c
index 6174878..61f5abd 100644
--- a/CORE/HDD/src/wlan_hdd_wext.c
+++ b/CORE/HDD/src/wlan_hdd_wext.c
@@ -5700,6 +5700,166 @@
return ret;
}
+static int
+wlan_hdd_sta_mon_op(hdd_context_t *hdd_ctx, uint32_t set_value,
+ hdd_adapter_t *mon_adapter, hdd_mon_ctx_t *mon_ctx)
+{
+ hdd_station_ctx_t *sta_ctx;
+ VOS_STATUS disable_bmps_status;
+ hdd_adapter_t *sta_adapter;
+ v_CONTEXT_t vos_ctx = (WLAN_HDD_GET_CTX(mon_adapter))->pvosContext;
+
+ if (!test_bit(DEVICE_IFACE_OPENED, &mon_adapter->event_flags)) {
+ hddLog(LOGE, FL("Monitor Interface is not OPENED"));
+ return -EINVAL;
+ }
+
+ if (set_value == MON_MODE_STOP) {
+ if (wlan_hdd_check_monitor_state(hdd_ctx))
+ return 0;
+ return -EINVAL;
+ }
+
+ sta_adapter = hdd_get_adapter(hdd_ctx, WLAN_HDD_INFRA_STATION);
+ if (!sta_adapter) {
+ hddLog(LOGE, FL("No Station adapter"));
+ return -EINVAL;
+ }
+
+ sta_ctx = WLAN_HDD_GET_STATION_CTX_PTR(sta_adapter);
+ if (!sta_ctx || !hdd_connIsConnected(sta_ctx)) {
+ hddLog(LOGE, FL("STA is not connected"));
+ return -EINVAL;
+ }
+
+ if (hdd_isConnectionInProgress(hdd_ctx, NULL, NULL)) {
+ hddLog(LOGE, FL("Roaming or set-key is in progress"));
+ return -EBUSY;
+ }
+
+ hdd_disable_roaming(hdd_ctx);
+
+ hddLog(LOG1, FL("Disable BMPS"));
+ disable_bmps_status = hdd_disable_bmps_imps(hdd_ctx,
+ WLAN_HDD_INFRA_STATION);
+ if (disable_bmps_status != VOS_STATUS_SUCCESS) {
+ hddLog(LOGE, FL("Cannot start monitor mode"));
+ hdd_restore_roaming(hdd_ctx);
+ return -EINVAL;
+ }
+
+ mon_ctx->ChannelNo = sta_ctx->conn_info.operationChannel;
+
+ /*
+ * In STA + Mon mode, firmware should not consider ChannelBW
+ */
+ mon_ctx->ChannelBW = 0;
+ mon_ctx->crcCheckEnabled = 0;
+ wlan_hdd_mon_set_typesubtype(mon_ctx, 100);
+ mon_ctx->is80211to803ConReq = 0;
+ WLANTL_SetIsConversionReq(vos_ctx, 0);
+ mon_adapter->dev->type = ARPHRD_IEEE80211_RADIOTAP;
+
+ mon_ctx->state = MON_MODE_START;
+ return 0;
+}
+
+/* set param sub-ioctls */
+static int __iw_mon_setint_getnone(struct net_device *dev,
+ struct iw_request_info *info,
+ union iwreq_data *wrqu, char *extra)
+{
+ hdd_adapter_t *adapter;
+ hdd_context_t *hdd_ctx;
+ hdd_mon_ctx_t *mon_ctx;
+ int *value = (int *)extra;
+ int sub_cmd = value[0];
+ int set_value = value[1];
+ int ret = 0; /* success */
+ tVOS_CONCURRENCY_MODE concurrency_mode;
+
+ ENTER();
+ adapter = WLAN_HDD_GET_PRIV_PTR(dev);
+ if (!adapter || adapter->device_mode != WLAN_HDD_MONITOR)
+ return -EINVAL;
+
+ hdd_ctx = WLAN_HDD_GET_CTX(adapter);
+ ret = wlan_hdd_validate_context(hdd_ctx);
+ if (ret)
+ return ret;
+
+ concurrency_mode = hdd_ctx->concurrency_mode;
+ if (concurrency_mode != VOS_STA_MON) {
+ hddLog(LOGE, "invalid concurrency mode %d", concurrency_mode);
+ return -EINVAL;
+ }
+
+ switch(sub_cmd) {
+
+ case WE_SET_MONITOR_STATE:
+ {
+ v_U32_t magic = 0;
+ struct completion cmp_var;
+ long waitRet = 0;
+
+ mon_ctx = WLAN_HDD_GET_MONITOR_CTX_PTR(adapter);
+ if(!mon_ctx) {
+ hddLog(LOGE, "Monitor Context NULL");
+ ret = -EIO;
+ break;
+ }
+
+ if (mon_ctx->state == set_value) {
+ hddLog(LOGE, FL("already in same mode curr_mode:%d req_mode: %d"),
+ mon_ctx->state, set_value);
+ break;
+ }
+
+ ret = wlan_hdd_sta_mon_op(hdd_ctx, set_value,
+ adapter,mon_ctx);
+ if (ret)
+ break;
+
+ mon_ctx->state = set_value;
+ magic = MON_MODE_MSG_MAGIC;
+ init_completion(&cmp_var);
+ if (wlan_hdd_mon_postMsg(&magic, &cmp_var, mon_ctx,
+ hdd_monPostMsgCb) != VOS_STATUS_SUCCESS) {
+ hddLog(LOGE, FL("failed to post MON MODE REQ"));
+ mon_ctx->state =
+ (mon_ctx->state==MON_MODE_START) ?
+ MON_MODE_STOP : MON_MODE_START;
+ magic = 0;
+ ret = -EIO;
+ break;
+ }
+
+ waitRet = wait_for_completion_timeout(&cmp_var,
+ MON_MODE_MSG_TIMEOUT);
+ magic = 0;
+ if (waitRet <= 0 ){
+ hddLog(LOGE, FL("failed to wait on monitor mode completion %ld"),
+ waitRet);
+ } else if (mon_ctx->state == MON_MODE_STOP) {
+ hddLog(LOG1, FL("Enable BMPS"));
+ hdd_enable_bmps_imps(hdd_ctx);
+ hdd_restore_roaming(hdd_ctx);
+ }
+ }
+ break;
+
+ default:
+ {
+ hddLog(LOGE, "Invalid IOCTL setvalue command %d value %d",
+ sub_cmd, set_value);
+ }
+ break;
+ }
+
+ EXIT();
+ return ret;
+}
+
/* set param sub-ioctls */
static int __iw_setint_getnone(struct net_device *dev,
struct iw_request_info *info,
@@ -5802,6 +5962,12 @@
}
case WE_SET_POWER:
{
+ if (wlan_hdd_check_monitor_state(pHddCtx)) {
+ hddLog(LOGE, FL("setPower not allowed in STA + MON"));
+ ret = -EOPNOTSUPP;
+ break;
+ }
+
switch (set_value)
{
case 0: //Full Power
@@ -6440,6 +6606,21 @@
return 0;
}
+
+static
+int iw_mon_setint_getnone(struct net_device *dev,
+ struct iw_request_info *info,
+ union iwreq_data *wrqu, char *extra)
+{
+ int ret;
+
+ vos_ssr_protect(__func__);
+ ret = __iw_mon_setint_getnone(dev, info, wrqu, extra);
+ vos_ssr_unprotect(__func__);
+
+ return 0;
+}
+
/* set param sub-ioctls */
static int __iw_setchar_getnone(struct net_device *dev,
struct iw_request_info *info,
@@ -6515,10 +6696,22 @@
switch(sub_cmd)
{
case WE_WOWL_ADD_PTRN:
+ if (wlan_hdd_check_monitor_state(pHddCtx)) {
+ hddLog(LOGE, FL("wowlAddPtrn not allowed in STA + MON"));
+ ret = -EOPNOTSUPP;
+ break;
+ }
+
VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO, "ADD_PTRN");
hdd_add_wowl_ptrn(pAdapter, pBuffer);
break;
case WE_WOWL_DEL_PTRN:
+ if (wlan_hdd_check_monitor_state(pHddCtx)) {
+ hddLog(LOGE, FL("wowlDelPtrn not allowed in STA + MON"));
+ ret = -EOPNOTSUPP;
+ break;
+ }
+
VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO, "DEL_PTRN");
hdd_del_wowl_ptrn(pAdapter, pBuffer);
break;
@@ -7593,6 +7786,12 @@
"adapter and try again\n");
break;
}
+
+ if (wlan_hdd_check_monitor_state(pHddCtx)) {
+ hddLog(LOGE, FL("initAP not allowed in STA + MON"));
+ ret = -EOPNOTSUPP;
+ break;
+ }
pr_info("Init AP trigger\n");
hdd_open_adapter( WLAN_HDD_GET_CTX(pAdapter), WLAN_HDD_SOFTAP, "softap.%d",
wlan_hdd_get_intf_addr( WLAN_HDD_GET_CTX(pAdapter) ),TRUE);
@@ -11176,6 +11375,20 @@
[WLAN_GET_LINK_SPEED - SIOCIWFIRSTPRIV] = iw_get_linkspeed_priv,
};
+static const iw_handler we_mon_private[] = {
+ [WLAN_PRIV_SET_INT_GET_NONE - SIOCIWFIRSTPRIV] =
+ iw_mon_setint_getnone,
+};
+
+static const struct iw_priv_args we_mon_private_args[] = {
+ {WE_SET_MONITOR_STATE, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
+ 0, "monitor"},
+
+ /* handlers for main ioctl */
+ {WLAN_PRIV_SET_INT_GET_NONE, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
+ 0, "" },
+};
+
/*Maximum command length can be only 15 */
static const struct iw_priv_args we_private_args[] = {
@@ -11785,6 +11998,17 @@
.get_wireless_stats = get_wireless_stats,
};
+const struct iw_handler_def we_mon_handler_def = {
+ .num_standard = 0,
+ .num_private = sizeof(we_mon_private) / sizeof(we_mon_private[0]),
+ .num_private_args =
+ sizeof(we_mon_private_args) / sizeof(we_mon_private_args[0]),
+ .standard = NULL,
+ .private = (iw_handler *)we_mon_private,
+ .private_args = we_mon_private_args,
+ .get_wireless_stats = NULL,
+};
+
int hdd_validate_mcc_config(hdd_adapter_t *pAdapter, v_UINT_t staId, v_UINT_t arg1, v_UINT_t arg2, v_UINT_t arg3)
{
v_U32_t cmd = 288; //Command to RIVA
@@ -12012,6 +12236,13 @@
ENTER();
+ if (pAdapter->device_mode == WLAN_HDD_MONITOR &&
+ hdd_get_conparam() != VOS_MONITOR_MODE) {
+ // Register as a wireless device
+ dev->wireless_handlers = (struct iw_handler_def *)&we_mon_handler_def;
+ return 0;
+ }
+
// Zero the memory. This zeros the profile structure.
memset(pwextBuf, 0,sizeof(hdd_wext_state_t));
diff --git a/CORE/MAC/src/include/sirParams.h b/CORE/MAC/src/include/sirParams.h
index 98f5107..b1bd9c0 100644
--- a/CORE/MAC/src/include/sirParams.h
+++ b/CORE/MAC/src/include/sirParams.h
@@ -158,6 +158,7 @@
FATAL_EVENT_LOGGING = 69,
/*70 reserved for WIFI_DUAL_BAND_ENABLE */
PROBE_RSP_TEMPLATE_VER1 = 71,
+ STA_MONITOR_SCC = 72,
//MAX_FEATURE_SUPPORTED = 128
} placeHolderInCapBitmap;
diff --git a/CORE/MAC/src/pe/lim/limProcessAuthFrame.c b/CORE/MAC/src/pe/lim/limProcessAuthFrame.c
index 321658c..3112f7b 100644
--- a/CORE/MAC/src/pe/lim/limProcessAuthFrame.c
+++ b/CORE/MAC/src/pe/lim/limProcessAuthFrame.c
@@ -1858,6 +1858,16 @@
pBody = WDA_GET_RX_MPDU_DATA(pBd);
frameLen = WDA_GET_RX_PAYLOAD_LEN(pBd);
+ /*
+ * since, roaming is not supported in sta + mon scc, ignore
+ * pre-auth when capture on monitor mode is started
+ */
+ if (vos_check_monitor_state())
+ {
+ limLog(pMac, LOG1, FL("Ignore pre-auth frame in monitor mode"));
+ return eSIR_FAILURE;
+ }
+
limLog(pMac, LOG1, FL("Auth Frame Received: BSSID " MAC_ADDRESS_STR
" (RSSI %d)"),MAC_ADDR_ARRAY(pHdr->bssId),
(uint)abs((tANI_S8)WDA_GET_RX_RSSI_DB(pBd)));
diff --git a/CORE/MAC/src/pe/lim/limProcessMessageQueue.c b/CORE/MAC/src/pe/lim/limProcessMessageQueue.c
index a09aead..bc8dcf2 100644
--- a/CORE/MAC/src/pe/lim/limProcessMessageQueue.c
+++ b/CORE/MAC/src/pe/lim/limProcessMessageQueue.c
@@ -826,6 +826,11 @@
#ifdef WLAN_FEATURE_ROAM_SCAN_OFFLOAD
if (WDA_GET_ROAMCANDIDATEIND(pRxPacketInfo))
{
+ if (vos_check_monitor_state())
+ {
+ limLog( pMac, LOGW, FL("Ignore raom candidate when roam started"));
+ goto end;
+ }
limLog( pMac, LOGW, FL("Notify SME with candidate ind"));
if (WDA_IF_PER_ROAMCANDIDATEIND(pRxPacketInfo) &&
diff --git a/CORE/SME/src/csr/csrNeighborRoam.c b/CORE/SME/src/csr/csrNeighborRoam.c
index 7efaf10..8e98c59 100644
--- a/CORE/SME/src/csr/csrNeighborRoam.c
+++ b/CORE/SME/src/csr/csrNeighborRoam.c
@@ -5396,6 +5396,13 @@
{
tpCsrNeighborRoamControlInfo pNeighborRoamInfo = &pMac->roam.neighborRoamInfo;
eHalStatus status = eHAL_STATUS_SUCCESS;
+
+ if (vos_check_monitor_state())
+ {
+ smsLog(pMac, LOGW, FL("Ignore raom candidate when roam started"));
+ return eHAL_STATUS_FAILURE;
+ }
+
/* we must be in connected state, if not ignore it */
if ((eCSR_NEIGHBOR_ROAM_STATE_CONNECTED != pNeighborRoamInfo->neighborRoamState)
|| (pNeighborRoamInfo->uOsRequestedHandoff))
diff --git a/CORE/VOSS/inc/vos_api.h b/CORE/VOSS/inc/vos_api.h
index 43c9bfd..9754fcc 100644
--- a/CORE/VOSS/inc/vos_api.h
+++ b/CORE/VOSS/inc/vos_api.h
@@ -535,4 +535,14 @@
void vos_update_arp_fw_tx_delivered(void);
void vos_update_arp_rx_drop_reorder(void);
v_U16_t vos_get_rate_from_rateidx(uint32 rateindex);
+
+/**
+ * vos_check_monitor_state() - vos api to check monitor mode capture state
+ *
+ * This function is used to check whether capture of monitor mode is ON/OFF
+ *
+ * Return: TRUE - capture is ON, FALSE - capture is OFF
+ */
+v_BOOL_t vos_check_monitor_state(void);
+
#endif // if !defined __VOS_NVITEM_H
diff --git a/CORE/VOSS/inc/vos_types.h b/CORE/VOSS/inc/vos_types.h
index 6f9a8e9..6ffd9e0 100755
--- a/CORE/VOSS/inc/vos_types.h
+++ b/CORE/VOSS/inc/vos_types.h
@@ -152,6 +152,7 @@
//bit 1 - ap mode
//bit 2 - p2p client mode
//bit 3 - p2p go mode
+//bit 4 - monitor mode
typedef enum
{
VOS_STA=1,
@@ -159,6 +160,8 @@
VOS_STA_SAP=3, //to support sta, softAp mode . This means STA+AP mode
VOS_P2P_CLIENT=4,
VOS_P2P_GO=8,
+ VOS_MON=16,
+ VOS_STA_MON=17, /* station and monitor mode together */
VOS_MAX_CONCURRENCY_PERSONA=4
} tVOS_CONCURRENCY_MODE;
diff --git a/CORE/VOSS/src/vos_api.c b/CORE/VOSS/src/vos_api.c
index c868ff7..11e118f 100644
--- a/CORE/VOSS/src/vos_api.c
+++ b/CORE/VOSS/src/vos_api.c
@@ -3901,3 +3901,18 @@
pAdapter->hdd_stats.hddArpStats.rx_host_drop_reorder++;
}
+
+v_BOOL_t vos_check_monitor_state(void)
+{
+ hdd_context_t *hdd_ctx;
+
+ v_CONTEXT_t vos_ctx = vos_get_global_context(VOS_MODULE_ID_HDD, NULL);
+ if (!vos_ctx)
+ return VOS_FALSE;
+
+ hdd_ctx = vos_get_context(VOS_MODULE_ID_HDD, vos_ctx);
+ if (!hdd_ctx)
+ return VOS_FALSE;
+
+ return wlan_hdd_check_monitor_state(hdd_ctx);
+}
diff --git a/CORE/WDI/CP/src/wlan_qct_wdi.c b/CORE/WDI/CP/src/wlan_qct_wdi.c
index 4cadad1..e96d633 100644
--- a/CORE/WDI/CP/src/wlan_qct_wdi.c
+++ b/CORE/WDI/CP/src/wlan_qct_wdi.c
@@ -229,6 +229,7 @@
,FEATURE_NOT_SUPPORTED //69 reserved for FATAL_EVENT_LOGGING
,FEATURE_NOT_SUPPORTED //70 reserved for WIFI_DUAL_BAND_ENABLE
,PROBE_RSP_TEMPLATE_VER1 //71
+ ,STA_MONITOR_SCC //72
};
/*--------------------------------------------------------------------------