diff --git a/wpa_supplicant/dpp_supplicant.c b/wpa_supplicant/dpp_supplicant.c
index e775422..152e257 100644
--- a/wpa_supplicant/dpp_supplicant.c
+++ b/wpa_supplicant/dpp_supplicant.c
@@ -469,7 +469,7 @@
 		wpa_printf(MSG_INFO,
 			   "DPP: No response received from responder - stopping initiation attempt");
 		wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_AUTH_INIT_FAILED);
-		wpas_notify_dpp_timeout(wpa_s->ifname);
+		wpas_notify_dpp_timeout(wpa_s);
 		offchannel_send_action_done(wpa_s);
 		wpas_dpp_listen_stop(wpa_s);
 		dpp_auth_deinit(auth);
@@ -731,6 +731,7 @@
 			wpa_printf(MSG_INFO,
 				   "DPP: No response received from responder - stopping initiation attempt");
 			wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_AUTH_INIT_FAILED);
+			wpas_notify_dpp_timeout(wpa_s);
 			eloop_cancel_timeout(wpas_dpp_reply_wait_timeout,
 					     wpa_s, NULL);
 			offchannel_send_action_done(wpa_s);
@@ -1141,7 +1142,7 @@
 					  peer_bi, own_bi, freq, hdr, buf, len);
 	if (!wpa_s->dpp_auth) {
 		wpa_printf(MSG_DEBUG, "DPP: No response generated");
-		wpas_notify_dpp_auth_failure(wpa_s->ifname);
+		wpas_notify_dpp_auth_failure(wpa_s);
 		return;
 	}
 	wpas_dpp_set_testing_options(wpa_s, wpa_s->dpp_auth);
@@ -1264,7 +1265,7 @@
 
 	wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_NETWORK_ID "%d", ssid->id);
 
-	wpas_notify_dpp_config_received(wpa_s->ifname, ssid);
+	wpas_notify_dpp_config_received(wpa_s, ssid);
 
 	if (wpa_s->conf->dpp_config_processing < 2) {
 		return;
@@ -1389,7 +1390,7 @@
 
 fail:
 	wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_CONF_FAILED);
-	wpas_notify_dpp_configuration_failure(wpa_s->ifname);
+	wpas_notify_dpp_configuration_failure(wpa_s);
 	dpp_auth_deinit(wpa_s->dpp_auth);
 	wpa_s->dpp_auth = NULL;
 }
@@ -1467,7 +1468,7 @@
 {
 	wpa_printf(MSG_DEBUG, "DPP: Authentication succeeded");
 	wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_AUTH_SUCCESS "init=%d", initiator);
-	wpas_notify_dpp_auth_success(wpa_s->ifname);
+	wpas_notify_dpp_auth_success(wpa_s);
 #ifdef CONFIG_TESTING_OPTIONS
 	if (dpp_test == DPP_TEST_STOP_AT_AUTH_CONF) {
 		wpa_printf(MSG_INFO,
@@ -1524,13 +1525,13 @@
 		if (auth->auth_resp_status == DPP_STATUS_RESPONSE_PENDING) {
 			wpa_printf(MSG_DEBUG,
 				   "DPP: Start wait for full response");
-			wpas_notify_dpp_resp_pending(wpa_s->ifname);
+			wpas_notify_dpp_resp_pending(wpa_s);
 			offchannel_send_action_done(wpa_s);
 			wpas_dpp_listen_start(wpa_s, auth->curr_freq);
 			return;
 		}
 		wpa_printf(MSG_DEBUG, "DPP: No confirm generated");
-		wpas_notify_dpp_auth_failure(wpa_s->ifname);
+		wpas_notify_dpp_auth_failure(wpa_s);
 		return;
 	}
 	os_memcpy(auth->peer_mac_addr, src, ETH_ALEN);
@@ -1568,7 +1569,7 @@
 
 	if (dpp_auth_conf_rx(auth, hdr, buf, len) < 0) {
 		wpa_printf(MSG_DEBUG, "DPP: Authentication failed");
-		wpas_notify_dpp_auth_failure(wpa_s->ifname);
+		wpas_notify_dpp_auth_failure(wpa_s);
 		return;
 	}
 
@@ -2161,7 +2162,7 @@
 	resp = dpp_conf_req_rx(auth, query, query_len);
 	if (!resp) {
 		wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_CONF_FAILED);
-		wpas_notify_dpp_configuration_failure(wpa_s->ifname);
+		wpas_notify_dpp_configuration_failure(wpa_s);
 	}
 	auth->conf_resp = resp;
 	return resp;
@@ -2194,11 +2195,11 @@
 	wpas_dpp_listen_stop(wpa_s);
 	if (ok) {
 		wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_CONF_SENT);
-		wpas_notify_dpp_config_sent(wpa_s->ifname);
+		wpas_notify_dpp_config_sent(wpa_s);
 	}
 	else {
 		wpa_msg(wpa_s, MSG_INFO, DPP_EVENT_CONF_FAILED);
-		wpas_notify_dpp_configuration_failure(wpa_s->ifname);
+		wpas_notify_dpp_configuration_failure(wpa_s);
 	}
 	dpp_auth_deinit(wpa_s->dpp_auth);
 	wpa_s->dpp_auth = NULL;
diff --git a/wpa_supplicant/hidl/1.2/hidl.cpp b/wpa_supplicant/hidl/1.2/hidl.cpp
index 60ee85f..d8fa82f 100644
--- a/wpa_supplicant/hidl/1.2/hidl.cpp
+++ b/wpa_supplicant/hidl/1.2/hidl.cpp
@@ -27,9 +27,9 @@
 using android::hardware::wifi::supplicant::V1_2::implementation::HidlManager;
 using namespace android::hardware::wifi::supplicant::V1_2;
 
-static void wpas_hidl_notify_dpp_success(const char *ifname, DppSuccessCode code);
-static void wpas_hidl_notify_dpp_failure(const char *ifname, DppFailureCode code);
-static void wpas_hidl_notify_dpp_progress(const char *ifname, DppProgressCode code);
+static void wpas_hidl_notify_dpp_success(struct wpa_supplicant *wpa_s, DppSuccessCode code);
+static void wpas_hidl_notify_dpp_failure(struct wpa_supplicant *wpa_s, DppFailureCode code);
+static void wpas_hidl_notify_dpp_progress(struct wpa_supplicant *wpa_s, DppProgressCode code);
 
 void wpas_hidl_sock_handler(
     int sock, void * /* eloop_ctx */, void * /* sock_ctx */)
@@ -648,10 +648,10 @@
 	hidl_manager->notifyEapError(wpa_s, error_code);
 }
 
-void wpas_hidl_notify_dpp_config_received(const char *ifname,
+void wpas_hidl_notify_dpp_config_received(struct wpa_supplicant *wpa_s,
 	    struct wpa_ssid *ssid)
 {
-	if (!ifname || !ssid)
+	if (!wpa_s || !ssid)
 		return;
 
 	wpa_printf(
@@ -662,85 +662,85 @@
 	if (!hidl_manager)
 		return;
 
-	hidl_manager->notifyDppConfigReceived(ifname, ssid);
+	hidl_manager->notifyDppConfigReceived(wpa_s, ssid);
 }
 
-void wpas_hidl_notify_dpp_config_sent(const char *ifname)
+void wpas_hidl_notify_dpp_config_sent(struct wpa_supplicant *wpa_s)
 {
-	if (!ifname)
+	if (!wpa_s)
 		return;
 
-	wpas_hidl_notify_dpp_success(ifname, DppSuccessCode::CONFIGURATION_SENT);
+	wpas_hidl_notify_dpp_success(wpa_s, DppSuccessCode::CONFIGURATION_SENT);
 }
 
 /* DPP Progress notifications */
-void wpas_hidl_notify_dpp_auth_success(const char *ifname)
+void wpas_hidl_notify_dpp_auth_success(struct wpa_supplicant *wpa_s)
 {
-	if (!ifname)
+	if (!wpa_s)
 		return;
 
-	wpas_hidl_notify_dpp_progress(ifname, DppProgressCode::AUTHENTICATION_SUCCESS);
+	wpas_hidl_notify_dpp_progress(wpa_s, DppProgressCode::AUTHENTICATION_SUCCESS);
 }
 
-void wpas_hidl_notify_dpp_resp_pending(const char *ifname)
+void wpas_hidl_notify_dpp_resp_pending(struct wpa_supplicant *wpa_s)
 {
-	if (!ifname)
+	if (!wpa_s)
 		return;
 
-	wpas_hidl_notify_dpp_progress(ifname, DppProgressCode::RESPONSE_PENDING);
+	wpas_hidl_notify_dpp_progress(wpa_s, DppProgressCode::RESPONSE_PENDING);
 }
 
 /* DPP Failure notifications */
-void wpas_hidl_notify_dpp_not_compatible(const char *ifname)
+void wpas_hidl_notify_dpp_not_compatible(struct wpa_supplicant *wpa_s)
 {
-	if (!ifname)
+	if (!wpa_s)
 		return;
 
-	wpas_hidl_notify_dpp_failure(ifname, DppFailureCode::NOT_COMPATIBLE);
+	wpas_hidl_notify_dpp_failure(wpa_s, DppFailureCode::NOT_COMPATIBLE);
 }
 
-void wpas_hidl_notify_dpp_missing_auth(const char *ifname)
+void wpas_hidl_notify_dpp_missing_auth(struct wpa_supplicant *wpa_s)
 {
-	if (!ifname)
+	if (!wpa_s)
 		return;
 }
 
-void wpas_hidl_notify_dpp_configuration_failure(const char *ifname)
+void wpas_hidl_notify_dpp_configuration_failure(struct wpa_supplicant *wpa_s)
 {
-	if (!ifname)
+	if (!wpa_s)
 		return;
 
-	wpas_hidl_notify_dpp_failure(ifname, DppFailureCode::CONFIGURATION);
+	wpas_hidl_notify_dpp_failure(wpa_s, DppFailureCode::CONFIGURATION);
 }
 
-void wpas_hidl_notify_dpp_timeout(const char *ifname)
+void wpas_hidl_notify_dpp_timeout(struct wpa_supplicant *wpa_s)
 {
-	if (!ifname)
+	if (!wpa_s)
 		return;
 
-	wpas_hidl_notify_dpp_failure(ifname, DppFailureCode::TIMEOUT);
+	wpas_hidl_notify_dpp_failure(wpa_s, DppFailureCode::TIMEOUT);
 }
 
-void wpas_hidl_notify_dpp_auth_failure(const char *ifname)
+void wpas_hidl_notify_dpp_auth_failure(struct wpa_supplicant *wpa_s)
 {
-	if (!ifname)
+	if (!wpa_s)
 		return;
 
-	wpas_hidl_notify_dpp_failure(ifname, DppFailureCode::AUTHENTICATION);
+	wpas_hidl_notify_dpp_failure(wpa_s, DppFailureCode::AUTHENTICATION);
 }
 
-void wpas_hidl_notify_dpp_fail(const char *ifname)
+void wpas_hidl_notify_dpp_fail(struct wpa_supplicant *wpa_s)
 {
-	if (!ifname)
+	if (!wpa_s)
 		return;
 
-	wpas_hidl_notify_dpp_failure(ifname, DppFailureCode::FAILURE);
+	wpas_hidl_notify_dpp_failure(wpa_s, DppFailureCode::FAILURE);
 }
 
 /* DPP notification helper functions */
-static void wpas_hidl_notify_dpp_success(const char *ifname, DppSuccessCode code)
+static void wpas_hidl_notify_dpp_success(struct wpa_supplicant *wpa_s, DppSuccessCode code)
 {
-	if (!ifname)
+	if (!wpa_s)
 		return;
 
 	wpa_printf(
@@ -751,12 +751,12 @@
 	if (!hidl_manager)
 		return;
 
-	hidl_manager->notifyDppSuccess(ifname, code);
+	hidl_manager->notifyDppSuccess(wpa_s, code);
 }
 
-static void wpas_hidl_notify_dpp_failure(const char *ifname, DppFailureCode code)
+static void wpas_hidl_notify_dpp_failure(struct wpa_supplicant *wpa_s, DppFailureCode code)
 {
-	if (!ifname)
+	if (!wpa_s)
 		return;
 
 	wpa_printf(
@@ -767,12 +767,12 @@
 	if (!hidl_manager)
 		return;
 
-	hidl_manager->notifyDppFailure(ifname, code);
+	hidl_manager->notifyDppFailure(wpa_s, code);
 }
 
-static void wpas_hidl_notify_dpp_progress(const char *ifname, DppProgressCode code)
+static void wpas_hidl_notify_dpp_progress(struct wpa_supplicant *wpa_s, DppProgressCode code)
 {
-	if (!ifname)
+	if (!wpa_s)
 		return;
 
 	wpa_printf(
@@ -783,5 +783,5 @@
 	if (!hidl_manager)
 		return;
 
-	hidl_manager->notifyDppProgress(ifname, code);
+	hidl_manager->notifyDppProgress(wpa_s, code);
 }
diff --git a/wpa_supplicant/hidl/1.2/hidl.h b/wpa_supplicant/hidl/1.2/hidl.h
index 914bc7b..a177f6e 100644
--- a/wpa_supplicant/hidl/1.2/hidl.h
+++ b/wpa_supplicant/hidl/1.2/hidl.h
@@ -99,18 +99,18 @@
 	    const u8 *p2p_dev_addr);
 	void wpas_hidl_notify_eap_error(
 	    struct wpa_supplicant *wpa_s, int error_code);
-	void wpas_hidl_notify_dpp_config_received(const char *ifname,
+	void wpas_hidl_notify_dpp_config_received(struct wpa_supplicant *wpa_s,
 		    struct wpa_ssid *ssid);
-	void wpas_hidl_notify_dpp_config_sent(const char *ifname);
-	void wpas_hidl_notify_dpp_auth_success(const char *ifname);
-	void wpas_hidl_notify_dpp_resp_pending(const char *ifname);
-	void wpas_hidl_notify_dpp_not_compatible(const char *ifname);
-	void wpas_hidl_notify_dpp_missing_auth(const char *ifname);
-	void wpas_hidl_notify_dpp_configuration_failure(const char *ifname);
-	void wpas_hidl_notify_dpp_invalid_uri(const char *ifname);
-	void wpas_hidl_notify_dpp_timeout(const char *ifname);
-	void wpas_hidl_notify_dpp_auth_failure(const char *ifname);
-	void wpas_hidl_notify_dpp_fail(const char *ifname);
+	void wpas_hidl_notify_dpp_config_sent(struct wpa_supplicant *wpa_s);
+	void wpas_hidl_notify_dpp_auth_success(struct wpa_supplicant *wpa_s);
+	void wpas_hidl_notify_dpp_resp_pending(struct wpa_supplicant *wpa_s);
+	void wpas_hidl_notify_dpp_not_compatible(struct wpa_supplicant *wpa_s);
+	void wpas_hidl_notify_dpp_missing_auth(struct wpa_supplicant *wpa_s);
+	void wpas_hidl_notify_dpp_configuration_failure(struct wpa_supplicant *wpa_s);
+	void wpas_hidl_notify_dpp_invalid_uri(struct wpa_supplicant *wpa_s);
+	void wpas_hidl_notify_dpp_timeout(struct wpa_supplicant *wpa_s);
+	void wpas_hidl_notify_dpp_auth_failure(struct wpa_supplicant *wpa_s);
+	void wpas_hidl_notify_dpp_fail(struct wpa_supplicant *wpa_s);
 #else   // CONFIG_CTRL_IFACE_HIDL
 static inline int wpas_hidl_register_interface(struct wpa_supplicant *wpa_s)
 {
diff --git a/wpa_supplicant/hidl/1.2/hidl_manager.cpp b/wpa_supplicant/hidl/1.2/hidl_manager.cpp
index 19ea4b1..62fb9aa 100644
--- a/wpa_supplicant/hidl/1.2/hidl_manager.cpp
+++ b/wpa_supplicant/hidl/1.2/hidl_manager.cpp
@@ -1489,20 +1489,23 @@
  * @param ifname Interface name
  * @param config Configuration object
  */
-void HidlManager::notifyDppConfigReceived(const char *ifname,
+void HidlManager::notifyDppConfigReceived(struct wpa_supplicant *wpa_s,
 		struct wpa_ssid *config)
 {
 	DppAkm securityAkm;
 	char *password;
-	std::string hidl_ifname = ifname;
+	std::string hidl_ifname = wpa_s->ifname;
 
-	if (config->key_mgmt & WPA_KEY_MGMT_SAE) {
+	if ((config->key_mgmt & WPA_KEY_MGMT_SAE) &&
+			(wpa_s->drv_flags & WPA_DRIVER_FLAGS_SAE)) {
 		securityAkm = DppAkm::SAE;
 	} else if (config->key_mgmt & WPA_KEY_MGMT_PSK) {
 			securityAkm = DppAkm::PSK;
 	} else {
 		/* Unsupported AKM */
-		notifyDppFailure(ifname, DppFailureCode::CONFIGURATION);
+		wpa_printf(MSG_ERROR, "DPP: Error: Unsupported AKM 0x%X",
+				config->key_mgmt);
+		notifyDppFailure(wpa_s, DppFailureCode::CONFIGURATION);
 		return;
 	}
 
@@ -1526,9 +1529,9 @@
  * @param ifname Interface name
  * @param code Status code
  */
-void HidlManager::notifyDppSuccess(const char *ifname, DppSuccessCode code)
+void HidlManager::notifyDppSuccess(struct wpa_supplicant *wpa_s, DppSuccessCode code)
 {
-	std::string hidl_ifname = ifname;
+	std::string hidl_ifname = wpa_s->ifname;
 
 	callWithEachStaIfaceCallback_1_2(hidl_ifname,
 			std::bind(&V1_2::ISupplicantStaIfaceCallback::onDppSuccess,
@@ -1541,9 +1544,9 @@
  * @param ifname Interface name
  * @param code Status code
  */
-void HidlManager::notifyDppFailure(const char *ifname, DppFailureCode code)
+void HidlManager::notifyDppFailure(struct wpa_supplicant *wpa_s, DppFailureCode code)
 {
-	std::string hidl_ifname = ifname;
+	std::string hidl_ifname = wpa_s->ifname;
 
 	callWithEachStaIfaceCallback_1_2(hidl_ifname,
 			std::bind(&V1_2::ISupplicantStaIfaceCallback::onDppFailure,
@@ -1556,9 +1559,9 @@
  * @param ifname Interface name
  * @param code Status code
  */
-void HidlManager::notifyDppProgress(const char *ifname, DppProgressCode code)
+void HidlManager::notifyDppProgress(struct wpa_supplicant *wpa_s, DppProgressCode code)
 {
-	std::string hidl_ifname = ifname;
+	std::string hidl_ifname = wpa_s->ifname;
 
 	callWithEachStaIfaceCallback_1_2(hidl_ifname,
 			std::bind(&V1_2::ISupplicantStaIfaceCallback::onDppProgress,
diff --git a/wpa_supplicant/hidl/1.2/hidl_manager.h b/wpa_supplicant/hidl/1.2/hidl_manager.h
index a7e2c86..e0038ae 100644
--- a/wpa_supplicant/hidl/1.2/hidl_manager.h
+++ b/wpa_supplicant/hidl/1.2/hidl_manager.h
@@ -128,11 +128,11 @@
 	    struct wpa_supplicant *wpa_s, const u8 *sta,
 	    const u8 *p2p_dev_addr);
 	void notifyEapError(struct wpa_supplicant *wpa_s, int error_code);
-	void notifyDppConfigReceived(const char *ifname,
+	void notifyDppConfigReceived(struct wpa_supplicant *wpa_s,
 			struct wpa_ssid *config);
-	void notifyDppSuccess(const char *ifname, DppSuccessCode code);
-	void notifyDppFailure(const char *ifname, DppFailureCode code);
-	void notifyDppProgress(const char *ifname, DppProgressCode code);
+	void notifyDppSuccess(struct wpa_supplicant *wpa_s, DppSuccessCode code);
+	void notifyDppFailure(struct wpa_supplicant *wpa_s, DppFailureCode code);
+	void notifyDppProgress(struct wpa_supplicant *wpa_s, DppProgressCode code);
 
 	// Methods called from hidl objects.
 	void notifyExtRadioWorkStart(struct wpa_supplicant *wpa_s, uint32_t id);
diff --git a/wpa_supplicant/hidl/1.2/sta_iface.cpp b/wpa_supplicant/hidl/1.2/sta_iface.cpp
index ae5fcbe..8c5178e 100644
--- a/wpa_supplicant/hidl/1.2/sta_iface.cpp
+++ b/wpa_supplicant/hidl/1.2/sta_iface.cpp
@@ -1187,6 +1187,14 @@
 	cmd += (own_bootstrap_id > 0) ?
 			" own=" + std::to_string(own_bootstrap_id) : "";
 
+	/* Check for supported AKMs */
+	if (security_akm != DppAkm::PSK && security_akm != DppAkm::SAE &&
+			security_akm != DppAkm::PSK_SAE) {
+		wpa_printf(MSG_ERROR, "DPP: Error: invalid AKM specified: %d",
+				security_akm);
+		return {SupplicantStatusCode::FAILURE_UNKNOWN, ""};
+	}
+
 	/* SAE AKM requires SSID and password to be initialized */
 	if ((security_akm == DppAkm::SAE ||
 			security_akm == DppAkm::PSK_SAE) &&
@@ -1204,9 +1212,6 @@
 			wpa_printf(MSG_ERROR, "DPP: Error: Password or PSK not specified");
 			return {SupplicantStatusCode::FAILURE_UNKNOWN, ""};
 		}
-	} else {
-		wpa_printf(MSG_ERROR, "DPP: Error: invalid AKM specified");
-		return {SupplicantStatusCode::FAILURE_UNKNOWN, ""};
 	}
 
 	cmd += " role=configurator";
diff --git a/wpa_supplicant/notify.c b/wpa_supplicant/notify.c
index 37a4595..30bdb6d 100644
--- a/wpa_supplicant/notify.c
+++ b/wpa_supplicant/notify.c
@@ -1033,105 +1033,105 @@
 
 /* DPP Success notifications */
 
-void wpas_notify_dpp_config_received(const char *ifname,
+void wpas_notify_dpp_config_received(struct wpa_supplicant *wpa_s,
 	    struct wpa_ssid *ssid)
 {
 #ifdef CONFIG_DPP
-	if (!ifname)
+	if (!wpa_s)
 		return;
 
-	wpas_hidl_notify_dpp_config_received(ifname, ssid);
+	wpas_hidl_notify_dpp_config_received(wpa_s, ssid);
 #endif /* CONFIG_DPP */
 }
 
-void wpas_notify_dpp_config_sent(const char *ifname)
+void wpas_notify_dpp_config_sent(struct wpa_supplicant *wpa_s)
 {
 #ifdef CONFIG_DPP
-	if (!ifname)
+	if (!wpa_s)
 		return;
 
-	wpas_hidl_notify_dpp_config_sent(ifname);
+	wpas_hidl_notify_dpp_config_sent(wpa_s);
 #endif /* CONFIG_DPP */
 }
 
 /* DPP Progress notifications */
-void wpas_notify_dpp_auth_success(const char *ifname)
+void wpas_notify_dpp_auth_success(struct wpa_supplicant *wpa_s)
 {
 #ifdef CONFIG_DPP
-	if (!ifname)
+	if (!wpa_s)
 		return;
 
-	wpas_hidl_notify_dpp_auth_success(ifname);
+	wpas_hidl_notify_dpp_auth_success(wpa_s);
 #endif /* CONFIG_DPP */
 }
 
-void wpas_notify_dpp_resp_pending(const char *ifname)
+void wpas_notify_dpp_resp_pending(struct wpa_supplicant *wpa_s)
 {
 #ifdef CONFIG_DPP
-	if (!ifname)
+	if (!wpa_s)
 		return;
 
-	wpas_hidl_notify_dpp_resp_pending(ifname);
+	wpas_hidl_notify_dpp_resp_pending(wpa_s);
 #endif /* CONFIG_DPP */
 }
 
 /* DPP Failure notifications */
-void wpas_notify_dpp_not_compatible(const char *ifname)
+void wpas_notify_dpp_not_compatible(struct wpa_supplicant *wpa_s)
 {
 #ifdef CONFIG_DPP
-	if (!ifname)
+	if (!wpa_s)
 		return;
 
-	wpas_hidl_notify_dpp_not_compatible(ifname);
+	wpas_hidl_notify_dpp_not_compatible(wpa_s);
 #endif /* CONFIG_DPP */
 }
 
-void wpas_notify_dpp_missing_auth(const char *ifname)
+void wpas_notify_dpp_missing_auth(struct wpa_supplicant *wpa_s)
 {
 #ifdef CONFIG_DPP
-	if (!ifname)
+	if (!wpa_s)
 		return;
 
-	wpas_hidl_notify_dpp_missing_auth(ifname);
+	wpas_hidl_notify_dpp_missing_auth(wpa_s);
 #endif /* CONFIG_DPP */
 }
 
-void wpas_notify_dpp_configuration_failure(const char *ifname)
+void wpas_notify_dpp_configuration_failure(struct wpa_supplicant *wpa_s)
 {
 #ifdef CONFIG_DPP
-	if (!ifname)
+	if (!wpa_s)
 		return;
 
-	wpas_hidl_notify_dpp_configuration_failure(ifname);
+	wpas_hidl_notify_dpp_configuration_failure(wpa_s);
 #endif /* CONFIG_DPP */
 }
 
-void wpas_notify_dpp_timeout(const char *ifname)
+void wpas_notify_dpp_timeout(struct wpa_supplicant *wpa_s)
 {
 #ifdef CONFIG_DPP
-	if (!ifname)
+	if (!wpa_s)
 		return;
 
-	wpas_hidl_notify_dpp_timeout(ifname);
+	wpas_hidl_notify_dpp_timeout(wpa_s);
 #endif /* CONFIG_DPP */
 }
 
-void wpas_notify_dpp_auth_failure(const char *ifname)
+void wpas_notify_dpp_auth_failure(struct wpa_supplicant *wpa_s)
 {
 #ifdef CONFIG_DPP
-	if (!ifname)
+	if (!wpa_s)
 		return;
 
-	wpas_hidl_notify_dpp_auth_failure(ifname);
+	wpas_hidl_notify_dpp_auth_failure(wpa_s);
 #endif /* CONFIG_DPP */
 }
 
-void wpas_notify_dpp_failure(const char *ifname)
+void wpas_notify_dpp_failure(struct wpa_supplicant *wpa_s)
 {
 #ifdef CONFIG_DPP
-	if (!ifname)
+	if (!wpa_s)
 		return;
 
-	wpas_hidl_notify_dpp_fail(ifname);
+	wpas_hidl_notify_dpp_fail(wpa_s);
 #endif /* CONFIG_DPP */
 }
diff --git a/wpa_supplicant/notify.h b/wpa_supplicant/notify.h
index b4cb476..703ef8f 100644
--- a/wpa_supplicant/notify.h
+++ b/wpa_supplicant/notify.h
@@ -167,16 +167,16 @@
 void wpas_notify_hs20_rx_deauth_imminent_notice(struct wpa_supplicant *wpa_s,
 						u8 code, u16 reauth_delay,
 						const char *url);
-void wpas_notify_dpp_config_received(const char *ifname,
+void wpas_notify_dpp_config_received(struct wpa_supplicant *wpa_s,
 	    struct wpa_ssid *ssid);
-void wpas_notify_dpp_config_sent(const char *ifname);
-void wpas_notify_dpp_auth_success(const char *ifname);
-void wpas_notify_dpp_resp_pending(const char *ifname);
-void wpas_notify_dpp_not_compatible(const char *ifname);
-void wpas_notify_dpp_missing_auth(const char *ifname);
-void wpas_notify_dpp_configuration_failure(const char *ifname);
-void wpas_notify_dpp_timeout(const char *ifname);
-void wpas_notify_dpp_auth_failure(const char *ifname);
-void wpas_notify_dpp_failure(const char *ifname);
+void wpas_notify_dpp_config_sent(struct wpa_supplicant *wpa_s);
+void wpas_notify_dpp_auth_success(struct wpa_supplicant *wpa_s);
+void wpas_notify_dpp_resp_pending(struct wpa_supplicant *wpa_s);
+void wpas_notify_dpp_not_compatible(struct wpa_supplicant *wpa_s);
+void wpas_notify_dpp_missing_auth(struct wpa_supplicant *wpa_s);
+void wpas_notify_dpp_configuration_failure(struct wpa_supplicant *wpa_s);
+void wpas_notify_dpp_timeout(struct wpa_supplicant *wpa_s);
+void wpas_notify_dpp_auth_failure(struct wpa_supplicant *wpa_s);
+void wpas_notify_dpp_failure(struct wpa_supplicant *wpa_s);
 
 #endif /* NOTIFY_H */