diff --git a/drivers/wifi/nrf_wifi/inc/wpa_supp_if.h b/drivers/wifi/nrf_wifi/inc/wpa_supp_if.h
index c543644e3128..45aa9eabbf9d 100644
--- a/drivers/wifi/nrf_wifi/inc/wpa_supp_if.h
+++ b/drivers/wifi/nrf_wifi/inc/wpa_supp_if.h
@@ -123,8 +123,16 @@ int nrf_wifi_supp_get_conn_info(void *if_priv, struct wpa_conn_info *info);
 void nrf_wifi_supp_event_proc_get_conn_info(void *os_vif_ctx,
 					    struct nrf_wifi_umac_event_conn_info *info,
 					    unsigned int event_len);
+void nrf_wifi_supp_event_roc_complete(void *os_vif_ctx,
+					    struct nrf_wifi_event_remain_on_channel *info,
+					    unsigned int event_len);
+void nrf_wifi_supp_event_roc_cancel_complete(void *os_vif_ctx,
+					    struct nrf_wifi_event_remain_on_channel *info,
+					    unsigned int event_len);
 int nrf_wifi_supp_set_country(void *if_priv, const char *alpha2);
 int nrf_wifi_supp_get_country(void *if_priv, char *alpha2);
+int nrf_wifi_supp_remain_on_channel(void *if_priv, unsigned int freq, unsigned int duration);
+int nrf_wifi_supp_cancel_remain_on_channel(void *if_priv);
 
 #endif /* CONFIG_NRF70_STA_MODE */
 #ifdef CONFIG_NRF70_AP_MODE
diff --git a/drivers/wifi/nrf_wifi/src/fmac_main.c b/drivers/wifi/nrf_wifi/src/fmac_main.c
index 47ca53d5a61c..92db8e203744 100644
--- a/drivers/wifi/nrf_wifi/src/fmac_main.c
+++ b/drivers/wifi/nrf_wifi/src/fmac_main.c
@@ -843,6 +843,8 @@ static int nrf_wifi_drv_main_zep(const struct device *dev)
 	callbk_fns.event_get_wiphy = nrf_wifi_wpa_supp_event_get_wiphy;
 	callbk_fns.mgmt_rx_callbk_fn = nrf_wifi_wpa_supp_event_mgmt_rx_callbk_fn;
 	callbk_fns.get_conn_info_callbk_fn = nrf_wifi_supp_event_proc_get_conn_info;
+	callbk_fns.roc_callbk_fn = nrf_wifi_supp_event_roc_complete;
+	callbk_fns.roc_cancel_callbk_fn = nrf_wifi_supp_event_roc_cancel_complete;
 #endif /* CONFIG_NRF70_STA_MODE */
 
 	/* The OSAL layer needs to be initialized before any other initialization
@@ -963,6 +965,8 @@ static const struct zep_wpa_supp_dev_ops wpa_supp_ops = {
 	.get_conn_info = nrf_wifi_supp_get_conn_info,
 	.set_country = nrf_wifi_supp_set_country,
 	.get_country = nrf_wifi_supp_get_country,
+	.remain_on_channel = nrf_wifi_supp_remain_on_channel,
+	.cancel_remain_on_channel = nrf_wifi_supp_cancel_remain_on_channel,
 #ifdef CONFIG_NRF70_AP_MODE
 	.init_ap = nrf_wifi_wpa_supp_init_ap,
 	.start_ap = nrf_wifi_wpa_supp_start_ap,
diff --git a/drivers/wifi/nrf_wifi/src/wpa_supp_if.c b/drivers/wifi/nrf_wifi/src/wpa_supp_if.c
index 88ea9f9215b4..29db8dd57010 100644
--- a/drivers/wifi/nrf_wifi/src/wpa_supp_if.c
+++ b/drivers/wifi/nrf_wifi/src/wpa_supp_if.c
@@ -545,16 +545,16 @@ int nrf_wifi_wpa_supp_scan2(void *if_priv, struct wpa_driver_scan_params *params
 		scan_info->scan_params.num_scan_channels = indx;
 	}
 
-	if (params->filter_ssids) {
-		scan_info->scan_params.num_scan_ssids = params->num_filter_ssids;
+	if (params->num_ssids) {
+		scan_info->scan_params.num_scan_ssids = params->num_ssids;
 
-		for (indx = 0; indx < params->num_filter_ssids; indx++) {
+		for (indx = 0; indx < params->num_ssids; indx++) {
 			memcpy(scan_info->scan_params.scan_ssids[indx].nrf_wifi_ssid,
-			       params->filter_ssids[indx].ssid,
-			       params->filter_ssids[indx].ssid_len);
+			       params->ssids[indx].ssid,
+			       params->ssids[indx].ssid_len);
 
 			scan_info->scan_params.scan_ssids[indx].nrf_wifi_ssid_len =
-				params->filter_ssids[indx].ssid_len;
+				params->ssids[indx].ssid_len;
 		}
 	}
 
@@ -1435,6 +1435,10 @@ int nrf_wifi_nl80211_send_mlme(void *if_priv, const u8 *data,
 		goto out;
 	}
 
+	if (vif_ctx_zep->if_type == NRF_WIFI_IFTYPE_STATION) {
+		offchanok = 1;
+	}
+
 	if (offchanok) {
 		mgmt_tx_info->nrf_wifi_flags |= NRF_WIFI_CMD_FRAME_OFFCHANNEL_TX_OK;
 	}
@@ -1698,7 +1702,7 @@ int nrf_wifi_supp_register_frame(void *if_priv,
 	struct nrf_wifi_ctx_zep *rpu_ctx_zep = NULL;
 	struct nrf_wifi_umac_mgmt_frame_info frame_info;
 
-	if (!if_priv || !match || !match_len) {
+	if (!if_priv) {
 		LOG_ERR("%s: Invalid parameters", __func__);
 		return -1;
 	}
@@ -1719,8 +1723,14 @@ int nrf_wifi_supp_register_frame(void *if_priv,
 	memset(&frame_info, 0, sizeof(frame_info));
 
 	frame_info.frame_type = type;
-	frame_info.frame_match.frame_match_len = match_len;
-	memcpy(frame_info.frame_match.frame_match, match, match_len);
+	if (match_len > 0) {
+		if (!match) {
+			LOG_ERR("%s: Invalid match parameters", __func__);
+			goto out;
+		}
+		frame_info.frame_match.frame_match_len = match_len;
+		memcpy(frame_info.frame_match.frame_match, match, match_len);
+	}
 
 	status = nrf_wifi_sys_fmac_register_frame(rpu_ctx_zep->rpu_ctx, vif_ctx_zep->vif_idx,
 			&frame_info);
@@ -1798,6 +1808,9 @@ int nrf_wifi_supp_get_capa(void *if_priv, struct wpa_driver_capa *capa)
 	if (IS_ENABLED(CONFIG_NRF70_AP_MODE)) {
 		capa->flags |= WPA_DRIVER_FLAGS_AP;
 	}
+	if (IS_ENABLED(CONFIG_NRF70_P2P_MODE)) {
+		capa->flags |= WPA_DRIVER_FLAGS_P2P_CAPABLE;
+	}
 
 	capa->enc |= WPA_DRIVER_CAPA_ENC_WEP40 |
 			WPA_DRIVER_CAPA_ENC_WEP104 |
@@ -1983,6 +1996,145 @@ void nrf_wifi_supp_event_proc_get_conn_info(void *if_priv,
 	k_sem_give(&wait_for_event_sem);
 }
 
+void nrf_wifi_supp_event_roc_complete(void *if_priv,
+					       struct nrf_wifi_event_remain_on_channel *roc_complete,
+					       unsigned int event_len)
+{
+	struct nrf_wifi_vif_ctx_zep *vif_ctx_zep = NULL;
+
+	if (!if_priv) {
+		LOG_ERR("%s: Missing interface context", __func__);
+		return;
+	}
+
+	vif_ctx_zep = if_priv;
+
+	if (!roc_complete) {
+		LOG_ERR("%s: Missing ROC complete event data", __func__);
+		return;
+	}
+
+	LOG_DBG("%s: ROC complete on freq %d, dur %d, vif_idx %d",
+		    __func__, roc_complete->frequency,
+		    roc_complete->dur, vif_ctx_zep->vif_idx);
+
+	if (vif_ctx_zep->supp_drv_if_ctx && vif_ctx_zep->supp_callbk_fns.roc_complete) {
+		vif_ctx_zep->supp_callbk_fns.roc_complete(vif_ctx_zep->supp_drv_if_ctx,
+				roc_complete->frequency,
+				roc_complete->dur);
+	}
+}
+
+void nrf_wifi_supp_event_roc_cancel_complete(void *if_priv,
+					       struct nrf_wifi_event_remain_on_channel *roc_cancel_complete,
+					       unsigned int event_len)
+{
+	struct nrf_wifi_vif_ctx_zep *vif_ctx_zep = NULL;
+
+	if (!if_priv) {
+		LOG_ERR("%s: Missing interface context", __func__);
+		return;
+	}
+
+	vif_ctx_zep = if_priv;
+
+	if (!roc_cancel_complete) {
+		LOG_ERR("%s: Missing ROC cancel complete event data", __func__);
+		return;
+	}
+
+	LOG_DBG("%s: ROC cancel complete on freq %d, vif_idx %d",
+		    __func__, roc_cancel_complete->frequency,
+		    vif_ctx_zep->vif_idx);
+
+	if (vif_ctx_zep->supp_drv_if_ctx && vif_ctx_zep->supp_callbk_fns.roc_cancel_complete) {
+		vif_ctx_zep->supp_callbk_fns.roc_cancel_complete(vif_ctx_zep->supp_drv_if_ctx,
+				roc_cancel_complete->frequency);
+	}
+}
+
+int nrf_wifi_supp_remain_on_channel(void *if_priv, unsigned int freq,
+									unsigned int duration)
+{
+	enum nrf_wifi_status status = NRF_WIFI_STATUS_FAIL;
+#ifdef NRF70_P2P_MODE
+	struct nrf_wifi_vif_ctx_zep *vif_ctx_zep = NULL;
+	struct nrf_wifi_ctx_zep *rpu_ctx_zep = NULL;
+	struct remain_on_channel_info roc_info;
+
+	if (!if_priv) {
+		LOG_ERR("%s: Invalid params", __func__);
+		return -1;
+	}
+
+	vif_ctx_zep = if_priv;
+	rpu_ctx_zep = vif_ctx_zep->rpu_ctx_zep;
+	if (!rpu_ctx_zep) {
+		LOG_ERR("%s: rpu_ctx_zep is NULL", __func__);
+		return -1;
+	}
+
+	k_mutex_lock(&vif_ctx_zep->vif_lock, K_FOREVER);
+	if (!rpu_ctx_zep->rpu_ctx) {
+		LOG_DBG("%s: RPU context not initialized", __func__);
+		goto out;
+	}
+
+	memset(&roc_info, 0, sizeof(roc_info));
+	roc_info.nrf_wifi_freq_params.frequency = freq;
+	roc_info.nrf_wifi_freq_params.channel_width = NRF_WIFI_CHAN_WIDTH_20;
+	roc_info.nrf_wifi_freq_params.center_frequency1 = freq;
+	roc_info.nrf_wifi_freq_params.center_frequency2 = 0;
+	roc_info.nrf_wifi_freq_params.channel_type = NRF_WIFI_CHAN_HT20;
+	roc_info.dur = duration;
+
+	status = nrf_wifi_sys_fmac_p2p_roc_start(rpu_ctx_zep->rpu_ctx, vif_ctx_zep->vif_idx, &roc_info);
+	if (status != NRF_WIFI_STATUS_SUCCESS) {
+		LOG_ERR("%s: nrf_wifi_fmac_remain_on_channel failed", __func__);
+		goto out;
+	}
+out:
+	k_mutex_unlock(&vif_ctx_zep->vif_lock);
+#endif /* NRF70_P2P_MODE */
+	return status;
+}
+
+int nrf_wifi_supp_cancel_remain_on_channel(void *if_priv)
+{
+	enum nrf_wifi_status status = NRF_WIFI_STATUS_FAIL;
+#ifdef NRF70_P2P_MODE
+	struct nrf_wifi_vif_ctx_zep *vif_ctx_zep = NULL;
+	struct nrf_wifi_ctx_zep *rpu_ctx_zep = NULL;
+
+	if (!if_priv) {
+		LOG_ERR("%s: Invalid params", __func__);
+		return -1;
+	}
+
+	vif_ctx_zep = if_priv;
+	rpu_ctx_zep = vif_ctx_zep->rpu_ctx_zep;
+	if (!rpu_ctx_zep) {
+		LOG_ERR("%s: rpu_ctx_zep is NULL", __func__);
+		return -1;
+	}
+
+	k_mutex_lock(&vif_ctx_zep->vif_lock, K_FOREVER);
+	if (!rpu_ctx_zep->rpu_ctx) {
+		LOG_DBG("%s: RPU context not initialized", __func__);
+		goto out;
+	}
+
+	status = nrf_wifi_sys_fmac_p2p_roc_stop(rpu_ctx_zep->rpu_ctx, vif_ctx_zep->vif_idx, 0);
+	if (status != NRF_WIFI_STATUS_SUCCESS) {
+		LOG_ERR("%s: nrf_wifi_fmac_cancel_remain_on_channel failed", __func__);
+		goto out;
+	}
+out:
+	k_mutex_unlock(&vif_ctx_zep->vif_lock);
+#endif /* NRF70_P2P_MODE */
+	return status;
+}
+
 #ifdef CONFIG_NRF70_AP_MODE
 static int nrf_wifi_vif_state_change(struct nrf_wifi_vif_ctx_zep *vif_ctx_zep,
 	enum nrf_wifi_fmac_if_op_state state)
diff --git a/include/zephyr/net/wifi_mgmt.h b/include/zephyr/net/wifi_mgmt.h
index a9dbd74607ca..30f67bbf5574 100644
--- a/include/zephyr/net/wifi_mgmt.h
+++ b/include/zephyr/net/wifi_mgmt.h
@@ -137,6 +137,10 @@ enum net_request_wifi_cmd {
 	NET_REQUEST_WIFI_CMD_AP_WPS_CONFIG,
 	/** Configure BSS maximum idle period */
 	NET_REQUEST_WIFI_CMD_BSS_MAX_IDLE_PERIOD,
+	/** Configure background scanning */
+	NET_REQUEST_WIFI_CMD_BGSCAN,
+	/** Wi-Fi Direct (P2P) operations*/
+	NET_REQUEST_WIFI_CMD_P2P_OPER,
 	/** @cond INTERNAL_HIDDEN */
 	NET_REQUEST_WIFI_CMD_MAX
 	/** @endcond */
@@ -332,6 +336,16 @@ NET_MGMT_DEFINE_REQUEST_HANDLER(NET_REQUEST_WIFI_NEIGHBOR_REP_COMPLETE);
 
 NET_MGMT_DEFINE_REQUEST_HANDLER(NET_REQUEST_WIFI_BSS_MAX_IDLE_PERIOD);
 
+#define NET_REQUEST_WIFI_BGSCAN					\
+	(NET_WIFI_BASE | NET_REQUEST_WIFI_CMD_BGSCAN)
+
+NET_MGMT_DEFINE_REQUEST_HANDLER(NET_REQUEST_WIFI_BGSCAN);
+
+#define NET_REQUEST_WIFI_P2P_OPER						\
+	(NET_WIFI_BASE | NET_REQUEST_WIFI_CMD_P2P_OPER)
+
+NET_MGMT_DEFINE_REQUEST_HANDLER(NET_REQUEST_WIFI_P2P_OPER);
+
 /** @cond INTERNAL_HIDDEN */
 
 enum {
@@ -352,7 +366,7 @@ enum {
 	NET_EVENT_WIFI_CMD_AP_STA_CONNECTED_VAL,
 	NET_EVENT_WIFI_CMD_AP_STA_DISCONNECTED_VAL,
 	NET_EVENT_WIFI_CMD_SUPPLICANT_VAL,
-
+	NET_EVENT_WIFI_CMD_P2P_DEVICE_FOUND_VAL,
 	NET_EVENT_WIFI_CMD_MAX,
 };
 
@@ -399,6 +413,8 @@ enum net_event_wifi_cmd {
 	NET_MGMT_CMD(NET_EVENT_WIFI_CMD_AP_STA_DISCONNECTED),
 	/** Supplicant specific event */
 	NET_MGMT_CMD(NET_EVENT_WIFI_CMD_SUPPLICANT),
+	/** P2P device found */
+	NET_MGMT_CMD(NET_EVENT_WIFI_CMD_P2P_DEVICE_FOUND),
 };
 
 /** Event emitted for Wi-Fi scan result */
@@ -461,6 +477,38 @@ enum net_event_wifi_cmd {
 #define NET_EVENT_WIFI_AP_STA_DISCONNECTED			\
 	(NET_WIFI_EVENT | NET_EVENT_WIFI_CMD_AP_STA_DISCONNECTED)
 
+/** Event emitted for P2P device found event */
+#define NET_EVENT_WIFI_P2P_DEVICE_FOUND				\
+	(NET_WIFI_EVENT | NET_EVENT_WIFI_CMD_P2P_DEVICE_FOUND)
+
+#ifdef CONFIG_WIFI_NM_WPA_SUPPLICANT_P2P
+/** @brief Wi-Fi P2P device info */
+struct wifi_p2p_device_info {
+	/** Device MAC address */
+	uint8_t mac[WIFI_MAC_ADDR_LEN];
+	/** Device name (max 32 chars + null terminator) */
+	char device_name[33];
+	/** Primary device type */
+	uint8_t pri_dev_type[8];
+	/** Primary device type string */
+	char pri_dev_type_str[32];
+	/** Signal strength (RSSI) */
+	int8_t rssi;
+	/** WPS configuration methods supported */
+	uint16_t config_methods;
+	/** WPS configuration methods string */
+	char config_methods_str[16];
+	/** Device capability */
+	uint8_t dev_capab;
+	/** Group capability */
+	uint8_t group_capab;
+	/** Manufacturer (max 64 chars + null terminator) */
+	char manufacturer[65];
+	/** Model name (max 32 chars + null terminator) */
+	char model_name[33];
+};
+#endif /* CONFIG_WIFI_NM_WPA_SUPPLICANT_P2P */
+
 /** @brief Wi-Fi version */
 struct wifi_version {
 	/** Driver version */
@@ -1097,6 +1145,9 @@ union wifi_mgmt_events {
 #endif /* CONFIG_WIFI_MGMT_RAW_SCAN_RESULTS */
 	struct wifi_twt_params twt_params;
 	struct wifi_ap_sta_info ap_sta_info;
+#ifdef CONFIG_WIFI_NM_WPA_SUPPLICANT_P2P
+	struct wifi_p2p_device_info p2p_device_info;
+#endif
 };
 
 /** @endcond */
@@ -1380,6 +1431,75 @@ struct wifi_wps_config_params {
 	char pin[WIFI_WPS_PIN_MAX_LEN + 1];
 };
 
+#ifdef CONFIG_WIFI_NM_WPA_SUPPLICANT_P2P
+/** Wi-Fi P2P operation */
+enum wifi_p2p_op {
+	/** P2P find/discovery */
+	WIFI_P2P_FIND = 0,
+	/** P2P stop find/discovery */
+	WIFI_P2P_STOP_FIND,
+	/** P2P query peer info use broadcast MAC (ff:ff:ff:ff:ff:ff) to list all peers,
+	 *  or specific MAC address to query a single peer
+	 */
+	WIFI_P2P_PEER,
+	/** P2P connect to peer */
+	WIFI_P2P_CONNECT,
+};
+
+/** Wi-Fi P2P discovery type */
+enum wifi_p2p_discovery_type {
+	/** Start with full scan, then only social channels */
+	WIFI_P2P_FIND_START_WITH_FULL = 0,
+	/** Only social channels (1, 6, 11) */
+	WIFI_P2P_FIND_ONLY_SOCIAL,
+	/** Progressive - scan through all channels one at a time */
+	WIFI_P2P_FIND_PROGRESSIVE,
+};
+
+/** Wi-Fi P2P connection method */
+enum wifi_p2p_connection_method {
+	/** Push Button Configuration */
+	WIFI_P2P_METHOD_PBC = 0,
+	/** Display PIN (device displays PIN for peer to enter) */
+	WIFI_P2P_METHOD_DISPLAY,
+	/** Keypad PIN (user enters PIN on device) */
+	WIFI_P2P_METHOD_KEYPAD,
+};
+
+/** Maximum number of P2P peers that can be returned in a single query */
+#define WIFI_P2P_MAX_PEERS 32
+
+/** Wi-Fi P2P parameters */
+struct wifi_p2p_params {
+	/** P2P operation */
+	enum wifi_p2p_op oper;
+	/** Discovery type (for find operation) */
+	enum wifi_p2p_discovery_type discovery_type;
+	/** Timeout in seconds (0 = no timeout, run until stopped) */
+	uint16_t timeout;
+	/** Peer device address (for peer operation) */
+	uint8_t peer_addr[WIFI_MAC_ADDR_LEN];
+	/** Flag to list only discovered peers (for peers operation) */
+	bool discovered_only;
+	/** Pointer to array for peer info results */
+	struct wifi_p2p_device_info *peers;
+	/** Actual number of peers returned */
+	uint16_t peer_count;
+	/** Connect specific parameters */
+	struct {
+		/** Connection method */
+		enum wifi_p2p_connection_method method;
+		/** PIN for display/keypad methods (8 digits)
+		 * - For DISPLAY: Leave empty, PIN will be generated and returned
+		 * - For KEYPAD: Provide the PIN to use for connection
+		 */
+		char pin[WIFI_WPS_PIN_MAX_LEN + 1];
+		/** GO intent (0-15, higher values indicate higher willingness to be GO) */
+		uint8_t go_intent;
+	} connect;
+};
+#endif /* CONFIG_WIFI_NM_WPA_SUPPLICANT_P2P */
+
 /** Wi-Fi AP status
  */
 enum wifi_sap_iface_state {
@@ -1393,6 +1513,32 @@ enum wifi_sap_iface_state {
 	WIFI_SAP_IFACE_ENABLED
 };
 
+#if defined(CONFIG_WIFI_NM_WPA_SUPPLICANT_BGSCAN) || defined(__DOXYGEN__)
+/** @brief Wi-Fi background scan implementation */
+enum wifi_bgscan_type {
+	/** None, background scan is disabled */
+	WIFI_BGSCAN_NONE = 0,
+	/** Simple, periodic scan based on signal strength */
+	WIFI_BGSCAN_SIMPLE,
+	/** Learn channels used by the network (experimental) */
+	WIFI_BGSCAN_LEARN,
+};
+
+/** @brief Wi-Fi background scan parameters */
+struct wifi_bgscan_params {
+	/** The type of background scanning */
+	enum wifi_bgscan_type type;
+	/** Short scan interval in seconds */
+	uint16_t short_interval;
+	/** Long scan interval in seconds */
+	uint16_t long_interval;
+	/** Signal strength threshold in dBm */
+	int8_t rssi_threshold;
+	/** Number of BSS Transition Management (BTM) queries */
+	uint16_t btm_queries;
+};
+#endif
+
 /* Extended Capabilities */
 enum wifi_ext_capab {
 	WIFI_EXT_CAPAB_20_40_COEX = 0,
@@ -1732,6 +1878,27 @@ struct wifi_mgmt_ops {
 	 */
 	int (*set_bss_max_idle_period)(const struct device *dev,
 			unsigned short bss_max_idle_period);
+#if defined(CONFIG_WIFI_NM_WPA_SUPPLICANT_BGSCAN) || defined(__DOXYGEN__)
+	/** Configure background scanning
+	 *
+	 * @param dev Pointer to the device structure for the driver instance.
+	 * @param params Background scanning configuration parameters
+	 *
+	 * @return 0 if ok, < 0 if error
+	 */
+	int (*set_bgscan)(const struct device *dev, struct wifi_bgscan_params *params);
+#endif
+#ifdef CONFIG_WIFI_NM_WPA_SUPPLICANT_P2P
+	/** Wi-Fi Direct (P2P) operations for device discovery
+	 *
+	 * @param dev Pointer to the device structure for the driver instance.
+	 * @param params P2P operation parameters including operation type, discovery settings,
+	 * timeout values and peer information retrieval options
+	 *
+	 * @return 0 if ok, < 0 if error
+	 */
+	int (*p2p_oper)(const struct device *dev, struct wifi_p2p_params *params);
+#endif
 };
 
 /** Wi-Fi management offload API */
@@ -1863,6 +2030,17 @@ void wifi_mgmt_raise_ap_sta_connected_event(struct net_if *iface,
 void wifi_mgmt_raise_ap_sta_disconnected_event(struct net_if *iface,
 		struct wifi_ap_sta_info *sta_info);
 
+#ifdef CONFIG_WIFI_NM_WPA_SUPPLICANT_P2P
+/**
+ * @brief Raise P2P device found event
+ *
+ * @param iface Network interface
+ * @param device_info P2P device information
+ */
+void wifi_mgmt_raise_p2p_device_found_event(struct net_if *iface,
+		struct wifi_p2p_device_info *peer_info);
+#endif /* CONFIG_WIFI_NM_WPA_SUPPLICANT_P2P */
+
 /**
  * @}
  */
diff --git a/modules/hostap/CMakeLists.txt b/modules/hostap/CMakeLists.txt
index 5c750f545d2e..dfa542233eef 100644
--- a/modules/hostap/CMakeLists.txt
+++ b/modules/hostap/CMakeLists.txt
@@ -78,6 +78,16 @@ zephyr_library_compile_definitions_ifdef(CONFIG_WIFI_NM_WPA_SUPPLICANT_WNM
   CONFIG_WNM
 )
 
+zephyr_library_compile_definitions_ifdef(CONFIG_WIFI_NM_WPA_SUPPLICANT_BGSCAN
+  CONFIG_BGSCAN
+)
+zephyr_library_compile_definitions_ifdef(CONFIG_WIFI_NM_WPA_SUPPLICANT_BGSCAN_SIMPLE
+  CONFIG_BGSCAN_SIMPLE
+)
+zephyr_library_compile_definitions_ifdef(CONFIG_WIFI_NM_WPA_SUPPLICANT_BGSCAN_LEARN
+  CONFIG_BGSCAN_LEARN
+)
+
 zephyr_library_include_directories(
   ${CMAKE_CURRENT_SOURCE_DIR}/src
   ${HOSTAP_BASE}/
@@ -156,6 +166,16 @@ zephyr_library_sources_ifdef(CONFIG_WIFI_NM_WPA_SUPPLICANT_WNM
   ${WIFI_NM_WPA_SUPPLICANT_BASE}/wnm_sta.c
 )
 
+zephyr_library_sources_ifdef(CONFIG_WIFI_NM_WPA_SUPPLICANT_BGSCAN
+  ${WIFI_NM_WPA_SUPPLICANT_BASE}/bgscan.c
+)
+zephyr_library_sources_ifdef(CONFIG_WIFI_NM_WPA_SUPPLICANT_BGSCAN_SIMPLE
+  ${WIFI_NM_WPA_SUPPLICANT_BASE}/bgscan_simple.c
+)
+zephyr_library_sources_ifdef(CONFIG_WIFI_NM_WPA_SUPPLICANT_BGSCAN_LEARN
+  ${WIFI_NM_WPA_SUPPLICANT_BASE}/bgscan_learn.c
+)
+
 zephyr_library_sources_ifdef(CONFIG_WPA_CLI
   src/wpa_cli.c
 )
@@ -365,14 +385,6 @@ zephyr_library_sources_ifdef(CONFIG_WIFI_NM_WPA_SUPPLICANT_WPS
   ${HOSTAP_SRC_BASE}/crypto/dh_groups.c
 )
 
-if(NOT CONFIG_WIFI_NM_WPA_SUPPLICANT_CRYPTO_ALT)
-# dh_group5 is only needed if we are not using mbedtls, as mbedtls provides
-# its own definition
-zephyr_library_sources_ifdef(CONFIG_WIFI_NM_WPA_SUPPLICANT_WPS
-  ${HOSTAP_SRC_BASE}/crypto/dh_group5.c
-)
-endif()
-
 zephyr_library_compile_definitions_ifdef(CONFIG_WIFI_NM_WPA_SUPPLICANT_P2P
   CONFIG_P2P
   CONFIG_GAS
@@ -572,6 +584,10 @@ zephyr_library_compile_definitions_ifdef(CONFIG_EAP_FAST
   EAP_FAST
 )
 
+zephyr_library_compile_definitions_ifdef(CONFIG_EAP_TLSV1_3
+  EAP_TLSV1_3
+)
+
 zephyr_library_sources_ifdef(CONFIG_WIFI_NM_WPA_SUPPLICANT_EAPOL
   ${HOSTAP_SRC_BASE}/eapol_supp/eapol_supp_sm.c
   ${HOSTAP_SRC_BASE}/eap_peer/eap.c
diff --git a/modules/hostap/Kconfig b/modules/hostap/Kconfig
index 1aa21670bb71..dabe3e2d33b3 100644
--- a/modules/hostap/Kconfig
+++ b/modules/hostap/Kconfig
@@ -46,6 +46,7 @@ config HEAP_MEM_POOL_ADD_SIZE_HOSTAP
 	def_int 66560 if WIFI_NM_HOSTAPD_AP
 	def_int 55000 if WIFI_NM_WPA_SUPPLICANT_CRYPTO_ENTERPRISE && WIFI_CREDENTIALS
 	def_int 48000 if WIFI_NM_WPA_SUPPLICANT_CRYPTO_ENTERPRISE
+	def_int 50000 if WIFI_NM_WPA_SUPPLICANT_P2P
 	def_int 41808 if WIFI_NM_WPA_SUPPLICANT_AP
 	# 30K is mandatory, but might need more for long duration use cases
 	def_int 30000
@@ -54,6 +55,7 @@ endif # WIFI_NM_WPA_SUPPLICANT_GLOBAL_HEAP
 
 config WIFI_NM_WPA_SUPPLICANT_THREAD_STACK_SIZE
 	int "Stack size for wpa_supplicant thread"
+	default 10000 if WIFI_NM_WPA_SUPPLICANT_P2P
 	# TODO: Providing higher stack size for Enterprise mode to fix stack
 	# overflow issues. Need to identify the cause for higher stack usage.
 	default 8192 if WIFI_NM_WPA_SUPPLICANT_CRYPTO_ENTERPRISE
@@ -299,6 +301,14 @@ config EAP_ALL
 	select EAP_TTLS
 	select EAP_MSCHAPV2
 	default y
+
+config EAP_TLSV1_3
+	bool "EAP TLSv1.3 support"
+	select MBEDTLS_TLS_VERSION_1_3
+	select MBEDTLS_TLS_SESSION_TICKETS
+	select MBEDTLS_SSL_TLS1_3_KEY_EXCHANGE_MODE_PSK_ENABLED
+	select MBEDTLS_SSL_TLS1_3_KEY_EXCHANGE_MODE_EPHEMERAL_ENABLED
+	select MBEDTLS_SSL_TLS1_3_KEY_EXCHANGE_MODE_PSK_EPHEMERAL_ENABLED
 endif # WIFI_NM_WPA_SUPPLICANT_CRYPTO_ENTERPRISE
 
 config WIFI_NM_WPA_SUPPLICANT_WPA3
@@ -443,6 +453,27 @@ config WIFI_NM_WPA_SUPPLICANT_SKIP_DHCP_ON_ROAMING
 	  needs to get new IP address after roaming to new AP. Disable this to keep
 	  DHCP after roaming.
 
+config WIFI_NM_WPA_SUPPLICANT_BGSCAN
+	bool "Background scanning (for legacy roaming), recommended if 802.11r is not supported"
+	depends on WIFI_NM_WPA_SUPPLICANT_WNM
+	depends on !WIFI_NM_WPA_SUPPLICANT_ROAMING
+
+if WIFI_NM_WPA_SUPPLICANT_BGSCAN
+
+config WIFI_NM_WPA_SUPPLICANT_BGSCAN_SIMPLE
+	bool "Simple background scanning"
+	default y
+	help
+	  Periodic background scans based on signal strength.
+
+config WIFI_NM_WPA_SUPPLICANT_BGSCAN_LEARN
+	bool "Learning"
+	help
+	  Learn channels used by the network and try to avoid
+	  background scans on other channels (experimental).
+
+endif # WIFI_NM_WPA_SUPPLICANT_BGSCAN
+
 # Create hidden config options that are used in hostap. This way we do not need
 # to mark them as allowed for CI checks, and also someone else cannot use the
 # same name options.
@@ -474,6 +505,15 @@ config NO_RANDOM_POOL
 config WNM
 	bool
 
+config BGSCAN
+	bool
+
+config BGSCAN_SIMPLE
+	bool
+
+config BGSCAN_LEARN
+	bool
+
 config NO_WPA
 	bool
 	default y if WIFI_NM_WPA_SUPPLICANT_CRYPTO_NONE
diff --git a/modules/hostap/src/supp_api.c b/modules/hostap/src/supp_api.c
index 8ae45d6db2af..53edfa6e349e 100644
--- a/modules/hostap/src/supp_api.c
+++ b/modules/hostap/src/supp_api.c
@@ -60,6 +60,15 @@ enum status_thread_state {
 static struct wifi_enterprise_creds_params enterprise_creds;
 #endif
 
+#ifdef CONFIG_WIFI_NM_WPA_SUPPLICANT_P2P
+/* TODO: Define size with references */
+#define P2P_CMD_BUF_SIZE 256
+#define P2P_RESP_BUF_SIZE 256
+#define P2P_ADDR_SIZE 32
+#define P2P_CMD_SIZE 64
+#define P2P_PEER_INFO_SIZE 512
+#endif /* CONFIG_WIFI_NM_WPA_SUPPLICANT_P2P */
+
 K_MUTEX_DEFINE(wpa_supplicant_mutex);
 
 extern struct k_work_q *get_workq(void);
@@ -80,20 +89,19 @@ static void supp_shell_connect_status(struct k_work *work);
 static K_WORK_DELAYABLE_DEFINE(wpa_supp_status_work,
 		supp_shell_connect_status);
 
-#define wpa_cli_cmd_v(cmd, ...)	({					\
-	bool status;							\
-									\
-	if (zephyr_wpa_cli_cmd_v(cmd, ##__VA_ARGS__) < 0) {		\
-		wpa_printf(MSG_ERROR,					\
-			   "Failed to execute wpa_cli command: %s",	\
-			   cmd);					\
-		status = false;						\
-	} else {							\
-		status = true;						\
-	}								\
-									\
-	status;								\
-})
+#define wpa_cli_cmd_v(cmd, ...)                                                                    \
+	({                                                                                         \
+		bool status;                                                                       \
+                                                                                                   \
+		if (zephyr_wpa_cli_cmd_v(wpa_s->ctrl_conn, cmd, ##__VA_ARGS__) < 0) {              \
+			wpa_printf(MSG_ERROR, "Failed to execute wpa_cli command: %s", cmd);       \
+			status = false;                                                            \
+		} else {                                                                           \
+			status = true;                                                             \
+		}                                                                                  \
+                                                                                                   \
+		status;                                                                            \
+	})
 
 static struct wpa_supplicant *get_wpa_s_handle(const struct device *dev)
 {
@@ -626,7 +634,7 @@ static int wpas_add_and_config_network(struct wpa_supplicant *wpa_s,
 		goto out;
 	}
 
-	ret = z_wpa_ctrl_add_network(&resp);
+	ret = z_wpa_ctrl_add_network(wpa_s->ctrl_conn, &resp);
 	if (ret) {
 		wpa_printf(MSG_ERROR, "Failed to add network");
 		goto out;
@@ -1365,7 +1373,7 @@ int supplicant_status(const struct device *dev, struct wifi_iface_status *status
 		status->channel = channel;
 
 		if (ssid_len == 0) {
-			int _res = z_wpa_ctrl_status(&cli_status);
+			int _res = z_wpa_ctrl_status(wpa_s->ctrl_conn, &cli_status);
 
 			if (_res < 0) {
 				ssid_len = 0;
@@ -1394,7 +1402,7 @@ int supplicant_status(const struct device *dev, struct wifi_iface_status *status
 
 		status->rssi = -WPA_INVALID_NOISE;
 		if (status->iface_mode == WIFI_MODE_INFRA) {
-			ret = z_wpa_ctrl_signal_poll(&signal_poll);
+			ret = z_wpa_ctrl_signal_poll(wpa_s->ctrl_conn, &signal_poll);
 			if (!ret) {
 				status->rssi = signal_poll.rssi;
 				status->current_phy_tx_rate = signal_poll.current_txrate;
@@ -1901,6 +1909,71 @@ int supplicant_set_bss_max_idle_period(const struct device *dev,
 	return wifi_mgmt_api->set_bss_max_idle_period(dev, bss_max_idle_period);
 }
 
+#ifdef CONFIG_WIFI_NM_WPA_SUPPLICANT_BGSCAN
+int supplicant_set_bgscan(const struct device *dev, struct wifi_bgscan_params *params)
+{
+	struct wpa_supplicant *wpa_s;
+	struct wpa_ssid *ssid;
+	int ret = -1;
+
+	k_mutex_lock(&wpa_supplicant_mutex, K_FOREVER);
+
+	wpa_s = get_wpa_s_handle(dev);
+	if (wpa_s == NULL) {
+		wpa_printf(MSG_ERROR, "Interface %s not found", dev->name);
+		goto out;
+	}
+
+	ssid = wpa_s->current_ssid;
+	if (ssid == NULL) {
+		wpa_printf(MSG_ERROR, "SSID for %s not found", dev->name);
+		goto out;
+	}
+
+	switch (params->type) {
+	case WIFI_BGSCAN_SIMPLE:
+		if (!IS_ENABLED(CONFIG_WIFI_NM_WPA_SUPPLICANT_BGSCAN_SIMPLE)) {
+			wpa_printf(MSG_ERROR, "Invalid bgscan type, enable "
+					      "CONFIG_WIFI_NM_WPA_SUPPLICANT_BGSCAN_SIMPLE");
+			ret = -ENOTSUP;
+			goto out;
+		}
+		if (!wpa_cli_cmd_v("set_network %d bgscan \"simple:%d:%d:%d:%d\"", ssid->id,
+				   params->short_interval, params->rssi_threshold,
+				   params->long_interval, params->btm_queries)) {
+			goto out;
+		}
+		break;
+	case WIFI_BGSCAN_LEARN:
+		if (!IS_ENABLED(CONFIG_WIFI_NM_WPA_SUPPLICANT_BGSCAN_LEARN)) {
+			wpa_printf(MSG_ERROR, "Invalid bgscan type, enable "
+					      "CONFIG_WIFI_NM_WPA_SUPPLICANT_BGSCAN_LEARN");
+			ret = -ENOTSUP;
+			goto out;
+		}
+		if (!wpa_cli_cmd_v("set_network %d bgscan \"learn:%d:%d:%d\"", ssid->id,
+				   params->short_interval, params->rssi_threshold,
+				   params->long_interval)) {
+			goto out;
+		}
+		break;
+	case WIFI_BGSCAN_NONE:
+	default:
+		if (!wpa_cli_cmd_v("set_network %d bgscan \"\"", ssid->id)) {
+			goto out;
+		}
+		break;
+	}
+
+	ret = 0;
+
+out:
+	k_mutex_unlock(&wpa_supplicant_mutex);
+
+	return ret;
+}
+#endif
+
 #ifdef CONFIG_WIFI_NM_WPA_SUPPLICANT_WNM
 int supplicant_btm_query(const struct device *dev, uint8_t reason)
 {
@@ -2007,7 +2080,7 @@ static int supplicant_wps_pin(const struct device *dev, struct wifi_wps_config_p
 	}
 
 	if (params->oper == WIFI_WPS_PIN_GET) {
-		if (zephyr_wpa_cli_cmd_resp(get_pin_cmd, params->pin)) {
+		if (zephyr_wpa_cli_cmd_resp(wpa_s->ctrl_conn, get_pin_cmd, params->pin)) {
 			goto out;
 		}
 	} else if (params->oper == WIFI_WPS_PIN_SET) {
@@ -2440,6 +2513,7 @@ int supplicant_dpp_dispatch(const struct device *dev, struct wifi_dpp_params *pa
 {
 	int ret;
 	char *cmd = NULL;
+	struct wpa_supplicant *wpa_s = get_wpa_s_handle(dev);
 
 	if (params == NULL) {
 		return -EINVAL;
@@ -2458,7 +2532,7 @@ int supplicant_dpp_dispatch(const struct device *dev, struct wifi_dpp_params *pa
 	}
 
 	wpa_printf(MSG_DEBUG, "wpa_cli %s", cmd);
-	if (zephyr_wpa_cli_cmd_resp(cmd, params->resp)) {
+	if (zephyr_wpa_cli_cmd_resp(wpa_s->ctrl_conn, cmd, params->resp)) {
 		os_free(cmd);
 		return -ENOEXEC;
 	}
@@ -2495,3 +2569,307 @@ int supplicant_config_params(const struct device *dev, struct wifi_config_params
 	k_mutex_unlock(&wpa_supplicant_mutex);
 	return ret;
 }
+
+#ifdef CONFIG_WIFI_NM_WPA_SUPPLICANT_P2P
+static inline void extract_value(const char *src, char *dest, size_t dest_size)
+{
+	size_t i = 0;
+
+	while (src[i] != '\0' && src[i] != '\n' && i < dest_size - 1) {
+		dest[i] = src[i];
+		i++;
+	}
+	dest[i] = '\0';
+}
+
+static void parse_peer_info_line(const char *line, struct wifi_p2p_device_info *info)
+{
+	const char *pos;
+
+	if (strncmp(line, "device_name=", 12) == 0) {
+		extract_value(line + 12, info->device_name, sizeof(info->device_name));
+	} else if (strncmp(line, "pri_dev_type=", 13) == 0) {
+		extract_value(line + 13, info->pri_dev_type_str, sizeof(info->pri_dev_type_str));
+	} else if (strncmp(line, "level=", 6) == 0) {
+		pos = line + 6;
+		/* Skip extraction for numeric values, atoi handles it */
+		info->rssi = (int8_t)atoi(pos);
+	} else if (strncmp(line, "config_methods=", 15) == 0) {
+		pos = line + 15;
+		extract_value(pos, info->config_methods_str, sizeof(info->config_methods_str));
+
+		if (pos[0] == '0' && (pos[1] == 'x' || pos[1] == 'X')) {
+			info->config_methods = (uint16_t)strtol(pos, NULL, 16);
+		} else {
+			info->config_methods = (uint16_t)atoi(pos);
+		}
+	} else if (strncmp(line, "manufacturer=", 13) == 0) {
+		extract_value(line + 13, info->manufacturer, sizeof(info->manufacturer));
+	} else if (strncmp(line, "model_name=", 11) == 0) {
+		extract_value(line + 11, info->model_name, sizeof(info->model_name));
+	}
+}
+
+static void parse_peer_info_response(const char *resp, const uint8_t *mac,
+				     struct wifi_p2p_device_info *info)
+{
+	const char *line = resp;
+	const char *next_line;
+
+	memset(info, 0, sizeof(*info));
+
+	if (mac) {
+		memcpy(info->mac, mac, WIFI_MAC_ADDR_LEN);
+	}
+
+	while (line && *line) {
+		if (*line == '\n') {
+			line++;
+			continue;
+		}
+		next_line = strchr(line, '\n');
+		parse_peer_info_line(line, info);
+		if (next_line) {
+			line = next_line + 1;
+		} else {
+			break;
+		}
+	}
+}
+
+int supplicant_p2p_oper(const struct device *dev, struct wifi_p2p_params *params)
+{
+	struct wpa_supplicant *wpa_s =  get_wpa_s_handle(dev);
+	char cmd_buf[P2P_CMD_BUF_SIZE];
+	char resp_buf[P2P_RESP_BUF_SIZE];
+	int ret = -1;
+	const char *discovery_type_str = "";
+
+	if (!wpa_s || !wpa_s->ctrl_conn) {
+		wpa_printf(MSG_ERROR, "wpa_supplicant control interface not initialized");
+		return -ENOTSUP;
+	}
+
+	switch (params->oper) {
+	case WIFI_P2P_FIND:
+		switch (params->discovery_type) {
+		case WIFI_P2P_FIND_ONLY_SOCIAL:
+			discovery_type_str = "type=social";
+			break;
+		case WIFI_P2P_FIND_PROGRESSIVE:
+			discovery_type_str = "type=progressive";
+			break;
+		case WIFI_P2P_FIND_START_WITH_FULL:
+		default:
+			discovery_type_str = "";
+			break;
+		}
+
+		if (params->timeout > 0) {
+			if (strlen(discovery_type_str) > 0) {
+				snprintf(cmd_buf, sizeof(cmd_buf), "P2P_FIND %u %s",
+					 params->timeout, discovery_type_str);
+			} else {
+				snprintf(cmd_buf, sizeof(cmd_buf), "P2P_FIND %u",
+					 params->timeout);
+			}
+		} else {
+			if (strlen(discovery_type_str) > 0) {
+				snprintf(cmd_buf, sizeof(cmd_buf), "P2P_FIND %s",
+					 discovery_type_str);
+			} else {
+				snprintf(cmd_buf, sizeof(cmd_buf), "P2P_FIND");
+			}
+		}
+		ret = zephyr_wpa_cli_cmd_resp_noprint(wpa_s->ctrl_conn, cmd_buf, resp_buf);
+		if (ret < 0) {
+			wpa_printf(MSG_ERROR, "P2P_FIND command failed: %d", ret);
+			return -EIO;
+		}
+		ret = 0;
+		break;
+
+	case WIFI_P2P_STOP_FIND:
+		snprintf(cmd_buf, sizeof(cmd_buf), "P2P_STOP_FIND");
+		ret = zephyr_wpa_cli_cmd_resp_noprint(wpa_s->ctrl_conn, cmd_buf, resp_buf);
+		if (ret < 0) {
+			wpa_printf(MSG_ERROR, "P2P_STOP_FIND command failed: %d", ret);
+			return -EIO;
+		}
+		ret = 0;
+		break;
+
+	case WIFI_P2P_PEER:
+		char addr[P2P_ADDR_SIZE];
+		char cmd[P2P_CMD_SIZE];
+		char peer_info[P2P_PEER_INFO_SIZE];
+		char *pos;
+		size_t len;
+		uint16_t peer_idx = 0;
+		uint8_t mac[WIFI_MAC_ADDR_LEN];
+		struct net_eth_addr peer_mac;
+		bool query_all_peers;
+
+		if (!params->peers) {
+			wpa_printf(MSG_ERROR, "Peer info array not provided");
+			return -EINVAL;
+		}
+
+		memcpy(&peer_mac, params->peer_addr, WIFI_MAC_ADDR_LEN);
+		query_all_peers = net_eth_is_addr_broadcast(&peer_mac);
+
+		if (query_all_peers) {
+			os_strlcpy(cmd_buf, "P2P_PEER FIRST", sizeof(cmd_buf));
+
+			while (peer_idx < params->peer_count) {
+				ret = zephyr_wpa_cli_cmd_resp_noprint(wpa_s->ctrl_conn,
+								      cmd_buf, resp_buf);
+
+				if (ret < 0 || resp_buf[0] == '\0' ||
+				    os_strncmp(resp_buf, "FAIL", 4) == 0) {
+					if (peer_idx == 0) {
+						wpa_printf(MSG_DEBUG, "No P2P peers found");
+					}
+					break;
+				}
+
+				len = 0;
+				pos = resp_buf;
+				while (*pos != '\0' && *pos != '\n' && len < sizeof(addr) - 1) {
+					addr[len++] = *pos++;
+				}
+				addr[len] = '\0';
+
+				if (os_strncmp(addr, "00:00:00:00:00:00", 17) != 0) {
+					if (sscanf(addr, "%hhx:%hhx:%hhx:%hhx:%hhx:%hhx",
+						   &mac[0], &mac[1], &mac[2],
+						   &mac[3], &mac[4], &mac[5]) == WIFI_MAC_ADDR_LEN) {
+
+						os_snprintf(cmd, sizeof(cmd), "P2P_PEER %s", addr);
+						ret = zephyr_wpa_cli_cmd_resp_noprint(
+							wpa_s->ctrl_conn, cmd, peer_info);
+
+						if (ret >= 0 && (!params->discovered_only ||
+						    os_strstr(peer_info, "[PROBE_REQ_ONLY]") == NULL)) {
+							parse_peer_info_response(peer_info, mac,
+										 &params->peers[peer_idx]);
+							peer_idx++;
+						}
+					}
+				}
+				os_snprintf(cmd_buf, sizeof(cmd_buf), "P2P_PEER NEXT-%s", addr);
+			}
+			params->peer_count = peer_idx;
+		} else {
+			char addr_str[18];
+
+			if (params->peer_count < 1) {
+				wpa_printf(MSG_ERROR, "Peer count must be at least 1");
+				return -EINVAL;
+			}
+
+			snprintf(addr_str, sizeof(addr_str), "%02x:%02x:%02x:%02x:%02x:%02x",
+				 params->peer_addr[0], params->peer_addr[1], params->peer_addr[2],
+				 params->peer_addr[3], params->peer_addr[4], params->peer_addr[5]);
+			snprintf(cmd_buf, sizeof(cmd_buf), "P2P_PEER %s", addr_str);
+
+			ret = zephyr_wpa_cli_cmd_resp_noprint(wpa_s->ctrl_conn,
+							      cmd_buf, resp_buf);
+			if (ret < 0) {
+				wpa_printf(MSG_ERROR, "P2P_PEER command failed: %d", ret);
+				return -EIO;
+			}
+			if (os_strncmp(resp_buf, "FAIL", 4) == 0) {
+				wpa_printf(MSG_ERROR, "Peer %s not found", addr_str);
+				return -ENODEV;
+			}
+			parse_peer_info_response(resp_buf, params->peer_addr,
+						 &params->peers[0]);
+			params->peer_count = 1;
+		}
+		ret = 0;
+		break;
+
+	case WIFI_P2P_CONNECT: {
+		char addr_str[18];
+		const char *method_str = "";
+
+		if (!params) {
+			wpa_printf(MSG_ERROR, "P2P connect params are NULL");
+			return -EINVAL;
+		}
+
+		snprintf(addr_str, sizeof(addr_str), "%02x:%02x:%02x:%02x:%02x:%02x",
+			 params->peer_addr[0], params->peer_addr[1], params->peer_addr[2],
+			 params->peer_addr[3], params->peer_addr[4], params->peer_addr[5]);
+
+		switch (params->connect.method) {
+		case WIFI_P2P_METHOD_PBC:
+			method_str = "pbc";
+			snprintf(cmd_buf, sizeof(cmd_buf), "P2P_CONNECT %s %s go_intent=%d",
+				 addr_str, method_str, params->connect.go_intent);
+			break;
+		case WIFI_P2P_METHOD_DISPLAY:
+			method_str = "pin";
+			snprintf(cmd_buf, sizeof(cmd_buf), "P2P_CONNECT %s %s go_intent=%d",
+				 addr_str, method_str, params->connect.go_intent);
+			break;
+		case WIFI_P2P_METHOD_KEYPAD:
+			method_str = "keypad";
+			if (params->connect.pin[0] == '\0') {
+				wpa_printf(MSG_ERROR, "PIN required for keypad method");
+				return -EINVAL;
+			}
+			snprintf(cmd_buf, sizeof(cmd_buf), "P2P_CONNECT %s %s %s go_intent=%d",
+				 addr_str, method_str, params->connect.pin, params->connect.go_intent);
+			break;
+		default:
+			wpa_printf(MSG_ERROR, "Unknown P2P connection method: %d",
+				   params->connect.method);
+			return -EINVAL;
+		}
+
+		ret = zephyr_wpa_cli_cmd_resp_noprint(wpa_s->ctrl_conn, cmd_buf, resp_buf);
+		if (ret < 0) {
+			wpa_printf(MSG_ERROR, "P2P_CONNECT command failed: %d", ret);
+			return -EIO;
+		}
+		if (os_strncmp(resp_buf, "FAIL", 4) == 0) {
+			wpa_printf(MSG_ERROR, "P2P connect failed: %s", resp_buf);
+			return -ENODEV;
+		}
+
+		/* For DISPLAY method, capture the generated PIN from response */
+		if (params->connect.method == WIFI_P2P_METHOD_DISPLAY) {
+			size_t len = 0;
+			char *pos = resp_buf;
+
+			while (*pos == ' ' || *pos == '\t' || *pos == '\n') {
+				pos++;
+			}
+
+			while (*pos != '\0' && *pos != '\n' && *pos != ' ' &&
+			       len < WIFI_WPS_PIN_MAX_LEN) {
+				params->connect.pin[len++] = *pos++;
+			}
+			params->connect.pin[len] = '\0';
+
+			if (params->connect.pin[0] == '\0') {
+				wpa_printf(MSG_ERROR, "P2P connect: No PIN returned");
+				return -ENODEV;
+			}
+		}
+
+		ret = 0;
+		break;
+	}
+
+	default:
+		wpa_printf(MSG_ERROR, "Unknown P2P operation: %d", params->oper);
+		ret = -EINVAL;
+		break;
+	}
+
+	return ret;
+}
+#endif /* CONFIG_WIFI_NM_WPA_SUPPLICANT_P2P */
diff --git a/modules/hostap/src/supp_api.h b/modules/hostap/src/supp_api.h
index 1ef63474f3fb..692db61bf277 100644
--- a/modules/hostap/src/supp_api.h
+++ b/modules/hostap/src/supp_api.h
@@ -321,6 +321,17 @@ int supplicant_wps_config(const struct device *dev, struct wifi_wps_config_param
  */
 int supplicant_set_bss_max_idle_period(const struct device *dev,
 				       unsigned short bss_max_idle_period);
+
+#if defined(CONFIG_WIFI_NM_WPA_SUPPLICANT_BGSCAN) || defined(__DOXYGEN__)
+/** @ Set Wi-Fi background scanning parameters
+ *
+ * @param dev Wi-Fi interface handle to use
+ * @param params bgscan parameters
+ * @return 0 for OK; -1 for ERROR
+ */
+int supplicant_set_bgscan(const struct device *dev, struct wifi_bgscan_params *params);
+#endif
+
 #ifdef CONFIG_AP
 int set_ap_bandwidth(const struct device *dev, enum wifi_frequency_bandwidths bandwidth);
 
@@ -375,4 +386,16 @@ int supplicant_dpp_dispatch(const struct device *dev, struct wifi_dpp_params *pa
  * @return 0 for OK; -1 for ERROR
  */
 int supplicant_config_params(const struct device *dev, struct wifi_config_params *params);
+
+#ifdef CONFIG_WIFI_NM_WPA_SUPPLICANT_P2P
+/**
+ * @brief P2P operation
+ *
+ * @param dev Wi-Fi interface handle to use
+ * @param params P2P parameters
+ * @return 0 for OK; -1 for ERROR
+ */
+int supplicant_p2p_oper(const struct device *dev, struct wifi_p2p_params *params);
+#endif /* CONFIG_WIFI_NM_WPA_SUPPLICANT_P2P */
+
 #endif /* ZEPHYR_SUPP_MGMT_H */
diff --git a/modules/hostap/src/supp_events.c b/modules/hostap/src/supp_events.c
index c4175a416bea..ee6a05a568ec 100644
--- a/modules/hostap/src/supp_events.c
+++ b/modules/hostap/src/supp_events.c
@@ -43,6 +43,9 @@ static const struct wpa_supp_event_info {
 	{ "CTRL-EVENT-NETWORK-REMOVED", SUPPLICANT_EVENT_NETWORK_REMOVED },
 	{ "CTRL-EVENT-DSCP-POLICY", SUPPLICANT_EVENT_DSCP_POLICY },
 	{ "CTRL-EVENT-REGDOM-CHANGE", SUPPLICANT_EVENT_REGDOM_CHANGE },
+#ifdef CONFIG_WIFI_NM_WPA_SUPPLICANT_P2P
+	{ "P2P-DEVICE-FOUND", SUPPLICANT_EVENT_P2P_DEVICE_FOUND },
+#endif
 };
 
 static void copy_mac_addr(const unsigned int *src, uint8_t *dst)
@@ -174,6 +177,43 @@ static int supplicant_process_status(struct supplicant_int_event_data *event_dat
 		event_data->data_len = sizeof(data->bss_removed);
 		copy_mac_addr(tmp_mac_addr, data->bss_removed.bssid);
 		break;
+#ifdef CONFIG_WIFI_NM_WPA_SUPPLICANT_P2P
+	case SUPPLICANT_EVENT_P2P_DEVICE_FOUND:
+	{
+		char *ptr, *name_start, *name_end;
+		unsigned int config_methods = 0;
+
+		memset(&data->p2p_device_found, 0, sizeof(data->p2p_device_found));
+		ret = sscanf(event_no_prefix, MACSTR, MACADDR2STR(tmp_mac_addr));
+		if (ret > 0) {
+			copy_mac_addr(tmp_mac_addr, data->p2p_device_found.mac);
+		}
+		name_start = strstr(event_no_prefix, "name='");
+		if (name_start) {
+			name_start += 6;
+			name_end = strchr(name_start, '\'');
+			if (name_end) {
+				size_t name_len = name_end - name_start;
+
+				if (name_len >= sizeof(data->p2p_device_found.device_name)) {
+					name_len = sizeof(data->p2p_device_found.device_name) - 1;
+				}
+				memcpy(data->p2p_device_found.device_name, name_start, name_len);
+				data->p2p_device_found.device_name[name_len] = '\0';
+			}
+		}
+		ptr = strstr(event_no_prefix, "config_methods=");
+		if (ptr) {
+			ret = sscanf(ptr, "config_methods=%x", &config_methods);
+			if (ret > 0) {
+				data->p2p_device_found.config_methods = config_methods;
+			}
+		}
+		event_data->data_len = sizeof(data->p2p_device_found);
+		ret = 1;
+		break;
+	}
+#endif
 	case SUPPLICANT_EVENT_TERMINATING:
 	case SUPPLICANT_EVENT_SCAN_STARTED:
 	case SUPPLICANT_EVENT_SCAN_RESULTS:
@@ -386,8 +426,18 @@ int supplicant_send_wifi_mgmt_event(const char *ifname, enum net_event_wifi_cmd
 	case NET_EVENT_WIFI_CMD_SUPPLICANT:
 		event_data.data = &data;
 		if (supplicant_process_status(&event_data, (char *)supplicant_status) > 0) {
-			net_mgmt_event_notify_with_info(NET_EVENT_SUPPLICANT_INT_EVENT,
-						iface, &event_data, sizeof(event_data));
+#ifdef CONFIG_WIFI_NM_WPA_SUPPLICANT_P2P
+			/* Handle P2P events directly */
+			if (event_data.event == SUPPLICANT_EVENT_P2P_DEVICE_FOUND) {
+				wifi_mgmt_raise_p2p_device_found_event(iface,
+						&data.p2p_device_found);
+			} else {
+#endif
+				net_mgmt_event_notify_with_info(NET_EVENT_SUPPLICANT_INT_EVENT,
+							iface, &event_data, sizeof(event_data));
+#ifdef CONFIG_WIFI_NM_WPA_SUPPLICANT_P2P
+			}
+#endif
 		}
 		break;
 	default:
diff --git a/modules/hostap/src/supp_events.h b/modules/hostap/src/supp_events.h
index 1c74af528492..6ff8812c2fb8 100644
--- a/modules/hostap/src/supp_events.h
+++ b/modules/hostap/src/supp_events.h
@@ -137,6 +137,10 @@ union supplicant_event_data {
 		unsigned int id;
 	} network_removed;
 
+#ifdef CONFIG_WIFI_NM_WPA_SUPPLICANT_P2P
+	struct wifi_p2p_device_info p2p_device_found;
+#endif
+
 	char supplicant_event_str[NM_WIFI_EVENT_STR_LEN];
 };
 
@@ -158,6 +162,9 @@ enum supplicant_event_num {
 	SUPPLICANT_EVENT_NETWORK_REMOVED,
 	SUPPLICANT_EVENT_DSCP_POLICY,
 	SUPPLICANT_EVENT_REGDOM_CHANGE,
+#ifdef CONFIG_WIFI_NM_WPA_SUPPLICANT_P2P
+	SUPPLICANT_EVENT_P2P_DEVICE_FOUND,
+#endif
 };
 
 struct supplicant_int_event_data {
diff --git a/modules/hostap/src/supp_main.c b/modules/hostap/src/supp_main.c
index 74d195386b1f..8afdba33b203 100644
--- a/modules/hostap/src/supp_main.c
+++ b/modules/hostap/src/supp_main.c
@@ -85,6 +85,9 @@ static const struct wifi_mgmt_ops mgmt_ops = {
 	.get_conn_params = supplicant_get_wifi_conn_params,
 	.wps_config = supplicant_wps_config,
 	.set_bss_max_idle_period = supplicant_set_bss_max_idle_period,
+#ifdef CONFIG_WIFI_NM_WPA_SUPPLICANT_BGSCAN
+	.set_bgscan = supplicant_set_bgscan,
+#endif /* CONFIG_WIFI_NM_WPA_SUPPLICANT_BGSCAN */
 #ifdef CONFIG_AP
 	.ap_enable = supplicant_ap_enable,
 	.ap_disable = supplicant_ap_disable,
@@ -98,6 +101,9 @@ static const struct wifi_mgmt_ops mgmt_ops = {
 	.enterprise_creds = supplicant_add_enterprise_creds,
 #endif
 	.config_params = supplicant_config_params,
+#ifdef CONFIG_WIFI_NM_WPA_SUPPLICANT_P2P
+	.p2p_oper = supplicant_p2p_oper,
+#endif
 };
 
 DEFINE_WIFI_NM_INSTANCE(wifi_supplicant, &mgmt_ops);
@@ -242,6 +248,12 @@ static void zephyr_wpa_supplicant_msg(void *ctx, const char *txt, size_t len)
 		supplicant_send_wifi_mgmt_event(wpa_s->ifname,
 						NET_EVENT_WIFI_CMD_NEIGHBOR_REP_RECEIVED,
 						(void *)txt, len);
+#ifdef CONFIG_WIFI_NM_WPA_SUPPLICANT_P2P
+	} else if (strncmp(txt, "P2P-", 4) == 0) {
+		supplicant_send_wifi_mgmt_event(wpa_s->ifname,
+						NET_EVENT_WIFI_CMD_SUPPLICANT,
+						(void *)txt, len);
+#endif
 	}
 }
 
diff --git a/modules/hostap/src/supp_main.h b/modules/hostap/src/supp_main.h
index 60ac642f9c79..2b2d5fc61112 100644
--- a/modules/hostap/src/supp_main.h
+++ b/modules/hostap/src/supp_main.h
@@ -58,8 +58,6 @@ struct wpa_supplicant *zephyr_get_handle_by_ifname(const char *ifname);
 struct hapd_interfaces *zephyr_get_default_hapd_context(void);
 #endif
 
-struct wpa_supplicant *zephyr_get_handle_by_ifname(const char *ifname);
-
 struct wpa_supplicant_event_msg {
 #ifdef CONFIG_WIFI_NM_HOSTAPD_AP
 	int hostapd;
diff --git a/modules/hostap/src/wpa_cli.c b/modules/hostap/src/wpa_cli.c
index 406008da101a..0e1b41728b74 100644
--- a/modules/hostap/src/wpa_cli.c
+++ b/modules/hostap/src/wpa_cli.c
@@ -8,10 +8,17 @@
  * @brief wpa_cli implementation for Zephyr OS
  */
 
+#include <stdlib.h>
 #include <zephyr/kernel.h>
 #include <zephyr/shell/shell.h>
+#include <zephyr/net/net_if.h>
 #include <zephyr/init.h>
 
+
+#include "supp_main.h"
+
+#include "common.h"
+#include "wpa_supplicant_i.h"
 #include "wpa_cli_zephyr.h"
 #ifdef CONFIG_WIFI_NM_HOSTAPD_AP
 #include "hostapd_cli_zephyr.h"
@@ -21,8 +28,20 @@ static int cmd_wpa_cli(const struct shell *sh,
 			  size_t argc,
 			  const char *argv[])
 {
+	struct net_if *iface = net_if_get_first_wifi();
+	char if_name[CONFIG_NET_INTERFACE_NAME_LEN + 1];
+	struct wpa_supplicant *wpa_s = NULL;
+
 	ARG_UNUSED(sh);
 
+	if (iface == NULL) {
+		shell_error(sh, "No Wifi interface found");
+		return -ENOENT;
+	}
+
+	net_if_get_name(iface, if_name, sizeof(if_name));
+	wpa_s = zephyr_get_handle_by_ifname(if_name);
+
 	if (argc == 1) {
 		shell_error(sh, "Missing argument");
 		return -EINVAL;
@@ -32,7 +51,7 @@ static int cmd_wpa_cli(const struct shell *sh,
 	argc++;
 
 	/* Remove wpa_cli from the argument list */
-	return zephyr_wpa_ctrl_zephyr_cmd(argc - 1, &argv[1]);
+	return zephyr_wpa_ctrl_zephyr_cmd(wpa_s->ctrl_conn, argc - 1, &argv[1]);
 }
 
 #ifdef CONFIG_WIFI_NM_HOSTAPD_AP
diff --git a/subsys/net/l2/wifi/wifi_mgmt.c b/subsys/net/l2/wifi/wifi_mgmt.c
index a962fe317664..58d269e277be 100644
--- a/subsys/net/l2/wifi/wifi_mgmt.c
+++ b/subsys/net/l2/wifi/wifi_mgmt.c
@@ -1449,6 +1449,60 @@ static int wifi_set_bss_max_idle_period(uint64_t mgmt_request, struct net_if *if
 NET_MGMT_REGISTER_REQUEST_HANDLER(NET_REQUEST_WIFI_BSS_MAX_IDLE_PERIOD,
 				  wifi_set_bss_max_idle_period);
 
+#ifdef CONFIG_WIFI_NM_WPA_SUPPLICANT_BGSCAN
+static int wifi_set_bgscan(uint64_t mgmt_request, struct net_if *iface, void *data, size_t len)
+{
+	const struct device *dev = net_if_get_device(iface);
+	const struct wifi_mgmt_ops *const wifi_mgmt_api = get_wifi_api(iface);
+	struct wifi_bgscan_params *params = data;
+
+	if (wifi_mgmt_api == NULL || wifi_mgmt_api->set_bgscan == NULL) {
+		return -ENOTSUP;
+	}
+
+	if (!net_if_is_admin_up(iface)) {
+		return -ENETDOWN;
+	}
+
+	if (data == NULL || len != sizeof(*params)) {
+		return -EINVAL;
+	}
+
+	return wifi_mgmt_api->set_bgscan(dev, params);
+}
+
+NET_MGMT_REGISTER_REQUEST_HANDLER(NET_REQUEST_WIFI_BGSCAN, wifi_set_bgscan);
+#endif
+#ifdef CONFIG_WIFI_NM_WPA_SUPPLICANT_P2P
+static int wifi_p2p_oper(uint64_t mgmt_request, struct net_if *iface,
+		    void *data, size_t len)
+{
+	const struct device *dev = net_if_get_device(iface);
+	const struct wifi_mgmt_ops *const wifi_mgmt_api = get_wifi_api(iface);
+	struct wifi_p2p_params *params = data;
+
+	if (wifi_mgmt_api == NULL || wifi_mgmt_api->p2p_oper == NULL) {
+		return -ENOTSUP;
+	}
+
+	if (!data || len != sizeof(*params)) {
+		return -EINVAL;
+	}
+
+	return wifi_mgmt_api->p2p_oper(dev, params);
+}
+
+NET_MGMT_REGISTER_REQUEST_HANDLER(NET_REQUEST_WIFI_P2P_OPER, wifi_p2p_oper);
+
+void wifi_mgmt_raise_p2p_device_found_event(struct net_if *iface,
+					     struct wifi_p2p_device_info *peer_info)
+{
+	net_mgmt_event_notify_with_info(NET_EVENT_WIFI_P2P_DEVICE_FOUND,
+					iface, peer_info,
+					sizeof(*peer_info));
+}
+#endif /* CONFIG_WIFI_NM_WPA_SUPPLICANT_P2P */
+
 #ifdef CONFIG_WIFI_MGMT_RAW_SCAN_RESULTS
 void wifi_mgmt_raise_raw_scan_result_event(struct net_if *iface,
 					   struct wifi_raw_scan_result *raw_scan_result)
diff --git a/subsys/net/l2/wifi/wifi_shell.c b/subsys/net/l2/wifi/wifi_shell.c
index 555358aff0a9..5a4ce9703a34 100644
--- a/subsys/net/l2/wifi/wifi_shell.c
+++ b/subsys/net/l2/wifi/wifi_shell.c
@@ -46,7 +46,8 @@ LOG_MODULE_REGISTER(net_wifi_shell, LOG_LEVEL_INF);
 				NET_EVENT_WIFI_AP_STA_CONNECTED   |\
 				NET_EVENT_WIFI_AP_STA_DISCONNECTED|\
 				NET_EVENT_WIFI_SIGNAL_CHANGE      |\
-				NET_EVENT_WIFI_NEIGHBOR_REP_COMP)
+				NET_EVENT_WIFI_NEIGHBOR_REP_COMP  |\
+				NET_EVENT_WIFI_P2P_DEVICE_FOUND)
 
 #ifdef CONFIG_WIFI_MGMT_RAW_SCAN_RESULTS_ONLY
 #define WIFI_SHELL_SCAN_EVENTS (                   \
@@ -519,6 +520,26 @@ static void handle_wifi_neighbor_rep_complete(struct net_mgmt_event_callback *cb
 }
 #endif
 
+#ifdef CONFIG_WIFI_NM_WPA_SUPPLICANT_P2P
+static void handle_wifi_p2p_device_found(struct net_mgmt_event_callback *cb)
+{
+	const struct wifi_p2p_device_info *peer_info =
+		(const struct wifi_p2p_device_info *)cb->info;
+	const struct shell *sh = context.sh;
+
+	if (!peer_info || peer_info->device_name[0] == '\0') {
+		return;
+	}
+
+	PR("Device Name: %-20s MAC Address: %02x:%02x:%02x:%02x:%02x:%02x      "
+	   "Config Methods: 0x%x\n",
+	   peer_info->device_name,
+	   peer_info->mac[0], peer_info->mac[1], peer_info->mac[2],
+	   peer_info->mac[3], peer_info->mac[4], peer_info->mac[5],
+	   peer_info->config_methods);
+}
+#endif /* CONFIG_WIFI_NM_WPA_SUPPLICANT_P2P */
+
 static void wifi_mgmt_event_handler(struct net_mgmt_event_callback *cb,
 				    uint64_t mgmt_event, struct net_if *iface)
 {
@@ -552,6 +573,11 @@ static void wifi_mgmt_event_handler(struct net_mgmt_event_callback *cb,
 		handle_wifi_neighbor_rep_complete(cb, iface);
 		break;
 #endif
+#ifdef CONFIG_WIFI_NM_WPA_SUPPLICANT_P2P
+	case NET_EVENT_WIFI_P2P_DEVICE_FOUND:
+		handle_wifi_p2p_device_found(cb);
+		break;
+#endif /* CONFIG_WIFI_NM_WPA_SUPPLICANT_P2P */
 	default:
 		break;
 	}
@@ -3516,6 +3542,279 @@ static int cmd_wifi_dpp_reconfig(const struct shell *sh, size_t argc, char *argv
 }
 
 #endif /* CONFIG_WIFI_NM_WPA_SUPPLICANT_DPP */
+
+#ifdef CONFIG_WIFI_NM_WPA_SUPPLICANT_P2P
+static void print_peer_info(const struct shell *sh, int index,
+			    const struct wifi_p2p_device_info *peer)
+{
+	uint8_t mac_string_buf[sizeof("xx:xx:xx:xx:xx:xx")];
+	const char *device_name;
+	const char *device_type;
+	const char *config_methods;
+
+	device_name = (peer->device_name[0] != '\0') ?
+		      peer->device_name : "<Unknown>";
+	device_type = (peer->pri_dev_type_str[0] != '\0') ?
+		      peer->pri_dev_type_str : "-";
+	config_methods = (peer->config_methods_str[0] != '\0') ?
+			 peer->config_methods_str : "-";
+
+	PR("%-4d | %-32s | %-17s | %-4d | %-20s | %s\n",
+	   index,
+	   device_name,
+	   net_sprint_ll_addr_buf(peer->mac, WIFI_MAC_ADDR_LEN,
+				  mac_string_buf,
+				  sizeof(mac_string_buf)),
+	   peer->rssi,
+	   device_type,
+	   config_methods);
+}
+
+static int cmd_wifi_p2p_peer(const struct shell *sh, size_t argc, char *argv[])
+{
+	struct net_if *iface = get_iface(IFACE_TYPE_STA, argc, argv);
+	struct wifi_p2p_params params = {0};
+	uint8_t mac_addr[WIFI_MAC_ADDR_LEN];
+	struct wifi_p2p_device_info *peers = NULL;
+	int ret;
+	int max_peers = (argc < 2) ? WIFI_P2P_MAX_PEERS : 1;
+
+	context.sh = sh;
+
+	peers = k_malloc(sizeof(struct wifi_p2p_device_info) * max_peers);
+	if (!peers) {
+		PR_ERROR("Failed to allocate memory for peer info\n");
+		return -ENOMEM;
+	}
+	memset(peers, 0, sizeof(struct wifi_p2p_device_info) * max_peers);
+
+	params.peers = peers;
+	params.oper = WIFI_P2P_PEER;
+	params.peer_count = max_peers;
+
+	if (argc >= 2) {
+		if (sscanf(argv[1], "%hhx:%hhx:%hhx:%hhx:%hhx:%hhx",
+			   &mac_addr[0], &mac_addr[1], &mac_addr[2],
+			   &mac_addr[3], &mac_addr[4], &mac_addr[5]) != WIFI_MAC_ADDR_LEN) {
+			PR_ERROR("Invalid MAC address format. Use: XX:XX:XX:XX:XX:XX\n");
+			k_free(peers);
+			return -EINVAL;
+		}
+		memcpy(params.peer_addr, mac_addr, WIFI_MAC_ADDR_LEN);
+		params.peer_count = 1;
+	} else {
+		/* Use broadcast MAC to query all peers */
+		memset(params.peer_addr, 0xFF, WIFI_MAC_ADDR_LEN);
+	}
+
+	ret = net_mgmt(NET_REQUEST_WIFI_P2P_OPER, iface, &params, sizeof(params));
+	if (ret) {
+		PR_WARNING("P2P peer info request failed\n");
+		k_free(peers);
+		return -ENOEXEC;
+	}
+
+	if (params.peer_count > 0) {
+		PR("\n%-4s | %-32s | %-17s | %-4s | %-20s | %s\n",
+		   "Num", "Device Name", "MAC Address", "RSSI", "Device Type", "Config Methods");
+		for (int i = 0; i < params.peer_count; i++) {
+			print_peer_info(sh, i + 1, &peers[i]);
+		}
+	} else {
+		if (argc >= 2) {
+			shell_print(sh, "No information available for peer %s", argv[1]);
+		} else {
+			shell_print(sh, "No P2P peers found");
+		}
+	}
+
+	k_free(peers);
+	return 0;
+}
+
+
+static int cmd_wifi_p2p_find(const struct shell *sh, size_t argc, char *argv[])
+{
+	struct net_if *iface = get_iface(IFACE_TYPE_STA, argc, argv);
+	struct wifi_p2p_params params = {0};
+
+	context.sh = sh;
+
+	params.oper = WIFI_P2P_FIND;
+	params.discovery_type = WIFI_P2P_FIND_START_WITH_FULL;
+	params.timeout = 10; /* Default 10 second timeout */
+
+	if (argc > 1) {
+		int opt;
+		int opt_index = 0;
+		struct getopt_state *state;
+		static const struct option long_options[] = {
+			{"timeout", required_argument, 0, 't'},
+			{"type", required_argument, 0, 'T'},
+			{"iface", required_argument, 0, 'i'},
+			{"help", no_argument, 0, 'h'},
+			{0, 0, 0, 0}
+		};
+		long val;
+
+		while ((opt = getopt_long(argc, argv, "t:T:i:h",
+						long_options, &opt_index)) != -1) {
+			state = getopt_state_get();
+			switch (opt) {
+			case 't':
+				if (!parse_number(sh, &val, state->optarg, "timeout", 0, 65535)) {
+					return -EINVAL;
+				}
+				params.timeout = (uint16_t)val;
+				break;
+			case 'T':
+				if (!parse_number(sh, &val, state->optarg, "type", 0, 2)) {
+					return -EINVAL;
+				}
+				switch (val) {
+				case 0:
+					params.discovery_type = WIFI_P2P_FIND_ONLY_SOCIAL;
+					break;
+				case 1:
+					params.discovery_type = WIFI_P2P_FIND_PROGRESSIVE;
+					break;
+				case 2:
+					params.discovery_type = WIFI_P2P_FIND_START_WITH_FULL;
+					break;
+				default:
+					return -EINVAL;
+				}
+				break;
+			case 'i':
+				/* Unused, but parsing to avoid unknown option error */
+				break;
+			case 'h':
+				shell_help(sh);
+				return -ENOEXEC;
+			default:
+				PR_ERROR("Invalid option %c\n", state->optopt);
+				return -EINVAL;
+			}
+		}
+	}
+
+	if (net_mgmt(NET_REQUEST_WIFI_P2P_OPER, iface, &params, sizeof(params))) {
+		PR_WARNING("P2P find request failed\n");
+		return -ENOEXEC;
+	}
+	PR("P2P find started\n");
+	return 0;
+}
+
+static int cmd_wifi_p2p_stop_find(const struct shell *sh, size_t argc, char *argv[])
+{
+	struct net_if *iface = get_iface(IFACE_TYPE_STA, argc, argv);
+	struct wifi_p2p_params params = {0};
+
+	context.sh = sh;
+
+	params.oper = WIFI_P2P_STOP_FIND;
+
+	if (net_mgmt(NET_REQUEST_WIFI_P2P_OPER, iface, &params, sizeof(params))) {
+		PR_WARNING("P2P stop find request failed\n");
+		return -ENOEXEC;
+	}
+	PR("P2P find stopped\n");
+	return 0;
+}
+
+static int cmd_wifi_p2p_connect(const struct shell *sh, size_t argc, char *argv[])
+{
+	struct net_if *iface = get_iface(IFACE_TYPE_STA, argc, argv);
+	struct wifi_p2p_params params = {0};
+	uint8_t mac_addr[WIFI_MAC_ADDR_LEN];
+	const char *method_arg = NULL;
+	int opt;
+	int opt_index = 0;
+	struct getopt_state *state;
+	static const struct option long_options[] = {
+		{"go-intent", required_argument, 0, 'g'},
+		{"iface", required_argument, 0, 'i'},
+		{"help", no_argument, 0, 'h'},
+		{0, 0, 0, 0}
+	};
+	long val;
+
+	context.sh = sh;
+
+	if (argc < 3) {
+		PR_ERROR("Usage: wifi p2p connect <MAC address> <pbc|pin> [PIN] "
+			 "[--go-intent=<0-15>]\n");
+		return -EINVAL;
+	}
+
+	/* Parse MAC address */
+	if (sscanf(argv[1], "%hhx:%hhx:%hhx:%hhx:%hhx:%hhx",
+		   &mac_addr[0], &mac_addr[1], &mac_addr[2],
+		   &mac_addr[3], &mac_addr[4], &mac_addr[5]) != WIFI_MAC_ADDR_LEN) {
+		PR_ERROR("Invalid MAC address format. Use: XX:XX:XX:XX:XX:XX\n");
+		return -EINVAL;
+	}
+	memcpy(params.peer_addr, mac_addr, WIFI_MAC_ADDR_LEN);
+
+	method_arg = argv[2];
+	if (strcmp(method_arg, "pbc") == 0) {
+		params.connect.method = WIFI_P2P_METHOD_PBC;
+	} else if (strcmp(method_arg, "pin") == 0) {
+		if (argc > 3 && argv[3][0] != '-') {
+			params.connect.method = WIFI_P2P_METHOD_KEYPAD;
+			strncpy(params.connect.pin, argv[3], WIFI_WPS_PIN_MAX_LEN);
+			params.connect.pin[WIFI_WPS_PIN_MAX_LEN] = '\0';
+		} else {
+			params.connect.method = WIFI_P2P_METHOD_DISPLAY;
+			params.connect.pin[0] = '\0';
+		}
+	} else {
+		PR_ERROR("Invalid connection method. Use: pbc or pin\n");
+		return -EINVAL;
+	}
+
+	/* Set default GO intent */
+	params.connect.go_intent = 0;
+
+	while ((opt = getopt_long(argc, argv, "g:i:h", long_options, &opt_index)) != -1) {
+		state = getopt_state_get();
+		switch (opt) {
+		case 'g':
+			if (!parse_number(sh, &val, state->optarg, "go-intent", 0, 15)) {
+				return -EINVAL;
+			}
+			params.connect.go_intent = (uint8_t)val;
+			break;
+		case 'i':
+			/* Unused, but parsing to avoid unknown option error */
+			break;
+		case 'h':
+			shell_help(sh);
+			return -ENOEXEC;
+		default:
+			PR_ERROR("Invalid option %c\n", state->optopt);
+			return -EINVAL;
+		}
+	}
+
+	params.oper = WIFI_P2P_CONNECT;
+
+	if (net_mgmt(NET_REQUEST_WIFI_P2P_OPER, iface, &params, sizeof(params))) {
+		PR_WARNING("P2P connect request failed\n");
+		return -ENOEXEC;
+	}
+
+	/* Display the generated PIN for DISPLAY method */
+	if (params.connect.method == WIFI_P2P_METHOD_DISPLAY && params.connect.pin[0] != '\0') {
+		PR("%s\n", params.connect.pin);
+	} else {
+		PR("P2P connection initiated\n");
+	}
+	return 0;
+}
+#endif /* CONFIG_WIFI_NM_WPA_SUPPLICANT_P2P */
+
 static int cmd_wifi_pmksa_flush(const struct shell *sh, size_t argc, char *argv[])
 {
 	struct net_if *iface = get_iface(IFACE_TYPE_STA, argc, argv);
@@ -3555,6 +3854,113 @@ static int cmd_wifi_set_bss_max_idle_period(const struct shell *sh, size_t argc,
 	return 0;
 }
 
+#ifdef CONFIG_WIFI_NM_WPA_SUPPLICANT_BGSCAN
+static int wifi_bgscan_args_to_params(const struct shell *sh, size_t argc, char *argv[],
+				      struct wifi_bgscan_params *params)
+{
+	int err;
+	int opt;
+	int opt_index = 0;
+	struct getopt_state *state;
+	static const struct option long_options[] = {
+		{"type", required_argument, 0, 't'},
+		{"short-interval", required_argument, 0, 's'},
+		{"rss-threshold", required_argument, 0, 'r'},
+		{"long-interval", required_argument, 0, 'l'},
+		{"btm-queries", required_argument, 0, 'b'},
+		{"iface", required_argument, 0, 'i'},
+		{0, 0, 0, 0}};
+	unsigned long uval;
+	long val;
+
+	while ((opt = getopt_long(argc, argv, "t:s:r:l:b:i:", long_options, &opt_index)) != -1) {
+		state = getopt_state_get();
+		switch (opt) {
+		case 't':
+			if (strcmp("simple", state->optarg) == 0) {
+				params->type = WIFI_BGSCAN_SIMPLE;
+			} else if (strcmp("learn", state->optarg) == 0) {
+				params->type = WIFI_BGSCAN_LEARN;
+			} else if (strcmp("none", state->optarg) == 0) {
+				params->type = WIFI_BGSCAN_NONE;
+			} else {
+				PR_ERROR("Invalid type %s\n", state->optarg);
+				shell_help(sh);
+				return SHELL_CMD_HELP_PRINTED;
+			}
+			break;
+		case 's':
+			uval = shell_strtoul(state->optarg, 10, &err);
+			if (err < 0) {
+				PR_ERROR("Invalid short interval %s\n", state->optarg);
+				return err;
+			}
+			params->short_interval = uval;
+			break;
+		case 'l':
+			uval = shell_strtoul(state->optarg, 10, &err);
+			if (err < 0) {
+				PR_ERROR("Invalid long interval %s\n", state->optarg);
+				return err;
+			}
+			params->long_interval = uval;
+			break;
+		case 'b':
+			uval = shell_strtoul(state->optarg, 10, &err);
+			if (err < 0) {
+				PR_ERROR("Invalid BTM queries %s\n", state->optarg);
+				return err;
+			}
+			params->btm_queries = uval;
+			break;
+		case 'r':
+			val = shell_strtol(state->optarg, 10, &err);
+			if (err < 0) {
+				PR_ERROR("Invalid RSSI threshold %s\n", state->optarg);
+				return err;
+			}
+			params->rssi_threshold = val;
+			break;
+		case 'i':
+			/* Unused, but parsing to avoid unknown option error */
+			break;
+		default:
+			PR_ERROR("Invalid option %c\n", state->optopt);
+			shell_help(sh);
+			return SHELL_CMD_HELP_PRINTED;
+		}
+	}
+
+	return 0;
+}
+
+static int cmd_wifi_set_bgscan(const struct shell *sh, size_t argc, char *argv[])
+{
+	struct net_if *iface = get_iface(IFACE_TYPE_STA, argc, argv);
+	struct wifi_bgscan_params bgscan_params = {
+		.type = WIFI_BGSCAN_NONE,
+		.short_interval = 30,
+		.long_interval = 300,
+		.rssi_threshold = 0,
+		.btm_queries = 0,
+	};
+	int ret;
+
+	if (wifi_bgscan_args_to_params(sh, argc, argv, &bgscan_params) != 0) {
+		return -ENOEXEC;
+	}
+
+	ret = net_mgmt(NET_REQUEST_WIFI_BGSCAN, iface, &bgscan_params,
+		       sizeof(struct wifi_bgscan_params));
+	if (ret != 0) {
+		PR_WARNING("Setting background scanning parameters failed: %s\n", strerror(-ret));
+		return -ENOEXEC;
+	}
+
+	return 0;
+}
+#endif
+
 static int wifi_config_args_to_params(const struct shell *sh, size_t argc, char *argv[],
 					 struct wifi_config_params *params)
 {
@@ -4098,6 +4504,67 @@ SHELL_SUBCMD_ADD((wifi), bss_max_idle_period, NULL,
 		 cmd_wifi_set_bss_max_idle_period,
 		 2, 2);
 
+#ifdef CONFIG_WIFI_NM_WPA_SUPPLICANT_BGSCAN
+SHELL_SUBCMD_ADD((wifi), bgscan, NULL,
+		 "Configure background scanning.\n"
+		 "<-t, --type simple/learn/none> : The scanning type, use none to disable.\n"
+		 "[-s, --short-interval <val>] : Short scan interval (default: 30).\n"
+		 "[-l, --long-interval <val>] : Long scan interval (default: 300).\n"
+		 "[-r, --rssi-threshold <val>] : Signal strength threshold (default: disabled).\n"
+		 "[-b, --btm-queries <val>] : BTM queries before scanning (default: disabled).\n"
+		 "[-i, --iface=<interface index>] : Interface index.\n",
+		 cmd_wifi_set_bgscan,
+		 2, 6);
+#endif /* CONFIG_WIFI_NM_WPA_SUPPLICANT_BGSCAN */
+
+#ifdef CONFIG_WIFI_NM_WPA_SUPPLICANT_P2P
+SHELL_STATIC_SUBCMD_SET_CREATE(
+	wifi_cmd_p2p,
+	SHELL_CMD_ARG(find, NULL,
+		      "Start P2P device discovery\n"
+		      "[-t, --timeout=<timeout in seconds>]: Discovery timeout\n"
+		      "[-T, --type=<0|1|2>]: Discovery type\n"
+		      "  0: Social channels only (1, 6, 11)\n"
+		      "  1: Progressive scan (all channels)\n"
+		      "  2: Full scan first, then social (default)\n"
+		      "[-i, --iface=<interface index>]: Interface index\n"
+		      "[-h, --help]: Show help\n",
+		      cmd_wifi_p2p_find, 1, 6),
+	SHELL_CMD_ARG(stop_find, NULL,
+		      "Stop P2P device discovery\n"
+		      "[-i, --iface=<interface index>]: Interface index\n",
+		      cmd_wifi_p2p_stop_find, 1, 2),
+	SHELL_CMD_ARG(peer, NULL,
+		      "Show information about P2P peers\n"
+		      "Usage: peer [<MAC address>]\n"
+		      "<MAC address>: Show detailed info for specific peer (format: XX:XX:XX:XX:XX:XX)\n"
+		      "[-i, --iface=<interface index>]: Interface index\n",
+		      cmd_wifi_p2p_peer, 1, 3),
+	SHELL_CMD_ARG(connect, NULL,
+		      "Connect to a P2P peer\n"
+		      "Usage: connect <MAC address> <pbc|pin> [PIN] [options]\n"
+		      "<MAC address>: Peer device MAC address (format: XX:XX:XX:XX:XX:XX)\n"
+		      "<pbc>: Use Push Button Configuration\n"
+		      "<pin>: Use PIN method\n"
+		      "  - Without PIN: Device displays generated PIN for peer to enter\n"
+		      "  - With PIN: Device uses provided PIN to connect\n"
+		      "[PIN]: 8-digit PIN (optional, generates if omitted)\n"
+		      "[-g, --go-intent=<0-15>]: GO intent (0=client, 15=GO, default: 0)\n"
+		      "[-i, --iface=<interface index>]: Interface index\n"
+		      "[-h, --help]: Show help\n"
+		      "Examples:\n"
+		      "  wifi p2p connect 9c:b1:50:e3:81:96 pin -g 0  (displays PIN)\n"
+		      "  wifi p2p connect 9c:b1:50:e3:81:96 pin 12345670 -g 0  (uses PIN)\n",
+		      cmd_wifi_p2p_connect, 3, 7),
+	SHELL_SUBCMD_SET_END
+);
+
+SHELL_SUBCMD_ADD((wifi), p2p, &wifi_cmd_p2p,
+		 "Wi-Fi Direct (P2P) commands.",
+		 NULL,
+		 0, 0);
+#endif /* CONFIG_WIFI_NM_WPA_SUPPLICANT_P2P */
+
 SHELL_SUBCMD_ADD((wifi), config, NULL,
 		 "Configure STA parameters.\n"
 		 "-o, --okc=<0/1>: Opportunistic Key Caching. 0: disable, 1: enable\n"
diff --git a/west.yml b/west.yml
index d3df0b617955..f6f2d133c9aa 100644
--- a/west.yml
+++ b/west.yml
@@ -281,7 +281,7 @@ manifest:
         - hal
     - name: hostap
       path: modules/lib/hostap
-      revision: 5abcff1c0ecff65f0f81e0cc086b7f766e5101bf
+      revision: pull/107/head
     - name: liblc3
       revision: 48bbd3eacd36e99a57317a0a4867002e0b09e183
       path: modules/lib/liblc3
@@ -337,7 +337,7 @@ manifest:
       revision: 40403f5f2805cca210d2a47c8717d89c4e816cda
       path: modules/bsim_hw_models/nrf_hw_models
     - name: nrf_wifi
-      revision: e269670cd17fb8ccc4b7004544276bc7d9578496
+      revision: pull/83/head
       path: modules/lib/nrf_wifi
     - name: open-amp
       revision: c30a6d8b92fcebdb797fc1a7698e8729e250f637