diff --git a/core/dp/txrx3.0/dp_rx_thread.c b/core/dp/txrx3.0/dp_rx_thread.c
index f173b41298af..55f7ac53840c 100644
--- a/core/dp/txrx3.0/dp_rx_thread.c
+++ b/core/dp/txrx3.0/dp_rx_thread.c
@@ -587,6 +587,7 @@ QDF_STATUS dp_rx_tm_init(struct dp_rx_tm_handle *rx_tm_hdl,
 	}
 
 	rx_tm_hdl->num_dp_rx_threads = num_dp_rx_threads;
+	rx_tm_hdl->state = DP_RX_THREADS_INVALID;
 
 	dp_info("initializing %u threads", num_dp_rx_threads);
 
@@ -618,6 +619,8 @@ QDF_STATUS dp_rx_tm_init(struct dp_rx_tm_handle *rx_tm_hdl,
 ret:
 	if (!QDF_IS_STATUS_SUCCESS(qdf_status))
 		dp_rx_tm_deinit(rx_tm_hdl);
+	else
+		rx_tm_hdl->state = DP_RX_THREADS_RUNNING;
 
 	return qdf_status;
 }
@@ -635,6 +638,11 @@ QDF_STATUS dp_rx_tm_suspend(struct dp_rx_tm_handle *rx_tm_hdl)
 	QDF_STATUS qdf_status;
 	struct dp_rx_thread *rx_thread;
 
+	if (rx_tm_hdl->state == DP_RX_THREADS_SUSPENDED) {
+		dp_info("already in suspend state! Ignoring.");
+		return QDF_STATUS_E_INVAL;
+	}
+
 	for (i = 0; i < rx_tm_hdl->num_dp_rx_threads; i++) {
 		if (!rx_tm_hdl->rx_thread[i])
 			continue;
@@ -659,7 +667,7 @@ QDF_STATUS dp_rx_tm_suspend(struct dp_rx_tm_handle *rx_tm_hdl)
 			dp_err("thread:%d failed while waiting for suspend",
 			       rx_thread->id);
 	}
-	rx_tm_hdl->state = DP_RX_THREAD_SUSPENDED;
+	rx_tm_hdl->state = DP_RX_THREADS_SUSPENDED;
 
 	return QDF_STATUS_SUCCESS;
 }
@@ -669,15 +677,15 @@ QDF_STATUS dp_rx_tm_suspend(struct dp_rx_tm_handle *rx_tm_hdl)
  * @rx_tm_hdl: dp_rx_tm_handle containing the overall thread
  *            infrastructure
  *
- * Return: QDF_STATUS_SUCCESS
+ * Return: QDF_STATUS_SUCCESS on resume success. QDF error otherwise.
  */
 QDF_STATUS dp_rx_tm_resume(struct dp_rx_tm_handle *rx_tm_hdl)
 {
 	int i;
 
-	if (rx_tm_hdl->state != DP_RX_THREAD_SUSPENDED) {
-		dp_err("resume callback received without suspend");
-		return QDF_STATUS_E_FAULT;
+	if (rx_tm_hdl->state != DP_RX_THREADS_SUSPENDED) {
+		dp_info("resume callback received w/o suspend! Ignoring.");
+		return QDF_STATUS_E_INVAL;
 	}
 
 	for (i = 0; i < rx_tm_hdl->num_dp_rx_threads; i++) {
@@ -687,6 +695,8 @@ QDF_STATUS dp_rx_tm_resume(struct dp_rx_tm_handle *rx_tm_hdl)
 		qdf_event_set(&rx_tm_hdl->rx_thread[i]->resume_event);
 	}
 
+	rx_tm_hdl->state = DP_RX_THREADS_RUNNING;
+
 	return QDF_STATUS_SUCCESS;
 }
 
@@ -718,6 +728,7 @@ static QDF_STATUS dp_rx_tm_shutdown(struct dp_rx_tm_handle *rx_tm_hdl)
 		qdf_wait_single_event(&rx_tm_hdl->rx_thread[i]->shutdown_event,
 				      0);
 	}
+	rx_tm_hdl->state = DP_RX_THREADS_INVALID;
 	return QDF_STATUS_SUCCESS;
 }
 
diff --git a/core/dp/txrx3.0/dp_rx_thread.h b/core/dp/txrx3.0/dp_rx_thread.h
index 981df028d510..473c3b9c7f99 100644
--- a/core/dp/txrx3.0/dp_rx_thread.h
+++ b/core/dp/txrx3.0/dp_rx_thread.h
@@ -99,18 +99,16 @@ struct dp_rx_thread {
 };
 
 /**
- * enum dp_rx_thread_state - enum to keep track of the state of the rx thread
- * @DP_RX_THREAD_INVALID: initial invalid state
- * @DP_RX_THREAD_INIT: state after being initialized
- * @DP_RX_THREAD_RUNNING: rx thread is functional(NOT suspended, processing
+ * enum dp_rx_thread_state - enum to keep track of the state of the rx threads
+ * @DP_RX_THREADS_INVALID: initial invalid state
+ * @DP_RX_THREADS_RUNNING: rx threads functional(NOT suspended, processing
  *			  packets or waiting on a wait_queue)
- * @DP_RX_THREAD_SUSPENDED: rx_thread operation is suspeded from cfg8011 suspend
+ * @DP_RX_THREADS_SUSPENDED: rx_threads suspended from cfg8011 suspend
  */
 enum dp_rx_thread_state {
-	DP_RX_THREAD_INVALID,
-	DP_RX_THREAD_INIT,
-	DP_RX_THREAD_RUNNING,
-	DP_RX_THREAD_SUSPENDED
+	DP_RX_THREADS_INVALID,
+	DP_RX_THREADS_RUNNING,
+	DP_RX_THREADS_SUSPENDED
 };
 
 /**
diff --git a/core/hdd/src/wlan_hdd_power.c b/core/hdd/src/wlan_hdd_power.c
index 9fe32f11ca0a..c3bf26248292 100644
--- a/core/hdd/src/wlan_hdd_power.c
+++ b/core/hdd/src/wlan_hdd_power.c
@@ -1279,6 +1279,8 @@ QDF_STATUS hdd_wlan_shutdown(void)
 
 	wlan_hdd_rx_thread_resume(hdd_ctx);
 
+	dp_txrx_resume(cds_get_context(QDF_MODULE_ID_SOC));
+
 	/*
 	 * After SSR, FW clear its txrx stats. In host,
 	 * as adapter is intact so those counts are still