diff --git a/wpa_supplicant/dbus/dbus_new.c b/wpa_supplicant/dbus/dbus_new.c
index 53fb136..2750763 100644
--- a/wpa_supplicant/dbus/dbus_new.c
+++ b/wpa_supplicant/dbus/dbus_new.c
@@ -1607,10 +1607,12 @@
 				   enum wpas_dbus_prop property)
 {
 	char *prop;
+	dbus_bool_t flush;
 
 	if (wpa_s->dbus_new_path == NULL)
 		return; /* Skip signal since D-Bus setup is not yet ready */
 
+	flush = FALSE;
 	switch (property) {
 	case WPAS_DBUS_PROP_AP_SCAN:
 		prop = "ApScan";
@@ -1635,6 +1637,7 @@
 		break;
 	case WPAS_DBUS_PROP_DISCONNECT_REASON:
 		prop = "DisconnectReason";
+		flush = TRUE;
 		break;
 	default:
 		wpa_printf(MSG_ERROR, "dbus: %s: Unknown Property value %d",
@@ -1645,6 +1648,10 @@
 	wpa_dbus_mark_property_changed(wpa_s->global->dbus,
 				       wpa_s->dbus_new_path,
 				       WPAS_DBUS_NEW_IFACE_INTERFACE, prop);
+	if (flush)
+		wpa_dbus_flush_object_changed_properties(wpa_s->global->dbus->con,
+							 wpa_s->dbus_new_path);
+
 }
 
 
diff --git a/wpa_supplicant/dbus/dbus_new_handlers.c b/wpa_supplicant/dbus/dbus_new_handlers.c
index 8c17ebc..7e2dbc5 100644
--- a/wpa_supplicant/dbus/dbus_new_handlers.c
+++ b/wpa_supplicant/dbus/dbus_new_handlers.c
@@ -2242,7 +2242,7 @@
 }
 
 /**
- * wpas_dbus_getter_disconenct_reason - Get most recent reason for disconect
+ * wpas_dbus_getter_disconnect_reason - Get most recent reason for disconect
  * @iter: Pointer to incoming dbus message iter
  * @error: Location to store error on failure
  * @user_data: Function specific data
diff --git a/wpa_supplicant/events.c b/wpa_supplicant/events.c
index 28ba38f..1de07d2 100644
--- a/wpa_supplicant/events.c
+++ b/wpa_supplicant/events.c
@@ -1721,7 +1721,7 @@
 	if (wpa_s->wpa_state >= WPA_AUTHENTICATING)
 		wpas_connection_failed(wpa_s, bssid);
 	wpa_sm_notify_disassoc(wpa_s->wpa);
-        wpa_s->disconnect_reason = reason_code;
+	wpa_s->disconnect_reason = reason_code;
         if (locally_generated) {
         	wpa_s->disconnect_reason = -wpa_s->disconnect_reason;
         }
diff --git a/wpa_supplicant/notify.c b/wpa_supplicant/notify.c
index 3b09760..079d015 100644
--- a/wpa_supplicant/notify.c
+++ b/wpa_supplicant/notify.c
@@ -20,7 +20,6 @@
 #include "wpa_supplicant_i.h"
 #include "wps_supplicant.h"
 #include "dbus/dbus_common.h"
-#include "dbus/dbus_common_i.h"
 #include "dbus/dbus_old.h"
 #include "dbus/dbus_new.h"
 #include "rsn_supp/wpa.h"
@@ -107,8 +106,6 @@
 void wpas_notify_disconnect_reason(struct wpa_supplicant *wpa_s)
 {
 	wpas_dbus_signal_prop_changed(wpa_s, WPAS_DBUS_PROP_DISCONNECT_REASON);
-        wpa_dbus_flush_object_changed_properties(wpa_s->global->dbus->con,
-						 wpa_s->dbus_new_path);
 }
 
 
diff --git a/wpa_supplicant/wpa_supplicant_i.h b/wpa_supplicant/wpa_supplicant_i.h
index e0d5e49..b66ddad 100644
--- a/wpa_supplicant/wpa_supplicant_i.h
+++ b/wpa_supplicant/wpa_supplicant_i.h
@@ -538,7 +538,7 @@
 
 	int pno;
 
-	// WLAN_REASON_* reason codes.  Negative if locally generated.
+	/* WLAN_REASON_* reason codes.  Negative if locally generated. */
 	int disconnect_reason;
 };
 
