qcacmn: Handle discontinuous link id values

MLO HW link ids need not be continuous. Handle
discontinuous link id values at host.

CRs-Fixed: 3111570
Change-Id: I561cdabed8a6b621dba87c49832f5c1d1b194b9a

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

@@ -177,6 +177,27 @@ mgmt_rx_reo_validate_mlo_hw_link_info(struct wlan_objmgr_psoc *psoc)
 }
 
 #ifndef WLAN_MGMT_RX_REO_SIM_SUPPORT
+/**
+ * mgmt_rx_reo_is_valid_link() - Check whether the given HW link is valid
+ *
+ * Return: true if @link_id is a valid link else false
+ */
+static bool
+mgmt_rx_reo_is_valid_link(uint8_t link_id)
+{
+	uint16_t valid_hw_link_bitmap;
+
+	if (link_id >= MAX_MLO_LINKS) {
+		mgmt_rx_reo_err("Invalid link id %u", link_id);
+		return false;
+	}
+
+	valid_hw_link_bitmap = wlan_mlo_get_valid_hw_link_bitmap();
+	qdf_assert_always(valid_hw_link_bitmap);
+
+	return (valid_hw_link_bitmap & (1 << link_id));
+}
+
 /**
  * mgmt_rx_reo_get_num_mlo_links() - Get number of MLO HW links active in the
  * system
@@ -210,6 +231,58 @@ mgmt_rx_reo_handle_stale_frame(struct mgmt_rx_reo_list *reo_list,
 	return QDF_STATUS_SUCCESS;
 }
 #else
+/**
+ * mgmt_rx_reo_sim_is_valid_link() - Check whether the given HW link is valid
+ *
+ * Return: true if @link_id is a valid link, else false
+ */
+static bool
+mgmt_rx_reo_sim_is_valid_link(struct mgmt_rx_reo_sim_context *sim_context,
+			      uint8_t link_id)
+{
+	bool is_valid_link = false;
+
+	if (!sim_context) {
+		mgmt_rx_reo_err("Mgmt reo sim context is null");
+		return false;
+	}
+
+	if (link_id >= MAX_MLO_LINKS) {
+		mgmt_rx_reo_err("Invalid link id %u", link_id);
+		return false;
+	}
+
+	qdf_spin_lock(&sim_context->link_id_to_pdev_map.lock);
+
+	if (sim_context->link_id_to_pdev_map.map[link_id])
+		is_valid_link = true;
+
+	qdf_spin_unlock(&sim_context->link_id_to_pdev_map.lock);
+
+	return is_valid_link;
+}
+
+/**
+ * mgmt_rx_reo_is_valid_link() - Check whether the given HW link is valid
+ *
+ * Return: true if @link_id is a valid link else false
+ */
+static bool
+mgmt_rx_reo_is_valid_link(uint8_t link_id)
+{
+	struct mgmt_rx_reo_context *reo_context;
+
+	reo_context = mgmt_rx_reo_get_context();
+
+	if (!reo_context) {
+		mgmt_rx_reo_err("Mgmt reo context is null");
+		return false;
+	}
+
+	return mgmt_rx_reo_sim_is_valid_link(&reo_context->sim_context,
+					     link_id);
+}
+
 /**
  * mgmt_rx_reo_sim_get_num_mlo_links() - Get number of MLO HW links from the reo
  * simulation context object
@@ -294,14 +367,13 @@ mgmt_rx_reo_sim_get_mlo_link_id_from_pdev(struct wlan_objmgr_pdev *pdev)
 
 	qdf_spin_lock(&sim_context->link_id_to_pdev_map.lock);
 
-	for (link_id = 0; link_id <
-	     sim_context->link_id_to_pdev_map.num_mlo_links; link_id++)
+	for (link_id = 0; link_id < MAX_MLO_LINKS; link_id++)
 		if (sim_context->link_id_to_pdev_map.map[link_id] == pdev)
 			break;
 
 	/* pdev is not found in map */
-	if (link_id == sim_context->link_id_to_pdev_map.num_mlo_links)
-		link_id = -1;
+	if (link_id == MAX_MLO_LINKS)
+		link_id = MGMT_RX_REO_INVALID_LINK_ID;
 
 	qdf_spin_unlock(&sim_context->link_id_to_pdev_map.lock);
 
@@ -314,7 +386,6 @@ mgmt_rx_reo_sim_get_pdev_from_mlo_link_id(uint8_t mlo_link_id,
 {
 	struct mgmt_rx_reo_sim_context *sim_context;
 	struct wlan_objmgr_pdev *pdev;
-	int8_t num_mlo_links;
 	QDF_STATUS status;
 
 	sim_context = mgmt_rx_reo_sim_get_context();
@@ -323,16 +394,8 @@ mgmt_rx_reo_sim_get_pdev_from_mlo_link_id(uint8_t mlo_link_id,
 		return NULL;
 	}
 
-	num_mlo_links = mgmt_rx_reo_sim_get_num_mlo_links(sim_context);
-	if (num_mlo_links <= 0) {
-		mgmt_rx_reo_err("invalid number of MLO links %d",
-				num_mlo_links);
-		return NULL;
-	}
-
-	if (mlo_link_id >= num_mlo_links) {
-		mgmt_rx_reo_err("Invalid link id %u, total links = %d",
-				mlo_link_id, num_mlo_links);
+	if (mlo_link_id >= MAX_MLO_LINKS) {
+		mgmt_rx_reo_err("Invalid link id %u", mlo_link_id);
 		return NULL;
 	}
 
@@ -562,7 +625,6 @@ wlan_mgmt_rx_reo_get_priv_object(struct wlan_objmgr_pdev *pdev)
  * frames an incoming frame should wait for before it gets delivered.
  * @in_frame_pdev: pdev on which this frame is received
  * @in_frame_params: Pointer to MGMT REO parameters of this frame
- * @num_mlo_links: Number of MLO links
  * @wait_count: Pointer to wait count data structure to fill the calculated
  * wait count
  *
@@ -583,7 +645,6 @@ static QDF_STATUS
 wlan_mgmt_rx_reo_algo_calculate_wait_count(
 	struct wlan_objmgr_pdev *in_frame_pdev,
 	struct mgmt_rx_reo_params *in_frame_params,
-	uint8_t num_mlo_links,
 	struct mgmt_rx_reo_wait_count *wait_count)
 {
 	QDF_STATUS status;
@@ -614,14 +675,20 @@ wlan_mgmt_rx_reo_algo_calculate_wait_count(
 		return QDF_STATUS_E_NULL_VALUE;
 	}
 
-	qdf_assert_always(num_mlo_links <= MGMT_RX_REO_MAX_LINKS);
-
 	/* Get the MLO link ID of incoming frame */
 	in_frame_link = wlan_get_mlo_link_id_from_pdev(in_frame_pdev);
 	qdf_assert_always(in_frame_link >= 0);
+	qdf_assert_always(in_frame_link < MAX_MLO_LINKS);
+	qdf_assert_always(mgmt_rx_reo_is_valid_link(in_frame_link));
+
+	/* Iterate over all the valid MLO links */
+	for (link = 0; link < MAX_MLO_LINKS; link++) {
+		/* No need wait for any frames on an invalid link */
+		if (!mgmt_rx_reo_is_valid_link(link)) {
+			frames_pending = 0;
+			goto update_pending_frames;
+		}
 
-	/* Iterate over all the MLO links */
-	for (link = 0; link < num_mlo_links; link++) {
 		/* No need wait for any frames on the same link */
 		if (link == in_frame_link) {
 			frames_pending = 0;
@@ -912,13 +979,11 @@ struct mgmt_rx_reo_list_entry_debug_info {
 /**
  * mgmt_rx_reo_list_display() - API to print the entries in the reorder list
  * @reo_list: Pointer to reorder list
- * @num_mlo_links: Number of MLO HW links
  *
  * Return: QDF_STATUS
  */
 static QDF_STATUS
-mgmt_rx_reo_list_display(struct mgmt_rx_reo_list *reo_list,
-			 uint8_t num_mlo_links)
+mgmt_rx_reo_list_display(struct mgmt_rx_reo_list *reo_list)
 {
 	uint32_t reo_list_size;
 	uint32_t index;
@@ -930,11 +995,6 @@ mgmt_rx_reo_list_display(struct mgmt_rx_reo_list *reo_list,
 		return QDF_STATUS_E_NULL_VALUE;
 	}
 
-	if (num_mlo_links == 0 || num_mlo_links > MGMT_RX_REO_MAX_LINKS) {
-		mgmt_rx_reo_err("Invalid number of links %u", num_mlo_links);
-		return QDF_STATUS_E_INVAL;
-	}
-
 	qdf_spin_lock_bh(&reo_list->list_lock);
 
 	reo_list_size = qdf_list_size(&reo_list->list);
@@ -987,7 +1047,7 @@ mgmt_rx_reo_list_display(struct mgmt_rx_reo_list *reo_list,
 		mgmt_rx_reo_debug("Total wait count = 0x%llx",
 				  debug_info[index].wait_count.total_count);
 
-		for (link_id = 0; link_id < num_mlo_links; link_id++)
+		for (link_id = 0; link_id < MAX_MLO_LINKS; link_id++)
 			mgmt_rx_reo_debug("Link id = %u, wait_count = 0x%x",
 					  link_id, debug_info[index].wait_count.
 					  per_link_count[link_id]);
@@ -1016,11 +1076,10 @@ mgmt_rx_reo_print_egress_frame_stats(struct mgmt_rx_reo_context *reo_ctx)
 	struct reo_egress_frame_stats *stats;
 	uint8_t link_id;
 	uint8_t reason;
-	int8_t num_mlo_links;
 	uint64_t total_delivery_attempts_count = 0;
 	uint64_t total_delivery_success_count = 0;
 	uint64_t total_premature_delivery_count = 0;
-	uint64_t delivery_count_per_link[MGMT_RX_REO_MAX_LINKS] = {0};
+	uint64_t delivery_count_per_link[MAX_MLO_LINKS] = {0};
 	uint64_t delivery_count_per_reason[MGMT_RX_REO_RELEASE_REASON_MAX] = {0};
 	uint64_t total_delivery_count = 0;
 
@@ -1029,11 +1088,7 @@ mgmt_rx_reo_print_egress_frame_stats(struct mgmt_rx_reo_context *reo_ctx)
 
 	stats = &reo_ctx->egress_frame_debug_info.stats;
 
-	num_mlo_links = mgmt_rx_reo_get_num_mlo_links(reo_ctx);
-	qdf_assert_always(num_mlo_links > 0);
-	qdf_assert_always(num_mlo_links <= MGMT_RX_REO_MAX_LINKS);
-
-	for (link_id = 0; link_id < num_mlo_links; link_id++) {
+	for (link_id = 0; link_id < MAX_MLO_LINKS; link_id++) {
 		total_delivery_attempts_count +=
 				stats->delivery_attempts_count[link_id];
 		total_delivery_success_count +=
@@ -1042,15 +1097,15 @@ mgmt_rx_reo_print_egress_frame_stats(struct mgmt_rx_reo_context *reo_ctx)
 				stats->premature_delivery_count[link_id];
 	}
 
-	for (link_id = 0; link_id < num_mlo_links; link_id++) {
+	for (link_id = 0; link_id < MAX_MLO_LINKS; link_id++) {
 		for (reason = 0; reason < MGMT_RX_REO_RELEASE_REASON_MAX;
 		     reason++)
 			delivery_count_per_link[link_id] +=
 				stats->delivery_count[link_id][reason];
 		total_delivery_count += delivery_count_per_link[link_id];
 	}
-	for (reason = 0; reason <= MGMT_RX_REO_RELEASE_REASON_MAX; reason++)
-		for (link_id = 0; link_id < num_mlo_links; link_id++)
+	for (reason = 0; reason < MGMT_RX_REO_RELEASE_REASON_MAX; reason++)
+		for (link_id = 0; link_id < MAX_MLO_LINKS; link_id++)
 			delivery_count_per_reason[reason] +=
 				stats->delivery_count[link_id][reason];
 
@@ -1060,7 +1115,7 @@ mgmt_rx_reo_print_egress_frame_stats(struct mgmt_rx_reo_context *reo_ctx)
 	mgmt_rx_reo_err("\t|link id   |Attempts |Success |Premature |");
 	mgmt_rx_reo_err("\t|          | count   | count  | count    |");
 	mgmt_rx_reo_err("\t------------------------------------------");
-	for (link_id = 0; link_id < num_mlo_links; link_id++) {
+	for (link_id = 0; link_id < MAX_MLO_LINKS; link_id++) {
 		mgmt_rx_reo_err("\t|%10u|%9llu|%8llu|%10llu|", link_id,
 				stats->delivery_attempts_count[link_id],
 				stats->delivery_success_count[link_id],
@@ -1082,23 +1137,26 @@ mgmt_rx_reo_print_egress_frame_stats(struct mgmt_rx_reo_context *reo_ctx)
 			MGMT_RX_REO_LIST_ENTRY_RELEASE_REASON_OLDER_THAN_AGED_OUT_FRAME);
 	mgmt_rx_reo_err("\tRELEASE_REASON_LIST_MAX_SIZE_EXCEEDED - 0x%lx",
 			MGMT_RX_REO_LIST_ENTRY_RELEASE_REASON_LIST_MAX_SIZE_EXCEEDED);
-	mgmt_rx_reo_err("\t--------------------------------------------------");
-	mgmt_rx_reo_err("\t|Release Reason/ |       |       |       |       |");
-	mgmt_rx_reo_err("\t|link id         |      0|      1|      2|      3|");
-	mgmt_rx_reo_err("\t---------------------------------------------------------");
+	mgmt_rx_reo_err("\t------------------------------------------------------------------");
+	mgmt_rx_reo_err("\t|Release Reason/ |       |       |       |       |       |       |");
+	mgmt_rx_reo_err("\t|link id         |      0|      1|      2|      3|      4|      5| ");
+	mgmt_rx_reo_err("\t------------------------------------------------------------------");
 
 	for (reason = 0; reason < MGMT_RX_REO_RELEASE_REASON_MAX; reason++) {
-		mgmt_rx_reo_err("\t|%16x|%7llu|%7llu|%7llu|%7llu|%7llu", reason,
+		mgmt_rx_reo_err("\t|%16x|%7llu|%7llu|%7llu|%7llu|%7llu|%7llu|%7llu", reason,
 				stats->delivery_count[0][reason],
 				stats->delivery_count[1][reason],
 				stats->delivery_count[2][reason],
 				stats->delivery_count[3][reason],
+				stats->delivery_count[4][reason],
+				stats->delivery_count[5][reason],
 				delivery_count_per_reason[reason]);
 		mgmt_rx_reo_err("\t---------------------------------------------------------");
 	}
-	mgmt_rx_reo_err("\t                |%7llu|%7llu|%7llu|%7llu|%7llu\n\n",
+	mgmt_rx_reo_err("\t                 |%7llu|%7llu|%7llu|%7llu|%7llu|%7llu|%7llu\n\n",
 			delivery_count_per_link[0], delivery_count_per_link[1],
 			delivery_count_per_link[2], delivery_count_per_link[3],
+			delivery_count_per_link[4], delivery_count_per_link[5],
 			total_delivery_count);
 
 	return QDF_STATUS_SUCCESS;
@@ -1405,7 +1463,7 @@ mgmt_rx_reo_list_entry_get_release_reason(struct mgmt_rx_reo_list_entry *entry)
  * Return: QDF_STATUS
  */
 static QDF_STATUS
-mgmt_rx_reo_list_entry_send_up(const struct mgmt_rx_reo_list *reo_list,
+mgmt_rx_reo_list_entry_send_up(struct mgmt_rx_reo_list *reo_list,
 			       struct mgmt_rx_reo_list_entry *entry)
 {
 	uint8_t release_reason;
@@ -1742,7 +1800,6 @@ mgmt_rx_reo_prepare_list_entry(
 /**
  * mgmt_rx_reo_update_wait_count() - Update the wait count for a frame based
  * on the wait count of a frame received after that on air.
- * @num_mlo_links: Number of MLO links
  * @wait_count_old_frame: Pointer to the wait count structure for the old frame.
  * @wait_count_new_frame: Pointer to the wait count structure for the new frame.
  *
@@ -1758,7 +1815,6 @@ mgmt_rx_reo_prepare_list_entry(
  */
 static QDF_STATUS
 mgmt_rx_reo_update_wait_count(
-		uint8_t num_mlo_links,
 		struct mgmt_rx_reo_wait_count *wait_count_old_frame,
 		const struct mgmt_rx_reo_wait_count *wait_count_new_frame)
 {
@@ -1767,9 +1823,7 @@ mgmt_rx_reo_update_wait_count(
 	qdf_assert_always(wait_count_old_frame);
 	qdf_assert_always(wait_count_new_frame);
 
-	qdf_assert_always(num_mlo_links <= MGMT_RX_REO_MAX_LINKS);
-
-	for (link_id = 0; link_id < num_mlo_links; link_id++) {
+	for (link_id = 0; link_id < MAX_MLO_LINKS; link_id++) {
 		if (wait_count_old_frame->per_link_count[link_id]) {
 			uint32_t temp_wait_count;
 			uint32_t wait_count_diff;
@@ -1794,7 +1848,6 @@ mgmt_rx_reo_update_wait_count(
 /**
  * mgmt_rx_reo_update_list() - Modify the reorder list when a frame is received
  * @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
  *
@@ -1821,7 +1874,6 @@ 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,
 			bool *is_queued)
 {
@@ -1862,6 +1914,15 @@ mgmt_rx_reo_update_list(struct mgmt_rx_reo_list *reo_list,
 
 	frame_desc->list_size_rx = qdf_list_size(&reo_list->list);
 
+	frame_desc->is_stale = false;
+	if (mgmt_rx_reo_is_stale_frame(&reo_list->ts_last_released_frame,
+				       new_frame_global_ts)) {
+		frame_desc->is_stale = true;
+
+		status = mgmt_rx_reo_handle_stale_frame(reo_list, frame_desc);
+		goto exit_free_entry;
+	}
+
 	qdf_list_for_each(&reo_list->list, cur_entry, node) {
 		uint32_t cur_entry_global_ts;
 
@@ -1878,37 +1939,24 @@ mgmt_rx_reo_update_list(struct mgmt_rx_reo_list *reo_list,
 		list_insertion_pos++;
 
 		status = mgmt_rx_reo_update_wait_count(
-					num_mlo_links,
 					&cur_entry->wait_count,
 					&frame_desc->wait_count);
 		if (QDF_IS_STATUS_ERROR(status))
-			goto error;
+			goto exit_free_entry;
 
 		if (cur_entry->wait_count.total_count == 0)
 			cur_entry->status &=
 			      ~MGMT_RX_REO_STATUS_WAIT_FOR_FRAME_ON_OTHER_LINKS;
 	}
 
-	frame_desc->is_stale = false;
-	if (mgmt_rx_reo_is_stale_frame(&reo_list->ts_last_released_frame,
-				       new_frame_global_ts)) {
-		frame_desc->is_stale = true;
-
-		status = mgmt_rx_reo_handle_stale_frame(reo_list, frame_desc);
-		if (QDF_IS_STATUS_ERROR(status))
-			goto error;
-	}
-
-	if (frame_desc->type == MGMT_RX_REO_FRAME_DESC_HOST_CONSUMED_FRAME &&
-	    !frame_desc->is_stale) {
+	if (frame_desc->type == MGMT_RX_REO_FRAME_DESC_HOST_CONSUMED_FRAME) {
 		if (least_greater_entry_found) {
 			status = mgmt_rx_reo_update_wait_count(
-					num_mlo_links,
 					&new_entry->wait_count,
 					&least_greater_entry->wait_count);
 
 			if (QDF_IS_STATUS_ERROR(status))
-				goto error;
+				goto exit_free_entry;
 
 			frame_desc->wait_count = new_entry->wait_count;
 
@@ -1930,7 +1978,7 @@ mgmt_rx_reo_update_list(struct mgmt_rx_reo_list *reo_list,
 					&reo_list->list, &new_entry->node);
 
 		if (QDF_IS_STATUS_ERROR(status))
-			goto error;
+			goto exit_free_entry;
 
 		*is_queued = true;
 
@@ -1965,9 +2013,9 @@ mgmt_rx_reo_update_list(struct mgmt_rx_reo_list *reo_list,
 	}
 
 	status = QDF_STATUS_SUCCESS;
-	goto exit;
+	goto exit_release_list_lock;
 
-error:
+exit_free_entry:
 	/* Cleanup the entry if it is not queued */
 	if (new_entry && !*is_queued) {
 		/**
@@ -1979,7 +2027,7 @@ error:
 		qdf_mem_free(new_entry);
 	}
 
-exit:
+exit_release_list_lock:
 	qdf_spin_unlock_bh(&reo_list->list_lock);
 
 	if (!*is_queued)
@@ -2093,14 +2141,13 @@ mgmt_rx_reo_print_ingress_frame_stats(struct mgmt_rx_reo_context *reo_ctx)
 	struct reo_ingress_frame_stats *stats;
 	uint8_t link_id;
 	uint8_t desc_type;
-	int8_t num_mlo_links;
-	uint64_t ingress_count_per_link[MGMT_RX_REO_MAX_LINKS] = {0};
+	uint64_t ingress_count_per_link[MAX_MLO_LINKS] = {0};
 	uint64_t ingress_count_per_desc_type[MGMT_RX_REO_FRAME_DESC_TYPE_MAX] = {0};
 	uint64_t total_ingress_count = 0;
-	uint64_t stale_count_per_link[MGMT_RX_REO_MAX_LINKS] = {0};
+	uint64_t stale_count_per_link[MAX_MLO_LINKS] = {0};
 	uint64_t stale_count_per_desc_type[MGMT_RX_REO_FRAME_DESC_TYPE_MAX] = {0};
 	uint64_t total_stale_count = 0;
-	uint64_t error_count_per_link[MGMT_RX_REO_MAX_LINKS] = {0};
+	uint64_t error_count_per_link[MAX_MLO_LINKS] = {0};
 	uint64_t error_count_per_desc_type[MGMT_RX_REO_FRAME_DESC_TYPE_MAX] = {0};
 	uint64_t total_error_count = 0;
 	uint64_t total_queued_count = 0;
@@ -2112,11 +2159,7 @@ mgmt_rx_reo_print_ingress_frame_stats(struct mgmt_rx_reo_context *reo_ctx)
 
 	stats = &reo_ctx->ingress_frame_debug_info.stats;
 
-	num_mlo_links = mgmt_rx_reo_get_num_mlo_links(reo_ctx);
-	qdf_assert_always(num_mlo_links > 0);
-	qdf_assert_always(num_mlo_links <= MGMT_RX_REO_MAX_LINKS);
-
-	for (link_id = 0; link_id < num_mlo_links; link_id++) {
+	for (link_id = 0; link_id < MAX_MLO_LINKS; link_id++) {
 		for (desc_type = 0; desc_type < MGMT_RX_REO_FRAME_DESC_TYPE_MAX;
 		     desc_type++) {
 			ingress_count_per_link[link_id] +=
@@ -2134,7 +2177,7 @@ mgmt_rx_reo_print_ingress_frame_stats(struct mgmt_rx_reo_context *reo_ctx)
 
 	for (desc_type = 0; desc_type < MGMT_RX_REO_FRAME_DESC_TYPE_MAX;
 	     desc_type++) {
-		for (link_id = 0; link_id < num_mlo_links; link_id++) {
+		for (link_id = 0; link_id < MAX_MLO_LINKS; link_id++) {
 			ingress_count_per_desc_type[desc_type] +=
 				stats->ingress_count[link_id][desc_type];
 			stale_count_per_desc_type[desc_type] +=
@@ -2144,7 +2187,7 @@ mgmt_rx_reo_print_ingress_frame_stats(struct mgmt_rx_reo_context *reo_ctx)
 		}
 	}
 
-	for (link_id = 0; link_id < num_mlo_links; link_id++) {
+	for (link_id = 0; link_id < MAX_MLO_LINKS; link_id++) {
 		total_queued_count += stats->queued_count[link_id];
 		total_zero_wait_count_rx_count +=
 				stats->zero_wait_count_rx_count[link_id];
@@ -2163,7 +2206,7 @@ mgmt_rx_reo_print_ingress_frame_stats(struct mgmt_rx_reo_context *reo_ctx)
 	mgmt_rx_reo_err("\t|desc type |      0|      1|      2|");
 	mgmt_rx_reo_err("\t-------------------------------------------");
 
-	for (link_id = 0; link_id < num_mlo_links; link_id++) {
+	for (link_id = 0; link_id < MAX_MLO_LINKS; link_id++) {
 		mgmt_rx_reo_err("\t|%10u|%7llu|%7llu|%7llu|%7llu", link_id,
 				stats->ingress_count[link_id][0],
 				stats->ingress_count[link_id][1],
@@ -2182,7 +2225,7 @@ mgmt_rx_reo_print_ingress_frame_stats(struct mgmt_rx_reo_context *reo_ctx)
 	mgmt_rx_reo_err("\t|link id/  |       |       |       |");
 	mgmt_rx_reo_err("\t|desc type |      0|      1|      2|");
 	mgmt_rx_reo_err("\t-------------------------------------------");
-	for (link_id = 0; link_id < num_mlo_links; link_id++) {
+	for (link_id = 0; link_id < MAX_MLO_LINKS; link_id++) {
 		mgmt_rx_reo_err("\t|%10u|%7llu|%7llu|%7llu|%7llu", link_id,
 				stats->stale_count[link_id][0],
 				stats->stale_count[link_id][1],
@@ -2201,7 +2244,7 @@ mgmt_rx_reo_print_ingress_frame_stats(struct mgmt_rx_reo_context *reo_ctx)
 	mgmt_rx_reo_err("\t|link id/  |       |       |       |");
 	mgmt_rx_reo_err("\t|desc type |      0|      1|      2|");
 	mgmt_rx_reo_err("\t-------------------------------------------");
-	for (link_id = 0; link_id < num_mlo_links; link_id++) {
+	for (link_id = 0; link_id < MAX_MLO_LINKS; link_id++) {
 		mgmt_rx_reo_err("\t|%10u|%7llu|%7llu|%7llu|%7llu", link_id,
 				stats->error_count[link_id][0],
 				stats->error_count[link_id][1],
@@ -2217,10 +2260,10 @@ mgmt_rx_reo_print_ingress_frame_stats(struct mgmt_rx_reo_context *reo_ctx)
 
 	mgmt_rx_reo_err("\t4) Host consumed frames related stats:");
 	mgmt_rx_reo_err("\t------------------------------------------------");
-	mgmt_rx_reo_err("\t|link id   |Queued frame |Zero wait |Zero wait |");
+	mgmt_rx_reo_err("\t|link id   |Queued frame |Zero wait |Immediate |");
 	mgmt_rx_reo_err("\t|          |    count    |  count   | delivery |");
 	mgmt_rx_reo_err("\t------------------------------------------------");
-	for (link_id = 0; link_id < num_mlo_links; link_id++) {
+	for (link_id = 0; link_id < MAX_MLO_LINKS; link_id++) {
 		mgmt_rx_reo_err("\t|%10u|%13llu|%10llu|%10llu|", link_id,
 				stats->queued_count[link_id],
 				stats->zero_wait_count_rx_count[link_id],
@@ -2301,6 +2344,8 @@ mgmt_rx_reo_log_ingress_frame(struct mgmt_rx_reo_context *reo_ctx,
 		stats->immediate_delivery_count[link_id]++;
 	if (is_error)
 		stats->error_count[link_id][desc->type]++;
+	if (desc->is_stale)
+		stats->stale_count[link_id][desc->type]++;
 
 	return QDF_STATUS_SUCCESS;
 }
@@ -2464,7 +2509,6 @@ wlan_mgmt_rx_reo_algo_entry(struct wlan_objmgr_pdev *pdev,
 {
 	struct mgmt_rx_reo_context *reo_ctx;
 	QDF_STATUS ret;
-	int8_t num_mlo_links;
 
 	if (!is_queued)
 		return QDF_STATUS_E_NULL_VALUE;
@@ -2482,10 +2526,6 @@ wlan_mgmt_rx_reo_algo_entry(struct wlan_objmgr_pdev *pdev,
 		return QDF_STATUS_E_NULL_VALUE;
 	}
 
-	num_mlo_links = mgmt_rx_reo_get_num_mlo_links(reo_ctx);
-	qdf_assert_always(num_mlo_links > 0);
-	qdf_assert_always(num_mlo_links <= MGMT_RX_REO_MAX_LINKS);
-
 	/**
 	 * Critical Section = Host snapshot update + Calculation of wait
 	 * counts + Update reorder list. Following section describes the
@@ -2586,14 +2626,12 @@ wlan_mgmt_rx_reo_algo_entry(struct wlan_objmgr_pdev *pdev,
 	ret = wlan_mgmt_rx_reo_algo_calculate_wait_count(
 						pdev,
 						desc->rx_params->reo_params,
-						num_mlo_links,
 						&desc->wait_count);
 	if (QDF_IS_STATUS_ERROR(ret))
 		goto failure;
 
 	/* Update the REO list */
-	ret = mgmt_rx_reo_update_list(&reo_ctx->reo_list, num_mlo_links,
-				      desc, is_queued);
+	ret = mgmt_rx_reo_update_list(&reo_ctx->reo_list, desc, is_queued);
 	if (QDF_IS_STATUS_ERROR(ret))
 		goto failure;
 
@@ -2880,7 +2918,6 @@ mgmt_rx_reo_sim_process_rx_frame(struct wlan_objmgr_pdev *pdev, qdf_nbuf_t buf,
 	struct mgmt_rx_reo_sim_context *sim_context;
 	QDF_STATUS status;
 	struct mgmt_rx_reo_params *reo_params;
-	int8_t num_mlo_links;
 
 	if (!mgmt_rx_params) {
 		mgmt_rx_reo_err("Mgmt rx params null");
@@ -2897,14 +2934,6 @@ mgmt_rx_reo_sim_process_rx_frame(struct wlan_objmgr_pdev *pdev, qdf_nbuf_t buf,
 
 	sim_context = &reo_context->sim_context;
 
-	num_mlo_links = mgmt_rx_reo_sim_get_num_mlo_links(sim_context);
-
-	if (num_mlo_links < 0 || num_mlo_links > MGMT_RX_REO_MAX_LINKS) {
-		mgmt_rx_reo_err("Invalid number of MLO links %d",
-				num_mlo_links);
-		return QDF_STATUS_E_INVAL;
-	}
-
 	qdf_spin_lock(&sim_context->master_frame_list.lock);
 
 	if (qdf_list_empty(&sim_context->master_frame_list.pending_list)) {
@@ -3379,6 +3408,34 @@ error_free_mac_hw_frame:
 			link_id);
 }
 
+/**
+ * mgmt_rx_reo_sim_get_link_id() - Helper API to get the link id value
+ * from the index to the valid link list
+ * @valid_link_list_index: Index to list of valid links
+ *
+ * Return: link id
+ */
+static int8_t
+mgmt_rx_reo_sim_get_link_id(uint8_t valid_link_list_index)
+{
+	struct mgmt_rx_reo_sim_context *sim_context;
+
+	if (valid_link_list_index >= MAX_MLO_LINKS) {
+		mgmt_rx_reo_err("Invalid index %u to valid link list",
+				valid_link_list_index);
+		return MGMT_RX_REO_INVALID_LINK_ID;
+	}
+
+	sim_context = mgmt_rx_reo_sim_get_context();
+	if (!sim_context) {
+		mgmt_rx_reo_err("Mgmt reo simulation context is null");
+		return MGMT_RX_REO_INVALID_LINK_ID;
+	}
+
+	return sim_context->link_id_to_pdev_map.valid_link_list
+						[valid_link_list_index];
+}
+
 /**
  * mgmt_rx_reo_sim_receive_from_air() - Simulate management frame reception from
  * the air
@@ -3395,14 +3452,16 @@ mgmt_rx_reo_sim_receive_from_air(struct mgmt_rx_reo_sim_mac_hw *mac_hw,
 				 uint8_t num_mlo_links,
 				 struct mgmt_rx_frame_params *frame)
 {
-	uint8_t link_id;
+	uint8_t valid_link_list_index;
+	QDF_STATUS status;
+	int8_t link_id;
 
 	if (!mac_hw) {
 		mgmt_rx_reo_err("pointer to MAC HW struct is null");
 		return QDF_STATUS_E_NULL_VALUE;
 	}
 
-	if (num_mlo_links == 0 || num_mlo_links > MGMT_RX_REO_MAX_LINKS) {
+	if (num_mlo_links == 0 || num_mlo_links > MAX_MLO_LINKS) {
 		mgmt_rx_reo_err("Invalid number of MLO links %u",
 				num_mlo_links);
 		return QDF_STATUS_E_INVAL;
@@ -3413,7 +3472,11 @@ mgmt_rx_reo_sim_receive_from_air(struct mgmt_rx_reo_sim_mac_hw *mac_hw,
 		return QDF_STATUS_E_NULL_VALUE;
 	}
 
-	link_id = mgmt_rx_reo_sim_get_random_unsigned_int(num_mlo_links);
+	valid_link_list_index = mgmt_rx_reo_sim_get_random_unsigned_int(
+							num_mlo_links);
+	link_id = mgmt_rx_reo_sim_get_link_id(valid_link_list_index);
+	qdf_assert_always(link_id >= 0);
+	qdf_assert_always(link_id < MAX_MLO_LINKS);
 
 	frame->global_timestamp = div_u64(ktime_get_ns(), NSEC_PER_USEC);
 	frame->mgmt_pkt_ctr = ++mac_hw->mgmt_pkt_ctr[link_id];
@@ -3444,7 +3507,7 @@ mgmt_rx_reo_sim_undo_receive_from_air(struct mgmt_rx_reo_sim_mac_hw *mac_hw,
 		return QDF_STATUS_E_NULL_VALUE;
 	}
 
-	if (frame->link_id >= MGMT_RX_REO_MAX_LINKS) {
+	if (frame->link_id >= MAX_MLO_LINKS) {
 		mgmt_rx_reo_err("Invalid link id %u", frame->link_id);
 		return QDF_STATUS_E_INVAL;
 	}
@@ -3488,7 +3551,7 @@ mgmt_rx_reo_sim_mac_hw_thread(void *data)
 
 		num_mlo_links = mgmt_rx_reo_sim_get_num_mlo_links(sim_context);
 		if (num_mlo_links < 0 ||
-		    num_mlo_links > MGMT_RX_REO_MAX_LINKS) {
+		    num_mlo_links > MAX_MLO_LINKS) {
 			mgmt_rx_reo_err("Invalid number of MLO links %d",
 					num_mlo_links);
 			qdf_assert_always(0);
@@ -3642,6 +3705,49 @@ mgmt_rx_reo_sim_deinit_master_frame_list(
 	return QDF_STATUS_SUCCESS;
 }
 
+/**
+ * mgmt_rx_reo_sim_generate_unique_link_id() - Helper API to generate
+ * unique link id values
+ * @link_id_to_pdev_map: pointer to link id to pdev map
+ * @link_id: Pointer to unique link id
+ *
+ * This API generates unique link id values for each pdev. This API should be
+ * called after acquiring the spin lock protecting link id to pdev map.
+ *
+ * Return: QDF_STATUS
+ */
+static QDF_STATUS
+mgmt_rx_reo_sim_generate_unique_link_id(
+		struct wlan_objmgr_pdev *link_id_to_pdev_map, uint8_t *link_id)
+{
+	uint8_t random_link_id;
+	uint8_t link_id;
+
+	if (!link_id_to_pdev_map || !link_id)
+		return QDF_STATUS_E_NULL_VALUE;
+
+	for (link_id = 0; link_id < MAX_MLO_LINKS; link_id++)
+		if (!link_id_to_pdev_map[link_id])
+			break;
+
+	if (link_id == MAX_MLO_LINKS) {
+		mgmt_rx_reo_err("All link ids are already allocated");
+		return QDF_STATUS_E_FAILURE;
+	}
+
+	while (1) {
+		random_link_id = mgmt_rx_reo_sim_get_random_unsigned_int(
+							MAX_MLO_LINKS);
+
+		if (!link_id_to_pdev_map[random_link_id])
+			break;
+	}
+
+	*link_id = random_link_id;
+
+	return QDF_STATUS_SUCCESS;
+}
+
 /**
  * mgmt_rx_reo_sim_insert_into_link_id_to_pdev_map() - Builds the MLO HW link id
  * to pdev map
@@ -3658,6 +3764,8 @@ mgmt_rx_reo_sim_insert_into_link_id_to_pdev_map(
 		struct mgmt_rx_reo_sim_link_id_to_pdev_map *link_id_to_pdev_map,
 		struct wlan_objmgr_pdev *pdev)
 {
+	uint8_t link_id;
+
 	if (!link_id_to_pdev_map) {
 		mgmt_rx_reo_err("Link id to pdev map is null");
 		return QDF_STATUS_E_NULL_VALUE;
@@ -3670,7 +3778,17 @@ mgmt_rx_reo_sim_insert_into_link_id_to_pdev_map(
 
 	qdf_spin_lock(&link_id_to_pdev_map->lock);
 
-	link_id_to_pdev_map->map[link_id_to_pdev_map->num_mlo_links] = pdev;
+	status = mgmt_rx_reo_sim_generate_unique_link_id(
+					link_id_to_pdev_map->map, &link_id)
+	if (QDF_IS_STATUS_ERROR(status)) {
+		qdf_spin_unlock(&link_id_to_pdev_map->lock);
+		return QDF_STATUS_E_FAILURE;
+	}
+	qdf_assert_always(link_id < MAX_MLO_LINKS);
+
+	link_id_to_pdev_map->map[link_id] = pdev;
+	link_id_to_pdev_map->valid_link_list
+			[link_id_to_pdev_map->num_mlo_links] = link_id;
 	link_id_to_pdev_map->num_mlo_links++;
 
 	qdf_spin_unlock(&link_id_to_pdev_map->lock);
@@ -3708,8 +3826,7 @@ mgmt_rx_reo_sim_remove_from_link_id_to_pdev_map(
 
 	qdf_spin_lock(&link_id_to_pdev_map->lock);
 
-	for (link_id = 0; link_id < link_id_to_pdev_map->num_mlo_links;
-	     link_id++) {
+	for (link_id = 0; link_id < MAX_MLO_LINKS; link_id++) {
 		if (link_id_to_pdev_map->map[link_id] == pdev) {
 			link_id_to_pdev_map->map[link_id] = NULL;
 			qdf_spin_unlock(&link_id_to_pdev_map->lock);
@@ -3779,7 +3896,6 @@ mgmt_rx_reo_sim_start(void)
 	qdf_thread_t *mac_hw_thread;
 	uint8_t link_id;
 	uint8_t id;
-	int8_t num_mlo_links;
 	QDF_STATUS status;
 
 	reo_context = mgmt_rx_reo_get_context();
@@ -3792,14 +3908,7 @@ mgmt_rx_reo_sim_start(void)
 
 	sim_context = &reo_context->sim_context;
 
-	num_mlo_links = mgmt_rx_reo_sim_get_num_mlo_links(sim_context);
-	if (num_mlo_links <= 0) {
-		mgmt_rx_reo_err("Invalid number of MLO links %d",
-				num_mlo_links);
-		return QDF_STATUS_E_INVAL;
-	}
-
-	for (link_id = 0; link_id < num_mlo_links; link_id++) {
+	for (link_id = 0; link_id < MAX_MLO_LINKS; link_id++) {
 		struct workqueue_struct *wq;
 
 		wq = alloc_ordered_workqueue("mgmt_rx_reo_sim_host-%u", 0,
@@ -3863,7 +3972,6 @@ mgmt_rx_reo_sim_stop(void)
 	struct mgmt_rx_reo_master_frame_list *master_frame_list;
 	uint8_t link_id;
 	QDF_STATUS status;
-	int8_t num_mlo_links;
 
 	reo_context = mgmt_rx_reo_get_context();
 	if (!reo_context) {
@@ -3873,13 +3981,6 @@ mgmt_rx_reo_sim_stop(void)
 
 	sim_context = &reo_context->sim_context;
 
-	num_mlo_links = mgmt_rx_reo_sim_get_num_mlo_links(sim_context);
-	if (num_mlo_links <= 0) {
-		mgmt_rx_reo_err("Invalid number of MLO links %d",
-				num_mlo_links);
-		return QDF_STATUS_E_INVAL;
-	}
-
 	status = qdf_thread_join(sim_context->mac_hw_sim.mac_hw_thread);
 	if (QDF_IS_STATUS_ERROR(status)) {
 		mgmt_rx_reo_err("Failed to stop the thread");
@@ -3888,7 +3989,7 @@ mgmt_rx_reo_sim_stop(void)
 
 	sim_context->mac_hw_sim.mac_hw_thread = NULL;
 
-	for (link_id = 0; link_id < num_mlo_links; link_id++) {
+	for (link_id = 0; link_id < MAX_MLO_LINKS; link_id++) {
 		/* Wait for all the pending frames to be processed by FW */
 		drain_workqueue(sim_context->fw_mgmt_frame_handler[link_id]);
 		destroy_workqueue(sim_context->fw_mgmt_frame_handler[link_id]);
@@ -3928,8 +4029,7 @@ mgmt_rx_reo_sim_stop(void)
 	    !qdf_list_empty(&master_frame_list->stale_list)) {
 		mgmt_rx_reo_err("reo sim failure: pending/stale frame list non empty");
 
-		status = mgmt_rx_reo_list_display(
-				&reo_context->reo_list, num_mlo_links);
+		status = mgmt_rx_reo_list_display(&reo_context->reo_list);
 		if (QDF_IS_STATUS_ERROR(status)) {
 			mgmt_rx_reo_err("Failed to print reorder list");
 			return status;
@@ -3957,6 +4057,7 @@ mgmt_rx_reo_sim_init(struct mgmt_rx_reo_context *reo_context)
 {
 	QDF_STATUS status;
 	struct mgmt_rx_reo_sim_context *sim_context;
+	uint8_t link_id;
 
 	if (!reo_context) {
 		mgmt_rx_reo_err("reo context is null");
@@ -3976,6 +4077,10 @@ mgmt_rx_reo_sim_init(struct mgmt_rx_reo_context *reo_context)
 
 	qdf_spinlock_create(&sim_context->link_id_to_pdev_map.lock);
 
+	for (link_id = 0; link_id < MAX_MLO_LINKS; link_id++)
+		sim_context->link_id_to_pdev_map.valid_link_list[link_id] =
+					MGMT_RX_REO_INVALID_LINK_ID;
+
 	return QDF_STATUS_SUCCESS;
 }
 
@@ -4042,7 +4147,7 @@ mgmt_rx_reo_sim_get_snapshot_address(
 	}
 
 	link_id = wlan_get_mlo_link_id_from_pdev(pdev);
-	if (link_id < 0 || link_id >= MGMT_RX_REO_MAX_LINKS) {
+	if (link_id < 0 || link_id >= MAX_MLO_LINKS) {
 		mgmt_rx_reo_err("Invalid link id %d for the pdev %pK", link_id,
 				pdev);
 		return QDF_STATUS_E_INVAL;

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

@@ -34,21 +34,16 @@
 #include <wlan_mgmt_txrx_rx_reo_public_structs.h>
 #include <wlan_objmgr_pdev_obj.h>
 #include <wlan_objmgr_psoc_obj.h>
+#include <wlan_mlo_mgr_public_structs.h>
 
 #define MGMT_RX_REO_LIST_MAX_SIZE             (100)
-#define MGMT_RX_REO_LIST_TIMEOUT_US           (1000 * USEC_PER_MSEC)
-#define MGMT_RX_REO_AGEOUT_TIMER_PERIOD_MS    (500)
+#define MGMT_RX_REO_LIST_TIMEOUT_US           (500 * USEC_PER_MSEC)
+#define MGMT_RX_REO_AGEOUT_TIMER_PERIOD_MS    (250)
 #define MGMT_RX_REO_STATUS_WAIT_FOR_FRAME_ON_OTHER_LINKS         (BIT(0))
 #define MGMT_RX_REO_STATUS_AGED_OUT                              (BIT(1))
 #define MGMT_RX_REO_STATUS_OLDER_THAN_LATEST_AGED_OUT_FRAME      (BIT(2))
 #define MGMT_RX_REO_STATUS_LIST_MAX_SIZE_EXCEEDED                (BIT(3))
 
-/**
- * TODO: Dummy macro for Maximum MLO links on the system
- * This is added only as a place holder for the time being.
- * Remove this once the actual one is implemented.
- */
-#define MGMT_RX_REO_MAX_LINKS (4)
 #define MGMT_RX_REO_INVALID_LINK_ID   (-1)
 
 /* Reason to release an entry from the reorder list */
@@ -190,7 +185,7 @@ struct mgmt_rx_reo_list {
  * @total_count: Sum of entries in @per_link_count
  */
 struct mgmt_rx_reo_wait_count {
-	unsigned int per_link_count[MGMT_RX_REO_MAX_LINKS];
+	unsigned int per_link_count[MAX_MLO_LINKS];
 	unsigned long long int total_count;
 };
 
@@ -335,7 +330,7 @@ struct mgmt_rx_frame_fw {
  * @mgmt_pkt_ctr: Stores the last management packet counter for all the links
  */
 struct mgmt_rx_reo_sim_mac_hw {
-	uint16_t mgmt_pkt_ctr[MGMT_RX_REO_MAX_LINKS];
+	uint16_t mgmt_pkt_ctr[MAX_MLO_LINKS];
 };
 
 /**
@@ -346,11 +341,13 @@ struct mgmt_rx_reo_sim_mac_hw {
  * @num_mlo_links: Total number of MLO HW links. In case of simulation all the
  * pdevs are assumed to have MLO capability and number of MLO links is same as
  * the number of pdevs in the system.
+ * @valid_link_list: List of valid link id values
  */
 struct mgmt_rx_reo_sim_link_id_to_pdev_map {
-	struct wlan_objmgr_pdev *map[MGMT_RX_REO_MAX_LINKS];
+	struct wlan_objmgr_pdev *map[MAX_MLO_LINKS];
 	qdf_spinlock_t lock;
 	uint8_t num_mlo_links;
+	int8_t valid_link_list[MAX_MLO_LINKS];
 };
 
 /**
@@ -375,11 +372,11 @@ struct mgmt_rx_reo_mac_hw_simulator {
  * @link_id_to_pdev_map: link_id to pdev object map
  */
 struct mgmt_rx_reo_sim_context {
-	struct workqueue_struct *host_mgmt_frame_handler[MGMT_RX_REO_MAX_LINKS];
-	struct workqueue_struct *fw_mgmt_frame_handler[MGMT_RX_REO_MAX_LINKS];
+	struct workqueue_struct *host_mgmt_frame_handler[MAX_MLO_LINKS];
+	struct workqueue_struct *fw_mgmt_frame_handler[MAX_MLO_LINKS];
 	struct mgmt_rx_reo_master_frame_list master_frame_list;
 	struct mgmt_rx_reo_mac_hw_simulator mac_hw_sim;
-	struct mgmt_rx_reo_snapshot snapshot[MGMT_RX_REO_MAX_LINKS]
+	struct mgmt_rx_reo_snapshot snapshot[MAX_MLO_LINKS]
 					    [MGMT_RX_REO_SHARED_SNAPSHOT_MAX];
 	struct mgmt_rx_reo_sim_link_id_to_pdev_map link_id_to_pdev_map;
 };
@@ -487,13 +484,13 @@ struct reo_egress_debug_frame_info {
  */
 struct reo_ingress_frame_stats {
 	uint64_t ingress_count
-		[MGMT_RX_REO_MAX_LINKS][MGMT_RX_REO_FRAME_DESC_TYPE_MAX];
-	uint64_t queued_count[MGMT_RX_REO_MAX_LINKS];
-	uint64_t zero_wait_count_rx_count[MGMT_RX_REO_MAX_LINKS];
-	uint64_t immediate_delivery_count[MGMT_RX_REO_MAX_LINKS];
-	uint64_t stale_count[MGMT_RX_REO_MAX_LINKS]
+		[MAX_MLO_LINKS][MGMT_RX_REO_FRAME_DESC_TYPE_MAX];
+	uint64_t queued_count[MAX_MLO_LINKS];
+	uint64_t zero_wait_count_rx_count[MAX_MLO_LINKS];
+	uint64_t immediate_delivery_count[MAX_MLO_LINKS];
+	uint64_t stale_count[MAX_MLO_LINKS]
 			    [MGMT_RX_REO_FRAME_DESC_TYPE_MAX];
-	uint64_t error_count[MGMT_RX_REO_MAX_LINKS]
+	uint64_t error_count[MAX_MLO_LINKS]
 			    [MGMT_RX_REO_FRAME_DESC_TYPE_MAX];
 };
 
@@ -511,10 +508,10 @@ struct reo_ingress_frame_stats {
  * each link and release  reason.
  */
 struct reo_egress_frame_stats {
-	uint64_t delivery_attempts_count[MGMT_RX_REO_MAX_LINKS];
-	uint64_t delivery_success_count[MGMT_RX_REO_MAX_LINKS];
-	uint64_t premature_delivery_count[MGMT_RX_REO_MAX_LINKS];
-	uint64_t delivery_count[MGMT_RX_REO_MAX_LINKS]
+	uint64_t delivery_attempts_count[MAX_MLO_LINKS];
+	uint64_t delivery_success_count[MAX_MLO_LINKS];
+	uint64_t premature_delivery_count[MAX_MLO_LINKS];
+	uint64_t delivery_count[MAX_MLO_LINKS]
 			       [MGMT_RX_REO_RELEASE_REASON_MAX];
 };