qcacmn: Hook MGMT Rx REO algorithm in MGMT Rx path

When a management Rx frame enters the MGMT TxRx component, route it to the
MGMT Rx REO module where the REO algorithm decides whether the frame needs
to be processed right away or need to wait for frames on other links.

Change-Id: Ib7ca911dfaeee131fd71d9a4345f5bc720326228
CRs-Fixed: 2987784

umac/cmn_services/mgmt_txrx/core/src/wlan_mgmt_txrx_rx_reo.c

@@ -597,14 +597,15 @@ mgmt_rx_reo_list_entry_send_up(struct mgmt_rx_reo_list *reo_list,
 
 	link_id = mgmt_rx_reo_get_link_id(entry->rx_params);
 
-	pdev = wlan_get_pdev_from_mlo_link_id(link_id);
-
-	qdf_assert_always(pdev);
-
-	qdf_assert_always(QDF_IS_STATUS_SUCCESS(status));
-
 	free_mgmt_rx_event_params(entry->rx_params);
 
+	pdev = wlan_get_pdev_from_mlo_link_id(link_id);
+	if (!pdev) {
+		mgmt_rx_reo_err("Unable to get pdev corresponding to entry %pK",
+				entry);
+		return QDF_STATUS_E_FAILURE;
+	}
+
 	/**
 	 * Release the reference taken when the entry is inserted into
 	 * the reorder list
@@ -873,6 +874,7 @@ mgmt_rx_reo_update_wait_count(
  * @reo_list: Pointer to reorder list
  * @num_mlo_links: Number of MLO HW links
  * @frame_desc: Pointer to frame descriptor
+ * @is_queued: Whether this frame is queued in the REO list
  *
  * API to update the reorder list on every management frame reception.
  * This API does the following things.
@@ -898,7 +900,8 @@ mgmt_rx_reo_update_wait_count(
 static QDF_STATUS
 mgmt_rx_reo_update_list(struct mgmt_rx_reo_list *reo_list,
 			uint8_t num_mlo_links,
-			struct mgmt_rx_reo_frame_descriptor *frame_desc)
+			struct mgmt_rx_reo_frame_descriptor *frame_desc,
+			bool *is_queued)
 {
 	struct mgmt_rx_reo_list_entry *cur_entry;
 	struct mgmt_rx_reo_list_entry *least_greater_entry;
@@ -907,6 +910,10 @@ mgmt_rx_reo_update_list(struct mgmt_rx_reo_list *reo_list,
 	uint32_t new_frame_global_ts;
 	struct mgmt_rx_reo_list_entry *new_entry = NULL;
 
+	if (!is_queued)
+		return QDF_STATUS_E_NULL_VALUE;
+	*is_queued = false;
+
 	if (!reo_list) {
 		mgmt_rx_reo_err("Mgmt Rx reo list is null");
 		return QDF_STATUS_E_NULL_VALUE;
@@ -977,6 +984,8 @@ mgmt_rx_reo_update_list(struct mgmt_rx_reo_list *reo_list,
 						&least_greater_entry->node);
 		if (QDF_IS_STATUS_ERROR(status))
 			goto error;
+
+		*is_queued = true;
 	}
 
 	cur_entry = least_greater_entry;
@@ -997,28 +1006,32 @@ mgmt_rx_reo_update_list(struct mgmt_rx_reo_list *reo_list,
 	goto exit;
 
 error:
-	/* TODO check whether frame is not queued and then do the cleanup */
-	if (new_entry) {
+	/* Cleanup the entry if it is not queued */
+	if (!*is_queued) {
 		struct wlan_objmgr_pdev *pdev;
 		uint8_t link_id;
 
 		link_id = mgmt_rx_reo_get_link_id(new_entry->rx_params);
 
 		pdev = wlan_get_pdev_from_mlo_link_id(link_id);
-		qdf_assert_always(pdev);
-
 		/**
 		 * New entry created is not inserted to reorder list, free
 		 * the entry and release the reference
 		 */
+		if (pdev)
+			wlan_objmgr_pdev_release_ref(pdev, WLAN_MGMT_RX_REO_ID);
+		else
+			mgmt_rx_reo_err("Unable to get pdev corresponding to entry %pK",
+					new_entry);
 		qdf_mem_free(new_entry);
-		wlan_objmgr_pdev_release_ref(pdev, WLAN_MGMT_RX_REO_ID);
 	}
 
 exit:
 	qdf_spin_unlock_bh(&reo_list->list_lock);
 
-	/* TODO check whether frame is queued and then print */
+	if (!*is_queued)
+		return status;
+
 	if (frame_desc->type == MGMT_RX_REO_FRAME_DESC_HOST_CONSUMED_FRAME) {
 		if (least_greater_entry_found)
 			mgmt_rx_reo_debug("Inserting new entry %pK before %pK",
@@ -1099,6 +1112,61 @@ wlan_mgmt_rx_reo_update_host_snapshot(struct wlan_objmgr_pdev *pdev,
 	return QDF_STATUS_SUCCESS;
 }
 
+QDF_STATUS
+wlan_mgmt_rx_reo_algo_entry(struct wlan_objmgr_pdev *pdev,
+			    struct mgmt_rx_reo_frame_descriptor *desc,
+			    bool *is_queued)
+{
+	struct mgmt_rx_reo_context *reo_ctx;
+	QDF_STATUS status;
+
+	if (!is_queued)
+		return QDF_STATUS_E_NULL_VALUE;
+
+	*is_queued = false;
+
+	if (!desc || !desc->rx_params) {
+		mgmt_rx_reo_err("MGMT Rx REO descriptor or rx params are null");
+		return QDF_STATUS_E_NULL_VALUE;
+	}
+
+	reo_ctx = mgmt_rx_reo_get_context();
+	if (!reo_ctx) {
+		mgmt_rx_reo_err("REO context is NULL");
+		return QDF_STATUS_E_FAILURE;
+	}
+
+	/* Update the Host snapshot */
+	status = wlan_mgmt_rx_reo_update_host_snapshot(
+						pdev,
+						desc->rx_params->reo_params);
+	if (QDF_IS_STATUS_ERROR(status)) {
+		mgmt_rx_reo_err("Unable to update Host snapshot");
+		return QDF_STATUS_E_FAILURE;
+	}
+
+	/* Compute wait count for this frame/event */
+	status = wlan_mgmt_rx_reo_algo_calculate_wait_count(
+						pdev,
+						desc->rx_params->reo_params,
+						reo_ctx->num_mlo_links,
+						&desc->wait_count);
+	if (QDF_IS_STATUS_ERROR(status)) {
+		mgmt_rx_reo_err("Wait count calculation failed");
+		return QDF_STATUS_E_FAILURE;
+	}
+
+	/* Update the REO list */
+	status = mgmt_rx_reo_update_list(&reo_ctx->reo_list, desc, is_queued);
+	if (QDF_IS_STATUS_ERROR(status)) {
+		mgmt_rx_reo_err("REO list updation failed");
+		return QDF_STATUS_E_FAILURE;
+	}
+
+	/* Finally, release the entries for which pending frame is received */
+	return mgmt_rx_reo_list_release_entries(&reo_ctx->reo_list);
+}
+
 QDF_STATUS
 mgmt_rx_reo_init_context(void)
 {

umac/cmn_services/mgmt_txrx/core/src/wlan_mgmt_txrx_rx_reo_i.h

@@ -140,10 +140,12 @@ struct mgmt_rx_reo_list_entry {
  * @reo_list: Linked list used for reordering
  * @ts_last_delivered_frame: Stores the global time stamp for the last frame
  * delivered to the upper layer
+ * @num_mlo_links: Number of MLO links on the system
  */
 struct mgmt_rx_reo_context {
 	struct mgmt_rx_reo_list reo_list;
 	struct mgmt_rx_reo_global_ts_info ts_last_delivered_frame;
+	uint8_t num_mlo_links;
 };
 
 /**
@@ -245,5 +247,37 @@ mgmt_rx_reo_init_context(void);
  */
 QDF_STATUS
 mgmt_rx_reo_deinit_context(void);
+
+/**
+ * is_mgmt_rx_reo_required() - Whether MGMT REO required for this frame/event
+ * @pdev: pdev for which this frame/event is intended
+ * @desc: Descriptor corresponding to this frame/event
+ *
+ * Return: true if REO is required; else false
+ */
+static inline bool is_mgmt_rx_reo_required(
+			struct wlan_objmgr_pdev *pdev,
+			struct mgmt_rx_reo_frame_descriptor *desc)
+{
+	/**
+	 * TODO: Need to implement the actual policy based on WMI service bit.
+	 * For now, returning false so that algorithm won't kick in on mainline.
+	 */
+	return false;
+}
+
+/**
+ * wlan_mgmt_rx_reo_algo_entry() - Entry point to the MGMT Rx REO algorithm for
+ * a given MGMT frame/event.
+ * @pdev: pdev for which this frame/event is intended
+ * @desc: Descriptor corresponding to this frame/event
+ * @is_queued: Whether this frame/event is queued in the REO list
+ *
+ * Return: QDF_STATUS of operation
+ */
+QDF_STATUS
+wlan_mgmt_rx_reo_algo_entry(struct wlan_objmgr_pdev *pdev,
+			    struct mgmt_rx_reo_frame_descriptor *desc,
+			    bool *is_queued);
 #endif /* WLAN_MGMT_RX_REO_SUPPORT */
 #endif /* _WLAN_MGMT_TXRX_RX_REO_I_H */

umac/cmn_services/mgmt_txrx/dispatcher/inc/wlan_mgmt_txrx_rx_reo_tgt_api.h

@@ -25,8 +25,50 @@
 #include <qdf_types.h>
 #include <wlan_mgmt_txrx_rx_reo_public_structs.h>
 #include <wlan_mgmt_txrx_rx_reo_utils_api.h>
+#include <wlan_mgmt_txrx_tgt_api.h>
+#include <wlan_lmac_if_def.h>
 
 #ifdef WLAN_MGMT_RX_REO_SUPPORT
+/**
+ * wlan_pdev_get_mgmt_rx_reo_txops() - Get management rx-reorder txops from pdev
+ * @pdev: Pointer to pdev object
+ *
+ * Return: Pointer to management rx-reorder txops in case of success, else NULL
+ */
+static inline struct wlan_lmac_if_mgmt_rx_reo_tx_ops *
+wlan_pdev_get_mgmt_rx_reo_txops(struct wlan_objmgr_pdev *pdev)
+{
+	struct wlan_lmac_if_mgmt_txrx_tx_ops *mgmt_txrx_tx_ops;
+
+	mgmt_txrx_tx_ops = wlan_pdev_get_mgmt_txrx_txops(pdev);
+	if (!mgmt_txrx_tx_ops) {
+		mgmt_txrx_err("txops is null for mgmt txrx module");
+		return NULL;
+	}
+
+	return &mgmt_txrx_tx_ops->mgmt_rx_reo_tx_ops;
+}
+
+/**
+ * wlan_psoc_get_mgmt_rx_reo_txops() - Get management rx-reorder txops from psoc
+ * @psoc: Pointer to psoc object
+ *
+ * Return: Pointer to management rx-reorder txops in case of success, else NULL
+ */
+static inline struct wlan_lmac_if_mgmt_rx_reo_tx_ops *
+wlan_psoc_get_mgmt_rx_reo_txops(struct wlan_objmgr_psoc *psoc)
+{
+	struct wlan_lmac_if_mgmt_txrx_tx_ops *mgmt_txrx_tx_ops;
+
+	mgmt_txrx_tx_ops = wlan_psoc_get_mgmt_txrx_txops(psoc);
+	if (!mgmt_txrx_tx_ops) {
+		mgmt_txrx_err("txops is null for mgmt txrx module");
+		return NULL;
+	}
+
+	return &mgmt_txrx_tx_ops->mgmt_rx_reo_tx_ops;
+}
+
 /**
  * tgt_mgmt_rx_reo_read_snapshot() - Read management rx-reorder snapshot
  * @pdev: Pointer to pdev object
@@ -82,5 +124,38 @@ tgt_mgmt_rx_reo_get_snapshot_address(
 			struct wlan_objmgr_pdev *pdev,
 			enum mgmt_rx_reo_shared_snapshot_id id,
 			struct mgmt_rx_reo_snapshot **address);
+
+/**
+ * tgt_mgmt_rx_reo_frame_handler() - REO handler for management Rx frames.
+ * @pdev: pdev for which this management frame is intended
+ * @buf: buffer
+ * @mgmt_rx_params: rx event params
+ *
+ * Return: QDF_STATUS of operation.
+ */
+QDF_STATUS tgt_mgmt_rx_reo_frame_handler(
+			struct wlan_objmgr_pdev *pdev,
+			qdf_nbuf_t buf,
+			struct mgmt_rx_event_params *mgmt_rx_params);
+#else
+/**
+ * tgt_mgmt_rx_reo_frame_handler() - REO handler for management Rx frames.
+ * @pdev: pdev for which this management frame is intended
+ * @buf: buffer
+ * @mgmt_rx_params: rx event params
+ *
+ * Return: QDF_STATUS of operation.
+ */
+static inline QDF_STATUS tgt_mgmt_rx_reo_frame_handler(
+			struct wlan_objmgr_pdev *pdev,
+			qdf_nbuf_t buf,
+			struct mgmt_rx_event_params *mgmt_rx_params)
+{
+	/**
+	 * If MGMT Rx REO feature is not compiled,
+	 * process the frame right away.
+	 */
+	return tgt_mgmt_txrx_process_rx_frame(pdev, buf, mgmt_rx_params);
+}
 #endif /* WLAN_MGMT_RX_REO_SUPPORT */
 #endif /* _WLAN_MGMT_TXRX_RX_REO_TGT_API_H */

umac/cmn_services/mgmt_txrx/dispatcher/inc/wlan_mgmt_txrx_tgt_api.h

@@ -28,9 +28,10 @@
  */
 
 #include "wlan_objmgr_cmn.h"
+#include <wlan_objmgr_pdev_obj.h>
 #include "wlan_mgmt_txrx_utils_api.h"
 #include "qdf_nbuf.h"
-
+#include <wlan_lmac_if_def.h>
 
 /**
  * tgt_mgmt_txrx_rx_frame_handler() - handles rx mgmt. frames
@@ -137,4 +138,75 @@ tgt_mgmt_txrx_register_ev_handler(struct wlan_objmgr_psoc *psoc);
  */
 QDF_STATUS
 tgt_mgmt_txrx_unregister_ev_handler(struct wlan_objmgr_psoc *psoc);
+
+/**
+ * wlan_psoc_get_mgmt_txrx_txops() - Get txops of MGMT TxRx module using psoc
+ * @psoc: Pointer to psoc object
+ *
+ * Return: txops of MGMT TxRx module on success, otherwise NULL
+ */
+static inline struct wlan_lmac_if_mgmt_txrx_tx_ops *
+wlan_psoc_get_mgmt_txrx_txops(struct wlan_objmgr_psoc *psoc)
+{
+	struct wlan_lmac_if_tx_ops *tx_ops;
+
+	if (!psoc) {
+		mgmt_txrx_err("psoc is null");
+		return NULL;
+	}
+
+	tx_ops = wlan_psoc_get_lmac_if_txops(psoc);
+	if (!tx_ops) {
+		mgmt_txrx_err("tx_ops is NULL");
+		return NULL;
+	}
+
+	return &tx_ops->mgmt_txrx_tx_ops;
+}
+
+/**
+ * wlan_pdev_get_mgmt_txrx_txops() - Get txops of MGMT TxRx module using pdev
+ * @pdev: Pointer to pdev object
+ *
+ * Return: txops of MGMT TxRx module on success, otherwise NULL
+ */
+static inline struct wlan_lmac_if_mgmt_txrx_tx_ops *
+wlan_pdev_get_mgmt_txrx_txops(struct wlan_objmgr_pdev *pdev)
+{
+	if (!pdev) {
+		mgmt_txrx_err("pdev is null");
+		return NULL;
+	}
+
+	return wlan_psoc_get_mgmt_txrx_txops(wlan_pdev_get_psoc(pdev));
+}
+
+/**
+ * tgt_mgmt_txrx_process_rx_frame() - Process management rx frames
+ * @pdev: pdev for which this management frame is intended
+ * @buf: buffer
+ * @mgmt_rx_params: rx event params
+ *
+ * This API processes MGMT Rx frames and delivers them to the upper layers.
+ *
+ * Return: QDF_STATUS of operation.
+ */
+QDF_STATUS tgt_mgmt_txrx_process_rx_frame(
+			struct wlan_objmgr_pdev *pdev,
+			qdf_nbuf_t buf,
+			struct mgmt_rx_event_params *mgmt_rx_params);
+
+/**
+ * tgt_mgmt_txrx_rx_frame_entry() - Entry point to the MGMT TxRx module for
+ * management Rx frames.
+ * @pdev: pdev for which this management frame is intended
+ * @buf: buffer
+ * @mgmt_rx_params: rx event params
+ *
+ * Return: QDF_STATUS of operation.
+ */
+QDF_STATUS tgt_mgmt_txrx_rx_frame_entry(
+			struct wlan_objmgr_pdev *pdev,
+			qdf_nbuf_t buf,
+			struct mgmt_rx_event_params *mgmt_rx_params);
 #endif

umac/cmn_services/mgmt_txrx/dispatcher/src/wlan_mgmt_txrx_rx_reo_tgt_api.c

@@ -20,41 +20,7 @@
  *  definitions
  */
 #include <wlan_mgmt_txrx_rx_reo_tgt_api.h>
-#include <wlan_lmac_if_def.h>
-
-/**
- * wlan_pdev_get_mgmt_rx_reo_txops() - Get management rx-reorder txops from pdev
- * @pdev: Pointer to pdev object
- *
- * Read management rx-reorder snapshots from target.
- *
- * Return: Pointer to management rx-reorder txops
- */
-static struct wlan_lmac_if_mgmt_rx_reo_tx_ops *
-wlan_pdev_get_mgmt_rx_reo_txops(struct wlan_objmgr_pdev *pdev)
-{
-	struct wlan_objmgr_psoc *psoc;
-	struct wlan_lmac_if_tx_ops *tx_ops;
-
-	if (!pdev) {
-		mgmt_rx_reo_err("pdev is NULL");
-		return NULL;
-	}
-
-	psoc = wlan_pdev_get_psoc(pdev);
-	if (!psoc) {
-		mgmt_rx_reo_err("psoc is NULL");
-		return NULL;
-	}
-
-	tx_ops = wlan_psoc_get_lmac_if_txops(psoc);
-	if (!tx_ops) {
-		mgmt_rx_reo_err("tx_ops is NULL");
-		return NULL;
-	}
-
-	return &tx_ops->mgmt_txrx_tx_ops.mgmt_rx_reo_tx_ops;
-}
+#include "../../core/src/wlan_mgmt_txrx_rx_reo_i.h"
 
 QDF_STATUS
 tgt_mgmt_rx_reo_read_snapshot(
@@ -127,3 +93,53 @@ tgt_mgmt_rx_reo_get_snapshot_address(
 	return mgmt_rx_reo_txops->get_mgmt_rx_reo_snapshot_address(pdev, id,
 								   address);
 }
+
+QDF_STATUS tgt_mgmt_rx_reo_frame_handler(
+				struct wlan_objmgr_pdev *pdev,
+				qdf_nbuf_t buf,
+				struct mgmt_rx_event_params *mgmt_rx_params)
+{
+	QDF_STATUS status;
+	struct mgmt_rx_reo_frame_descriptor desc;
+	bool is_queued;
+
+	if (!pdev) {
+		mgmt_rx_reo_err("pdev is NULL");
+		status = QDF_STATUS_E_NULL_VALUE;
+		goto cleanup;
+	}
+
+	if (!buf) {
+		mgmt_rx_reo_err("nbuf is NULL");
+		status = QDF_STATUS_E_NULL_VALUE;
+		goto cleanup;
+	}
+
+	if (!mgmt_rx_params) {
+		mgmt_rx_reo_err("MGMT rx params is NULL");
+		status = QDF_STATUS_E_NULL_VALUE;
+		goto cleanup;
+	}
+
+	/* Populate frame descriptor */
+	desc.type = MGMT_RX_REO_FRAME_DESC_HOST_CONSUMED_FRAME;
+	desc.nbuf = buf;
+	desc.rx_params = mgmt_rx_params;
+
+	/* If REO is not required for this frame, process it right away */
+	if (!is_mgmt_rx_reo_required(pdev, &desc)) {
+		return tgt_mgmt_txrx_process_rx_frame(pdev, buf,
+						      mgmt_rx_params);
+	}
+
+	status = wlan_mgmt_rx_reo_algo_entry(pdev, &desc, &is_queued);
+
+	/* If frame is queued, we shouldn't free up params and buf pointers */
+	if (is_queued)
+		return status;
+cleanup:
+	qdf_nbuf_free(buf);
+	free_mgmt_rx_event_params(mgmt_rx_params);
+
+	return status;
+}

umac/cmn_services/mgmt_txrx/dispatcher/src/wlan_mgmt_txrx_tgt_api.c

@@ -28,7 +28,7 @@
 #include "wlan_objmgr_psoc_obj.h"
 #include "wlan_objmgr_peer_obj.h"
 #include "wlan_objmgr_pdev_obj.h"
-
+#include "wlan_mgmt_txrx_rx_reo_tgt_api.h"
 
 /**
  * mgmt_get_spec_mgmt_action_subtype() - gets spec mgmt action subtype
@@ -1460,22 +1460,14 @@ fail:
 QDF_STATUS
 tgt_mgmt_txrx_register_ev_handler(struct wlan_objmgr_psoc *psoc)
 {
-	struct wlan_lmac_if_tx_ops *tx_ops;
 	struct wlan_lmac_if_mgmt_txrx_tx_ops *mgmt_txrx_tx_ops;
 
-	if (!psoc) {
-		mgmt_txrx_err("psoc is null");
-		return QDF_STATUS_E_NULL_VALUE;
-	}
-
-	tx_ops = wlan_psoc_get_lmac_if_txops(psoc);
-	if (!tx_ops) {
-		mgmt_txrx_err("tx_ops is NULL");
+	mgmt_txrx_tx_ops = wlan_psoc_get_mgmt_txrx_txops(psoc);
+	if (!mgmt_txrx_tx_ops) {
+		mgmt_txrx_err("txops is null for mgmt txrx module");
 		return QDF_STATUS_E_NULL_VALUE;
 	}
 
-	mgmt_txrx_tx_ops = &tx_ops->mgmt_txrx_tx_ops;
-
 	if (mgmt_txrx_tx_ops->reg_ev_handler)
 		return mgmt_txrx_tx_ops->reg_ev_handler(psoc);
 
@@ -1485,24 +1477,54 @@ tgt_mgmt_txrx_register_ev_handler(struct wlan_objmgr_psoc *psoc)
 QDF_STATUS
 tgt_mgmt_txrx_unregister_ev_handler(struct wlan_objmgr_psoc *psoc)
 {
-	struct wlan_lmac_if_tx_ops *tx_ops;
 	struct wlan_lmac_if_mgmt_txrx_tx_ops *mgmt_txrx_tx_ops;
 
-	if (!psoc) {
-		mgmt_txrx_err("psoc is null");
+	mgmt_txrx_tx_ops = wlan_psoc_get_mgmt_txrx_txops(psoc);
+	if (!mgmt_txrx_tx_ops) {
+		mgmt_txrx_err("txops is null for mgmt txrx module");
 		return QDF_STATUS_E_NULL_VALUE;
 	}
 
-	tx_ops = wlan_psoc_get_lmac_if_txops(psoc);
-	if (!tx_ops) {
-		mgmt_txrx_err("tx_ops is NULL");
+	if (mgmt_txrx_tx_ops->unreg_ev_handler)
+		return mgmt_txrx_tx_ops->unreg_ev_handler(psoc);
+
+	return QDF_STATUS_SUCCESS;
+}
+
+QDF_STATUS tgt_mgmt_txrx_process_rx_frame(
+			struct wlan_objmgr_pdev *pdev,
+			qdf_nbuf_t buf,
+			struct mgmt_rx_event_params *mgmt_rx_params)
+{
+	QDF_STATUS status;
+	struct wlan_lmac_if_mgmt_txrx_tx_ops *mgmt_txrx_tx_ops;
+
+	mgmt_txrx_tx_ops = wlan_pdev_get_mgmt_txrx_txops(pdev);
+	if (!mgmt_txrx_tx_ops) {
+		mgmt_txrx_err("txops is null for mgmt txrx module");
+		qdf_nbuf_free(buf);
+		free_mgmt_rx_event_params(mgmt_rx_params);
 		return QDF_STATUS_E_NULL_VALUE;
 	}
 
-	mgmt_txrx_tx_ops = &tx_ops->mgmt_txrx_tx_ops;
+	/* Call the legacy handler to actually process and deliver frames */
+	status = mgmt_txrx_tx_ops->rx_frame_legacy_handler(pdev, buf,
+							   mgmt_rx_params);
+	/**
+	 * Free up the mgmt rx params.
+	 * nbuf shouldn't be freed here as it is taken care by
+	 * rx_frame_legacy_handler.
+	 */
+	free_mgmt_rx_event_params(mgmt_rx_params);
 
-	if (mgmt_txrx_tx_ops->unreg_ev_handler)
-		return mgmt_txrx_tx_ops->unreg_ev_handler(psoc);
+	return status;
+}
 
-	return QDF_STATUS_SUCCESS;
+QDF_STATUS tgt_mgmt_txrx_rx_frame_entry(
+			struct wlan_objmgr_pdev *pdev,
+			qdf_nbuf_t buf,
+			struct mgmt_rx_event_params *mgmt_rx_params)
+{
+	/* Call the MGMT Rx REO handler */
+	return tgt_mgmt_rx_reo_frame_handler(pdev, buf, mgmt_rx_params);
 }

umac/global_umac_dispatcher/lmac_if/inc/wlan_lmac_if_def.h

@@ -257,6 +257,7 @@ struct wlan_lmac_if_mgmt_rx_reo_rx_ops {
  * @reg_ev_handler: function pointer to register event handlers
  * @unreg_ev_handler: function pointer to unregister event handlers
  * @mgmt_rx_reo_tx_ops: management rx-reorder txops
+ * @rx_frame_legacy_handler: Legacy handler for Rx frames
  */
 struct wlan_lmac_if_mgmt_txrx_tx_ops {
 	QDF_STATUS (*mgmt_tx_send)(struct wlan_objmgr_vdev *vdev,
@@ -270,6 +271,10 @@ struct wlan_lmac_if_mgmt_txrx_tx_ops {
 				 qdf_nbuf_t nbuf);
 	QDF_STATUS (*reg_ev_handler)(struct wlan_objmgr_psoc *psoc);
 	QDF_STATUS (*unreg_ev_handler)(struct wlan_objmgr_psoc *psoc);
+	QDF_STATUS (*rx_frame_legacy_handler)(
+			struct wlan_objmgr_pdev *pdev,
+			qdf_nbuf_t buf,
+			struct mgmt_rx_event_params *mgmt_rx_params);
 #ifdef WLAN_MGMT_RX_REO_SUPPORT
 	struct wlan_lmac_if_mgmt_rx_reo_tx_ops mgmt_rx_reo_tx_ops;
 #endif
@@ -1298,6 +1303,8 @@ struct wlan_lmac_if_tx_ops {
  * @mgmt_txrx_get_peer_from_desc_id: function pointer to get peer from desc id
  * @mgmt_txrx_get_vdev_id_from_desc_id: function pointer to get vdev id from
  *                                      desc id
+ * @mgmt_rx_frame_entry: Entry point for Rx frames into MGMT TxRx component
+ * @mgmt_rx_reo_rx_ops: rxops of MGMT Rx REO module
  */
 struct wlan_lmac_if_mgmt_txrx_rx_ops {
 	QDF_STATUS (*mgmt_tx_completion_handler)(
@@ -1318,6 +1325,10 @@ struct wlan_lmac_if_mgmt_txrx_rx_ops {
 			uint32_t desc_id);
 	uint32_t (*mgmt_txrx_get_free_desc_pool_count)(
 			struct wlan_objmgr_pdev *pdev);
+	QDF_STATUS (*mgmt_rx_frame_entry)(
+			struct wlan_objmgr_pdev *pdev,
+			qdf_nbuf_t buf,
+			struct mgmt_rx_event_params *mgmt_rx_params);
 #ifdef WLAN_MGMT_RX_REO_SUPPORT
 	struct wlan_lmac_if_mgmt_rx_reo_rx_ops mgmt_rx_reo_rx_ops;
 #endif

umac/global_umac_dispatcher/lmac_if/src/wlan_lmac_if.c

@@ -617,6 +617,8 @@ wlan_lmac_if_mgmt_txrx_rx_ops_register(struct wlan_lmac_if_rx_ops *rx_ops)
 			tgt_mgmt_txrx_get_vdev_id_from_desc_id;
 	mgmt_txrx_rx_ops->mgmt_txrx_get_free_desc_pool_count =
 			tgt_mgmt_txrx_get_free_desc_pool_count;
+	mgmt_txrx_rx_ops->mgmt_rx_frame_entry =
+			tgt_mgmt_txrx_rx_frame_entry;
 
 	return wlan_lmac_if_mgmt_rx_reo_rx_ops_register(mgmt_txrx_rx_ops);
 }