Merge "qcacmn: Use monitor direct for smart monitor"

dp/wifi3.0/dp_htt.c

@@ -928,26 +928,48 @@ int htt_h2t_rx_ring_cfg(void *htt_soc, int pdev_id, void *hal_srng,
 	}
 
 	if (htt_tlv_filter->enable_md) {
+			/* TYPE: MGMT */
+		htt_rx_ring_pkt_enable_subtype_set(*msg_word, FLAG0,
+			MD, MGMT, 0000,
+			(htt_tlv_filter->md_mgmt_filter &
+			FILTER_MGMT_ASSOC_REQ) ? 1 : 0);
+		htt_rx_ring_pkt_enable_subtype_set(*msg_word, FLAG0,
+			MD, MGMT, 0001,
+			(htt_tlv_filter->md_mgmt_filter &
+			FILTER_MGMT_ASSOC_RES) ? 1 : 0);
+		htt_rx_ring_pkt_enable_subtype_set(*msg_word, FLAG0,
+			MD, MGMT, 0010,
+			(htt_tlv_filter->md_mgmt_filter &
+			FILTER_MGMT_REASSOC_REQ) ? 1 : 0);
+		htt_rx_ring_pkt_enable_subtype_set(*msg_word, FLAG0,
+			MD, MGMT, 0011,
+			(htt_tlv_filter->md_mgmt_filter &
+			FILTER_MGMT_REASSOC_RES) ? 1 : 0);
+		htt_rx_ring_pkt_enable_subtype_set(*msg_word, FLAG0,
+			MD, MGMT, 0100,
+			(htt_tlv_filter->md_mgmt_filter &
+			FILTER_MGMT_PROBE_REQ) ? 1 : 0);
+		htt_rx_ring_pkt_enable_subtype_set(*msg_word, FLAG0,
+			MD, MGMT, 0101,
+			(htt_tlv_filter->md_mgmt_filter &
+			FILTER_MGMT_PROBE_RES) ? 1 : 0);
+		htt_rx_ring_pkt_enable_subtype_set(*msg_word, FLAG0,
+			MD, MGMT, 0110,
+			(htt_tlv_filter->md_mgmt_filter &
+			FILTER_MGMT_TIM_ADVT) ? 1 : 0);
+		/* reserved */
 		htt_rx_ring_pkt_enable_subtype_set(*msg_word, FLAG0, MD,
-				MGMT, 0000, 1);
-		htt_rx_ring_pkt_enable_subtype_set(*msg_word, FLAG0, MD,
-				MGMT, 0001, 1);
-		htt_rx_ring_pkt_enable_subtype_set(*msg_word, FLAG0, MD,
-				MGMT, 0010, 1);
-		htt_rx_ring_pkt_enable_subtype_set(*msg_word, FLAG0, MD,
-				MGMT, 0011, 1);
-		htt_rx_ring_pkt_enable_subtype_set(*msg_word, FLAG0, MD,
-				MGMT, 0100, 1);
-		htt_rx_ring_pkt_enable_subtype_set(*msg_word, FLAG0, MD,
-				MGMT, 0101, 1);
-		htt_rx_ring_pkt_enable_subtype_set(*msg_word, FLAG0, MD,
-				MGMT, 0110, 1);
-		htt_rx_ring_pkt_enable_subtype_set(*msg_word, FLAG0, MD,
-				MGMT, 0111, 1);
-		htt_rx_ring_pkt_enable_subtype_set(*msg_word, FLAG0, MD,
-				MGMT, 1000, 1);
-		htt_rx_ring_pkt_enable_subtype_set(*msg_word, FLAG0, MD,
-				MGMT, 1001, 1);
+			MGMT, 0111,
+			(htt_tlv_filter->md_mgmt_filter &
+			FILTER_MGMT_RESERVED_7) ? 1 : 0);
+		htt_rx_ring_pkt_enable_subtype_set(*msg_word, FLAG0,
+			MD, MGMT, 1000,
+			(htt_tlv_filter->md_mgmt_filter &
+			FILTER_MGMT_BEACON) ? 1 : 0);
+		htt_rx_ring_pkt_enable_subtype_set(*msg_word, FLAG0,
+			MD, MGMT, 1001,
+			(htt_tlv_filter->md_mgmt_filter &
+			FILTER_MGMT_ATIM) ? 1 : 0);
 	}
 
 	if (htt_tlv_filter->enable_mo) {
@@ -1029,16 +1051,27 @@ int htt_h2t_rx_ring_cfg(void *htt_soc, int pdev_id, void *hal_srng,
 	}
 
 	if (htt_tlv_filter->enable_md) {
-		htt_rx_ring_pkt_enable_subtype_set(*msg_word, FLAG1, MD,
-				MGMT, 1010, 1);
-		htt_rx_ring_pkt_enable_subtype_set(*msg_word, FLAG1, MD,
-				MGMT, 1011, 1);
-		htt_rx_ring_pkt_enable_subtype_set(*msg_word, FLAG1, MD,
-				MGMT, 1100, 1);
-		htt_rx_ring_pkt_enable_subtype_set(*msg_word, FLAG1, MD,
-				MGMT, 1101, 1);
-		htt_rx_ring_pkt_enable_subtype_set(*msg_word, FLAG1, MD,
-				MGMT, 1110, 1);
+			/* TYPE: MGMT */
+		htt_rx_ring_pkt_enable_subtype_set(*msg_word, FLAG1,
+			MD, MGMT, 1010,
+			(htt_tlv_filter->md_mgmt_filter &
+			FILTER_MGMT_DISASSOC) ? 1 : 0);
+		htt_rx_ring_pkt_enable_subtype_set(*msg_word, FLAG1,
+			MD, MGMT, 1011,
+			(htt_tlv_filter->md_mgmt_filter &
+			FILTER_MGMT_AUTH) ? 1 : 0);
+		htt_rx_ring_pkt_enable_subtype_set(*msg_word, FLAG1,
+			MD, MGMT, 1100,
+			(htt_tlv_filter->md_mgmt_filter &
+			FILTER_MGMT_DEAUTH) ? 1 : 0);
+		htt_rx_ring_pkt_enable_subtype_set(*msg_word, FLAG1,
+			MD, MGMT, 1101,
+			(htt_tlv_filter->md_mgmt_filter &
+			FILTER_MGMT_ACTION) ? 1 : 0);
+		htt_rx_ring_pkt_enable_subtype_set(*msg_word, FLAG1,
+			MD, MGMT, 1110,
+			(htt_tlv_filter->md_mgmt_filter &
+			FILTER_MGMT_ACT_NO_ACK) ? 1 : 0);
 	}
 
 	if (htt_tlv_filter->enable_mo) {
@@ -1122,26 +1155,50 @@ int htt_h2t_rx_ring_cfg(void *htt_soc, int pdev_id, void *hal_srng,
 	}
 
 	if (htt_tlv_filter->enable_md) {
-		htt_rx_ring_pkt_enable_subtype_set(*msg_word, FLAG2, MO,
-				CTRL, 0000, 1);
-		htt_rx_ring_pkt_enable_subtype_set(*msg_word, FLAG2, MO,
-				CTRL, 0001, 1);
-		htt_rx_ring_pkt_enable_subtype_set(*msg_word, FLAG2, MO,
-				CTRL, 0010, 1);
-		htt_rx_ring_pkt_enable_subtype_set(*msg_word, FLAG2, MO,
-				CTRL, 0011, 1);
-		htt_rx_ring_pkt_enable_subtype_set(*msg_word, FLAG2, MO,
-				CTRL, 0100, 1);
-		htt_rx_ring_pkt_enable_subtype_set(*msg_word, FLAG2, MO,
-				CTRL, 0101, 1);
-		htt_rx_ring_pkt_enable_subtype_set(*msg_word, FLAG2, MO,
-				CTRL, 0110, 1);
+		/* TYPE: CTRL */
+		/* reserved */
 		htt_rx_ring_pkt_enable_subtype_set(*msg_word, FLAG2, MD,
-				CTRL, 0111, 1);
+			CTRL, 0000,
+			(htt_tlv_filter->md_ctrl_filter &
+			FILTER_CTRL_RESERVED_1) ? 1 : 0);
+		/* reserved */
 		htt_rx_ring_pkt_enable_subtype_set(*msg_word, FLAG2, MD,
-				CTRL, 1000, 1);
+			CTRL, 0001,
+			(htt_tlv_filter->md_ctrl_filter &
+			FILTER_CTRL_RESERVED_2) ? 1 : 0);
 		htt_rx_ring_pkt_enable_subtype_set(*msg_word, FLAG2, MD,
-				CTRL, 1001, 1);
+			CTRL, 0010,
+			(htt_tlv_filter->md_ctrl_filter &
+			FILTER_CTRL_TRIGGER) ? 1 : 0);
+		/* reserved */
+		htt_rx_ring_pkt_enable_subtype_set(*msg_word, FLAG2, MD,
+			CTRL, 0011,
+			(htt_tlv_filter->md_ctrl_filter &
+			FILTER_CTRL_RESERVED_4) ? 1 : 0);
+		htt_rx_ring_pkt_enable_subtype_set(*msg_word, FLAG2, MD,
+			CTRL, 0100,
+			(htt_tlv_filter->md_ctrl_filter &
+			FILTER_CTRL_BF_REP_POLL) ? 1 : 0);
+		htt_rx_ring_pkt_enable_subtype_set(*msg_word, FLAG2, MD,
+			CTRL, 0101,
+			(htt_tlv_filter->md_ctrl_filter &
+			FILTER_CTRL_VHT_NDP) ? 1 : 0);
+		htt_rx_ring_pkt_enable_subtype_set(*msg_word, FLAG2, MD,
+			CTRL, 0110,
+			(htt_tlv_filter->md_ctrl_filter &
+			FILTER_CTRL_FRAME_EXT) ? 1 : 0);
+		htt_rx_ring_pkt_enable_subtype_set(*msg_word, FLAG2, MD,
+			CTRL, 0111,
+			(htt_tlv_filter->md_ctrl_filter &
+			FILTER_CTRL_CTRLWRAP) ? 1 : 0);
+		htt_rx_ring_pkt_enable_subtype_set(*msg_word, FLAG2, MD,
+			CTRL, 1000,
+			(htt_tlv_filter->md_ctrl_filter &
+			FILTER_CTRL_BA_REQ) ? 1 : 0);
+		htt_rx_ring_pkt_enable_subtype_set(*msg_word, FLAG2, MD,
+			CTRL, 1001,
+			(htt_tlv_filter->md_ctrl_filter &
+			FILTER_CTRL_BA) ? 1 : 0);
 	}
 
 	if (htt_tlv_filter->enable_mo) {
@@ -1236,24 +1293,44 @@ int htt_h2t_rx_ring_cfg(void *htt_soc, int pdev_id, void *hal_srng,
 	}
 
 	if (htt_tlv_filter->enable_md) {
+		/* TYPE: CTRL */
 		htt_rx_ring_pkt_enable_subtype_set(*msg_word, FLAG3, MD,
-				CTRL, 1010, 1);
+			CTRL, 1010,
+			(htt_tlv_filter->md_ctrl_filter &
+			FILTER_CTRL_PSPOLL) ? 1 : 0);
 		htt_rx_ring_pkt_enable_subtype_set(*msg_word, FLAG3, MD,
-				CTRL, 1011, 1);
+			CTRL, 1011,
+			(htt_tlv_filter->md_ctrl_filter &
+			FILTER_CTRL_RTS) ? 1 : 0);
 		htt_rx_ring_pkt_enable_subtype_set(*msg_word, FLAG3, MD,
-				CTRL, 1100, 1);
+			CTRL, 1100,
+			(htt_tlv_filter->md_ctrl_filter &
+			FILTER_CTRL_CTS) ? 1 : 0);
 		htt_rx_ring_pkt_enable_subtype_set(*msg_word, FLAG3, MD,
-				CTRL, 1101, 1);
+			CTRL, 1101,
+			(htt_tlv_filter->md_ctrl_filter &
+			FILTER_CTRL_ACK) ? 1 : 0);
 		htt_rx_ring_pkt_enable_subtype_set(*msg_word, FLAG3, MD,
-				CTRL, 1110, 1);
+			CTRL, 1110,
+			(htt_tlv_filter->md_ctrl_filter &
+			FILTER_CTRL_CFEND) ? 1 : 0);
 		htt_rx_ring_pkt_enable_subtype_set(*msg_word, FLAG3, MD,
-				CTRL, 1111, 1);
+			CTRL, 1111,
+			(htt_tlv_filter->md_ctrl_filter &
+			FILTER_CTRL_CFEND_CFACK) ? 1 : 0);
+		/* TYPE: DATA */
 		htt_rx_ring_pkt_enable_subtype_set(*msg_word, FLAG3, MD,
-				DATA, MCAST, 1);
+			DATA, MCAST,
+			(htt_tlv_filter->md_data_filter &
+			FILTER_DATA_MCAST) ? 1 : 0);
 		htt_rx_ring_pkt_enable_subtype_set(*msg_word, FLAG3, MD,
-				DATA, UCAST, 1);
+			DATA, UCAST,
+			(htt_tlv_filter->md_data_filter &
+			FILTER_DATA_UCAST) ? 1 : 0);
 		htt_rx_ring_pkt_enable_subtype_set(*msg_word, FLAG3, MD,
-				DATA, NULL, 1);
+			DATA, NULL,
+			(htt_tlv_filter->md_data_filter &
+			FILTER_DATA_NULL) ? 1 : 0);
 	}
 
 	if (htt_tlv_filter->enable_mo) {

dp/wifi3.0/dp_htt.h

@@ -132,6 +132,9 @@ struct htt_rx_ring_tlv_filter {
 		mo_ctrl_filter:16;
 	u_int32_t fp_data_filter:16,
 		mo_data_filter:16;
+	u_int16_t md_data_filter;
+	u_int16_t md_mgmt_filter;
+	u_int16_t md_ctrl_filter;
 };
 
 void *

dp/wifi3.0/dp_main.c

@@ -4250,9 +4250,8 @@ static int dp_update_filter_neighbour_peers(struct cdp_vdev *vdev_handle,
 
 		/* first neighbour */
 		if (!pdev->neighbour_peers_added) {
-			if (!pdev->mcopy_mode && !pdev->enhanced_stats_en)
-				dp_ppdu_ring_cfg(pdev);
 			pdev->neighbour_peers_added = true;
+			dp_ppdu_ring_cfg(pdev);
 		}
 		return 1;
 
@@ -5805,6 +5804,10 @@ dp_print_soc_rx_stats(struct dp_soc *soc)
 	uint8_t index = 0;
 
 	DP_PRINT_STATS("SOC Rx Stats:\n");
+	DP_PRINT_STATS("Fragmented packets: %u",
+		       soc->stats.rx.rx_frags);
+	DP_PRINT_STATS("Reo reinjected packets: %u",
+		       soc->stats.rx.reo_reinject);
 	DP_PRINT_STATS("Errors:\n");
 	DP_PRINT_STATS("Rx Decrypt Errors = %d",
 			(soc->stats.rx.err.rxdma_error[HAL_RXDMA_ERR_DECRYPT] +
@@ -6464,6 +6467,11 @@ dp_ppdu_ring_cfg(struct dp_pdev *pdev)
 	htt_tlv_filter.ppdu_end_status_done = 1;
 	htt_tlv_filter.enable_fp = 1;
 	htt_tlv_filter.enable_md = 0;
+	if (pdev->neighbour_peers_added &&
+	    pdev->soc->hw_nac_monitor_support) {
+		htt_tlv_filter.enable_md = 1;
+		htt_tlv_filter.packet_header = 1;
+	}
 	if (pdev->mcopy_mode) {
 		htt_tlv_filter.packet_header = 1;
 		htt_tlv_filter.enable_mo = 1;
@@ -6474,6 +6482,9 @@ dp_ppdu_ring_cfg(struct dp_pdev *pdev)
 	htt_tlv_filter.mo_mgmt_filter = FILTER_MGMT_ALL;
 	htt_tlv_filter.mo_ctrl_filter = FILTER_CTRL_ALL;
 	htt_tlv_filter.mo_data_filter = FILTER_DATA_ALL;
+	if (pdev->neighbour_peers_added &&
+	    pdev->soc->hw_nac_monitor_support)
+		htt_tlv_filter.md_data_filter = FILTER_DATA_ALL;
 
 	for (mac_id = 0; mac_id < NUM_RXDMA_RINGS_PER_PDEV; mac_id++) {
 		int mac_for_pdev = dp_get_mac_id_for_pdev(mac_id,
@@ -8120,11 +8131,13 @@ void *dp_soc_attach_wifi3(void *ctrl_psoc, void *hif_handle,
 		wlan_cfg_set_reo_dst_ring_size(soc->wlan_cfg_ctx,
 					       REO_DST_RING_SIZE_QCA8074);
 		wlan_cfg_set_raw_mode_war(soc->wlan_cfg_ctx, true);
+		soc->hw_nac_monitor_support = 1;
 		break;
 	case TARGET_TYPE_QCA8074V2:
 		wlan_cfg_set_reo_dst_ring_size(soc->wlan_cfg_ctx,
 					       REO_DST_RING_SIZE_QCA8074);
 		wlan_cfg_set_raw_mode_war(soc->wlan_cfg_ctx, false);
+		soc->hw_nac_monitor_support = 1;
 		break;
 	default:
 		qdf_print("%s: Unknown tgt type %d\n", __func__, target_type);

dp/wifi3.0/dp_rx_defrag.c

@@ -1107,6 +1107,7 @@ dp_rx_defrag_nwifi_to_8023(qdf_nbuf_t nbuf, uint16_t hdrsize)
 
 	hal_srng_access_end(soc->hal_soc, hal_srng);
 
+	DP_STATS_INC(soc, rx.reo_reinject, 1);
 	QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_INFO,
 				"%s: reinjection done !", __func__);
 	return QDF_STATUS_SUCCESS;
@@ -1652,6 +1653,7 @@ uint32_t dp_rx_frag_handle(struct dp_soc *soc, void *ring_desc,
 				rx_desc->rx_buf_start);
 
 		qdf_nbuf_set_pktlen(msdu, (msdu_len + RX_PKT_TLVS_LEN));
+		qdf_nbuf_append_ext_list(msdu, NULL, 0);
 
 		tid = hal_rx_mpdu_start_tid_get(soc->hal_soc,
 						rx_desc->rx_buf_start);

dp/wifi3.0/dp_rx_mon_status.c

@@ -296,6 +296,57 @@ dp_rx_handle_mcopy_mode(struct dp_soc *soc, struct dp_pdev *pdev,
 }
 #endif
 
+/**
+ * dp_rx_handle_smart_mesh_mode() - Deliver header for smart mesh
+ * @soc: Datapath SOC handle
+ * @pdev: Datapath PDEV handle
+ * @ppdu_info: Structure for rx ppdu info
+ * @nbuf: Qdf nbuf abstraction for linux skb
+ *
+ * Return: 0 on success, 1 on failure
+ */
+static inline int
+dp_rx_handle_smart_mesh_mode(struct dp_soc *soc, struct dp_pdev *pdev,
+			      struct hal_rx_ppdu_info *ppdu_info,
+			      qdf_nbuf_t nbuf)
+{
+	uint8_t size = 0;
+
+	if (!pdev->monitor_vdev) {
+		QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,
+			  "[%s]:[%d] Monitor vdev is NULL !!",
+			  __func__, __LINE__);
+		return 1;
+	}
+	if (ppdu_info->msdu_info.first_msdu_payload == NULL) {
+		QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,
+			  "[%s]:[%d] First msdu payload not present",
+			  __func__, __LINE__);
+		return 1;
+	}
+
+	/* Include 2 bytes of reserved space appended to the msdu payload */
+	size = (ppdu_info->msdu_info.first_msdu_payload -
+		qdf_nbuf_data(nbuf)) + 2;
+	ppdu_info->msdu_info.first_msdu_payload = NULL;
+
+	if (qdf_nbuf_pull_head(nbuf, size) == NULL) {
+		QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,
+			  "[%s]:[%d] No header present",
+			__func__, __LINE__);
+		return 1;
+	}
+
+	/* only retain RX MSDU payload in the skb */
+	qdf_nbuf_trim_tail(nbuf, qdf_nbuf_len(nbuf) -
+			   ppdu_info->msdu_info.payload_len);
+	qdf_nbuf_update_radiotap(&(pdev->ppdu_info.rx_status),
+				 nbuf, sizeof(struct rx_pkt_tlvs));
+	pdev->monitor_vdev->osif_rx_mon(pdev->monitor_vdev->osif_vdev,
+					nbuf, NULL);
+
+	return 0;
+}
 
 /**
 * dp_rx_handle_ppdu_stats() - Allocate and deliver ppdu stats to cdp layer
@@ -400,6 +451,7 @@ dp_rx_mon_status_process_tlv(struct dp_soc *soc, uint32_t mac_id,
 	uint32_t tlv_status = HAL_TLV_STATUS_BUF_DONE;
 	QDF_STATUS m_copy_status = QDF_STATUS_SUCCESS;
 	struct cdp_pdev_mon_stats *rx_mon_stats;
+	int smart_mesh_status;
 
 	ppdu_info = &pdev->ppdu_info;
 	rx_mon_stats = &pdev->rx_mon_stats;
@@ -437,21 +489,28 @@ dp_rx_mon_status_process_tlv(struct dp_soc *soc, uint32_t mac_id,
 			} while (tlv_status == HAL_TLV_STATUS_PPDU_NOT_DONE);
 		}
 
+		if (ppdu_info->rx_status.monitor_direct_used && pdev->neighbour_peers_added
+		    && pdev->monitor_vdev) {
+			smart_mesh_status = dp_rx_handle_smart_mesh_mode(soc,
+						pdev, ppdu_info, status_nbuf);
+			if (smart_mesh_status)
+				qdf_nbuf_free(status_nbuf);
+		}
 		if (pdev->mcopy_mode) {
 			m_copy_status = dp_rx_handle_mcopy_mode(soc,
 						pdev, ppdu_info, status_nbuf);
 			if (m_copy_status == QDF_STATUS_SUCCESS)
 				qdf_nbuf_free(status_nbuf);
-		} else {
-			qdf_nbuf_free(status_nbuf);
 		}
+		if (!pdev->neighbour_peers_added && !pdev->mcopy_mode)
+			qdf_nbuf_free(status_nbuf);
 
 		if (tlv_status == HAL_TLV_STATUS_PPDU_NON_STD_DONE) {
 			dp_rx_mon_deliver_non_std(soc, mac_id);
 		} else if (tlv_status == HAL_TLV_STATUS_PPDU_DONE) {
 			rx_mon_stats->status_ppdu_done++;
 			if (pdev->enhanced_stats_en ||
-					pdev->mcopy_mode)
+			    pdev->mcopy_mode || pdev->neighbour_peers_added)
 				dp_rx_handle_ppdu_stats(soc, pdev, ppdu_info);
 
 			pdev->mon_ppdu_status = DP_PPDU_STATUS_DONE;

dp/wifi3.0/dp_types.h

@@ -558,6 +558,8 @@ struct dp_soc_stats {
 		uint32_t err_ring_pkts;
 		/* No of Fragments */
 		uint32_t rx_frags;
+		/* No of reinjected packets */
+		uint32_t reo_reinject;
 		struct {
 			/* Invalid RBM error count */
 			uint32_t invalid_rbm;
@@ -913,6 +915,9 @@ struct dp_soc {
 #endif
 	/* Device ID coming from Bus sub-system */
 	uint32_t device_id;
+
+	/* Smart monitor capability for HKv2 */
+	uint8_t hw_nac_monitor_support;
 };
 
 #ifdef IPA_OFFLOAD
@@ -1126,6 +1131,7 @@ struct dp_pdev {
 	uint16_t mo_mgmt_filter;
 	uint16_t mo_ctrl_filter;
 	uint16_t mo_data_filter;
+	uint16_t md_data_filter;
 
 	qdf_atomic_t num_tx_outstanding;
 

ftm/dispatcher/src/wlan_ftm_ucfg_api.c

@@ -51,7 +51,7 @@ wlan_ftm_process_utf_event(struct wlan_objmgr_pdev *pdev,
 			    uint8_t *event_buf, uint32_t len)
 {
 	struct wifi_ftm_pdev_priv_obj *ftm_pdev_obj;
-	u_int16_t utf_datalen;
+	uint32_t utf_datalen;
 	uint8_t *utf_data;
 	struct ftm_seg_hdr_info seghdr_info;
 	u_int8_t total_segments, current_seq;
@@ -82,6 +82,11 @@ wlan_ftm_process_utf_event(struct wlan_objmgr_pdev *pdev,
 		}
 	}
 
+	if ((len > FTM_CMD_MAX_BUF_LENGTH) ||
+	    (ftm_pdev_obj->offset > (FTM_CMD_MAX_BUF_LENGTH - utf_datalen))) {
+		ftm_err("Invalid utf data len :%d", len);
+		return QDF_STATUS_E_FAILURE;
+	}
 	qdf_mem_copy(&ftm_pdev_obj->data[ftm_pdev_obj->offset],
 			&utf_data[sizeof(seghdr_info)], utf_datalen);
 

hal/wifi3.0/hal_generic_api.h

@@ -997,6 +997,7 @@ hal_rx_status_get_tlv_info_generic(void *rx_tlv_hdr, void *ppduinfo,
 					RX_MPDU_INFO_RX_MPDU_INFO_DETAILS);
 		uint32_t ppdu_id = HAL_RX_GET(rx_mpdu_start, RX_MPDU_INFO_0,
 					      PHY_PPDU_ID);
+		uint8_t filter_category = 0;
 
 		ppdu_info->nac_info.fc_valid =
 			HAL_RX_GET(rx_mpdu_start,
@@ -1033,6 +1034,11 @@ hal_rx_status_get_tlv_info_generic(void *rx_tlv_hdr, void *ppduinfo,
 				HAL_RX_GET(rx_mpdu_start, RX_MPDU_INFO_13,
 				MPDU_LENGTH);
 		}
+
+		filter_category = HAL_RX_GET(rx_mpdu_start, RX_MPDU_INFO_0,
+							RXPCU_MPDU_FILTER_IN_CATEGORY);
+		if (filter_category == 1)
+			ppdu_info->rx_status.monitor_direct_used = 1;
 		break;
 	}
 	case 0:

hif/src/ce/ce_main.c

@@ -1953,9 +1953,9 @@ hif_pci_ce_send_done(struct CE_handle *copyeng, void *ce_context,
 					toeplitz_hash_result);
 		}
 
-		qdf_spin_lock(&pipe_info->completion_freeq_lock);
+		qdf_spin_lock_bh(&pipe_info->completion_freeq_lock);
 		pipe_info->num_sends_allowed++;
-		qdf_spin_unlock(&pipe_info->completion_freeq_lock);
+		qdf_spin_unlock_bh(&pipe_info->completion_freeq_lock);
 	} while (ce_completed_send_next(copyeng,
 			&ce_context, &transfer_context,
 			&CE_data, &nbytes, &transfer_id,

hif/src/ce/ce_service.c

@@ -2139,10 +2139,10 @@ more_completions:
 				struct HIF_CE_pipe_info *pipe_info =
 					(struct HIF_CE_pipe_info *)CE_context;
 
-				qdf_spin_lock(&pipe_info->
+				qdf_spin_lock_bh(&pipe_info->
 					      completion_freeq_lock);
 				pipe_info->num_sends_allowed++;
-				qdf_spin_unlock(&pipe_info->
+				qdf_spin_unlock_bh(&pipe_info->
 						completion_freeq_lock);
 			}
 		}

os_if/linux/scan/src/wlan_cfg80211_scan.c

@@ -534,8 +534,6 @@ int wlan_cfg80211_sched_scan_start(struct wlan_objmgr_pdev *pdev,
 	cfg80211_notice("Number of hidden networks being Configured = %d",
 		  request->n_ssids);
 
-	if (req->scan_random.randomize)
-		wlan_pno_scan_rand_attr(vdev, request, req);
 	/*
 	 * Before Kernel 4.4
 	 *   Driver gets only one time interval which is hard coded in
@@ -565,6 +563,10 @@ int wlan_cfg80211_sched_scan_start(struct wlan_objmgr_pdev *pdev,
 	ucfg_scan_register_pno_cb(psoc,
 		wlan_cfg80211_pno_callback, NULL);
 	ucfg_scan_get_pno_def_params(vdev, req);
+
+	if (req->scan_random.randomize)
+		wlan_pno_scan_rand_attr(vdev, request, req);
+
 	if (ucfg_ie_whitelist_enabled(psoc, vdev))
 		ucfg_copy_ie_whitelist_attrs(psoc, &req->ie_whitelist);
 	status = ucfg_scan_pno_start(vdev, req);

qdf/inc/qdf_nbuf.h

@@ -289,6 +289,7 @@ struct mon_rx_status {
 	uint32_t ppdu_id;
 	uint32_t device_id;
 	int16_t chan_noise_floor;
+	uint8_t monitor_direct_used;
 };
 
 /**
@@ -651,7 +652,7 @@ qdf_nbuf_set_send_complete_flag(qdf_nbuf_t buf, bool flag)
 	__qdf_nbuf_set_send_complete_flag(buf, flag);
 }
 
-#ifdef NBUF_MEMORY_DEBUG
+#ifdef NBUF_MAP_UNMAP_DEBUG
 /**
  * qdf_nbuf_map_check_for_leaks() - check for nbut map leaks
  *
@@ -739,7 +740,7 @@ void qdf_nbuf_unmap_nbytes_single_debug(qdf_device_t osdev,
 	qdf_nbuf_unmap_nbytes_single_debug(osdev, buf, dir, nbytes, \
 					   __FILE__, __LINE__)
 
-#else /* NBUF_MEMORY_DEBUG */
+#else /* NBUF_MAP_UNMAP_DEBUG */
 
 static inline void qdf_nbuf_map_check_for_leaks(void) {}
 
@@ -794,7 +795,7 @@ qdf_nbuf_unmap_nbytes_single(
 {
 	return __qdf_nbuf_unmap_nbytes_single(osdev, buf, dir, nbytes);
 }
-#endif /* NBUF_MEMORY_DEBUG */
+#endif /* NBUF_MAP_UNMAP_DEBUG */
 
 /**
  * qdf_nbuf_queue_head_dequeue() - dequeue nbuf from the head of queue

qdf/inc/qdf_types.h

@@ -887,6 +887,21 @@ struct qdf_ipv6_addr {
  */
 QDF_STATUS qdf_ipv6_parse(const char *ipv6_str, struct qdf_ipv6_addr *out_addr);
 
+/**
+ * qdf_uint8_array_parse() - parse the given string as uint8 array
+ * @in_str: the input string to parse
+ * @out_array: the output uint8 array, populated on success
+ * @array_size: size of the array
+ * @out_size: size of the populated array
+ *
+ * This API is called to convert string (each byte separated by
+ * a comma) into an u8 array
+ *
+ * Return: QDF_STATUS
+ */
+QDF_STATUS qdf_uint8_array_parse(const char *in_str, uint8_t *out_array,
+				 qdf_size_t array_size, qdf_size_t *out_size);
+
 #define QDF_MAX_NUM_CHAN   (128)
 
 #define QDF_BCAST_MAC_ADDR (0xFF)

qdf/linux/src/qdf_nbuf.c

@@ -577,7 +577,9 @@ qdf_nbuf_history_add(qdf_nbuf_t nbuf, const char *file, uint32_t line,
 	event->type = type;
 	event->timestamp = qdf_get_log_timestamp();
 }
+#endif /* NBUF_MEMORY_DEBUG */
 
+#ifdef NBUF_MAP_UNMAP_DEBUG
 struct qdf_nbuf_map_metadata {
 	struct hlist_node node;
 	qdf_nbuf_t nbuf;
@@ -853,7 +855,35 @@ void qdf_nbuf_unmap_nbytes_single_debug(qdf_device_t osdev,
 }
 
 qdf_export_symbol(qdf_nbuf_unmap_nbytes_single_debug);
-#endif /* NBUF_MEMORY_DEBUG */
+
+static void qdf_nbuf_panic_on_free_if_mapped(qdf_nbuf_t nbuf, uint8_t *file,
+					     uint32_t line)
+{
+	struct qdf_nbuf_map_metadata *meta;
+
+	qdf_spin_lock_irqsave(&qdf_nbuf_map_lock);
+	meta = qdf_nbuf_meta_get(nbuf);
+	if (meta)
+		QDF_DEBUG_PANIC(
+			"Nbuf freed @ %s:%u while mapped from %s:%u",
+			kbasename(file), line, meta->file, meta->line);
+	qdf_spin_unlock_irqrestore(&qdf_nbuf_map_lock);
+}
+#else
+static inline void qdf_nbuf_map_tracking_init(void)
+{
+}
+
+static inline void qdf_nbuf_map_tracking_deinit(void)
+{
+}
+
+static inline void qdf_nbuf_panic_on_free_if_mapped(qdf_nbuf_t nbuf,
+						    uint8_t *file,
+						    uint32_t line)
+{
+}
+#endif /* NBUF_MAP_UNMAP_DEBUG */
 
 /**
  * __qdf_nbuf_map() - map a buffer to local bus address space
@@ -2627,16 +2657,7 @@ void qdf_nbuf_free_debug(qdf_nbuf_t nbuf, uint8_t *file, uint32_t line)
 
 	/* Remove SKB from internal QDF tracking table */
 	if (qdf_likely(nbuf)) {
-		struct qdf_nbuf_map_metadata *meta;
-
-		qdf_spin_lock_irqsave(&qdf_nbuf_map_lock);
-		meta = qdf_nbuf_meta_get(nbuf);
-		if (meta)
-			QDF_DEBUG_PANIC(
-				"Nbuf freed @ %s:%u while mapped from %s:%u",
-				kbasename(file), line, meta->file, meta->line);
-		qdf_spin_unlock_irqrestore(&qdf_nbuf_map_lock);
-
+		qdf_nbuf_panic_on_free_if_mapped(nbuf, file, line);
 		qdf_net_buf_debug_delete_node(nbuf);
 		qdf_nbuf_history_add(nbuf, file, line, QDF_NBUF_FREE);
 	}

qdf/src/qdf_types.c

@@ -177,7 +177,7 @@ static QDF_STATUS qdf_consume_radix(const char **str, uint8_t *out_radix)
 }
 
 static QDF_STATUS
-qdf_int_parse(const char *int_str, uint64_t *out_int, bool *out_negate)
+__qdf_int_parse_lazy(const char **int_str, uint64_t *out_int, bool *out_negate)
 {
 	QDF_STATUS status;
 	bool negate = false;
@@ -185,28 +185,21 @@ qdf_int_parse(const char *int_str, uint64_t *out_int, bool *out_negate)
 	uint8_t digit;
 	uint64_t value = 0;
 	uint64_t next_value;
+	const char *str = *int_str;
 
-	QDF_BUG(int_str);
-	if (!int_str)
-		return QDF_STATUS_E_INVAL;
-
-	QDF_BUG(out_int);
-	if (!out_int)
-		return QDF_STATUS_E_INVAL;
-
-	int_str = qdf_str_left_trim(int_str);
+	str = qdf_str_left_trim(str);
 
-	status = qdf_consume_char(&int_str, '-');
+	status = qdf_consume_char(&str, '-');
 	if (QDF_IS_STATUS_SUCCESS(status))
 		negate = true;
 	else
-		qdf_consume_char(&int_str, '+');
+		qdf_consume_char(&str, '+');
 
-	status = qdf_consume_radix(&int_str, &radix);
+	status = qdf_consume_radix(&str, &radix);
 	if (QDF_IS_STATUS_ERROR(status))
 		return status;
 
-	while (QDF_IS_STATUS_SUCCESS(qdf_consume_hex(&int_str, &digit))) {
+	while (QDF_IS_STATUS_SUCCESS(qdf_consume_hex(&str, &digit))) {
 		if (digit >= radix)
 			return QDF_STATUS_E_FAILURE;
 
@@ -217,6 +210,32 @@ qdf_int_parse(const char *int_str, uint64_t *out_int, bool *out_negate)
 		value = next_value;
 	}
 
+	*int_str = str;
+	*out_negate = negate;
+	*out_int = value;
+
+	return QDF_STATUS_SUCCESS;
+}
+
+static QDF_STATUS
+qdf_int_parse(const char *int_str, uint64_t *out_int, bool *out_negate)
+{
+	QDF_STATUS status;
+	bool negate;
+	uint64_t value;
+
+	QDF_BUG(int_str);
+	if (!int_str)
+		return QDF_STATUS_E_INVAL;
+
+	QDF_BUG(out_int);
+	if (!out_int)
+		return QDF_STATUS_E_INVAL;
+
+	status = __qdf_int_parse_lazy(&int_str, &value, &negate);
+	if (QDF_IS_STATUS_ERROR(status))
+		return status;
+
 	int_str = qdf_str_left_trim(int_str);
 	if (int_str[0] != '\0')
 		return QDF_STATUS_E_FAILURE;
@@ -524,3 +543,52 @@ QDF_STATUS qdf_ipv6_parse(const char *ipv6_str, struct qdf_ipv6_addr *out_addr)
 	return QDF_STATUS_SUCCESS;
 }
 qdf_export_symbol(qdf_ipv6_parse);
+
+QDF_STATUS qdf_uint8_array_parse(const char *in_str, uint8_t *out_array,
+				 qdf_size_t array_size, qdf_size_t *out_size)
+{
+	QDF_STATUS status;
+	bool negate;
+	qdf_size_t size = 0;
+	uint64_t value;
+
+	QDF_BUG(in_str);
+	if (!in_str)
+		return QDF_STATUS_E_INVAL;
+
+	QDF_BUG(out_array);
+	if (!out_array)
+		return QDF_STATUS_E_INVAL;
+
+	QDF_BUG(out_size);
+	if (!out_size)
+		return QDF_STATUS_E_INVAL;
+
+	while (size < array_size) {
+		status = __qdf_int_parse_lazy(&in_str, &value, &negate);
+		if (QDF_IS_STATUS_ERROR(status))
+			return status;
+
+		if ((uint8_t)value != value || negate)
+			return QDF_STATUS_E_RANGE;
+
+		in_str = qdf_str_left_trim(in_str);
+
+		switch (in_str[0]) {
+		case ',':
+			out_array[size++] = value;
+			in_str++;
+			break;
+		case '\0':
+			out_array[size++] = value;
+			*out_size = size;
+			return QDF_STATUS_SUCCESS;
+		default:
+			return QDF_STATUS_E_FAILURE;
+		}
+	}
+
+	return QDF_STATUS_E_FAILURE;
+}
+
+qdf_export_symbol(qdf_uint8_array_parse);

target_if/spectral/target_if_spectral_phyerr.c

@@ -1406,7 +1406,10 @@ target_if_consume_spectral_report_gen3(
 	report_len = (fft_hdr_length + 8);
 
 	fft_bin_len = (fft_hdr_length - 16);
-	fft_bin_len >>= 2;
+	/* Divide fft bin length by 4 if fftbin_size_war is enabled */
+	if (spectral->fftbin_size_war) {
+		fft_bin_len >>= 2;
+	}
 	if ((spectral->params.ss_rpt_mode == 2) &&
 			spectral->inband_fftbin_size_adj) {
 		fft_bin_len >>= 1;
@@ -1526,7 +1529,10 @@ target_if_consume_spectral_report_gen3(
 		report_len     = (fft_hdr_length + 8);
 
 		fft_bin_len    = (fft_hdr_length - 16);
-		fft_bin_len >>= 2;
+		/* Divide fft bin length by 4 if fftbin_size_war is enabled */
+		if (spectral->fftbin_size_war) {
+			fft_bin_len >>= 2;
+		}
 		if ((spectral->params.ss_rpt_mode == 2) &&
 				spectral->inband_fftbin_size_adj) {
 			fft_bin_len >>= 1;

umac/cmn_services/serialization/inc/wlan_serialization_api.h

@@ -27,6 +27,7 @@
 #ifndef __WLAN_SERIALIZATION_API_H
 #define __WLAN_SERIALIZATION_API_H
 
+#ifdef CONFIG_SERIALIZATION_V1
 #include "qdf_status.h"
 #include "wlan_objmgr_cmn.h"
 
@@ -504,4 +505,495 @@ wlan_serialization_get_scan_cmd_using_scan_id(
 void *wlan_serialization_get_active_cmd(struct wlan_objmgr_psoc *psoc,
 				     uint8_t vdev_id,
 				     enum wlan_serialization_cmd_type cmd_type);
+#else /* New serialization code*/
+#include <qdf_status.h>
+#include <wlan_objmgr_cmn.h>
+
+/* Preprocessor Definitions and Constants */
+
+/*
+ * struct wlan_serialization_queued_cmd_info member queue_type specifies the
+ * below values to cancel the commands in these queues. Setting both the
+ * bits will cancel the commands in both the queues.
+ */
+#define WLAN_SERIALIZATION_ACTIVE_QUEUE  0x1
+#define WLAN_SERIALIZATION_PENDING_QUEUE 0x2
+
+/**
+ * enum wlan_serialization_cb_reason - reason for calling the callback
+ * @WLAN_SERIALIZATION_REASON_ACTIVATE_CMD: activate the cmd by sending it to FW
+ * @WLAN_SERIALIZATION_REASON_CANCEL_CMD: Cancel the cmd in the pending list
+ * @WLAN_SERIALIZATION_REASON_RELEASE_MEM_CMD:cmd execution complete. Release
+ *                                           the memory allocated while
+ *                                           building the command
+ * @WLAN_SER_CB_ACTIVE_CMD_TIMEOUT: active cmd has been timeout.
+ */
+enum wlan_serialization_cb_reason {
+	WLAN_SER_CB_ACTIVATE_CMD,
+	WLAN_SER_CB_CANCEL_CMD,
+	WLAN_SER_CB_RELEASE_MEM_CMD,
+	WLAN_SER_CB_ACTIVE_CMD_TIMEOUT,
+};
+
+/**
+ * struct wlan_serialization_scan_info - Information needed for scan cmd
+ * @is_cac_in_progress: boolean to check the cac status
+ * @is_tdls_in_progress: boolean to check the tdls status
+ *
+ * This information is needed for scan command from other components
+ * to apply the rules and check whether the cmd is allowed or not
+ */
+struct wlan_serialization_scan_info {
+	bool is_cac_in_progress;
+	bool is_tdls_in_progress;
+};
+
+/**
+ * union wlan_serialization_rules_info - union of all rules info structures
+ * @scan_info: information needed to apply rules on scan command
+ */
+union wlan_serialization_rules_info {
+	struct wlan_serialization_scan_info scan_info;
+};
+
+/**
+ * wlan_serialization_cmd_callback() - Callback registered by the component
+ * @wlan_cmd: Command passed by the component for serialization
+ * @reason: Reason code for which the callback is being called
+ *
+ * Reason specifies the reason for which the callback is being called. callback
+ * should return success or failure based up on overall success of callback.
+ * if callback returns failure then serialization will remove the command from
+ * active queue and proceed for next pending command.
+ *
+ * Return: QDF_STATUS_SUCCESS or QDF_STATUS_E_FAILURE
+ */
+typedef QDF_STATUS (*wlan_serialization_cmd_callback)(void *wlan_cmd,
+				 enum wlan_serialization_cb_reason reason);
+
+/**
+ * wlan_serialization_comp_info_cb() - callback to fill the rules information
+ * @vdev: VDEV object for which the command has been received
+ * @comp_info: Information filled by the component
+ *
+ * This callback is registered dynamically by the component with the
+ * serialization component. Serialization component invokes the callback
+ * while applying the rules for a particular command and the component
+ * fills in the required information to apply the rules
+ *
+ * Return: None
+ */
+typedef void (*wlan_serialization_comp_info_cb)(struct wlan_objmgr_vdev *vdev,
+		union wlan_serialization_rules_info *comp_info);
+
+/**
+ * wlan_serialization_apply_rules_cb() - callback per command to apply rules
+ * @comp_info: information needed to apply the rules
+ *
+ * The rules are applied using this callback and decided whether to
+ * allow or deny the command
+ *
+ * Return: true, if rules are successful and cmd can be queued
+ *         false, if rules failed and cmd should not be queued
+ */
+typedef bool (*wlan_serialization_apply_rules_cb)(
+		union wlan_serialization_rules_info *comp_info,
+		uint8_t comp_id);
+
+/**
+ * enum wlan_umac_cmd_id - Command Type
+ * @WLAN_SER_CMD_SCAN:     Scan command
+ */
+enum wlan_serialization_cmd_type {
+	/* all scan command before non-scan */
+	WLAN_SER_CMD_SCAN,
+	/* all non-scan command below */
+	WLAN_SER_CMD_NONSCAN,
+	WLAN_SER_CMD_FORCE_DISASSOC,
+	WLAN_SER_CMD_HDD_ISSUED,
+	WLAN_SER_CMD_LOST_LINK1,
+	WLAN_SER_CMD_LOST_LINK2,
+	WLAN_SER_CMD_LOST_LINK3,
+	WLAN_SER_CMD_FORCE_DISASSOC_MIC_FAIL,
+	WLAN_SER_CMD_HDD_ISSUE_REASSOC_SAME_AP,
+	WLAN_SER_CMD_SME_ISSUE_REASSOC_SAME_AP,
+	WLAN_SER_CMD_FORCE_DEAUTH,
+	WLAN_SER_CMD_SME_ISSUE_DISASSOC_FOR_HANDOFF,
+	WLAN_SER_CMD_SME_ISSUE_ASSOC_TO_SIMILAR_AP,
+	WLAN_SER_CMD_SME_ISSUE_IBSS_JOIN_FAIL,
+	WLAN_SER_CMD_FORCE_IBSS_LEAVE,
+	WLAN_SER_CMD_SME_ISSUE_FT_REASSOC,
+	WLAN_SER_CMD_FORCE_DISASSOC_STA,
+	WLAN_SER_CMD_FORCE_DEAUTH_STA,
+	WLAN_SER_CMD_PERFORM_PRE_AUTH,
+	WLAN_SER_CMD_WM_STATUS_CHANGE,
+	WLAN_SER_CMD_SET_KEY,
+	WLAN_SER_CMD_NDP_INIT_REQ,
+	WLAN_SER_CMD_NDP_RESP_REQ,
+	WLAN_SER_CMD_NDP_DATA_END_INIT_REQ,
+	WLAN_SER_CMD_ADDTS,
+	WLAN_SER_CMD_DELTS,
+	WLAN_SER_CMD_TDLS_SEND_MGMT,
+	WLAN_SER_CMD_TDLS_ADD_PEER,
+	WLAN_SER_CMD_TDLS_DEL_PEER,
+	WLAN_SER_CMD_TDLS_LINK_EST,
+	WLAN_SER_CMD_SET_HW_MODE,
+	WLAN_SER_CMD_NSS_UPDATE,
+	WLAN_SER_CMD_SET_DUAL_MAC_CONFIG,
+	WLAN_SER_CMD_SET_ANTENNA_MODE,
+	WLAN_SER_CMD_ENTER_BMPS,
+	WLAN_SER_CMD_EXIT_BMPS,
+	WLAN_SER_CMD_ENTER_UAPSD,
+	WLAN_SER_CMD_EXIT_UAPSD,
+	WLAN_SER_CMD_EXIT_WOWL,
+	WLAN_SER_CMD_DEL_STA_SESSION,
+	WLAN_SER_CMD_VDEV_START_BSS,
+	WLAN_SER_CMD_VDEV_STOP_BSS,
+	WLAN_SER_CMD_VDEV_CONNECT,
+	WLAN_SER_CMD_VDEV_DISCONNECT,
+	WLAN_SER_CMD_VDEV_RESTART,
+	WLAN_SER_CMD_MAX
+};
+
+/**
+ * enum wlan_serialization_cancel_type - Type of commands to be cancelled
+ * @WLAN_SER_CANCEL_SINGLE_SCAN: Cancel a single scan with a given ID
+ * @WLAN_SER_CANCEL_PDEV_SCANS: Cancel all the scans on a given pdev
+ * @WLAN_SER_CANCEL_VDEV_SCANS: Cancel all the scans on given vdev
+ * @WLAN_SER_CANCEL_NON_SCAN_CMD: Cancel the given non scan command
+ */
+enum wlan_serialization_cancel_type {
+	WLAN_SER_CANCEL_SINGLE_SCAN,
+	WLAN_SER_CANCEL_PDEV_SCANS,
+	WLAN_SER_CANCEL_VDEV_SCANS,
+	WLAN_SER_CANCEL_PDEV_NON_SCAN_CMD,
+	WLAN_SER_CANCEL_VDEV_NON_SCAN_CMD,
+	WLAN_SER_CANCEL_NON_SCAN_CMD,
+	WLAN_SER_CANCEL_MAX,
+};
+
+/**
+ * enum wlan_serialization_status - Return status of cmd serialization request
+ * @WLAN_SER_CMD_PENDING: Command is put into the pending queue
+ * @WLAN_SER_CMD_ACTIVE: Command is activated and put in active queue
+ * @WLAN_SER_CMD_DENIED_RULES_FAILED: Command denied as the rules fail
+ * @WLAN_SER_CMD_DENIED_LIST_FULL: Command denied as the pending list is full
+ * @WLAN_SER_CMD_DENIED_UNSPECIFIED: Command denied due to unknown reason
+ */
+enum wlan_serialization_status {
+	WLAN_SER_CMD_PENDING,
+	WLAN_SER_CMD_ACTIVE,
+	WLAN_SER_CMD_DENIED_RULES_FAILED,
+	WLAN_SER_CMD_DENIED_LIST_FULL,
+	WLAN_SER_CMD_DENIED_UNSPECIFIED,
+};
+
+/**
+ * enum wlan_serialization_cmd_status - Return status for a cancel request
+ * @WLAN_SER_CMD_IN_PENDING_LIST: Command cancelled from pending list
+ * @WLAN_SER_CMD_IN_ACTIVE_LIST: Command cancelled from active list
+ * @WLAN_SER_CMDS_IN_ALL_LISTS: Command cancelled from all lists
+ * @WLAN_SER_CMD_NOT_FOUND: Specified command to be cancelled
+ *                                    not found in the lists
+ */
+enum wlan_serialization_cmd_status {
+	WLAN_SER_CMD_IN_PENDING_LIST,
+	WLAN_SER_CMD_IN_ACTIVE_LIST,
+	WLAN_SER_CMDS_IN_ALL_LISTS,
+	WLAN_SER_CMD_MARKED_FOR_ACTIVATION,
+	WLAN_SER_CMD_NOT_FOUND,
+};
+
+/**
+ * struct wlan_serialization_command - Command to be serialized
+ * @wlan_serialization_cmd_type: Type of command
+ * @cmd_id: Command Identifier
+ * @cmd_cb: Command callback
+ * @source: component ID of the source of the command
+ * @is_high_priority: Normal/High Priority at which the cmd has to be queued
+ * @cmd_timeout_cb: Command timeout callback
+ * @cmd_timeout_duration: Timeout duration in milliseconds
+ * @vdev: VDEV object associated to the command
+ * @umac_cmd: Actual command that needs to be sent to WMI/firmware
+ *
+ * Note: Unnamed union has been used in this structure, so that in future if
+ * somebody wants to add pdev or psoc structure then that person can add without
+ * modifying existing code.
+ */
+struct wlan_serialization_command {
+	enum wlan_serialization_cmd_type cmd_type;
+	uint32_t cmd_id;
+	wlan_serialization_cmd_callback cmd_cb;
+	enum wlan_umac_comp_id source;
+	bool is_high_priority;
+	bool is_blocking;
+	uint16_t cmd_timeout_duration;
+	union {
+		struct wlan_objmgr_vdev *vdev;
+	};
+	void *umac_cmd;
+};
+
+/**
+ * struct wlan_serialization_queued_cmd_info  - cmd that has to be cancelled
+ * @requestor: component ID of the source requesting this action
+ * @cmd_type: Command type
+ * @cmd_id: Command ID
+ * @req_type: Commands that need to be cancelled
+ * @vdev: VDEV object associated to the command
+ * @queue_type: Queues from which the command to be cancelled
+ */
+struct wlan_serialization_queued_cmd_info {
+	enum wlan_umac_comp_id requestor;
+	enum wlan_serialization_cmd_type cmd_type;
+	uint32_t cmd_id;
+	enum wlan_serialization_cancel_type req_type;
+	union {
+		struct wlan_objmgr_vdev *vdev;
+	};
+	uint8_t queue_type;
+};
+
+/**
+ * wlan_serialization_cancel_request() - Request to cancel a command
+ * @req: Request information
+ *
+ * This API is used by external components to cancel a command
+ * that is either in the pending or active queue. Based on the
+ * req_type, it is decided whether to use pdev or vdev
+ * object. For all non-scan commands, it will be pdev.
+ *
+ * Return: Status specifying the removal of a command from a certain queue
+ */
+enum wlan_serialization_cmd_status
+wlan_serialization_cancel_request(
+		struct wlan_serialization_queued_cmd_info *req);
+
+/**
+ * wlan_serialization_remove_cmd() - Request to release a command
+ * @cmd: Command information
+ *
+ * This API is used to release a command sitting in the active
+ * queue upon successful completion of the command
+ *
+ * Return: None
+ */
+void wlan_serialization_remove_cmd(
+		struct wlan_serialization_queued_cmd_info *cmd);
+
+/**
+ * wlan_serialization_flush_cmd() - Request to flush command
+ * @cmd: Command information
+ *
+ * This API is used to flush a cmd sitting in the queue. It
+ * simply flushes the cmd from the queue and does not call
+ * any callbacks in between. If the request is for active
+ * queue, and if the active queue becomes empty upon flush,
+ * then it will pick the next pending cmd and put in the active
+ * queue before returning.
+ *
+ * Return: None
+ */
+void wlan_serialization_flush_cmd(
+		struct wlan_serialization_queued_cmd_info *cmd);
+/**
+ * wlan_serialization_request() - Request to serialize a command
+ * @cmd: Command information
+ *
+ * Return: Status of the serialization request
+ */
+enum wlan_serialization_status
+wlan_serialization_request(struct wlan_serialization_command *cmd);
+
+/**
+ * wlan_serialization_register_comp_info_cb() - Register component's info cb
+ * @psoc: PSOC object information
+ * @comp_id: Component ID
+ * @cmd_type: Command Type
+ * @cb: Callback
+ *
+ * This is called from component during its initialization.It initializes
+ * callback handler for given comp_id/cmd_id in a 2-D array.
+ *
+ * Return: QDF Status
+ */
+QDF_STATUS
+wlan_serialization_register_comp_info_cb(
+		struct wlan_objmgr_psoc *psoc,
+		enum wlan_umac_comp_id comp_id,
+		enum wlan_serialization_cmd_type cmd_type,
+		wlan_serialization_comp_info_cb cb);
+
+/**
+ * wlan_serialization_deregister_comp_info_cb() - Deregister component's info
+ *						callback
+ * @psoc: PSOC object information
+ * @comp_id: Component ID
+ * @cmd_type: Command Type
+ *
+ * This routine is called from other component during its de-initialization.
+ *
+ * Return: QDF Status
+ */
+QDF_STATUS
+wlan_serialization_deregister_comp_info_cb(
+		struct wlan_objmgr_psoc *psoc,
+		enum wlan_umac_comp_id comp_id,
+		enum wlan_serialization_cmd_type cmd_type);
+
+/**
+ * wlan_serialization_register_apply_rules_cb() - Register component's rules
+ *						callback
+ * @psoc: PSOC object information
+ * @cmd_type: Command Type
+ * @cb: Callback
+ *
+ * This is called from component during its initialization.It initializes
+ * callback handler for given cmd_type in a 1-D array.
+ *
+ * Return: QDF Status
+ */
+QDF_STATUS
+wlan_serialization_register_apply_rules_cb(
+		struct wlan_objmgr_psoc *psoc,
+		enum wlan_serialization_cmd_type cmd_type,
+		wlan_serialization_apply_rules_cb apply_rules_cb);
+
+/**
+ * wlan_serialization_deregister_apply_rules_cb() - Deregister component's rules
+ *						callback
+ * @psoc: PSOC object information
+ * @cmd_type: Command Type
+ *
+ * This routine is called from other component during its de-initialization.
+ *
+ * Return: QDF Status
+ */
+QDF_STATUS
+wlan_serialization_deregister_apply_rules_cb(
+		struct wlan_objmgr_psoc *psoc,
+		enum wlan_serialization_cmd_type cmd_type);
+
+/**
+ * @wlan_serialization_init() - Serialization component initialization routine
+ *
+ * Return - QDF Status
+ */
+QDF_STATUS wlan_serialization_init(void);
+
+/**
+ * @wlan_serialization_deinit() - Serialization component de-init routine
+ *
+ * Return - QDF Status
+ */
+QDF_STATUS wlan_serialization_deinit(void);
+
+/**
+ * @wlan_serialization_psoc_open() - Serialization component open routine
+ *
+ * Return - QDF Status
+ */
+QDF_STATUS wlan_serialization_psoc_open(struct wlan_objmgr_psoc *psoc);
+
+/**
+ * @wlan_serialization_psoc_close() - Serialization component close routine
+ *
+ * Return - QDF Status
+ */
+QDF_STATUS wlan_serialization_psoc_close(struct wlan_objmgr_psoc *psoc);
+
+/**
+ * wlan_serialization_vdev_scan_status() - Return the status of the vdev scan
+ * @vdev: VDEV Object
+ *
+ * Return: Status of the scans for the corresponding vdev
+ */
+enum wlan_serialization_cmd_status
+wlan_serialization_vdev_scan_status(struct wlan_objmgr_vdev *vdev);
+
+/**
+ * wlan_serialization_pdev_scan_status() - Return the status of the pdev scan
+ * @pdev: PDEV Object
+ *
+ * Return: Status of the scans for the corresponding pdev
+ */
+enum wlan_serialization_cmd_status
+wlan_serialization_pdev_scan_status(struct wlan_objmgr_pdev *pdev);
+
+/**
+ * wlan_serialization_non_scan_cmd_status() - Return status of pdev non-scan cmd
+ * @pdev: PDEV Object
+ * @cmd_id: ID of the command for which the status has to be checked
+ *
+ * Return: Status of the command for the corresponding pdev
+ */
+enum wlan_serialization_cmd_status
+wlan_serialization_non_scan_cmd_status(struct wlan_objmgr_pdev *pdev,
+				       enum wlan_serialization_cmd_type cmd_id);
+
+/**
+ * wlan_serialization_is_cmd_present_in_pending_queue() - Return if the command
+ *				is already present in pending queue
+ * @cmd: pointer to serialization command to check
+ *
+ * This API will check if command is present in pending queue. If present
+ * then return true, so use know that it is duplicated command
+ *
+ * Return: true or false
+ */
+bool wlan_serialization_is_cmd_present_in_pending_queue(
+		struct wlan_objmgr_psoc *psoc,
+		struct wlan_serialization_command *cmd);
+/**
+ * wlan_serialization_is_cmd_present_in_active_queue() - Return if the command
+ *			is already present in active queue
+ * @cmd: pointer to serialization command to check
+ *
+ * This API will check if command is present in active queue. If present
+ * then return true, so use know that it is duplicated command
+ *
+ * Return: true or false
+ */
+bool wlan_serialization_is_cmd_present_in_active_queue(
+		struct wlan_objmgr_psoc *psoc,
+		struct wlan_serialization_command *cmd);
+
+/**
+ * wlan_serialization_get_scan_cmd_using_scan_id() - Return command which
+ *					matches vdev_id and scan_id
+ * @psoc: pointer to soc
+ * @vdev_id: vdev id to pull vdev object
+ * @scan_id: scan id to match
+ * @is_scan_cmd_from_active_queue: to indicate active or pending queue
+ *
+ * This API fetches vdev/pdev object based on vdev_id, loops through scan
+ * command queue and find the command which matches scan id as well as vdev
+ * object.
+ *
+ * Return: pointer to serialization command
+ */
+struct wlan_serialization_command*
+wlan_serialization_get_scan_cmd_using_scan_id(
+		struct wlan_objmgr_psoc *psoc,
+		uint8_t vdev_id, uint16_t scan_id,
+		uint8_t is_scan_cmd_from_active_queue);
+/**
+ * wlan_serialization_get_active_cmd() - Return active umac command which
+ *  matches vdev and cmd type
+ * @psoc: pointer to soc
+ * @vdev_id: vdev id to pull vdev object
+ * @cmd_type: cmd type to match
+ *
+ * This API fetches vdev/pdev object based on vdev_id, loops through active
+ * command queue and find the active command which matches cmd_type as well
+ * as vdev object.
+ *
+ * Return: Pointer to umac command. NULL is returned if active command of given
+ *  type is not found.
+ */
+void *wlan_serialization_get_active_cmd(
+		struct wlan_objmgr_psoc *psoc,
+		uint8_t vdev_id,
+		enum wlan_serialization_cmd_type cmd_type);
+#endif
 #endif

umac/cmn_services/serialization/src/wlan_serialization_api.c

@@ -22,6 +22,7 @@
  * component.
  */
 
+#ifdef CONFIG_SERIALIZATION_V1
 /* Include files */
 #include "wlan_objmgr_psoc_obj.h"
 #include "wlan_objmgr_pdev_obj.h"
@@ -435,3 +436,573 @@ release_vdev_ref:
 
 	return umac_cmd;
 }
+#else /* New serialization code*/
+/* Include files */
+#include <wlan_objmgr_psoc_obj.h>
+#include <wlan_objmgr_pdev_obj.h>
+#include <wlan_objmgr_vdev_obj.h>
+#include "wlan_serialization_main_i.h"
+#include "wlan_serialization_utils_i.h"
+#include "wlan_serialization_queue_i.h"
+#include "wlan_serialization_scan_i.h"
+#include "wlan_serialization_internal_i.h"
+
+bool wlan_serialization_is_cmd_present_in_pending_queue(
+		struct wlan_objmgr_psoc *psoc,
+		struct wlan_serialization_command *cmd)
+{
+	bool status = false;
+
+	if (!cmd) {
+		ser_err("invalid cmd");
+		goto error;
+	}
+
+	status = wlan_serialization_is_cmd_present_queue(cmd, false);
+
+error:
+	return status;
+}
+
+bool wlan_serialization_is_cmd_present_in_active_queue(
+		struct wlan_objmgr_psoc *psoc,
+		struct wlan_serialization_command *cmd)
+{
+	bool status;
+
+	if (!cmd) {
+		ser_err("invalid cmd");
+		status = false;
+		goto error;
+	}
+
+	status = wlan_serialization_is_cmd_present_queue(cmd, true);
+
+	ser_debug("Cmd type:%d id:%d present: %d",
+		  cmd->cmd_type, cmd->cmd_id, status);
+
+error:
+	return status;
+}
+
+QDF_STATUS
+wlan_serialization_register_apply_rules_cb(
+		struct wlan_objmgr_psoc *psoc,
+		enum wlan_serialization_cmd_type cmd_type,
+		wlan_serialization_apply_rules_cb cb)
+{
+	struct wlan_ser_psoc_obj *ser_soc_obj;
+	QDF_STATUS status;
+
+	status = wlan_serialization_validate_cmdtype(cmd_type);
+	if (QDF_IS_STATUS_ERROR(status)) {
+		ser_err("invalid cmd_type %d", cmd_type);
+		goto error;
+	}
+
+	ser_soc_obj = wlan_serialization_get_psoc_obj(psoc);
+	if (!ser_soc_obj) {
+		ser_err("invalid ser_soc_obj");
+		status = QDF_STATUS_E_FAILURE;
+		goto error;
+	}
+
+	ser_soc_obj->apply_rules_cb[cmd_type] = cb;
+	status = QDF_STATUS_SUCCESS;
+
+error:
+	return status;
+}
+
+QDF_STATUS
+wlan_serialization_deregister_apply_rules_cb(
+		struct wlan_objmgr_psoc *psoc,
+		enum wlan_serialization_cmd_type cmd_type)
+{
+	struct wlan_ser_psoc_obj *ser_soc_obj;
+	QDF_STATUS status;
+
+	status = wlan_serialization_validate_cmdtype(cmd_type);
+	if (QDF_IS_STATUS_ERROR(status)) {
+		ser_err("invalid cmd_type %d", cmd_type);
+		goto error;
+	}
+	ser_soc_obj = wlan_serialization_get_psoc_obj(psoc);
+	if (!ser_soc_obj) {
+		ser_err("invalid ser_soc_obj");
+		status = QDF_STATUS_E_FAILURE;
+		goto error;
+	}
+	ser_soc_obj->apply_rules_cb[cmd_type] = NULL;
+	status = QDF_STATUS_SUCCESS;
+
+error:
+	return status;
+}
+
+QDF_STATUS
+wlan_serialization_register_comp_info_cb(
+		struct wlan_objmgr_psoc *psoc,
+		enum wlan_umac_comp_id comp_id,
+		enum wlan_serialization_cmd_type cmd_type,
+		wlan_serialization_comp_info_cb cb)
+{
+	struct wlan_ser_psoc_obj *ser_soc_obj;
+	QDF_STATUS status;
+
+	status = wlan_serialization_validate_cmd(comp_id, cmd_type);
+	if (QDF_IS_STATUS_ERROR(status)) {
+		ser_err("invalid comp_id %d or cmd_type %d",
+			comp_id, cmd_type);
+		goto error;
+	}
+	ser_soc_obj = wlan_serialization_get_psoc_obj(psoc);
+	if (!ser_soc_obj) {
+		ser_err("invalid ser_soc_obj");
+		status = QDF_STATUS_E_FAILURE;
+		goto error;
+	}
+	ser_soc_obj->comp_info_cb[cmd_type][comp_id] = cb;
+	status = QDF_STATUS_SUCCESS;
+
+error:
+	return status;
+}
+
+QDF_STATUS
+wlan_serialization_deregister_comp_info_cb(struct wlan_objmgr_psoc *psoc,
+					   enum wlan_umac_comp_id comp_id,
+		enum wlan_serialization_cmd_type cmd_type)
+{
+	struct wlan_ser_psoc_obj *ser_soc_obj;
+	QDF_STATUS status;
+
+	status = wlan_serialization_validate_cmd(comp_id, cmd_type);
+	if (QDF_IS_STATUS_ERROR(status)) {
+		ser_err("invalid comp_id %d or cmd_type %d",
+			comp_id, cmd_type);
+		goto error;
+	}
+	ser_soc_obj = wlan_serialization_get_psoc_obj(psoc);
+	if (!ser_soc_obj) {
+		ser_err("invalid ser_soc_obj");
+		status = QDF_STATUS_E_FAILURE;
+		goto error;
+	}
+	ser_soc_obj->comp_info_cb[cmd_type][comp_id] = NULL;
+	status = QDF_STATUS_SUCCESS;
+
+error:
+	return status;
+}
+
+enum wlan_serialization_cmd_status
+wlan_serialization_non_scan_cmd_status(
+		struct wlan_objmgr_pdev *pdev,
+		enum wlan_serialization_cmd_type cmd_type)
+{
+	bool cmd_in_active = 0;
+	bool cmd_in_pending = 0;
+	struct wlan_ser_pdev_obj *ser_pdev_obj =
+		wlan_serialization_get_pdev_obj(pdev);
+	enum wlan_serialization_cmd_status cmd_status = WLAN_SER_CMD_NOT_FOUND;
+	struct wlan_serialization_pdev_queue *pdev_q;
+	qdf_list_node_t *node = NULL;
+	qdf_list_t *queue = NULL;
+
+	ser_enter();
+
+	pdev_q = &ser_pdev_obj->pdev_q[SER_PDEV_QUEUE_COMP_NON_SCAN];
+
+	/* Look in the pdev non scan active queue */
+	queue = &pdev_q->active_list;
+
+	wlan_serialization_acquire_lock(pdev_q);
+
+	node = wlan_serialization_find_cmd(
+			queue, WLAN_SER_MATCH_CMD_TYPE,
+			NULL, cmd_type, NULL, NULL,  WLAN_SER_PDEV_NODE);
+
+	if (node)
+		cmd_in_active = true;
+
+	node = NULL;
+
+	/* Look in the pdev non scan pending queue */
+	queue = &pdev_q->pending_list;
+
+	node = wlan_serialization_find_cmd(
+			queue, WLAN_SER_MATCH_CMD_TYPE,
+			NULL, cmd_type, NULL, NULL,  WLAN_SER_PDEV_NODE);
+
+	if (node)
+		cmd_in_pending = true;
+
+	cmd_status = wlan_serialization_is_cmd_in_active_pending(
+			cmd_in_active, cmd_in_pending);
+
+	wlan_serialization_release_lock(pdev_q);
+
+	ser_exit();
+	return cmd_status;
+}
+
+enum wlan_serialization_cmd_status
+wlan_serialization_cancel_request(
+		struct wlan_serialization_queued_cmd_info *req)
+{
+	QDF_STATUS status;
+	enum wlan_serialization_cmd_status cmd_status;
+
+	struct wlan_serialization_command cmd;
+	struct wlan_objmgr_pdev *pdev;
+	struct wlan_ser_pdev_obj *ser_pdev_obj;
+	struct wlan_serialization_pdev_queue *pdev_queue;
+
+	ser_enter();
+
+	if (!req) {
+		ser_err("given request is empty");
+		cmd_status = WLAN_SER_CMD_NOT_FOUND;
+		goto error;
+	}
+
+	status = wlan_serialization_validate_cmd(req->requestor, req->cmd_type);
+	if (QDF_IS_STATUS_ERROR(status)) {
+		ser_err("req is not valid");
+		cmd_status = WLAN_SER_CMD_NOT_FOUND;
+		goto error;
+	}
+
+	cmd.cmd_type = req->cmd_type;
+	cmd.cmd_id = req->cmd_id;
+	cmd.source = req->requestor;
+	cmd.vdev = req->vdev;
+
+	pdev = wlan_serialization_get_pdev_from_cmd(&cmd);
+	if (!pdev) {
+		ser_err("pdev is invalid");
+		cmd_status = WLAN_SER_CMD_NOT_FOUND;
+		goto error;
+	}
+
+	ser_pdev_obj = wlan_serialization_get_pdev_obj(pdev);
+
+	pdev_queue = wlan_serialization_get_pdev_queue_obj(ser_pdev_obj,
+							   cmd.cmd_type);
+
+	if (!pdev_queue) {
+		ser_err("pdev_queue is invalid");
+		cmd_status = WLAN_SER_CMD_NOT_FOUND;
+		goto error;
+	}
+
+	cmd_status = wlan_serialization_find_and_cancel_cmd(
+			&cmd, req->req_type, req->queue_type);
+
+error:
+	ser_exit();
+	return cmd_status;
+}
+
+void wlan_serialization_remove_cmd(
+		struct wlan_serialization_queued_cmd_info *cmd_info)
+{
+	QDF_STATUS status;
+	struct wlan_serialization_command cmd = {0};
+
+	ser_enter();
+
+	if (!cmd_info) {
+		ser_err("given request is empty");
+		QDF_ASSERT(0);
+		return;
+	}
+	status = wlan_serialization_validate_cmd(cmd_info->requestor,
+						 cmd_info->cmd_type);
+	if (QDF_IS_STATUS_ERROR(status)) {
+		ser_err("cmd is not valid");
+		QDF_ASSERT(0);
+		goto error;
+	}
+
+	cmd.cmd_type = cmd_info->cmd_type;
+	cmd.cmd_id = cmd_info->cmd_id;
+	cmd.source = cmd_info->requestor;
+	cmd.vdev = cmd_info->vdev;
+
+	if (wlan_serialization_dequeue_cmd(&cmd, true) !=
+			WLAN_SER_CMD_IN_ACTIVE_LIST) {
+		ser_err("Can't dequeue requested cmd_id[%d] type[%d]",
+			cmd.cmd_id, cmd.cmd_type);
+	}
+
+error:
+	ser_exit();
+}
+
+enum wlan_serialization_status
+wlan_serialization_request(struct wlan_serialization_command *cmd)
+{
+	QDF_STATUS status;
+	enum wlan_serialization_status serialization_status;
+	uint8_t comp_id;
+	struct wlan_ser_psoc_obj *ser_soc_obj;
+	union wlan_serialization_rules_info info;
+	struct wlan_objmgr_psoc *psoc;
+
+	ser_enter();
+
+	serialization_status = WLAN_SER_CMD_DENIED_UNSPECIFIED;
+
+	if (!cmd) {
+		ser_err("serialization cmd is null");
+		goto error;
+	}
+	status = wlan_serialization_validate_cmd(cmd->source, cmd->cmd_type);
+	if (QDF_IS_STATUS_ERROR(status)) {
+		ser_err("cmd is not valid");
+		goto error;
+	}
+
+	psoc = wlan_serialization_get_psoc_from_cmd(cmd);
+	if (!psoc) {
+		ser_err("psoc _obj is invalid");
+		return WLAN_SER_CMD_DENIED_UNSPECIFIED;
+	}
+	ser_soc_obj = wlan_serialization_get_psoc_obj(psoc);
+
+	if (!ser_soc_obj) {
+		ser_err("ser_soc_obj is invalid");
+		return WLAN_SER_CMD_DENIED_UNSPECIFIED;
+	}
+
+	/*
+	 * Get Component Info callback by calling
+	 * each registered module
+	 */
+	for (comp_id = 0; comp_id < WLAN_UMAC_COMP_ID_MAX; comp_id++) {
+		if (!ser_soc_obj->comp_info_cb[cmd->cmd_type][comp_id])
+			continue;
+		ser_soc_obj->comp_info_cb[cmd->cmd_type][comp_id](cmd->vdev,
+			&info);
+		if (!ser_soc_obj->apply_rules_cb[cmd->cmd_type])
+			continue;
+		if (!ser_soc_obj->apply_rules_cb[cmd->cmd_type](&info, comp_id))
+			return WLAN_SER_CMD_DENIED_RULES_FAILED;
+	}
+
+	serialization_status = wlan_serialization_enqueue_cmd(cmd);
+
+error:
+	ser_exit();
+	return serialization_status;
+}
+
+enum wlan_serialization_cmd_status
+wlan_serialization_vdev_scan_status(struct wlan_objmgr_vdev *vdev)
+{
+	bool cmd_in_active = 0, cmd_in_pending = 0;
+	struct wlan_objmgr_pdev *pdev = wlan_vdev_get_pdev(vdev);
+	struct wlan_ser_pdev_obj *ser_pdev_obj =
+		wlan_serialization_get_pdev_obj(pdev);
+	struct wlan_serialization_pdev_queue *pdev_q;
+	enum wlan_serialization_cmd_status status;
+
+	ser_enter();
+
+	pdev_q = &ser_pdev_obj->pdev_q[SER_PDEV_QUEUE_COMP_SCAN];
+
+	wlan_serialization_acquire_lock(pdev_q);
+
+	cmd_in_active =
+	wlan_serialization_is_cmd_in_vdev_list(
+			vdev, &pdev_q->active_list, WLAN_SER_PDEV_NODE);
+
+	cmd_in_pending =
+	wlan_serialization_is_cmd_in_vdev_list(
+			vdev, &pdev_q->pending_list, WLAN_SER_PDEV_NODE);
+
+	status = wlan_serialization_is_cmd_in_active_pending(
+			cmd_in_active, cmd_in_pending);
+
+	wlan_serialization_release_lock(pdev_q);
+	ser_exit();
+
+	return status;
+}
+
+void wlan_serialization_flush_cmd(
+		struct wlan_serialization_queued_cmd_info *cmd)
+{
+	ser_enter();
+
+	if (!cmd) {
+		ser_err("cmd is null, can't flush");
+		goto error;
+	}
+
+error:
+	ser_exit();
+}
+
+enum wlan_serialization_cmd_status
+wlan_serialization_pdev_scan_status(struct wlan_objmgr_pdev *pdev)
+{
+	bool cmd_in_active, cmd_in_pending;
+	struct wlan_ser_pdev_obj *ser_pdev_obj =
+		wlan_serialization_get_pdev_obj(pdev);
+	struct wlan_serialization_pdev_queue *pdev_q;
+	enum wlan_serialization_cmd_status status;
+
+	pdev_q = &ser_pdev_obj->pdev_q[SER_PDEV_QUEUE_COMP_SCAN];
+
+	wlan_serialization_acquire_lock(pdev_q);
+
+	cmd_in_active = !qdf_list_empty(&pdev_q->active_list);
+	cmd_in_pending = !qdf_list_empty(&pdev_q->pending_list);
+
+	status = wlan_serialization_is_cmd_in_active_pending(
+			cmd_in_active, cmd_in_pending);
+
+	wlan_serialization_release_lock(pdev_q);
+
+	return status;
+}
+
+struct wlan_serialization_command*
+wlan_serialization_get_scan_cmd_using_scan_id(
+		struct wlan_objmgr_psoc *psoc,
+		uint8_t vdev_id, uint16_t scan_id,
+		uint8_t is_scan_cmd_from_active_queue)
+{
+	uint32_t qlen;
+	struct wlan_objmgr_vdev *vdev;
+	struct wlan_objmgr_pdev *pdev;
+	struct wlan_ser_pdev_obj *ser_pdev_obj;
+	struct wlan_serialization_command *cmd = NULL;
+	qdf_list_node_t *nnode = NULL;
+	qdf_list_t *queue;
+	struct wlan_serialization_pdev_queue *pdev_q;
+
+	if (!psoc) {
+		ser_err("invalid psoc");
+		goto error;
+	}
+	vdev = wlan_objmgr_get_vdev_by_id_from_psoc(psoc, vdev_id,
+						    WLAN_SERIALIZATION_ID);
+	if (!vdev) {
+		ser_err("invalid vdev");
+		goto error;
+	}
+
+	pdev = wlan_vdev_get_pdev(vdev);
+	if (!pdev) {
+		ser_err("invalid pdev");
+		goto release_vdev_ref;
+	}
+
+	ser_pdev_obj = wlan_serialization_get_pdev_obj(pdev);
+	if (!ser_pdev_obj) {
+		ser_err("invalid ser_pdev_obj");
+		goto release_vdev_ref;
+	}
+
+	pdev_q = &ser_pdev_obj->pdev_q[SER_PDEV_QUEUE_COMP_SCAN];
+
+	wlan_serialization_acquire_lock(pdev_q);
+
+	if (is_scan_cmd_from_active_queue)
+		queue = &pdev_q->active_list;
+	else
+		queue = &pdev_q->pending_list;
+
+	qlen = wlan_serialization_list_size(queue);
+
+	while (qlen--) {
+		if (QDF_IS_STATUS_ERROR(wlan_serialization_get_cmd_from_queue(
+					queue, &nnode))) {
+			ser_debug("Node not found");
+			break;
+		}
+		if (wlan_ser_match_cmd_scan_id(nnode, &cmd, scan_id,
+					       vdev)) {
+			break;
+		}
+	}
+
+	wlan_serialization_release_lock(pdev_q);
+
+release_vdev_ref:
+	wlan_objmgr_vdev_release_ref(vdev, WLAN_SERIALIZATION_ID);
+error:
+	return cmd;
+}
+
+void *wlan_serialization_get_active_cmd(
+		struct wlan_objmgr_psoc *psoc,
+		uint8_t vdev_id,
+		enum wlan_serialization_cmd_type cmd_type)
+{
+	struct wlan_objmgr_vdev *vdev;
+	struct wlan_objmgr_pdev *pdev;
+	struct wlan_ser_pdev_obj *ser_pdev_obj;
+	struct wlan_serialization_command_list *cmd_list = NULL;
+	void *umac_cmd = NULL;
+	qdf_list_node_t *node = NULL;
+	qdf_list_t *queue;
+	struct wlan_serialization_pdev_queue *pdev_q;
+
+	ser_enter();
+
+	if (!psoc) {
+		ser_err("invalid psoc");
+		goto error;
+	}
+	vdev = wlan_objmgr_get_vdev_by_id_from_psoc(psoc, vdev_id,
+						    WLAN_SERIALIZATION_ID);
+	if (!vdev) {
+		ser_err("invalid vdev");
+		goto error;
+	}
+
+	pdev = wlan_vdev_get_pdev(vdev);
+	if (!pdev) {
+		ser_err("invalid pdev");
+		goto release_vdev_ref;
+	}
+
+	ser_pdev_obj = wlan_serialization_get_pdev_obj(pdev);
+	if (!ser_pdev_obj) {
+		ser_err("invalid ser_pdev_obj");
+		goto release_vdev_ref;
+	}
+
+	pdev_q = wlan_serialization_get_pdev_queue_obj(ser_pdev_obj, cmd_type);
+
+	wlan_serialization_acquire_lock(pdev_q);
+
+	queue = &pdev_q->active_list;
+
+	node = wlan_serialization_find_cmd(
+			queue, WLAN_SER_MATCH_CMD_TYPE_VDEV,
+			NULL, cmd_type, NULL, vdev,  WLAN_SER_PDEV_NODE);
+
+	if (node) {
+		cmd_list = qdf_container_of(
+				node,
+				struct wlan_serialization_command_list,
+				pdev_node);
+
+		umac_cmd = cmd_list->cmd.umac_cmd;
+	}
+
+	wlan_serialization_release_lock(pdev_q);
+
+release_vdev_ref:
+	wlan_objmgr_vdev_release_ref(vdev, WLAN_SERIALIZATION_ID);
+error:
+	ser_exit();
+	return umac_cmd;
+}
+#endif

umac/cmn_services/serialization/src/wlan_serialization_dequeue.c

@@ -20,6 +20,7 @@
  * This file defines the routines which are pertinent
  * to the dequeue of commands.
  */
+#ifdef CONFIG_SERIALIZATION_V1
 #include <wlan_serialization_api.h>
 #include "wlan_serialization_main_i.h"
 #include "wlan_serialization_utils_i.h"
@@ -657,4 +658,4 @@ QDF_STATUS wlan_serialization_find_and_remove_cmd(
 
 	return QDF_STATUS_SUCCESS;
 }
-
+#endif

umac/cmn_services/serialization/src/wlan_serialization_enqueue.c

@@ -20,6 +20,7 @@
  * This file defines the routines which are pertinent
  * to the queuing of commands.
  */
+#ifdef CONFIG_SERIALIZATION_V1
 #include <wlan_serialization_api.h>
 #include "wlan_serialization_main_i.h"
 #include "wlan_serialization_utils_i.h"
@@ -271,3 +272,4 @@ wlan_serialization_enqueue_cmd(struct wlan_serialization_command *cmd,
 	return wlan_serialization_add_cmd_to_given_queue(queue, cmd, psoc,
 			ser_pdev_obj, is_cmd_for_active_queue, pcmd_list);
 }
+#endif

umac/cmn_services/serialization/src/wlan_serialization_internal.c

@@ -0,0 +1,902 @@
+/*
+ * Copyright (c) 2017-2018 The Linux Foundation. All rights reserved.
+ *
+ * Permission to use, copy, modify, and/or distribute this software for
+ * any purpose with or without fee is hereby granted, provided that the
+ * above copyright notice and this permission notice appear in all
+ * copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+ * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+ * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+ * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+ * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ */
+/**
+ * DOC: wlan_serialization_internal.c
+ * This file defines the functions which are called
+ * from serialization public API's and are internal
+ * to serialization.
+ */
+
+#include <wlan_objmgr_vdev_obj.h>
+#include <wlan_objmgr_pdev_obj.h>
+#include <wlan_objmgr_psoc_obj.h>
+#include <qdf_list.h>
+#include <qdf_status.h>
+#include <wlan_utility.h>
+#include "wlan_serialization_api.h"
+#include "wlan_serialization_main_i.h"
+#include "wlan_serialization_utils_i.h"
+#include "wlan_serialization_non_scan_i.h"
+#include "wlan_serialization_scan_i.h"
+#include "wlan_serialization_internal_i.h"
+
+bool wlan_serialization_is_cmd_present_queue(
+			struct wlan_serialization_command *cmd,
+			uint8_t is_active_queue)
+{
+	qdf_list_t *queue;
+	bool status = false;
+	enum wlan_serialization_node node_type;
+	struct wlan_ser_pdev_obj *ser_pdev_obj;
+	struct wlan_ser_vdev_obj *ser_vdev_obj;
+	enum wlan_serialization_cmd_type cmd_type;
+
+	if (!cmd) {
+		ser_err("invalid cmd");
+		goto error;
+	}
+
+	cmd_type = cmd->cmd_type;
+
+	ser_pdev_obj = wlan_serialization_get_pdev_obj(
+			wlan_serialization_get_pdev_from_cmd(cmd));
+
+	if (!ser_pdev_obj) {
+		ser_err("invalid ser vdev obj");
+		goto error;
+	}
+
+	ser_vdev_obj = wlan_serialization_get_vdev_obj(
+			wlan_serialization_get_vdev_from_cmd(cmd));
+	if (!ser_vdev_obj) {
+		ser_err("invalid ser pdev obj");
+		goto error;
+	}
+
+	if (cmd_type < WLAN_SER_CMD_NONSCAN) {
+		queue = wlan_serialization_get_list_from_pdev_queue(
+				ser_pdev_obj, cmd_type, is_active_queue);
+		node_type = WLAN_SER_PDEV_NODE;
+	} else {
+		queue = wlan_serialization_get_list_from_vdev_queue(
+				ser_vdev_obj, cmd_type, is_active_queue);
+		node_type = WLAN_SER_VDEV_NODE;
+	}
+
+	status = wlan_serialization_is_cmd_present_in_given_queue(queue, cmd,
+								  node_type);
+
+error:
+	return status;
+}
+
+enum wlan_serialization_status
+wlan_serialization_enqueue_cmd(struct wlan_serialization_command *cmd)
+{
+	enum wlan_serialization_status status = WLAN_SER_CMD_DENIED_UNSPECIFIED;
+	struct wlan_serialization_command_list *cmd_list;
+	qdf_list_node_t *nnode;
+	struct wlan_objmgr_pdev *pdev;
+	struct wlan_ser_pdev_obj *ser_pdev_obj;
+	struct wlan_serialization_pdev_queue *pdev_queue;
+	bool active_queue;
+
+	/* Enqueue process
+	 * 1) peek through command structure and see what is the command type
+	 * 2) two main types of commands to process
+	 *    a) SCAN
+	 *    b) NON-SCAN
+	 * 3) for each command there are separate command queues per pdev
+	 * 4) pull pdev from vdev structure and get the command queue associated
+	 *    with that pdev and try to enqueue on those queue
+	 * 5) Thumb rule:
+	 *    a) There could be only 1 active non-scan command at a
+	 *       time including all total non-scan commands of all pdevs.
+	 *
+	 *       example: pdev1 has 1 non-scan active command and
+	 *       pdev2 got 1 non-scan command then that command should go to
+	 *       pdev2's pending queue
+	 *
+	 *    b) There could be only N number of scan commands at a time
+	 *       including all total scan commands of all pdevs
+	 *
+	 *       example: Let's say N=8,
+	 *       pdev1's vdev1 has 5 scan command, pdev2's vdev1 has 3
+	 *       scan commands, if we get scan request on vdev2 then it will go
+	 *       to pending queue of vdev2 as we reached max allowed scan active
+	 *       command.
+	 */
+
+	ser_enter();
+
+	if (!cmd) {
+		ser_err("NULL command");
+		goto error;
+	}
+
+	if (!cmd->cmd_cb) {
+		ser_err("no cmd_cb for cmd type:%d, id: %d",
+			cmd->cmd_type,
+			cmd->cmd_id);
+		goto error;
+	}
+
+	pdev = wlan_serialization_get_pdev_from_cmd(cmd);
+	if (!pdev) {
+		ser_err("pdev is invalid");
+		goto error;
+	}
+
+	ser_pdev_obj =
+		wlan_objmgr_pdev_get_comp_private_obj(
+				pdev,
+				WLAN_UMAC_COMP_SERIALIZATION);
+	if (!ser_pdev_obj) {
+		ser_err("Invalid ser_pdev_obj");
+		goto error;
+	}
+
+	pdev_queue = wlan_serialization_get_pdev_queue_obj(ser_pdev_obj,
+							   cmd->cmd_type);
+	if (!pdev_queue) {
+		ser_err("pdev_queue is invalid");
+		goto error;
+	}
+
+	ser_debug("enqueue cmd: type[%d] id[%d] high_priority[%d] blocking[%d]",
+		  cmd->cmd_type,
+		  cmd->cmd_id,
+		  cmd->is_high_priority,
+		  cmd->is_blocking);
+
+	wlan_serialization_acquire_lock(pdev_queue);
+
+	active_queue = wlan_serialization_is_active_cmd_allowed(cmd);
+
+	if (wlan_serialization_is_cmd_present_queue(cmd, active_queue)) {
+		wlan_serialization_release_lock(pdev_queue);
+		ser_err("duplicate command, can't enqueue");
+		goto error;
+	}
+
+	if (wlan_serialization_remove_front(
+				&pdev_queue->cmd_pool_list,
+				&nnode) != QDF_STATUS_SUCCESS) {
+		wlan_serialization_release_lock(pdev_queue);
+		ser_err("Failed to get cmd buffer from global pool");
+		goto error;
+	}
+
+	ser_debug("Global pool node: %pK", nnode);
+
+	cmd_list =
+		qdf_container_of(nnode,
+				 struct wlan_serialization_command_list,
+				 pdev_node);
+
+	qdf_mem_copy(&cmd_list->cmd, cmd,
+		     sizeof(struct wlan_serialization_command));
+
+	if (cmd->cmd_type < WLAN_SER_CMD_NONSCAN) {
+		status = wlan_ser_add_scan_cmd(ser_pdev_obj,
+					       cmd_list,
+					       active_queue);
+	} else {
+		status = wlan_ser_add_non_scan_cmd(ser_pdev_obj,
+						   cmd_list,
+						   active_queue);
+	}
+
+	if (status != WLAN_SER_CMD_PENDING && status != WLAN_SER_CMD_ACTIVE) {
+		ser_err("Failed to add cmd to active/pending queue");
+		qdf_mem_zero(&cmd_list->cmd,
+			     sizeof(struct wlan_serialization_command));
+		wlan_serialization_insert_back(
+			&pdev_queue->cmd_pool_list,
+			&cmd_list->pdev_node);
+	}
+
+	if (WLAN_SER_CMD_ACTIVE == status) {
+		qdf_atomic_set_bit(CMD_MARKED_FOR_ACTIVATION,
+				   &cmd_list->cmd_in_use);
+	}
+
+	wlan_serialization_release_lock(pdev_queue);
+
+	if (WLAN_SER_CMD_ACTIVE == status)
+		wlan_serialization_activate_cmd(cmd_list,
+						ser_pdev_obj);
+
+error:
+	ser_exit();
+
+	return status;
+}
+
+QDF_STATUS
+wlan_serialization_activate_multiple_cmd(
+		struct wlan_ser_pdev_obj *ser_pdev_obj)
+{
+	struct wlan_serialization_pdev_queue *pdev_queue;
+	qdf_list_t *active_queue;
+	QDF_STATUS peek_status = QDF_STATUS_E_FAILURE;
+	struct wlan_serialization_command_list *active_cmd_list;
+	uint32_t qsize;
+	uint32_t vdev_id;
+	qdf_list_node_t *nnode = NULL;
+	QDF_STATUS status = QDF_STATUS_SUCCESS;
+	struct wlan_objmgr_psoc *psoc = NULL;
+
+	pdev_queue = &ser_pdev_obj->pdev_q[SER_PDEV_QUEUE_COMP_NON_SCAN];
+	active_queue = &pdev_queue->active_list;
+
+	qsize =  wlan_serialization_list_size(active_queue);
+	while (qsize--) {
+		peek_status = wlan_serialization_get_cmd_from_queue(
+				active_queue, &nnode);
+
+		if (peek_status != QDF_STATUS_SUCCESS) {
+			ser_err("can't peek cmd");
+			break;
+		}
+
+		active_cmd_list = qdf_container_of(
+				nnode, struct wlan_serialization_command_list,
+				pdev_node);
+
+		if (!qdf_atomic_test_bit(CMD_MARKED_FOR_ACTIVATION,
+					 &active_cmd_list->cmd_in_use)) {
+			continue;
+		}
+
+		/*
+		 * Command is already pushed to active queue.
+		 * Now start the timer.
+		 */
+		psoc = wlan_vdev_get_psoc(active_cmd_list->cmd.vdev);
+		wlan_serialization_find_and_start_timer(psoc,
+							&active_cmd_list->cmd);
+
+		ser_debug("cmd cb: type[%d] id[%d] : reason: %s",
+			  active_cmd_list->cmd.cmd_type,
+			  active_cmd_list->cmd.cmd_id,
+			  "WLAN_SER_CB_ACTIVATE_CMD");
+
+		status = active_cmd_list->cmd.cmd_cb(&active_cmd_list->cmd,
+					    WLAN_SER_CB_ACTIVATE_CMD);
+
+		qdf_atomic_clear_bit(CMD_MARKED_FOR_ACTIVATION,
+				     &active_cmd_list->cmd_in_use);
+
+		qdf_atomic_set_bit(CMD_IS_ACTIVE,
+				   &active_cmd_list->cmd_in_use);
+
+		vdev_id = wlan_vdev_get_id(active_cmd_list->cmd.vdev);
+		pdev_queue->vdev_active_cmd_bitmap |= (1 << vdev_id);
+
+		if (active_cmd_list->cmd.is_blocking)
+			pdev_queue->blocking_cmd_active = 1;
+
+		if (QDF_IS_STATUS_ERROR(status))
+			wlan_serialization_dequeue_cmd(&active_cmd_list->cmd,
+						       true);
+	}
+	return status;
+}
+
+QDF_STATUS wlan_serialization_activate_cmd(
+			struct wlan_serialization_command_list *cmd_list,
+			struct wlan_ser_pdev_obj *ser_pdev_obj)
+{
+	QDF_STATUS status = QDF_STATUS_E_FAILURE;
+	struct wlan_objmgr_psoc *psoc = NULL;
+
+	psoc = wlan_vdev_get_psoc(cmd_list->cmd.vdev);
+	if (!psoc) {
+		ser_err("invalid psoc");
+		goto error;
+	}
+
+	/*
+	 * command is already pushed to active queue above
+	 * now start the timer and notify requestor
+	 */
+	wlan_serialization_find_and_start_timer(psoc, &cmd_list->cmd);
+	/*
+	 * Remember that serialization module may send
+	 * this callback in same context through which it
+	 * received the serialization request. Due to which
+	 * it is caller's responsibility to ensure acquiring
+	 * and releasing its own lock appropriately.
+	 */
+
+	ser_debug("cmd cb: type[%d] id[%d] : reason: %s",
+		  cmd_list->cmd.cmd_type,
+		  cmd_list->cmd.cmd_id,
+		  "WLAN_SER_CB_ACTIVATE_CMD");
+
+	status = cmd_list->cmd.cmd_cb(&cmd_list->cmd,
+				WLAN_SER_CB_ACTIVATE_CMD);
+
+	qdf_atomic_clear_bit(CMD_MARKED_FOR_ACTIVATION,
+			     &cmd_list->cmd_in_use);
+	qdf_atomic_set_bit(CMD_IS_ACTIVE,
+			   &cmd_list->cmd_in_use);
+
+	if (QDF_IS_STATUS_ERROR(status))
+		wlan_serialization_dequeue_cmd(&cmd_list->cmd, true);
+
+error:
+	return status;
+}
+
+bool
+wlan_serialization_is_active_cmd_allowed(struct wlan_serialization_command *cmd)
+{
+	struct wlan_objmgr_pdev *pdev;
+	bool active_cmd_allowed = 0;
+
+	pdev = wlan_serialization_get_pdev_from_cmd(cmd);
+	if (!pdev) {
+		ser_err("NULL pdev");
+		goto error;
+	}
+
+	if (cmd->cmd_type < WLAN_SER_CMD_NONSCAN)
+		active_cmd_allowed =
+			wlan_serialization_is_active_scan_cmd_allowed(cmd);
+	else
+		active_cmd_allowed =
+			wlan_serialization_is_active_non_scan_cmd_allowed(cmd);
+
+	ser_debug("active cmd_type[%d] cmd_id[%d] allowed: %d",
+		  cmd->cmd_type,
+		  cmd->cmd_id,
+		  active_cmd_allowed);
+
+error:
+	return active_cmd_allowed;
+}
+
+enum wlan_serialization_status
+wlan_serialization_move_pending_to_active(
+		enum wlan_serialization_cmd_type cmd_type,
+		struct wlan_serialization_command_list **pcmd_list,
+		struct wlan_ser_pdev_obj *ser_pdev_obj,
+		struct wlan_objmgr_vdev *vdev,
+		bool blocking_cmd_removed,
+		bool blocking_cmd_waiting)
+{
+	enum wlan_serialization_status status;
+	struct wlan_serialization_pdev_queue *pdev_queue;
+
+	if (cmd_type < WLAN_SER_CMD_NONSCAN) {
+		status =
+		wlan_ser_move_scan_pending_to_active(
+				pcmd_list,
+				ser_pdev_obj);
+	} else {
+		pdev_queue =
+			&ser_pdev_obj->pdev_q[SER_PDEV_QUEUE_COMP_NON_SCAN];
+
+		if (!blocking_cmd_removed && !blocking_cmd_waiting)
+			status =
+			wlan_ser_move_non_scan_pending_to_active(
+				pcmd_list,
+				ser_pdev_obj,
+				vdev);
+		else
+			status =
+			wlan_ser_move_multiple_non_scan_pending_to_active(
+				ser_pdev_obj);
+	}
+
+	return status;
+}
+
+enum wlan_serialization_cmd_status
+wlan_serialization_dequeue_cmd(struct wlan_serialization_command *cmd,
+			       uint8_t active_cmd)
+{
+	enum wlan_serialization_cmd_status status =
+		WLAN_SER_CMD_NOT_FOUND;
+	enum wlan_serialization_status ser_status =
+		WLAN_SER_CMD_DENIED_UNSPECIFIED;
+
+	QDF_STATUS qdf_status;
+	struct wlan_objmgr_pdev *pdev;
+	struct wlan_objmgr_psoc *psoc;
+	struct wlan_ser_pdev_obj *ser_pdev_obj;
+	struct wlan_serialization_command cmd_bkup;
+	struct wlan_serialization_command_list *cmd_list;
+	struct wlan_serialization_command_list *pcmd_list;
+	struct wlan_serialization_pdev_queue *pdev_queue;
+	bool blocking_cmd_removed = 0;
+	bool blocking_cmd_waiting = 0;
+
+	ser_enter();
+
+	if (!cmd) {
+		ser_err("NULL command");
+		goto error;
+	}
+
+	pdev = wlan_serialization_get_pdev_from_cmd(cmd);
+	if (!pdev) {
+		ser_err("invalid pdev");
+		goto error;
+	}
+
+	psoc = wlan_pdev_get_psoc(pdev);
+	if (!psoc) {
+		ser_err("invalid psoc");
+		goto error;
+	}
+
+	ser_pdev_obj = wlan_serialization_get_pdev_obj(pdev);
+	if (!ser_pdev_obj) {
+		ser_err("ser_pdev_obj is empty");
+		goto error;
+	}
+
+	pdev_queue = wlan_serialization_get_pdev_queue_obj(
+			ser_pdev_obj, cmd->cmd_type);
+
+	ser_debug("dequeue cmd: type[%d] id[%d] high_priority[%d] blocking[%d]",
+		  cmd->cmd_type,
+		  cmd->cmd_id,
+		  cmd->is_high_priority,
+		  cmd->is_blocking);
+
+	wlan_serialization_acquire_lock(pdev_queue);
+
+	if (cmd->cmd_type < WLAN_SER_CMD_NONSCAN)
+		qdf_status = wlan_ser_remove_scan_cmd(
+				ser_pdev_obj, &cmd_list, cmd, active_cmd);
+	else {
+		qdf_status = wlan_ser_remove_non_scan_cmd(
+				ser_pdev_obj, &cmd_list, cmd, active_cmd);
+	}
+
+	if (qdf_status != QDF_STATUS_SUCCESS) {
+		wlan_serialization_release_lock(pdev_queue);
+		status = WLAN_SER_CMD_NOT_FOUND;
+		goto error;
+	}
+
+	if (active_cmd) {
+		wlan_serialization_find_and_stop_timer(psoc, &cmd_list->cmd);
+
+		if (cmd_list->cmd.cmd_type >= WLAN_SER_CMD_NONSCAN)
+			blocking_cmd_removed = cmd_list->cmd.is_blocking;
+	}
+
+	qdf_mem_copy(&cmd_bkup, &cmd_list->cmd,
+		     sizeof(struct wlan_serialization_command));
+	qdf_mem_zero(&cmd_list->cmd,
+		     sizeof(struct wlan_serialization_command));
+	qdf_status = wlan_serialization_insert_back(
+			&pdev_queue->cmd_pool_list,
+			&cmd_list->pdev_node);
+
+	/*
+	 * For NON SCAN commands, the following is possible:
+	 *
+	 * If the remove is for non blocking command,
+	 * and there is no blocking command waiting,
+	 * look at vdev pending queue and
+	 * only one command moves from pending
+	 * to active
+	 *
+	 * If the remove is for blocking comamnd,
+	 * look at the pdev queue and
+	 * either single blocking command
+	 * or multiple non blocking commands moves
+	 * from pending to active
+	 */
+
+	blocking_cmd_waiting = pdev_queue->blocking_cmd_waiting;
+
+	if (active_cmd) {
+		ser_status = wlan_serialization_move_pending_to_active(
+			cmd_bkup.cmd_type, &pcmd_list, ser_pdev_obj,
+			cmd_bkup.vdev,
+			blocking_cmd_removed,
+			blocking_cmd_waiting);
+	}
+
+	wlan_serialization_release_lock(pdev_queue);
+
+	/* Call cmd cb for remove request*/
+	if (cmd_bkup.cmd_cb) {
+		/* caller should release the memory */
+		ser_debug("cmd cb: type[%d] id[%d]: reason: %s",
+			  cmd_bkup.cmd_type,
+			  cmd_bkup.cmd_id,
+			  "WLAN_SER_CB_RELEASE_MEM_CMD");
+		cmd_bkup.cmd_cb(&cmd_bkup,
+				     WLAN_SER_CB_RELEASE_MEM_CMD);
+	}
+
+	/*
+	 * If the remove is for non blocking command,
+	 * and there is no blocking command waiting,
+	 * look at vdev pending queue and
+	 * only one command moves from pending
+	 * to active and gets activated
+	 */
+	if (WLAN_SER_CMD_ACTIVE == ser_status && !blocking_cmd_removed &&
+	    !blocking_cmd_waiting) {
+		ser_debug("cmd type[%d] id[%d] moved from pending to active",
+			  pcmd_list->cmd.cmd_type,
+			  pcmd_list->cmd.cmd_id);
+		wlan_serialization_activate_cmd(pcmd_list,
+						ser_pdev_obj);
+	} else if (ser_status == WLAN_SER_CMD_ACTIVE) {
+		/* If the remove is for blocking command
+		 * either one or multiple commands can move
+		 * from pending to active and gets activated
+		 */
+		wlan_serialization_activate_multiple_cmd(ser_pdev_obj);
+	} else {
+		goto exit;
+	}
+
+exit:
+	if (active_cmd)
+		status = WLAN_SER_CMD_IN_ACTIVE_LIST;
+	else
+		status = WLAN_SER_CMD_IN_PENDING_LIST;
+
+error:
+	ser_exit();
+	return status;
+}
+
+void wlan_serialization_generic_timer_cb(void *arg)
+{
+	struct wlan_serialization_timer *timer = arg;
+	struct wlan_serialization_command *cmd = timer->cmd;
+
+	if (!cmd) {
+		ser_err("command not found");
+		QDF_ASSERT(0);
+		return;
+	}
+
+	ser_err("active cmd timeout for cmd_type[%d] vdev[%pK]",
+		cmd->cmd_type, cmd->vdev);
+
+	if (cmd->cmd_cb)
+		cmd->cmd_cb(cmd, WLAN_SER_CB_ACTIVE_CMD_TIMEOUT);
+
+	/*
+	 * dequeue cmd API will cleanup and destroy the timer. If it fails to
+	 * dequeue command then we have to destroy the timer.
+	 */
+	wlan_serialization_dequeue_cmd(cmd, true);
+}
+
+static QDF_STATUS wlan_serialization_mc_flush_noop(struct scheduler_msg *msg)
+{
+	return QDF_STATUS_SUCCESS;
+}
+
+static void
+wlan_serialization_timer_cb_mc_ctx(void *arg)
+{
+	struct scheduler_msg msg = {0};
+
+	msg.type = SYS_MSG_ID_MC_TIMER;
+	msg.reserved = SYS_MSG_COOKIE;
+	msg.callback = wlan_serialization_generic_timer_cb;
+	msg.bodyptr = arg;
+	msg.bodyval = 0;
+	msg.flush_callback = wlan_serialization_mc_flush_noop;
+
+	if (scheduler_post_msg(QDF_MODULE_ID_SYS, &msg) == QDF_STATUS_SUCCESS)
+		return;
+
+	ser_err("Could not enqueue timer to timer queue");
+}
+
+#ifdef CONFIG_MCL
+static void wlan_serialization_timer_handler(void *arg)
+{
+	ser_enter();
+
+	wlan_serialization_timer_cb_mc_ctx(arg);
+
+	ser_exit();
+}
+#else
+static void wlan_serialization_timer_handler(void *arg)
+{
+	struct wlan_serialization_timer *timer = arg;
+	struct wlan_serialization_command *cmd = timer->cmd;
+
+	if (!cmd) {
+		ser_err("command not found");
+		QDF_ASSERT(0);
+		return;
+	}
+
+	if (cmd->cmd_type < WLAN_SER_CMD_NONSCAN)
+		wlan_serialization_timer_cb_mc_ctx(arg);
+	else
+		wlan_serialization_generic_timer_cb(arg);
+}
+#endif
+
+QDF_STATUS
+wlan_serialization_find_and_stop_timer(struct wlan_objmgr_psoc *psoc,
+				       struct wlan_serialization_command *cmd)
+{
+	struct wlan_ser_psoc_obj *psoc_ser_obj;
+	struct wlan_serialization_timer *ser_timer;
+	QDF_STATUS status = QDF_STATUS_E_FAILURE;
+	int i = 0;
+	uint32_t phy_version;
+
+	if (!psoc || !cmd) {
+		ser_err("invalid param");
+		goto error;
+	}
+
+	if (cmd->cmd_timeout_duration == 0) {
+		phy_version = wlan_psoc_get_nif_phy_version(psoc);
+		if (wlan_is_emulation_platform(phy_version)) {
+			ser_err("[SCAN-EMULATION]: Not performing timer funcs");
+			status = QDF_STATUS_SUCCESS;
+		goto exit;
+		}
+	}
+
+	psoc_ser_obj = wlan_serialization_get_psoc_obj(psoc);
+	/*
+	 * Here cmd_id and cmd_type are used to locate the timer being
+	 * associated with command. For scan command, cmd_id is expected to
+	 * be unique and For non-scan command, there should be only one active
+	 * command per pdev
+	 */
+	for (i = 0; psoc_ser_obj->max_active_cmds > i; i++) {
+		ser_timer = &psoc_ser_obj->timers[i];
+		if (!(ser_timer->cmd) ||
+		    (ser_timer->cmd->cmd_id != cmd->cmd_id) ||
+		    (ser_timer->cmd->cmd_type != cmd->cmd_type) ||
+		    (ser_timer->cmd->vdev != cmd->vdev))
+			continue;
+		status = wlan_serialization_stop_timer(ser_timer);
+		ser_debug("\n Stopping timer for cmd type:%d, id: %d",
+			  cmd->cmd_type, cmd->cmd_id);
+		break;
+	}
+
+	if (QDF_STATUS_SUCCESS != status)
+		ser_err("Can't find timer for cmd_type[%d]", cmd->cmd_type);
+
+error:
+exit:
+
+	return status;
+}
+
+QDF_STATUS
+wlan_serialization_find_and_start_timer(struct wlan_objmgr_psoc *psoc,
+					struct wlan_serialization_command *cmd)
+{
+	QDF_STATUS status = QDF_STATUS_E_FAILURE;
+	struct wlan_ser_psoc_obj *psoc_ser_obj;
+	struct wlan_serialization_timer *ser_timer;
+	int i = 0;
+	uint32_t nif_phy_ver;
+
+	if (!psoc || !cmd) {
+		ser_err("invalid param");
+		goto error;
+	}
+
+	nif_phy_ver = wlan_psoc_get_nif_phy_version(psoc);
+	if ((cmd->cmd_timeout_duration == 0) &&
+	    (wlan_is_emulation_platform(nif_phy_ver))) {
+		ser_err("[SCAN-EMULATION]: Not performing timer functions\n");
+		status = QDF_STATUS_SUCCESS;
+		goto exit;
+	}
+
+	psoc_ser_obj = wlan_serialization_get_psoc_obj(psoc);
+
+	for (i = 0; psoc_ser_obj->max_active_cmds > i; i++) {
+		/* Keep trying timer */
+		ser_timer = &psoc_ser_obj->timers[i];
+		if (ser_timer->cmd)
+			continue;
+
+		/* Remember timer is pointing to command */
+		ser_timer->cmd = cmd;
+		qdf_timer_init(NULL,
+			       &ser_timer->timer,
+			       wlan_serialization_timer_handler,
+			       ser_timer,
+			       QDF_TIMER_TYPE_SW);
+			       qdf_timer_mod(&ser_timer->timer,
+					     cmd->cmd_timeout_duration);
+
+		ser_debug("starting timer for cmd: type[%d] id[%d] high_priority[%d] blocking[%d]",
+			  cmd->cmd_type,
+			  cmd->cmd_id,
+			  cmd->is_high_priority,
+			  cmd->is_blocking);
+
+		status = QDF_STATUS_SUCCESS;
+		break;
+	}
+
+error:
+exit:
+
+	return status;
+}
+
+enum wlan_serialization_cmd_status
+wlan_serialization_cmd_cancel_handler(
+		struct wlan_ser_pdev_obj *ser_obj,
+		struct wlan_serialization_command *cmd,
+		struct wlan_objmgr_pdev *pdev, struct wlan_objmgr_vdev *vdev,
+		enum wlan_serialization_cmd_type cmd_type, uint8_t queue_type)
+{
+	enum wlan_serialization_cmd_status active_status =
+		WLAN_SER_CMD_NOT_FOUND;
+	enum wlan_serialization_cmd_status pending_status =
+		WLAN_SER_CMD_NOT_FOUND;
+	enum wlan_serialization_cmd_status status =
+		WLAN_SER_CMD_NOT_FOUND;
+
+	ser_enter();
+
+	if (!ser_obj) {
+		ser_err("invalid serial object");
+		goto error;
+	}
+
+	if (queue_type & WLAN_SERIALIZATION_ACTIVE_QUEUE) {
+		if (cmd_type < WLAN_SER_CMD_NONSCAN)
+			active_status = wlan_ser_cancel_scan_cmd(
+					ser_obj, pdev, vdev, cmd,
+					cmd_type, true);
+		else
+			active_status = wlan_ser_cancel_non_scan_cmd(
+					ser_obj, pdev, vdev, cmd,
+					cmd_type, true);
+	}
+
+	if (queue_type & WLAN_SERIALIZATION_PENDING_QUEUE) {
+		if (cmd_type < WLAN_SER_CMD_NONSCAN)
+			pending_status = wlan_ser_cancel_scan_cmd(
+					ser_obj, pdev, vdev, cmd,
+					cmd_type, false);
+		else
+			pending_status = wlan_ser_cancel_non_scan_cmd(
+					ser_obj, pdev, vdev, cmd,
+					cmd_type, false);
+	}
+
+	if (active_status == WLAN_SER_CMD_IN_ACTIVE_LIST &&
+	    pending_status == WLAN_SER_CMD_IN_PENDING_LIST)
+		status = WLAN_SER_CMDS_IN_ALL_LISTS;
+	else if (active_status == WLAN_SER_CMD_IN_ACTIVE_LIST)
+		status = active_status;
+	else if (pending_status == WLAN_SER_CMD_IN_PENDING_LIST)
+		status = pending_status;
+
+error:
+	ser_exit();
+	return status;
+}
+
+enum wlan_serialization_cmd_status
+wlan_serialization_find_and_cancel_cmd(
+		struct wlan_serialization_command *cmd,
+		enum wlan_serialization_cancel_type req_type,
+		uint8_t queue_type)
+{
+	enum wlan_serialization_cmd_status status = WLAN_SER_CMD_NOT_FOUND;
+	struct wlan_ser_pdev_obj *ser_obj = NULL;
+	struct wlan_objmgr_pdev *pdev;
+
+	ser_enter();
+
+	if (!cmd) {
+		ser_err("Invalid cmd");
+		goto error;
+	}
+
+	pdev = wlan_serialization_get_pdev_from_cmd(cmd);
+	if (!pdev) {
+		ser_err("Invalid pdev");
+		goto error;
+	}
+	ser_obj = wlan_serialization_get_pdev_obj(pdev);
+	if (!ser_obj) {
+		ser_err("Invalid ser_obj");
+		goto error;
+	}
+
+	switch (req_type) {
+	case WLAN_SER_CANCEL_SINGLE_SCAN:
+		/* remove scan cmd which matches the given cmd struct */
+		status =  wlan_serialization_cmd_cancel_handler(ser_obj,
+								cmd,
+								NULL,
+								NULL,
+								cmd->cmd_type,
+								queue_type);
+		break;
+	case WLAN_SER_CANCEL_PDEV_SCANS:
+		/* remove all scan cmds which matches the pdev object */
+		status = wlan_serialization_cmd_cancel_handler(
+				ser_obj,
+				NULL,
+				wlan_vdev_get_pdev(cmd->vdev),
+				NULL,
+				cmd->cmd_type,
+				queue_type);
+		break;
+	case WLAN_SER_CANCEL_VDEV_SCANS:
+		/* remove all scan cmds which matches the vdev object */
+		status = wlan_serialization_cmd_cancel_handler(ser_obj,
+							       NULL, NULL,
+							       cmd->vdev,
+							       cmd->cmd_type,
+							       queue_type);
+		break;
+	case WLAN_SER_CANCEL_NON_SCAN_CMD:
+		/* remove nonscan cmd which matches the given cmd */
+		status = wlan_serialization_cmd_cancel_handler(ser_obj,
+							       cmd,
+							       NULL,
+							       NULL,
+							       cmd->cmd_type,
+							       queue_type);
+		break;
+	case WLAN_SER_CANCEL_PDEV_NON_SCAN_CMD:
+		/* remove all non scan cmds which matches the pdev object */
+		status = wlan_serialization_cmd_cancel_handler(
+				ser_obj,
+				NULL,
+				wlan_vdev_get_pdev(cmd->vdev),
+				NULL,
+				cmd->cmd_type,
+				queue_type);
+		break;
+	case WLAN_SER_CANCEL_VDEV_NON_SCAN_CMD:
+		/* remove all non scan cmds which matches the vdev object */
+		status = wlan_serialization_cmd_cancel_handler(ser_obj,
+							       NULL, NULL,
+							       cmd->vdev,
+							       cmd->cmd_type,
+							       queue_type);
+		break;
+	default:
+		ser_err("Invalid request");
+	}
+
+error:
+	ser_exit();
+	return status;
+}

umac/cmn_services/serialization/src/wlan_serialization_internal_i.h

@@ -0,0 +1,211 @@
+/*
+ * Copyright (c) 2017-2018 The Linux Foundation. All rights reserved.
+ *
+ * Permission to use, copy, modify, and/or distribute this software for
+ * any purpose with or without fee is hereby granted, provided that the
+ * above copyright notice and this permission notice appear in all
+ * copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+ * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+ * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+ * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+ * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ */
+/**
+ * DOC: wlan_serialization_internal_i.h
+ * This file defines the prototypes of functions which are called
+ * from serialization public API's and are internal
+ * to serialization.
+ */
+#ifndef __WLAN_SERIALIZATION_PVT_I_H
+#define __WLAN_SERIALIZATION_PVT_I_H
+
+#include <wlan_objmgr_vdev_obj.h>
+#include <wlan_objmgr_pdev_obj.h>
+#include <wlan_objmgr_psoc_obj.h>
+#include <qdf_list.h>
+#include <qdf_status.h>
+#include "wlan_serialization_api.h"
+#include "wlan_serialization_main_i.h"
+#include "wlan_serialization_utils_i.h"
+#include "wlan_serialization_non_scan_i.h"
+
+/**
+ * wlan_serialization_is_cmd_present_queue() - Check if same command
+ *				is already present active or pending queue
+ * @cmd: pointer to command which we need to find
+ * @is_active_queue: flag to find the command in active or pending queue
+ *
+ * This API will check the given command is already present in active or
+ * pending queue based on flag
+ * If present then return true otherwise false
+ *
+ * Return: true or false
+ */
+bool
+wlan_serialization_is_cmd_present_queue(
+					struct wlan_serialization_command *cmd,
+					uint8_t is_active_queue);
+
+/**
+ * wlan_serialization_is_active_cmd_allowed() - Check if the given command
+ *			can be moved to active queue
+ * @cmd: Serialization command information
+ *
+ * Return: true or false
+ */
+bool
+wlan_serialization_is_active_cmd_allowed(
+		struct wlan_serialization_command *cmd);
+
+/**
+ * wlan_serialization_enqueue_cmd() - Enqueue the cmd to pending/active Queue
+ * @cmd: Command information
+ *
+ * Return: Status of the serialization request
+ */
+enum wlan_serialization_status
+wlan_serialization_enqueue_cmd(struct wlan_serialization_command *cmd);
+
+/**
+ * wlan_serialization_activate_cmd() - activate cmd in active queue
+ * @cmd_list: Command needs to be activated
+ * @ser_pdev_obj: Serialization private pdev object
+ *
+ * Return: Status of activation of the command
+ */
+QDF_STATUS
+wlan_serialization_activate_cmd(
+		struct wlan_serialization_command_list *cmd_list,
+		struct wlan_ser_pdev_obj *ser_pdev_obj);
+
+/**
+ * wlan_serialization_activate_multiple_cmd() - Activate multiple cmd in
+ *			active queue
+ * @ser_pdev_obj: Serialization private pdev object
+ *
+ * Return: Status of activation of the command
+ */
+QDF_STATUS
+wlan_serialization_activate_multiple_cmd(
+		struct wlan_ser_pdev_obj *ser_pdev_obj);
+
+/**
+ * wlan_serialization_move_pending_to_active() - Move a cmd from pending
+ *			queue to active queue
+ * @cmd_type: Type of command to be moved i.e scan or non scan
+ * @pcmd_list: Pointer to command list containing the command
+ * @ser_pdev_obj: Serialization private pdev object
+ * @vdev: Pointer to vdev object manager
+ * @blocking_cmd_removed: If a blocking cmd is removed from active queue
+ * @blocking_cmd_waiting: If a blocking cmd is waiting in pending queue
+ *
+ * Return: Status of command request
+ */
+enum wlan_serialization_status
+wlan_serialization_move_pending_to_active(
+		enum wlan_serialization_cmd_type cmd_type,
+		struct wlan_serialization_command_list **pcmd_list,
+		struct wlan_ser_pdev_obj *ser_pdev_obj,
+		struct wlan_objmgr_vdev *vdev,
+		bool blocking_cmd_removed,
+		bool blocking_cmd_waiting);
+
+/**
+ * wlan_serialization_dequeue_cmd() - dequeue the cmd to pending/active Queue
+ * @cmd: Command information
+ * @active_cmd: whether command is for active queue
+ *
+ * Return: Status of the serialization request
+ */
+enum wlan_serialization_cmd_status
+wlan_serialization_dequeue_cmd(struct wlan_serialization_command *cmd,
+			       uint8_t active_cmd);
+
+/**
+ * wlan_serialization_generic_timer_cb() - timer callback when timer fire
+ * @arg: argument that timer passes to this callback
+ *
+ * All the timers in serialization module calls this callback when they fire,
+ * and this API in turn calls command specific timeout callback and remove
+ * timed-out command from active queue and move any pending command to active
+ * queue of same cmd_type.
+ *
+ * Return: none
+ */
+void wlan_serialization_generic_timer_cb(void *arg);
+
+/**
+ * wlan_serialization_find_and_start_timer() - to find and start the timer
+ * @psoc: pointer to psoc
+ * @cmd: pointer to actual command
+ *
+ * find the free timer, initialize it, and start it
+ *
+ * Return: QDF_STATUS
+ */
+QDF_STATUS
+wlan_serialization_find_and_start_timer(struct wlan_objmgr_psoc *psoc,
+					struct wlan_serialization_command *cmd);
+
+/**
+ * wlan_serialization_find_and_stop_timer() - to find and stop the timer
+ * @psoc: pointer to psoc
+ * @cmd: pointer to actual command
+ *
+ * find the timer associated with command, stop it and destroy it
+ *
+ * Return: QDF_STATUS
+ */
+QDF_STATUS
+wlan_serialization_find_and_stop_timer(struct wlan_objmgr_psoc *psoc,
+				       struct wlan_serialization_command *cmd);
+
+/**
+ * wlan_serialization_find_and_cancel_cmd() - to find cmd from queue and cancel
+ * @cmd: pointer to serialization command
+ * @req_type: Command cancel request type
+ * @queue_type: Bitmask for member queue type i.e active or pending or both
+ *
+ * This api will find command from active queue and pending queue and
+ * removes the command. If it is in active queue then it will notifies the
+ * requester that it is in active queue and from there it expects requester
+ * to send remove command
+ *
+ * Return: wlan_serialization_cmd_status
+ */
+
+enum wlan_serialization_cmd_status
+wlan_serialization_find_and_cancel_cmd(
+		struct wlan_serialization_command *cmd,
+		enum wlan_serialization_cancel_type req_type,
+		uint8_t queue_type);
+
+/**
+ * wlan_serialization_cmd_cancel_handler() - helper func to cancel cmd
+ * @ser_obj: private pdev ser obj
+ * @cmd: pointer to command
+ * @pdev: pointer to pdev
+ * @vdev: pointer to vdev
+ * @cmd_type: pointer to cmd_type
+ * @queue_type: If active queue or pending queue
+ *
+ * This API will decide from which queue, command needs to be cancelled
+ * and pass that queue and other parameter required to cancel the command
+ * to helper function.
+ *
+ * Return: wlan_serialization_cmd_status
+ */
+enum wlan_serialization_cmd_status
+wlan_serialization_cmd_cancel_handler(
+				      struct wlan_ser_pdev_obj *ser_obj,
+				      struct wlan_serialization_command *cmd,
+				      struct wlan_objmgr_pdev *pdev,
+				      struct wlan_objmgr_vdev *vdev,
+				      enum wlan_serialization_cmd_type cmd_type,
+				      uint8_t queue_type);
+#endif

umac/cmn_services/serialization/src/wlan_serialization_main.c

@@ -22,6 +22,7 @@
  * serialization to initialize and de-initialize the
  * component.
  */
+#ifdef CONFIG_SERIALIZATION_V1
 #include "qdf_status.h"
 #include "qdf_list.h"
 #include "wlan_objmgr_cmn.h"
@@ -486,3 +487,609 @@ QDF_STATUS wlan_serialization_deinit(void)
 
 	return ret_status;
 }
+#else /* New serialition code*/
+#include <qdf_status.h>
+#include <qdf_list.h>
+#include <wlan_objmgr_cmn.h>
+#include <wlan_objmgr_global_obj.h>
+#include <wlan_objmgr_psoc_obj.h>
+#include "wlan_serialization_main_i.h"
+#include "wlan_serialization_rules_i.h"
+#include "wlan_serialization_utils_i.h"
+
+struct serialization_legacy_callback ser_legacy_cb;
+
+QDF_STATUS wlan_serialization_psoc_close(struct wlan_objmgr_psoc *psoc)
+{
+	QDF_STATUS status = QDF_STATUS_E_FAILURE;
+	struct wlan_ser_psoc_obj *ser_soc_obj =
+		wlan_serialization_get_psoc_obj(psoc);
+
+	ser_enter();
+
+	if (!ser_soc_obj) {
+		ser_err("invalid ser_soc_obj");
+		goto error;
+	}
+	/* clean up all timers before exiting */
+	status = wlan_serialization_cleanup_all_timers(ser_soc_obj);
+	if (status != QDF_STATUS_SUCCESS)
+		ser_err("ser cleanning up all timer failed");
+
+	qdf_mem_free(ser_soc_obj->timers);
+	ser_soc_obj->timers = NULL;
+	ser_soc_obj->max_active_cmds = 0;
+
+error:
+	ser_exit();
+	return status;
+}
+
+QDF_STATUS wlan_serialization_psoc_open(struct wlan_objmgr_psoc *psoc)
+{
+	uint8_t pdev_count;
+	struct wlan_ser_psoc_obj *ser_soc_obj =
+		wlan_serialization_get_psoc_obj(psoc);
+	QDF_STATUS status = QDF_STATUS_E_FAILURE;
+
+	if (!ser_soc_obj) {
+		ser_err("invalid ser_soc_obj");
+		goto error;
+	}
+
+	pdev_count = wlan_psoc_get_pdev_count(psoc);
+	ser_soc_obj->max_active_cmds = WLAN_SER_MAX_ACTIVE_SCAN_CMDS +
+					(pdev_count * WLAN_SER_MAX_VDEVS);
+
+	ser_soc_obj->timers =
+		qdf_mem_malloc(sizeof(struct wlan_serialization_timer) *
+				ser_soc_obj->max_active_cmds);
+	if (!ser_soc_obj->timers) {
+		ser_alert("Mem alloc failed for ser timers");
+		status = QDF_STATUS_E_NOMEM;
+		goto error;
+	}
+
+	status = QDF_STATUS_SUCCESS;
+
+error:
+	ser_exit();
+	return status;
+}
+
+/**
+ * wlan_serialization_psoc_create_handler() - PSOC obj create callback
+ * @psoc: PSOC object
+ * @arg_list: Variable argument list
+ *
+ * This callback is registered with object manager during initialization and
+ * when obj manager gets its turn to create the object, it would notify each
+ * component with the corresponding callback registered to inform the
+ * completion of the creation of the respective object.
+ *
+ * Return: QDF Status
+ */
+static QDF_STATUS wlan_serialization_psoc_create_handler(
+		struct wlan_objmgr_psoc *psoc, void *arg_list)
+{
+	struct wlan_ser_psoc_obj *soc_ser_obj;
+	QDF_STATUS status = QDF_STATUS_E_NOMEM;
+
+	ser_enter();
+
+	soc_ser_obj =
+		qdf_mem_malloc(sizeof(*soc_ser_obj));
+	if (!soc_ser_obj) {
+		ser_alert("Mem alloc failed for ser psoc priv obj");
+		goto error;
+	}
+	wlan_objmgr_psoc_component_obj_attach(psoc,
+					      WLAN_UMAC_COMP_SERIALIZATION,
+					      soc_ser_obj,
+					      QDF_STATUS_SUCCESS);
+	ser_debug("ser psoc obj created");
+
+	status = QDF_STATUS_SUCCESS;
+
+error:
+	ser_exit();
+	return status;
+}
+
+/**
+ * wlan_serialization_destroy_cmd_pool() - Destroy the global cmd pool
+ * @ser_pdev_obj: Serialization private pdev object
+ *
+ * Return: None
+ */
+static void wlan_serialization_destroy_cmd_pool(
+		struct wlan_serialization_pdev_queue *pdev_queue)
+{
+	qdf_list_node_t *node = NULL;
+	struct wlan_serialization_command_list *cmd_list;
+
+	ser_enter();
+	while (!qdf_list_empty(&pdev_queue->cmd_pool_list)) {
+		qdf_list_remove_front(&pdev_queue->cmd_pool_list,
+				      &node);
+		cmd_list = (struct wlan_serialization_command_list *)node;
+		ser_debug("Node being freed from global pool %pK",
+			  cmd_list);
+		qdf_mem_free(cmd_list);
+	}
+
+	qdf_list_destroy(&pdev_queue->cmd_pool_list);
+
+	ser_exit();
+}
+
+/**
+ * wlan_serialization_create_cmd_pool() - Create the global cmd pool
+ * @pdev: PDEV Object
+ * @ser_pdev_obj: Serialization private pdev object
+ *
+ * Global command pool of memory is created here.
+ * It is safe to allocate memory individually for each command rather than
+ * requesting for a huge chunk of memory at once.
+ *
+ * The individual command nodes allocated above will keep moving between
+ * the active, pending and global pool lists dynamically, but all the
+ * memory will be freed during driver unload only.
+ *
+ * Return: QDF Status
+ */
+static QDF_STATUS
+wlan_serialization_create_cmd_pool(
+		struct wlan_serialization_pdev_queue *pdev_queue,
+		uint16_t cmd_pool_size)
+{
+	struct wlan_serialization_command_list *cmd_list_ptr;
+	uint8_t i;
+	QDF_STATUS status = QDF_STATUS_E_NOMEM;
+
+	ser_enter();
+
+	for (i = 0; i < cmd_pool_size; i++) {
+		cmd_list_ptr = qdf_mem_malloc(sizeof(*cmd_list_ptr));
+		if (!cmd_list_ptr) {
+			ser_alert("Mem alloc failed for cmd node");
+			wlan_serialization_destroy_cmd_pool(pdev_queue);
+			goto error;
+		}
+
+		qdf_mem_zero(cmd_list_ptr, sizeof(*cmd_list_ptr));
+		qdf_list_insert_back(
+				     &pdev_queue->cmd_pool_list,
+				     &cmd_list_ptr->pdev_node);
+		cmd_list_ptr->cmd_in_use = 0;
+		ser_debug("Created node at %pK and inserted to pool",
+			  cmd_list_ptr);
+	}
+
+	status = QDF_STATUS_SUCCESS;
+
+error:
+	ser_exit();
+	return status;
+}
+
+/**
+ * wlan_serialization_pdev_create_handler() - PDEV obj create callback
+ * @pdev: PDEV object
+ * @arg_list: Variable argument list
+ *
+ * This callback is registered with object manager during initialization and
+ * when obj manager gets its turn to create the object, it would notify each
+ * component with the corresponding callback registered to inform the
+ * completion of the creation of the respective object.
+ *
+ * Return: QDF Status
+ */
+static QDF_STATUS wlan_serialization_pdev_create_handler(
+		struct wlan_objmgr_pdev *pdev, void *arg_list)
+{
+	struct wlan_ser_pdev_obj *ser_pdev_obj;
+	struct wlan_serialization_pdev_queue *pdev_queue;
+	QDF_STATUS status = QDF_STATUS_E_NOMEM;
+	uint8_t index;
+	uint8_t max_active_cmds;
+	uint8_t max_pending_cmds;
+	uint16_t cmd_pool_size;
+
+	ser_enter();
+
+	ser_pdev_obj =
+		qdf_mem_malloc(sizeof(*ser_pdev_obj));
+	if (!ser_pdev_obj) {
+		ser_alert("Mem alloc failed for ser pdev obj");
+		goto error;
+	}
+
+	for (index = 0; index < SER_PDEV_QUEUE_COMP_MAX; index++) {
+		pdev_queue = &ser_pdev_obj->pdev_q[index];
+
+		qdf_spinlock_create(&pdev_queue->pdev_queue_lock);
+
+		switch (index) {
+		case SER_PDEV_QUEUE_COMP_SCAN:
+			max_active_cmds = WLAN_SER_MAX_ACTIVE_SCAN_CMDS;
+			max_pending_cmds = WLAN_SER_MAX_PENDING_SCAN_CMDS;
+			cmd_pool_size = max_active_cmds + max_pending_cmds;
+			break;
+
+		case SER_PDEV_QUEUE_COMP_NON_SCAN:
+			max_active_cmds = WLAN_SER_MAX_ACTIVE_CMDS;
+			max_pending_cmds = WLAN_SER_MAX_PENDING_CMDS;
+			cmd_pool_size = max_active_cmds + max_pending_cmds;
+			break;
+		}
+		qdf_list_create(&pdev_queue->active_list,
+				max_active_cmds);
+		qdf_list_create(&pdev_queue->pending_list,
+				max_pending_cmds);
+		qdf_list_create(&pdev_queue->cmd_pool_list,
+				cmd_pool_size);
+
+		status = wlan_serialization_create_cmd_pool(pdev_queue,
+							    cmd_pool_size);
+		if (status != QDF_STATUS_SUCCESS) {
+			ser_err("ser_pdev_obj failed status %d", status);
+			goto error;
+	}
+
+		pdev_queue->vdev_active_cmd_bitmap = 0;
+		pdev_queue->blocking_cmd_active = 0;
+		pdev_queue->blocking_cmd_waiting = 0;
+	}
+
+	status = wlan_objmgr_pdev_component_obj_attach(
+			pdev, WLAN_UMAC_COMP_SERIALIZATION,
+			ser_pdev_obj, QDF_STATUS_SUCCESS);
+
+	if (status != QDF_STATUS_SUCCESS)
+		ser_err("serialization pdev obj attach failed");
+
+error:
+	ser_exit();
+	return status;
+}
+
+/**
+ * wlan_serialization_psoc_destroy_handler() - PSOC obj delete callback
+ * @psoc: PSOC object
+ * @arg_list: Variable argument list
+ *
+ * This callback is registered with object manager during initialization and
+ * when obj manager gets its turn to delete the object, it would notify each
+ * component with the corresponding callback registered to inform the
+ * completion of the deletion of the respective object.
+ *
+ * Return: QDF Status
+ */
+static QDF_STATUS
+wlan_serialization_psoc_destroy_handler(struct wlan_objmgr_psoc *psoc,
+					void *arg_list)
+{
+	QDF_STATUS status = QDF_STATUS_E_FAULT;
+	struct wlan_ser_psoc_obj *ser_soc_obj =
+		wlan_serialization_get_psoc_obj(psoc);
+
+	ser_enter();
+
+	if (!ser_soc_obj) {
+		ser_err("invalid ser_soc_obj");
+		goto error;
+	}
+	status = wlan_objmgr_psoc_component_obj_detach(
+			psoc, WLAN_UMAC_COMP_SERIALIZATION, ser_soc_obj);
+	if (status != QDF_STATUS_SUCCESS)
+		ser_err("ser psoc private obj detach failed");
+
+	ser_debug("ser psoc obj deleted with status %d", status);
+	qdf_mem_free(ser_soc_obj);
+
+error:
+	ser_exit();
+	return status;
+}
+
+/**
+ * wlan_serialization_pdev_destroy_handler() - PDEV obj delete callback
+ * @pdev: PDEV object
+ * @arg_list: Variable argument list
+ *
+ * This callback is registered with object manager during initialization and
+ * when obj manager gets its turn to delete the object, it would notify each
+ * component with the corresponding callback registered to inform the
+ * completion of the deletion of the respective object.
+ *
+ * Return: QDF Status
+ */
+static QDF_STATUS wlan_serialization_pdev_destroy_handler(
+		struct wlan_objmgr_pdev *pdev, void *arg_list)
+{
+	QDF_STATUS status;
+	struct wlan_serialization_pdev_queue *pdev_queue;
+	struct wlan_ser_pdev_obj *ser_pdev_obj =
+		wlan_serialization_get_pdev_obj(pdev);
+	uint8_t index;
+
+	ser_enter();
+
+	status = wlan_objmgr_pdev_component_obj_detach(
+			pdev, WLAN_UMAC_COMP_SERIALIZATION, ser_pdev_obj);
+
+	for (index = 0; index < SER_PDEV_QUEUE_COMP_MAX; index++) {
+		pdev_queue = &ser_pdev_obj->pdev_q[index];
+
+		wlan_serialization_destroy_pdev_list(pdev_queue);
+		wlan_serialization_destroy_cmd_pool(pdev_queue);
+
+		qdf_spinlock_destroy(&pdev_queue->pdev_queue_lock);
+	}
+
+	qdf_mem_free(ser_pdev_obj);
+
+	ser_exit();
+	return status;
+}
+
+/**
+ * wlan_serialization_vdev_create_handler() - VDEV obj create callback
+ * @vdev: VDEV object
+ * @arg_list: Variable argument list
+ *
+ * This callback is registered with object manager during initialization and
+ * when obj manager gets its turn to create the object, it would notify each
+ * component with the corresponding callback registered to inform the
+ * completion of the creation of the respective object.
+ *
+ * Return: QDF Status
+ */
+static QDF_STATUS
+wlan_serialization_vdev_create_handler(struct wlan_objmgr_vdev *vdev,
+				       void *arg_list)
+{
+	struct wlan_ser_vdev_obj *ser_vdev_obj;
+	struct wlan_serialization_vdev_queue *vdev_q;
+	QDF_STATUS status = QDF_STATUS_E_NOMEM;
+	uint8_t index;
+	uint8_t max_active_cmds;
+	uint8_t max_pending_cmds;
+
+	ser_enter();
+
+	ser_vdev_obj = qdf_mem_malloc(sizeof(*ser_vdev_obj));
+	if (!ser_vdev_obj) {
+		ser_alert("Mem alloc failed for ser vdev obj");
+		goto error;
+	}
+
+	for (index = 0; index < SER_VDEV_QUEUE_COMP_MAX; index++) {
+		vdev_q = &ser_vdev_obj->vdev_q[index];
+
+		switch (index) {
+		case SER_VDEV_QUEUE_COMP_NON_SCAN:
+			max_active_cmds = WLAN_SER_MAX_ACTIVE_CMDS /
+				WLAN_SER_MAX_VDEVS;
+			max_pending_cmds = WLAN_SER_MAX_PENDING_CMDS /
+				WLAN_SER_MAX_VDEVS;
+			break;
+		}
+
+		qdf_list_create(&vdev_q->active_list,
+				max_active_cmds);
+		qdf_list_create(&vdev_q->pending_list,
+				max_pending_cmds);
+	}
+
+	status = wlan_objmgr_vdev_component_obj_attach(
+			vdev, WLAN_UMAC_COMP_SERIALIZATION, ser_vdev_obj,
+			QDF_STATUS_SUCCESS);
+
+	if (status != QDF_STATUS_SUCCESS)
+		ser_err("serialization vdev obj attach failed");
+
+error:
+	ser_exit();
+	return status;
+}
+
+/**
+ * wlan_serialization_vdev_destroy_handler() - vdev obj delete callback
+ * @vdev: VDEV object
+ * @arg_list: Variable argument list
+ *
+ * This callback is registered with object manager during initialization and
+ * when obj manager gets its turn to delete the object, it would notify each
+ * component with the corresponding callback registered to inform the
+ * completion of the deletion of the respective object.
+ *
+ * Return: QDF Status
+ */
+static QDF_STATUS wlan_serialization_vdev_destroy_handler(
+		struct wlan_objmgr_vdev *vdev, void *arg_list)
+{
+	QDF_STATUS status = QDF_STATUS_SUCCESS;
+	struct wlan_serialization_vdev_queue *vdev_q;
+	struct wlan_ser_vdev_obj *ser_vdev_obj =
+		wlan_serialization_get_vdev_obj(vdev);
+	uint8_t vdev_id = wlan_vdev_get_id(vdev);
+	uint8_t index;
+
+	ser_enter();
+
+	status = wlan_objmgr_vdev_component_obj_detach(
+			vdev, WLAN_UMAC_COMP_SERIALIZATION, ser_vdev_obj);
+
+	for (index = 0; index < SER_VDEV_QUEUE_COMP_MAX; index++) {
+		vdev_q = &ser_vdev_obj->vdev_q[index];
+		wlan_serialization_destroy_vdev_list(&vdev_q->active_list);
+		wlan_serialization_destroy_vdev_list(&vdev_q->pending_list);
+	}
+
+	qdf_mem_free(ser_vdev_obj);
+	if (!ser_legacy_cb.serialization_purge_cmd_list)
+		goto error;
+
+	ser_debug("for vdev_id[%d] vdev[%pK] flush all cmds",
+		  vdev_id, vdev);
+	ser_legacy_cb.serialization_purge_cmd_list(wlan_vdev_get_psoc(vdev),
+						   vdev, false, false,
+						   false, false, true);
+
+error:
+	ser_exit();
+	return status;
+}
+
+QDF_STATUS wlan_serialization_init(void)
+{
+	QDF_STATUS status = QDF_STATUS_SUCCESS;
+
+	ser_enter();
+
+	status = wlan_objmgr_register_psoc_create_handler(
+			WLAN_UMAC_COMP_SERIALIZATION,
+			wlan_serialization_psoc_create_handler, NULL);
+	if (status != QDF_STATUS_SUCCESS) {
+		ser_err("Failed to reg soc ser obj create handler");
+		goto err_psoc_create;
+	}
+
+	status = wlan_objmgr_register_psoc_destroy_handler(
+			WLAN_UMAC_COMP_SERIALIZATION,
+			wlan_serialization_psoc_destroy_handler, NULL);
+	if (status != QDF_STATUS_SUCCESS) {
+		ser_err("Failed to reg soc ser obj delete handler");
+		goto err_psoc_delete;
+	}
+
+	status = wlan_objmgr_register_pdev_create_handler(
+			WLAN_UMAC_COMP_SERIALIZATION,
+			wlan_serialization_pdev_create_handler, NULL);
+	if (status != QDF_STATUS_SUCCESS) {
+		ser_err("Failed to reg pdev ser obj create handler");
+		goto err_pdev_create;
+	}
+
+	status = wlan_objmgr_register_pdev_destroy_handler(
+			WLAN_UMAC_COMP_SERIALIZATION,
+			wlan_serialization_pdev_destroy_handler, NULL);
+	if (status != QDF_STATUS_SUCCESS) {
+		ser_err("Failed to reg pdev ser obj delete handler");
+		goto err_pdev_delete;
+	}
+
+	status = wlan_objmgr_register_vdev_create_handler(
+			WLAN_UMAC_COMP_SERIALIZATION,
+			wlan_serialization_vdev_create_handler, NULL);
+	if (status != QDF_STATUS_SUCCESS) {
+		ser_err("Failed to reg vdev ser obj create handler");
+		goto err_vdev_create;
+	}
+
+	status = wlan_objmgr_register_vdev_destroy_handler(
+			WLAN_UMAC_COMP_SERIALIZATION,
+			wlan_serialization_vdev_destroy_handler, NULL);
+	if (status != QDF_STATUS_SUCCESS) {
+		ser_err("Failed to reg vdev ser obj delete handler");
+		goto err_vdev_delete;
+	}
+	ser_debug("serialization handlers registered with obj mgr");
+	/*
+	 * Initialize the structure so all callbacks are registered
+	 * initially as NULL.
+	 */
+	qdf_mem_zero(&ser_legacy_cb, sizeof(ser_legacy_cb));
+
+	status = QDF_STATUS_SUCCESS;
+	goto exit;
+
+err_vdev_delete:
+	wlan_objmgr_unregister_vdev_create_handler(
+			WLAN_UMAC_COMP_SERIALIZATION,
+			wlan_serialization_vdev_create_handler,
+			NULL);
+err_vdev_create:
+	wlan_objmgr_unregister_pdev_destroy_handler(
+			WLAN_UMAC_COMP_SERIALIZATION,
+			wlan_serialization_pdev_destroy_handler,
+			NULL);
+err_pdev_delete:
+	wlan_objmgr_unregister_pdev_create_handler(
+			WLAN_UMAC_COMP_SERIALIZATION,
+			wlan_serialization_pdev_create_handler,
+			NULL);
+err_pdev_create:
+	wlan_objmgr_unregister_psoc_destroy_handler(
+			WLAN_UMAC_COMP_SERIALIZATION,
+			wlan_serialization_psoc_destroy_handler,
+			NULL);
+err_psoc_delete:
+	wlan_objmgr_unregister_psoc_create_handler(
+			WLAN_UMAC_COMP_SERIALIZATION,
+			wlan_serialization_psoc_create_handler,
+			NULL);
+err_psoc_create:
+exit:
+	ser_exit();
+	return status;
+}
+
+QDF_STATUS wlan_serialization_deinit(void)
+{
+	QDF_STATUS status;
+	QDF_STATUS ret_status = QDF_STATUS_SUCCESS;
+
+	ser_enter();
+
+	status = wlan_objmgr_unregister_psoc_create_handler(
+			WLAN_UMAC_COMP_SERIALIZATION,
+			wlan_serialization_psoc_create_handler,
+			NULL);
+
+	if (status != QDF_STATUS_SUCCESS) {
+		ser_err("unreg fail for psoc ser obj create notf:%d", status);
+		ret_status = QDF_STATUS_E_FAILURE;
+	}
+	status = wlan_objmgr_unregister_psoc_destroy_handler(
+			WLAN_UMAC_COMP_SERIALIZATION,
+			wlan_serialization_psoc_destroy_handler,
+			NULL);
+
+	if (status != QDF_STATUS_SUCCESS) {
+		ser_err("unreg fail for psoc ser obj destroy notf:%d", status);
+		ret_status = QDF_STATUS_E_FAILURE;
+	}
+
+	status = wlan_objmgr_unregister_pdev_create_handler(
+			WLAN_UMAC_COMP_SERIALIZATION,
+			wlan_serialization_pdev_create_handler,
+			NULL);
+	if (status != QDF_STATUS_SUCCESS) {
+		ser_err("unreg fail for pdev ser obj create notf:%d", status);
+		ret_status = QDF_STATUS_E_FAILURE;
+	}
+
+	status = wlan_objmgr_unregister_pdev_destroy_handler(
+			WLAN_UMAC_COMP_SERIALIZATION,
+			wlan_serialization_pdev_destroy_handler,
+			NULL);
+
+	if (status != QDF_STATUS_SUCCESS) {
+		ser_err("unreg fail for pdev ser destroy notf:%d", status);
+		ret_status = QDF_STATUS_E_FAILURE;
+	}
+
+	ser_alert("deregistered callbacks with obj mgr successfully");
+	/*
+	 * Initialize the structure so all callbacks are registered
+	 * initially as NULL.
+	 */
+	qdf_mem_zero(&ser_legacy_cb, sizeof(ser_legacy_cb));
+
+	ser_exit();
+	return ret_status;
+}
+#endif

umac/cmn_services/serialization/src/wlan_serialization_main_i.h

@@ -22,6 +22,8 @@
  */
 #ifndef __WLAN_SERIALIZATION_MAIN_I_H
 #define __WLAN_SERIALIZATION_MAIN_I_H
+
+#ifdef CONFIG_SERIALIZATION_V1
 /* Include files */
 #include "wlan_objmgr_cmn.h"
 #include "wlan_objmgr_psoc_obj.h"
@@ -72,5 +74,54 @@ struct serialization_legacy_callback {
 	void (*serialization_purge_cmd_list) (struct wlan_objmgr_psoc *,
 		struct wlan_objmgr_vdev *, bool, bool, bool, bool, bool);
 };
+#else /*New serialization code*/
+/* Include files */
+#include <wlan_objmgr_cmn.h>
+#include <wlan_objmgr_psoc_obj.h>
+#include <wlan_objmgr_pdev_obj.h>
+#include <qdf_mc_timer.h>
+
+#define WLAN_SER_MAX_VDEVS 17
+
+#define WLAN_SER_MAX_ACTIVE_CMDS WLAN_SER_MAX_VDEVS
+#define WLAN_SER_MAX_PENDING_CMDS (WLAN_SER_MAX_VDEVS * 4)
 
+#define WLAN_SER_MAX_ACTIVE_SCAN_CMDS 8
+#define WLAN_SER_MAX_PENDING_SCAN_CMDS 24
+
+#define WLAN_SERIALIZATION_MAX_GLOBAL_POOL_CMDS \
+	(WLAN_SER_MAX_ACTIVE_CMDS + \
+	 WLAN_SER_MAX_PENDING_CMDS + \
+	 WLAN_SER_MAX_ACTIVE_SCAN_CMDS + \
+	 WLAN_SER_MAX_PENDING_SCAN_CMDS)
+
+#define ser_alert(params...) \
+	QDF_TRACE_FATAL(QDF_MODULE_ID_SERIALIZATION, params)
+#define ser_err(params...) \
+	QDF_TRACE_ERROR(QDF_MODULE_ID_SERIALIZATION, params)
+#define ser_warn(params...) \
+	QDF_TRACE_WARN(QDF_MODULE_ID_SERIALIZATION, params)
+#define ser_info(params...) \
+	QDF_TRACE_INFO(QDF_MODULE_ID_SERIALIZATION, params)
+#define ser_debug(params...) \
+	QDF_TRACE_DEBUG(QDF_MODULE_ID_SERIALIZATION, params)
+#define ser_enter() \
+	QDF_TRACE_ENTER(QDF_MODULE_ID_SERIALIZATION, "enter")
+#define ser_exit() \
+	QDF_TRACE_EXIT(QDF_MODULE_ID_SERIALIZATION, "exit")
+
+/**
+ * struct serialization_legacy_callback - to handle legacy serialization cb
+ * @serialization_purge_cmd_list: function ptr to be filled by serialization
+ *				  module
+ *
+ * Some of the legacy modules wants to call API to purge the commands in
+ * order to handle backward compatibility.
+ */
+struct serialization_legacy_callback {
+	void (*serialization_purge_cmd_list)(struct wlan_objmgr_psoc *,
+					     struct wlan_objmgr_vdev *,
+					     bool, bool, bool, bool, bool);
+};
+#endif
 #endif

umac/cmn_services/serialization/src/wlan_serialization_non_scan.c

@@ -0,0 +1,649 @@
+/*
+ * Copyright (c) 2017-2018 The Linux Foundation. All rights reserved.
+ *
+ * Permission to use, copy, modify, and/or distribute this software for
+ * any purpose with or without fee is hereby granted, provided that the
+ * above copyright notice and this permission notice appear in all
+ * copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+ * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+ * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+ * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+ * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ */
+/**
+ * DOC: wlan_serialization_non_scan.c
+ * This file defines the functions which deals with
+ * serialization non scan commands.
+ */
+
+#include <wlan_objmgr_psoc_obj.h>
+#include <wlan_objmgr_pdev_obj.h>
+#include <wlan_objmgr_vdev_obj.h>
+#include "wlan_serialization_main_i.h"
+#include "wlan_serialization_utils_i.h"
+#include "wlan_serialization_non_scan_i.h"
+
+/**
+ * wlan_serialization_is_active_nonscan_cmd_allowed() - find if cmd allowed
+ * @pdev: pointer to pdev object
+ *
+ * This API will be called to find out if non scan cmd is allowed.
+ *
+ * Return: true or false
+ */
+bool
+wlan_serialization_is_active_non_scan_cmd_allowed(
+		struct wlan_serialization_command *cmd)
+{
+	struct wlan_serialization_pdev_queue *pdev_queue;
+	struct wlan_ser_pdev_obj *ser_pdev_obj;
+	uint32_t vdev_active_cmd_bitmap;
+	bool blocking_cmd_active = 0;
+	uint8_t blocking_cmd_waiting = 0;
+	bool status = false;
+	uint32_t vdev_id;
+
+	ser_pdev_obj = wlan_serialization_get_pdev_obj(
+			wlan_serialization_get_pdev_from_cmd(cmd));
+
+	pdev_queue = wlan_serialization_get_pdev_queue_obj(ser_pdev_obj,
+							   cmd->cmd_type);
+
+	vdev_active_cmd_bitmap = pdev_queue->vdev_active_cmd_bitmap;
+	blocking_cmd_active = pdev_queue->blocking_cmd_active;
+	blocking_cmd_waiting = pdev_queue->blocking_cmd_waiting;
+
+	/*
+	 * Command is blocking
+	 */
+	if (cmd->is_blocking) {
+		/*
+		 * For blocking commands, no other
+		 * commands from any vdev should be active
+		 */
+		if (vdev_active_cmd_bitmap) {
+			status = false;
+			pdev_queue->blocking_cmd_waiting++;
+		} else {
+			status = true;
+		}
+	} else {
+		/*
+		 * Command is non blocking
+		 * For activating non blocking commands, if there any blocking
+		 * commands, waiting or active, put it to pending queue
+		 */
+		if (blocking_cmd_active || blocking_cmd_waiting) {
+			status = false;
+		} else {
+		/*
+		 * For non blocking command, and no blocking commands
+		 * waiting or active, check if a cmd for that vdev is active
+		 * If not active, put to active else pending queue
+		 */
+			vdev_id = wlan_vdev_get_id(cmd->vdev);
+			status = vdev_active_cmd_bitmap & (1 << vdev_id)
+						? false : true;
+		}
+	}
+	return status;
+}
+
+enum wlan_serialization_status wlan_ser_add_non_scan_cmd(
+		struct wlan_ser_pdev_obj *ser_pdev_obj,
+		struct wlan_serialization_command_list *cmd_list,
+		uint8_t is_cmd_for_active_queue)
+{
+	enum wlan_serialization_status pdev_status, vdev_status;
+	enum wlan_serialization_status status = WLAN_SER_CMD_DENIED_UNSPECIFIED;
+	struct wlan_serialization_command_list *pcmd_list;
+	uint8_t vdev_id;
+	struct wlan_serialization_pdev_queue *pdev_queue;
+
+	ser_debug("add non scan cmd: type[%d] id[%d] prio[%d] blocking[%d]",
+		  cmd_list->cmd.cmd_type,
+		  cmd_list->cmd.cmd_id,
+		  cmd_list->cmd.is_high_priority,
+		  cmd_list->cmd.is_blocking);
+
+	vdev_status = wlan_serialization_add_cmd_to_vdev_queue(
+			ser_pdev_obj, cmd_list, is_cmd_for_active_queue);
+
+	if (vdev_status == WLAN_SER_CMD_DENIED_LIST_FULL) {
+		status = vdev_status;
+		goto vdev_error;
+	}
+
+	if (is_cmd_for_active_queue) {
+		if (vdev_status != WLAN_SER_CMD_ACTIVE) {
+			ser_err("Failed to add to vdev active queue");
+			QDF_ASSERT(0);
+			goto vdev_error;
+		}
+	} else {
+		if (vdev_status != WLAN_SER_CMD_PENDING) {
+			ser_err("Failed to add to vdev pending queue");
+			QDF_ASSERT(0);
+			goto vdev_error;
+		}
+	}
+
+	pdev_status = wlan_serialization_add_cmd_to_pdev_queue(
+			ser_pdev_obj, cmd_list, is_cmd_for_active_queue);
+
+	if (pdev_status == WLAN_SER_CMD_DENIED_LIST_FULL) {
+		status = pdev_status;
+		goto pdev_error;
+	}
+
+	if (is_cmd_for_active_queue) {
+		if (pdev_status != WLAN_SER_CMD_ACTIVE) {
+			ser_err("Failed to add to pdev active queue");
+			QDF_ASSERT(0);
+			goto pdev_error;
+		}
+	} else {
+		if (pdev_status != WLAN_SER_CMD_PENDING) {
+			ser_err("Failed to add to pdev pending queue");
+			QDF_ASSERT(0);
+			goto pdev_error;
+		}
+	}
+pdev_error:
+	/*
+	 * If cmd added to vdev queue, but failed while
+	 * adding to pdev queue, remove cmd from vdev queue as well
+	 */
+	if (pdev_status != vdev_status) {
+		wlan_serialization_remove_cmd_from_vdev_queue(
+			ser_pdev_obj, &pcmd_list,
+			&cmd_list->cmd,
+			is_cmd_for_active_queue);
+	} else {
+		status = pdev_status;
+	}
+
+	if (is_cmd_for_active_queue) {
+		pdev_queue = wlan_serialization_get_pdev_queue_obj(
+				ser_pdev_obj, cmd_list->cmd.cmd_type);
+		vdev_id = wlan_vdev_get_id(cmd_list->cmd.vdev);
+		pdev_queue->vdev_active_cmd_bitmap |= (1 << vdev_id);
+
+		if (cmd_list->cmd.is_blocking)
+			pdev_queue->blocking_cmd_active = 1;
+	}
+
+vdev_error:
+	return status;
+}
+
+static
+struct wlan_serialization_command_list*
+wlan_serialization_get_next_non_scan_active_cmd(
+		struct wlan_ser_pdev_obj *ser_pdev_obj,
+		struct wlan_objmgr_vdev *vdev)
+{
+	qdf_list_t *pending_queue;
+	qdf_list_node_t *pending_node = NULL;
+	struct wlan_serialization_command_list *pending_cmd_list = NULL;
+	struct wlan_ser_vdev_obj *ser_vdev_obj;
+	struct wlan_serialization_vdev_queue *vdev_q_obj;
+	QDF_STATUS status;
+
+	ser_vdev_obj = wlan_serialization_get_vdev_obj(vdev);
+
+	vdev_q_obj = &ser_vdev_obj->vdev_q[SER_VDEV_QUEUE_COMP_NON_SCAN];
+	pending_queue = &vdev_q_obj->pending_list;
+
+	if (wlan_serialization_list_empty(pending_queue)) {
+		ser_debug("nothing to move from pending to active queue");
+		goto error;
+	}
+
+	status = wlan_serialization_get_cmd_from_queue(pending_queue,
+						       &pending_node);
+
+	if (status != QDF_STATUS_SUCCESS) {
+		ser_err("can't read cmd from queue");
+		pending_cmd_list = NULL;
+		goto error;
+	}
+
+	pending_cmd_list =
+		qdf_container_of(pending_node,
+				 struct wlan_serialization_command_list,
+				 vdev_node);
+
+	if (pending_cmd_list)
+		ser_debug("next non scan active cmd found from pending queue");
+
+error:
+	return pending_cmd_list;
+}
+
+enum wlan_serialization_status
+wlan_ser_move_multiple_non_scan_pending_to_active(
+		struct wlan_ser_pdev_obj *ser_pdev_obj)
+{
+	struct wlan_serialization_pdev_queue *pdev_queue;
+	qdf_list_t *active_queue;
+	qdf_list_t *pending_queue;
+	qdf_list_node_t *nnode = NULL;
+	struct wlan_serialization_command_list *pending_cmd_list;
+	struct wlan_serialization_command_list *active_cmd_list;
+	struct wlan_serialization_command cmd_to_remove;
+	uint32_t blocking_cmd_waiting;
+	uint32_t vdev_id;
+	uint32_t qsize;
+	bool vdev_cmd_active = 0;
+
+	enum wlan_serialization_status status = WLAN_SER_CMD_DENIED_UNSPECIFIED;
+	QDF_STATUS peek_status = QDF_STATUS_E_FAILURE;
+	QDF_STATUS qdf_status = QDF_STATUS_E_FAILURE;
+
+	pdev_queue = &ser_pdev_obj->pdev_q[SER_PDEV_QUEUE_COMP_NON_SCAN];
+	active_queue = &pdev_queue->active_list;
+	pending_queue = &pdev_queue->pending_list;
+	blocking_cmd_waiting = pdev_queue->blocking_cmd_waiting;
+
+	qsize =  wlan_serialization_list_size(pending_queue);
+	while (qsize--) {
+		peek_status = wlan_serialization_get_cmd_from_queue(
+				pending_queue, &nnode);
+		if (peek_status != QDF_STATUS_SUCCESS) {
+			ser_err("can't peek cmd");
+			break;
+		}
+
+		pending_cmd_list = qdf_container_of(
+				nnode, struct wlan_serialization_command_list,
+				pdev_node);
+		if (!pending_cmd_list) {
+			ser_debug(
+				"non scan cmd cannot move from pending to active");
+			goto error;
+		}
+
+		if (pending_cmd_list->cmd.is_blocking &&
+		    pdev_queue->vdev_active_cmd_bitmap) {
+			break;
+		}
+
+		vdev_id = wlan_vdev_get_id(pending_cmd_list->cmd.vdev);
+		vdev_cmd_active =
+			pdev_queue->vdev_active_cmd_bitmap & (1 << vdev_id);
+		if (vdev_cmd_active)
+			continue;
+
+		status = WLAN_SER_CMD_ACTIVE;
+
+		qdf_mem_copy(&cmd_to_remove, &pending_cmd_list->cmd,
+			     sizeof(struct wlan_serialization_command));
+
+		if (!wlan_serialization_is_active_cmd_allowed(&cmd_to_remove)) {
+			ser_debug("Can't add to active queue cmd_id:%d",
+				  cmd_to_remove.cmd_id);
+			continue;
+		}
+
+		qdf_status = wlan_ser_remove_non_scan_cmd(ser_pdev_obj,
+							  &pending_cmd_list,
+							  &cmd_to_remove,
+							  false);
+
+		if (QDF_STATUS_SUCCESS != qdf_status) {
+			ser_err("Can't remove cmd from pendingQ id-%d type-%d",
+				pending_cmd_list->cmd.cmd_id,
+				pending_cmd_list->cmd.cmd_type);
+			QDF_ASSERT(0);
+			status = WLAN_SER_CMD_DENIED_UNSPECIFIED;
+			goto error;
+		}
+
+		active_cmd_list = pending_cmd_list;
+
+		status = wlan_ser_add_non_scan_cmd(
+				ser_pdev_obj, active_cmd_list, true);
+
+		if (WLAN_SER_CMD_ACTIVE != status) {
+			ser_err("Can't move cmd to activeQ id-%d type-%d",
+				pending_cmd_list->cmd.cmd_id,
+				pending_cmd_list->cmd.cmd_type);
+			wlan_serialization_insert_back(
+				&pdev_queue->cmd_pool_list,
+				&active_cmd_list->pdev_node);
+			status = WLAN_SER_CMD_DENIED_UNSPECIFIED;
+			goto error;
+		}
+
+		qdf_atomic_set_bit(CMD_MARKED_FOR_ACTIVATION,
+				   &active_cmd_list->cmd_in_use);
+
+		nnode = NULL;
+		if (active_cmd_list->cmd.is_blocking)
+			pdev_queue->blocking_cmd_waiting--;
+
+		if (pending_cmd_list->cmd.is_blocking)
+			break;
+	}
+
+error:
+	return status;
+}
+
+enum wlan_serialization_status
+wlan_ser_move_non_scan_pending_to_active(
+		struct wlan_serialization_command_list **pcmd_list,
+		struct wlan_ser_pdev_obj *ser_pdev_obj,
+		struct wlan_objmgr_vdev *vdev)
+{
+	struct wlan_serialization_command_list *pending_cmd_list;
+	struct wlan_serialization_command_list *active_cmd_list;
+	struct wlan_serialization_command cmd_to_remove;
+	enum wlan_serialization_status status = WLAN_SER_CMD_DENIED_UNSPECIFIED;
+	QDF_STATUS qdf_status;
+	struct wlan_serialization_pdev_queue *pdev_queue;
+
+	pdev_queue = &ser_pdev_obj->pdev_q[SER_PDEV_QUEUE_COMP_NON_SCAN];
+
+	ser_enter();
+
+	if (!ser_pdev_obj) {
+		ser_err("Can't find ser_pdev_obj");
+		goto error;
+	}
+
+	pending_cmd_list =
+		wlan_serialization_get_next_non_scan_active_cmd(
+						ser_pdev_obj,
+						vdev);
+
+	if (!pending_cmd_list) {
+		ser_debug("non scan cmd cannot move from pending to active");
+		goto error;
+	}
+
+	qdf_mem_copy(&cmd_to_remove, &pending_cmd_list->cmd,
+		     sizeof(struct wlan_serialization_command));
+
+	qdf_status = wlan_ser_remove_non_scan_cmd(ser_pdev_obj,
+						  &pending_cmd_list,
+						  &cmd_to_remove, false);
+
+	if (QDF_STATUS_SUCCESS != qdf_status) {
+		ser_err("Can't remove cmd from pendingQ id-%d type-%d",
+			pending_cmd_list->cmd.cmd_id,
+			pending_cmd_list->cmd.cmd_type);
+		QDF_ASSERT(0);
+		status = WLAN_SER_CMD_DENIED_UNSPECIFIED;
+		goto error;
+	}
+
+	active_cmd_list = pending_cmd_list;
+
+	status = wlan_ser_add_non_scan_cmd(
+				ser_pdev_obj, active_cmd_list, true);
+
+	if (WLAN_SER_CMD_ACTIVE != status) {
+		ser_err("Can't move cmd to activeQ id-%d type-%d",
+			pending_cmd_list->cmd.cmd_id,
+			pending_cmd_list->cmd.cmd_type);
+		wlan_serialization_insert_back(
+			&pdev_queue->cmd_pool_list,
+			&active_cmd_list->pdev_node);
+		goto error;
+	}
+
+	qdf_atomic_set_bit(CMD_MARKED_FOR_ACTIVATION,
+			   &active_cmd_list->cmd_in_use);
+
+	*pcmd_list = active_cmd_list;
+
+error:
+	ser_exit();
+	return status;
+}
+
+QDF_STATUS wlan_ser_remove_non_scan_cmd(
+		struct wlan_ser_pdev_obj *ser_pdev_obj,
+		struct wlan_serialization_command_list **pcmd_list,
+		struct wlan_serialization_command *cmd,
+		uint8_t is_active_cmd)
+{
+	QDF_STATUS pdev_status, vdev_status;
+	QDF_STATUS status = QDF_STATUS_E_FAILURE;
+	uint32_t vdev_id;
+	bool blocking_cmd_removed = 0;
+	struct wlan_serialization_pdev_queue *pdev_queue;
+
+	ser_debug("remove non scan cmd: type[%d] id[%d] prio[%d] blocking[%d]",
+		  cmd->cmd_type,
+		  cmd->cmd_id,
+		  cmd->is_high_priority,
+		  cmd->is_blocking);
+
+	vdev_status =
+		wlan_serialization_remove_cmd_from_vdev_queue(ser_pdev_obj,
+							      pcmd_list,
+							      cmd,
+							      is_active_cmd);
+
+	if (vdev_status != QDF_STATUS_SUCCESS) {
+		ser_err("Failed to remove cmd from vdev active/pending queue");
+		goto error;
+	}
+
+	pdev_status =
+		wlan_serialization_remove_cmd_from_pdev_queue(ser_pdev_obj,
+							      pcmd_list,
+							      cmd,
+							      is_active_cmd);
+
+	if (pdev_status != QDF_STATUS_SUCCESS) {
+		ser_err("Failed to remove cmd from pdev active/pending queue");
+		goto error;
+	}
+
+	if (is_active_cmd) {
+		blocking_cmd_removed = (*pcmd_list)->cmd.is_blocking;
+		pdev_queue = wlan_serialization_get_pdev_queue_obj(
+				ser_pdev_obj, (*pcmd_list)->cmd.cmd_type);
+
+		if (blocking_cmd_removed)
+			pdev_queue->blocking_cmd_active = 0;
+
+		vdev_id = wlan_vdev_get_id(cmd->vdev);
+		pdev_queue->vdev_active_cmd_bitmap &= ~(1 << vdev_id);
+	}
+
+	status = QDF_STATUS_SUCCESS;
+
+error:
+	return status;
+}
+
+enum wlan_serialization_cmd_status
+wlan_ser_cancel_non_scan_cmd(
+		struct wlan_ser_pdev_obj *ser_pdev_obj,
+		struct wlan_objmgr_pdev *pdev, struct wlan_objmgr_vdev *vdev,
+		struct wlan_serialization_command *cmd,
+		enum wlan_serialization_cmd_type cmd_type,
+		uint8_t is_active_queue)
+{
+	qdf_list_t *pdev_queue;
+	qdf_list_t *vdev_queue;
+	struct wlan_serialization_pdev_queue *pdev_q;
+	uint32_t qsize;
+	struct wlan_serialization_command_list *cmd_list = NULL;
+	struct wlan_serialization_command cmd_bkup;
+	qdf_list_node_t *nnode = NULL, *pnode = NULL;
+	enum wlan_serialization_cmd_status status = WLAN_SER_CMD_NOT_FOUND;
+	struct wlan_objmgr_psoc *psoc = NULL;
+	QDF_STATUS qdf_status;
+	QDF_STATUS pdev_status, vdev_status;
+	struct wlan_ser_vdev_obj *ser_vdev_obj;
+
+	ser_enter();
+
+	pdev_q = wlan_serialization_get_pdev_queue_obj(ser_pdev_obj, cmd_type);
+
+	pdev_queue = wlan_serialization_get_list_from_pdev_queue(
+			ser_pdev_obj, cmd_type, is_active_queue);
+
+	if (pdev)
+		psoc = wlan_pdev_get_psoc(pdev);
+	else if (vdev)
+		psoc = wlan_vdev_get_psoc(vdev);
+	else if (cmd && cmd->vdev)
+		psoc = wlan_vdev_get_psoc(cmd->vdev);
+	else
+		ser_debug("Can't find psoc");
+
+	wlan_serialization_acquire_lock(pdev_q);
+
+	qsize = wlan_serialization_list_size(pdev_queue);
+	while (!wlan_serialization_list_empty(pdev_queue) && qsize--) {
+		if (wlan_serialization_get_cmd_from_queue(pdev_queue, &nnode)
+		    != QDF_STATUS_SUCCESS) {
+			ser_err("can't read cmd from queue");
+			status = WLAN_SER_CMD_NOT_FOUND;
+			break;
+		}
+		cmd_list =
+			qdf_container_of(nnode,
+					 struct wlan_serialization_command_list,
+					 pdev_node);
+		if (cmd && !wlan_serialization_match_cmd_id_type(
+							nnode, cmd,
+							WLAN_SER_PDEV_NODE)) {
+			pnode = nnode;
+			continue;
+		}
+
+		if (vdev &&
+		    !wlan_serialization_match_cmd_vdev(nnode,
+						      vdev,
+						      WLAN_SER_PDEV_NODE)) {
+			pnode = nnode;
+			continue;
+		}
+
+		if (pdev &&
+		    !wlan_serialization_match_cmd_pdev(nnode,
+						       pdev,
+						       WLAN_SER_PDEV_NODE)) {
+			pnode = nnode;
+			continue;
+		}
+
+		/*
+		 * active queue can't be removed directly, requester needs to
+		 * wait for active command response and send remove request for
+		 * active command separately
+		 */
+		if (is_active_queue) {
+			if (!psoc || !cmd_list) {
+				ser_err("psoc:0x%pK, cmd_list:0x%pK",
+					psoc, cmd_list);
+				status = WLAN_SER_CMD_NOT_FOUND;
+				break;
+			}
+
+			/* Cancel request received for a cmd in active
+			 * queue which has not been activated yet, we
+			 * should assert here
+			 */
+			if (qdf_atomic_test_bit(CMD_MARKED_FOR_ACTIVATION,
+						&cmd_list->cmd_in_use)) {
+				wlan_serialization_release_lock(pdev_q);
+				status = WLAN_SER_CMD_MARKED_FOR_ACTIVATION;
+				goto error;
+			}
+
+			qdf_status = wlan_serialization_find_and_stop_timer(
+							psoc, &cmd_list->cmd);
+			if (QDF_STATUS_SUCCESS != qdf_status) {
+				ser_err("Can't fix timer for active cmd");
+				status = WLAN_SER_CMD_NOT_FOUND;
+				break;
+			}
+			status = WLAN_SER_CMD_IN_ACTIVE_LIST;
+		}
+
+		qdf_mem_copy(&cmd_bkup, &cmd_list->cmd,
+			     sizeof(struct wlan_serialization_command));
+
+		pdev_status =
+			wlan_serialization_remove_node(pdev_queue,
+						       &cmd_list->pdev_node);
+
+		ser_vdev_obj = wlan_serialization_get_vdev_obj(
+					cmd_list->cmd.vdev);
+
+		vdev_queue = wlan_serialization_get_list_from_vdev_queue(
+			ser_vdev_obj, cmd_type, is_active_queue);
+
+		vdev_status =
+			wlan_serialization_remove_node(vdev_queue,
+						       &cmd_list->vdev_node);
+
+		if (pdev_status != QDF_STATUS_SUCCESS ||
+		    vdev_status != QDF_STATUS_SUCCESS) {
+			ser_err("can't remove cmd from pdev/vdev queue");
+			status = WLAN_SER_CMD_NOT_FOUND;
+			break;
+		}
+
+		qdf_mem_zero(&cmd_list->cmd,
+			     sizeof(struct wlan_serialization_command));
+
+		qdf_status = wlan_serialization_insert_back(
+			&pdev_q->cmd_pool_list,
+			&cmd_list->pdev_node);
+
+		if (QDF_STATUS_SUCCESS != qdf_status) {
+			ser_err("can't remove cmd from queue");
+			status = WLAN_SER_CMD_NOT_FOUND;
+			break;
+		}
+		nnode = pnode;
+
+		wlan_serialization_release_lock(pdev_q);
+		/*
+		 * call pending cmd's callback to notify that
+		 * it is being removed
+		 */
+		if (cmd_bkup.cmd_cb) {
+			/* caller should now do necessary clean up */
+			ser_debug("cmd cb: type[%d] id[%d]",
+				  cmd_bkup.cmd_type,
+				  cmd_bkup.cmd_id);
+			ser_debug("reason: WLAN_SER_CB_CANCEL_CMD");
+			cmd_bkup.cmd_cb(&cmd_bkup,
+					WLAN_SER_CB_CANCEL_CMD);
+			/* caller should release the memory */
+			ser_debug("reason: WLAN_SER_CB_RELEASE_MEM_CMD");
+			cmd_bkup.cmd_cb(&cmd_bkup,
+					WLAN_SER_CB_RELEASE_MEM_CMD);
+		}
+
+		wlan_serialization_acquire_lock(pdev_q);
+
+		if (!is_active_queue)
+			status = WLAN_SER_CMD_IN_PENDING_LIST;
+
+		if (!vdev && !pdev)
+			break;
+	}
+
+	wlan_serialization_release_lock(pdev_q);
+
+error:
+	ser_exit();
+	return status;
+}

umac/cmn_services/serialization/src/wlan_serialization_non_scan_i.h

@@ -0,0 +1,126 @@
+/*
+ * Copyright (c) 2017-2018 The Linux Foundation. All rights reserved.
+ *
+ * Permission to use, copy, modify, and/or distribute this software for
+ * any purpose with or without fee is hereby granted, provided that the
+ * above copyright notice and this permission notice appear in all
+ * copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+ * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+ * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+ * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+ * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ */
+
+/**
+ * DOC: wlan_serialization_non_scan_i.h
+ * This file defines the prototypes for functions which deals with
+ * serialization non scan commands.
+ */
+
+#ifndef __WLAN_SERIALIZATION_NON_SCAN_I_H
+#define __WLAN_SERIALIZATION_NON_SCAN_I_H
+
+#include <wlan_objmgr_vdev_obj.h>
+#include <wlan_objmgr_pdev_obj.h>
+#include <qdf_mc_timer.h>
+#include <wlan_utility.h>
+#include "wlan_serialization_utils_i.h"
+#include "wlan_serialization_main_i.h"
+#include "wlan_serialization_api.h"
+#include "wlan_serialization_internal_i.h"
+#include "wlan_serialization_queue_i.h"
+
+/**
+ * wlan_serialization_is_active_nonscan_cmd_allowed() - find if cmd allowed
+ *			to be enqueued in active queue
+ * @cmd: Serialization command information
+ *
+ * This API will be called to find out if non scan cmd is allowed.
+ *
+ * Return: true or false
+ */
+bool
+wlan_serialization_is_active_non_scan_cmd_allowed(
+		struct wlan_serialization_command *cmd);
+
+/**
+ * wlan_ser_add_non_scan_cmd() - Add a non-scan cmd to serialization queue
+ * @ser_pdev_obj: Serialization private pdev object
+ * @cmd_list: Command list with command info that is to be queued
+ * @is_cmd_for_active_queue: If the cmd to be enqueued in active queue or
+ *			pending queue
+ *
+ * Return: Status of the cmd's serialization request
+ */
+enum wlan_serialization_status
+wlan_ser_add_non_scan_cmd(
+		struct wlan_ser_pdev_obj *ser_pdev_obj,
+		struct wlan_serialization_command_list *cmd_list,
+		uint8_t is_cmd_for_active_queue);
+/**
+ * wlan_ser_move_non_scan_pending_to_active() - Move a non-scan cmd from pending
+ *			queue to active queue
+ * @pcmd_list: Pointer to command list containing the command
+ * @ser_pdev_obj: Serialization private pdev object
+ * @vdev: Pointer to object manager vdev
+ *
+ * Return: Status of the cmd's serialization request
+ */
+enum wlan_serialization_status
+wlan_ser_move_non_scan_pending_to_active(
+		struct wlan_serialization_command_list **pcmd_list,
+		struct wlan_ser_pdev_obj *ser_pdev_obj,
+		struct wlan_objmgr_vdev *vdev);
+
+/**
+ * wlan_ser_move_multiple_non_scan_pending_to_active() - Move multiple non-scan
+ *			cmd from pending queue to active queue
+ * @ser_pdev_obj: Serialization private pdev object
+ *
+ * Return: Status of the cmd's serialization request
+ */
+enum wlan_serialization_status
+wlan_ser_move_multiple_non_scan_pending_to_active(
+		struct wlan_ser_pdev_obj *ser_pdev_obj);
+
+/**
+ * wlan_ser_remove_non_scan_cmd() - Remove a non-scan cmd from the given queue
+ * @ser_pdev_obj: Serialization private pdev object
+ * @pcmd_list: Pointer to command list containing the command
+ * @cmd: Serialization command information
+ * @is_active_cmd: If the cmd has to be removed from active queue or pending
+ *			queue
+ *
+ * Return: QDF_STATUS_SUCCESS on successfully removing the cmd else
+ *			QDF_STATUS_E_FAILURE
+ */
+QDF_STATUS
+wlan_ser_remove_non_scan_cmd(struct wlan_ser_pdev_obj *ser_pdev_obj,
+			     struct wlan_serialization_command_list **pcmd_list,
+			     struct wlan_serialization_command *cmd,
+			     uint8_t is_active_cmd);
+/**
+ * wlan_ser_cancel_non_scan_cmd() - Cancel a non-scan cmd from the given queue
+ * @ser_obj: Serialization private pdev object
+ * @pdev: Pointer to object manager pdev
+ * @vdev: Pointer to object manager vdev
+ * @cmd: Serialization command information
+ * @cmd_type: Serialization command type to be cancelled
+ * @is_active_queue: If the cmd has to be removed from active queue or pending
+ *			queue
+ *
+ * Return: Status specifying the cancel of a command from the given queue
+ */
+enum wlan_serialization_cmd_status
+wlan_ser_cancel_non_scan_cmd(struct wlan_ser_pdev_obj *ser_obj,
+			     struct wlan_objmgr_pdev *pdev,
+			     struct wlan_objmgr_vdev *vdev,
+			     struct wlan_serialization_command *cmd,
+			     enum wlan_serialization_cmd_type cmd_type,
+			     uint8_t is_active_queue);
+#endif

umac/cmn_services/serialization/src/wlan_serialization_queue.c

@@ -0,0 +1,198 @@
+/*
+ * Copyright (c) 2017-2018 The Linux Foundation. All rights reserved.
+ *
+ * Permission to use, copy, modify, and/or distribute this software for
+ * any purpose with or without fee is hereby granted, provided that the
+ * above copyright notice and this permission notice appear in all
+ * copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+ * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+ * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+ * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+ * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ */
+/**
+ * DOC: wlan_serialization_queue.c
+ * This file defines the functions which deals with the
+ * serialization queue objects.
+ */
+#include <wlan_objmgr_vdev_obj.h>
+#include <wlan_objmgr_pdev_obj.h>
+#include <wlan_objmgr_psoc_obj.h>
+#include <qdf_list.h>
+#include <qdf_status.h>
+#include "wlan_serialization_api.h"
+#include "wlan_serialization_main_i.h"
+#include "wlan_serialization_utils_i.h"
+#include "wlan_serialization_queue_i.h"
+
+struct wlan_serialization_pdev_queue *wlan_serialization_get_pdev_queue_obj(
+		struct wlan_ser_pdev_obj *pdev_obj,
+		enum wlan_serialization_cmd_type cmd_type)
+{
+	struct wlan_serialization_pdev_queue *pdev_queue = NULL;
+
+	if (cmd_type < WLAN_SER_CMD_NONSCAN)
+		pdev_queue = &pdev_obj->pdev_q[SER_PDEV_QUEUE_COMP_SCAN];
+	else
+		pdev_queue = &pdev_obj->pdev_q[SER_PDEV_QUEUE_COMP_NON_SCAN];
+
+	return pdev_queue;
+}
+
+struct wlan_serialization_vdev_queue *wlan_serialization_get_vdev_queue_obj(
+		struct wlan_ser_vdev_obj *vdev_obj,
+		enum wlan_serialization_cmd_type cmd_type)
+{
+	struct wlan_serialization_vdev_queue *vdev_queue = NULL;
+
+	vdev_queue = &vdev_obj->vdev_q[SER_VDEV_QUEUE_COMP_NON_SCAN];
+
+	return vdev_queue;
+}
+
+qdf_list_t *wlan_serialization_get_list_from_pdev_queue(
+		struct wlan_ser_pdev_obj *pdev_obj,
+		enum wlan_serialization_cmd_type cmd_type,
+		uint8_t is_active_cmd)
+{
+	struct wlan_serialization_pdev_queue *pdev_queue;
+	qdf_list_t *queue = NULL;
+
+	pdev_queue = wlan_serialization_get_pdev_queue_obj(pdev_obj, cmd_type);
+	if (is_active_cmd)
+		queue = &pdev_queue->active_list;
+	else
+		queue = &pdev_queue->pending_list;
+
+	return queue;
+}
+
+qdf_list_t *wlan_serialization_get_list_from_vdev_queue(
+		struct wlan_ser_vdev_obj *vdev_obj,
+		enum wlan_serialization_cmd_type cmd_type,
+		uint8_t is_active_cmd)
+{
+	struct wlan_serialization_vdev_queue *vdev_queue;
+	qdf_list_t *queue = NULL;
+
+	vdev_queue = wlan_serialization_get_vdev_queue_obj(vdev_obj, cmd_type);
+	if (is_active_cmd)
+		queue = &vdev_queue->active_list;
+	else
+		queue = &vdev_queue->pending_list;
+
+	return queue;
+}
+
+enum wlan_serialization_status
+wlan_serialization_add_cmd_to_pdev_queue(
+		struct wlan_ser_pdev_obj *pdev_obj,
+		struct wlan_serialization_command_list *cmd_list,
+		uint8_t for_active_queue)
+{
+	qdf_list_t *queue;
+	enum wlan_serialization_status status = WLAN_SER_CMD_DENIED_UNSPECIFIED;
+
+	if (!pdev_obj) {
+		ser_err("invalid serialization pdev");
+		status = WLAN_SER_CMD_DENIED_UNSPECIFIED;
+		goto error;
+	}
+
+	queue = wlan_serialization_get_list_from_pdev_queue(
+			pdev_obj, cmd_list->cmd.cmd_type, for_active_queue);
+
+	status = wlan_serialization_add_cmd_to_queue(queue, cmd_list,
+						     pdev_obj,
+						     for_active_queue,
+						     WLAN_SER_PDEV_NODE);
+
+error:
+	return status;
+}
+
+enum wlan_serialization_status
+wlan_serialization_add_cmd_to_vdev_queue(
+		struct wlan_ser_pdev_obj *pdev_obj,
+		struct wlan_serialization_command_list *cmd_list,
+		uint8_t for_active_queue)
+{
+	qdf_list_t *queue;
+	enum wlan_serialization_status status;
+	struct wlan_serialization_command *cmd;
+	struct wlan_ser_vdev_obj *vdev_obj;
+
+	cmd = &cmd_list->cmd;
+
+	vdev_obj = wlan_serialization_get_vdev_obj(
+			wlan_serialization_get_vdev_from_cmd(cmd));
+
+	queue = wlan_serialization_get_list_from_vdev_queue(vdev_obj,
+							    cmd->cmd_type,
+							    for_active_queue);
+
+	status = wlan_serialization_add_cmd_to_queue(queue, cmd_list,
+						     pdev_obj,
+						     for_active_queue,
+						     WLAN_SER_VDEV_NODE);
+
+	return status;
+}
+
+QDF_STATUS
+wlan_serialization_remove_cmd_from_pdev_queue(
+		struct wlan_ser_pdev_obj *pdev_obj,
+		struct wlan_serialization_command_list **pcmd_list,
+		struct wlan_serialization_command *cmd,
+		uint8_t is_active_queue)
+{
+	qdf_list_t *queue;
+	QDF_STATUS status = QDF_STATUS_E_FAILURE;
+
+	if (!pdev_obj) {
+		ser_err("Invalid pdev");
+		return status;
+	}
+
+	queue = wlan_serialization_get_list_from_pdev_queue(
+			pdev_obj, cmd->cmd_type, is_active_queue);
+
+	status = wlan_serialization_remove_cmd_from_queue(queue, cmd,
+							  pcmd_list,
+							  pdev_obj,
+							  WLAN_SER_PDEV_NODE);
+
+	return status;
+}
+
+QDF_STATUS
+wlan_serialization_remove_cmd_from_vdev_queue(
+		struct wlan_ser_pdev_obj *pdev_obj,
+		struct wlan_serialization_command_list **pcmd_list,
+		struct wlan_serialization_command *cmd,
+		uint8_t is_active_queue)
+{
+	qdf_list_t *queue;
+	QDF_STATUS status = QDF_STATUS_E_FAILURE;
+	struct wlan_ser_vdev_obj *vdev_obj;
+
+	vdev_obj = wlan_serialization_get_vdev_obj(
+			wlan_serialization_get_vdev_from_cmd(cmd));
+
+	queue = wlan_serialization_get_list_from_vdev_queue(vdev_obj,
+							    cmd->cmd_type,
+							    is_active_queue);
+
+	status = wlan_serialization_remove_cmd_from_queue(queue, cmd,
+							  pcmd_list,
+							  pdev_obj,
+							  WLAN_SER_VDEV_NODE);
+
+	return status;
+}
+

umac/cmn_services/serialization/src/wlan_serialization_queue_i.h

@@ -0,0 +1,148 @@
+/*
+ * Copyright (c) 2017-2018 The Linux Foundation. All rights reserved.
+ *
+ * Permission to use, copy, modify, and/or distribute this software for
+ * any purpose with or without fee is hereby granted, provided that the
+ * above copyright notice and this permission notice appear in all
+ * copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+ * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+ * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+ * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+ * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ */
+
+/**
+ * DOC: wlan_serialization_queue_i.h
+ * This file defines the prototpye for functions which deals with the
+ * serialization queue objects.
+ */
+#ifndef __WLAN_SERIALIZATION_QUEUE_I_H
+#define __WLAN_SERIALIZATION_QUEUE_I_H
+
+#include <wlan_serialization_api.h>
+#include "wlan_serialization_main_i.h"
+#include "wlan_serialization_utils_i.h"
+#include <wlan_objmgr_vdev_obj.h>
+#include <wlan_objmgr_pdev_obj.h>
+#include <wlan_objmgr_psoc_obj.h>
+#include <qdf_list.h>
+#include <qdf_status.h>
+
+/**
+ * wlan_serialization_get_pdev_queue_obj() - Get serialization pdev queue for
+ *			the given cmd_type
+ * @pdev_obj: Serialization private pdev object
+ * @cmd_type: Serialization command type i.e scan or non-scan
+ *
+ * Return: Pointer to serialization pdev queue
+ */
+struct wlan_serialization_pdev_queue *wlan_serialization_get_pdev_queue_obj(
+		struct wlan_ser_pdev_obj *pdev_obj,
+		enum wlan_serialization_cmd_type cmd_type);
+
+/**
+ * wlan_serialization_get_vdev_queue_obj() - Get serialization vdev queue for
+ *			the given cmd_type
+ * @vdev_obj: Serialization private vdev object
+ * @cmd_type: Serialization command type i.e scan or non-scan
+ *
+ * Return: Pointer to serialization vdev queue
+ */
+struct wlan_serialization_vdev_queue *wlan_serialization_get_vdev_queue_obj(
+		struct wlan_ser_vdev_obj *vdev_obj,
+		enum wlan_serialization_cmd_type cmd_type);
+
+/**
+ * wlan_serialization_get_list_from_pdev_queue() - Get list member from the pdev
+ *			queue for the given cmd type
+ * @pdev_obj: Serialization private pdev object
+ * @cmd_type: Serialization command type i.e scan or non-scan
+ * @is_active_cmd: Get list from active queue or pending queue
+ *
+ * Return: Pointer to the obtained list member
+ */
+qdf_list_t *wlan_serialization_get_list_from_pdev_queue(
+		struct wlan_ser_pdev_obj *pdev_obj,
+		enum wlan_serialization_cmd_type cmd_type,
+		uint8_t is_active_cmd);
+
+/**
+ * wlan_serialization_get_list_from_vdev_queue() - Get list member from the vdev
+ *			queue for the given cmd type
+ * @vdev_obj: Serialization private vdev object
+ * @cmd_type: Serialization command type i.e scan or non-scan
+ * @is_active_cmd: Get list from active queue or pending queue
+ *
+ * Return: Pointer to the obtained list member
+ */
+qdf_list_t *wlan_serialization_get_list_from_vdev_queue(
+		struct wlan_ser_vdev_obj *vdev_obj,
+		enum wlan_serialization_cmd_type cmd_type,
+		uint8_t is_active_cmd);
+
+/**
+ * wlan_serialization_add_cmd_to_pdev_queue() - Add given cmd to the pdev
+ *			queue for the given cmd type
+ * @pdev_obj: Serialization private pdev object
+ * @cmd_list: Pointer to command list containing the command
+ * @is_cmd_for_active_queue: Add to active queue or pending queue
+ *
+ * Return: Status of the cmd's serialization request
+ */
+enum wlan_serialization_status wlan_serialization_add_cmd_to_pdev_queue(
+		struct wlan_ser_pdev_obj *pdev_obj,
+		struct wlan_serialization_command_list *cmd_list,
+		uint8_t is_cmd_for_active_queue);
+
+/**
+ * wlan_serialization_add_cmd_to_vdev_queue() - Add given cmd to the vdev
+ *			queue for the given cmd type
+ * @pdev_obj: Serialization private pdev object
+ * @cmd_list: Pointer to command list containing the command
+ * @is_cmd_for_active_queue: Add to active queue or pending queue
+ *
+ * Return: Status of the cmd's serialization request
+ */
+enum wlan_serialization_status wlan_serialization_add_cmd_to_vdev_queue(
+		struct wlan_ser_pdev_obj *pdev_obj,
+		struct wlan_serialization_command_list *cmd_list,
+		uint8_t is_cmd_for_active_queue);
+
+/**
+ * wlan_serialization_remove_cmd_from_pdev_queue() - Remove given cmd from
+ *			the pdev queue for the given cmd type
+ * @pdev_obj: Serialization private pdev object
+ * @pcmd_list: Pointer to command list containing the command
+ * @cmd: Serialization command information
+ * @is_active_queue: Remove from active queue or pending queue
+ *
+ * Return: QDF_STATUS_SUCCESS on success, error code on failure
+ */
+QDF_STATUS wlan_serialization_remove_cmd_from_pdev_queue(
+		struct wlan_ser_pdev_obj *pdev_obj,
+		struct wlan_serialization_command_list **pcmd_list,
+		struct wlan_serialization_command *cmd,
+		uint8_t is_active_queue);
+
+/**
+ * wlan_serialization_remove_cmd_from_vdev_queue() - Remove given cmd from
+ *			the vdev queue for the given cmd type
+ * @pdev_obj: Serialization private pdev object
+ * @pcmd_list: Pointer to command list containing the command
+ * @cmd: Serialization command information
+ * @is_active_queue: Remove from active queue or pending queue
+ *
+ * Return: QDF_STATUS_SUCCESS on success, error code on failure
+ */
+QDF_STATUS wlan_serialization_remove_cmd_from_vdev_queue(
+		struct wlan_ser_pdev_obj *pdev_obj,
+		struct wlan_serialization_command_list **pcmd_list,
+		struct wlan_serialization_command *cmd,
+		uint8_t is_active_queue);
+
+#endif

umac/cmn_services/serialization/src/wlan_serialization_scan.c

@@ -0,0 +1,424 @@
+/*
+ * Copyright (c) 2017-2018 The Linux Foundation. All rights reserved.
+ *
+ * Permission to use, copy, modify, and/or distribute this software for
+ * any purpose with or without fee is hereby granted, provided that the
+ * above copyright notice and this permission notice appear in all
+ * copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+ * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+ * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+ * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+ * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ */
+
+/**
+ * DOC: wlan_serialization_scan.c
+ * This file defines the functions which deals with
+ * serialization scan commands.
+ */
+
+#include "wlan_serialization_utils_i.h"
+#include "wlan_serialization_main_i.h"
+#include "wlan_serialization_api.h"
+#include "wlan_serialization_scan_i.h"
+#include <wlan_objmgr_vdev_obj.h>
+#include <wlan_objmgr_pdev_obj.h>
+#include <qdf_mc_timer.h>
+#include <wlan_utility.h>
+
+void
+wlan_serialization_active_scan_cmd_count_handler(struct wlan_objmgr_psoc *psoc,
+						 void *obj, void *arg)
+{
+	struct wlan_objmgr_pdev *pdev = obj;
+	struct wlan_ser_pdev_obj *ser_pdev_obj;
+	struct wlan_serialization_pdev_queue *pdev_q;
+	uint32_t *count = arg;
+
+	if (!pdev) {
+		ser_err("invalid pdev");
+		return;
+	}
+
+	ser_pdev_obj = wlan_objmgr_pdev_get_comp_private_obj(
+			pdev, WLAN_UMAC_COMP_SERIALIZATION);
+
+	pdev_q = &ser_pdev_obj->pdev_q[SER_PDEV_QUEUE_COMP_SCAN];
+	*count += wlan_serialization_list_size(&pdev_q->active_list);
+}
+
+bool
+wlan_serialization_is_active_scan_cmd_allowed(
+		struct wlan_serialization_command *cmd)
+{
+	uint32_t count = 0;
+	struct wlan_objmgr_pdev *pdev = NULL;
+	struct wlan_objmgr_psoc *psoc;
+	bool status = false;
+
+	pdev = wlan_serialization_get_pdev_from_cmd(cmd);
+	if (!pdev) {
+		ser_err("invalid pdev");
+		goto error;
+	}
+
+	psoc = wlan_pdev_get_psoc(pdev);
+	if (!psoc) {
+		ser_err("invalid psoc");
+		goto error;
+	}
+
+	wlan_objmgr_iterate_obj_list(
+			psoc, WLAN_PDEV_OP,
+			wlan_serialization_active_scan_cmd_count_handler,
+			&count, 1, WLAN_SERIALIZATION_ID);
+	if (count < ucfg_scan_get_max_active_scans(psoc)) {
+		ser_debug("count is [%d]", count);
+		status =  true;
+	}
+
+error:
+	return status;
+}
+
+bool wlan_ser_match_cmd_scan_id(
+			qdf_list_node_t *nnode,
+			struct wlan_serialization_command **cmd,
+			uint16_t scan_id, struct wlan_objmgr_vdev *vdev)
+{
+	struct wlan_serialization_command_list *cmd_list = NULL;
+	bool match_found = false;
+
+	cmd_list = qdf_container_of(nnode,
+				    struct wlan_serialization_command_list,
+				    pdev_node);
+	if ((cmd_list->cmd.cmd_id == scan_id) &&
+	    (cmd_list->cmd.vdev == vdev)) {
+		*cmd = &cmd_list->cmd;
+		match_found = true;
+	};
+
+	ser_debug("match found: %d", match_found);
+
+	return match_found;
+}
+
+enum wlan_serialization_status
+wlan_ser_add_scan_cmd(
+		struct wlan_ser_pdev_obj *ser_pdev_obj,
+		struct wlan_serialization_command_list *cmd_list,
+		uint8_t is_cmd_for_active_queue)
+{
+	enum wlan_serialization_status status;
+
+	ser_debug("add scan cmd: type[%d] id[%d] prio[%d] blocking[%d]",
+		  cmd_list->cmd.cmd_type,
+		  cmd_list->cmd.cmd_id,
+		  cmd_list->cmd.is_high_priority,
+		  cmd_list->cmd.is_blocking);
+
+	status = wlan_serialization_add_cmd_to_pdev_queue(
+			ser_pdev_obj, cmd_list,
+			is_cmd_for_active_queue);
+
+	return status;
+}
+
+QDF_STATUS
+wlan_ser_remove_scan_cmd(
+		struct wlan_ser_pdev_obj *ser_pdev_obj,
+		struct wlan_serialization_command_list **pcmd_list,
+		struct wlan_serialization_command *cmd,
+		uint8_t is_active_cmd)
+{
+	QDF_STATUS status;
+
+	ser_debug("remove scan cmd: type[%d] id[%d] prio[%d] blocking[%d]",
+		  cmd->cmd_type,
+		  cmd->cmd_id,
+		  cmd->is_high_priority,
+		  cmd->is_blocking);
+
+	status = wlan_serialization_remove_cmd_from_pdev_queue(
+			ser_pdev_obj, pcmd_list, cmd, is_active_cmd);
+
+	return status;
+}
+
+enum wlan_serialization_cmd_status
+wlan_ser_cancel_scan_cmd(
+		struct wlan_ser_pdev_obj *ser_obj,
+		struct wlan_objmgr_pdev *pdev, struct wlan_objmgr_vdev *vdev,
+		struct wlan_serialization_command *cmd,
+		enum wlan_serialization_cmd_type cmd_type,
+		uint8_t is_active_queue)
+{
+	qdf_list_t *queue;
+	struct wlan_serialization_pdev_queue *pdev_q;
+	uint32_t qsize;
+	struct wlan_serialization_command_list *cmd_list = NULL;
+	struct wlan_serialization_command cmd_bkup;
+	qdf_list_node_t *nnode = NULL, *pnode = NULL;
+	enum wlan_serialization_cmd_status status = WLAN_SER_CMD_NOT_FOUND;
+	struct wlan_objmgr_psoc *psoc = NULL;
+	QDF_STATUS qdf_status;
+
+	ser_enter();
+
+	pdev_q = &ser_obj->pdev_q[SER_PDEV_QUEUE_COMP_SCAN];
+
+	if (is_active_queue)
+		queue = &pdev_q->active_list;
+	else
+		queue = &pdev_q->pending_list;
+
+	if (pdev)
+		psoc = wlan_pdev_get_psoc(pdev);
+	else if (vdev)
+		psoc = wlan_vdev_get_psoc(vdev);
+	else if (cmd && cmd->vdev)
+		psoc = wlan_vdev_get_psoc(cmd->vdev);
+	else
+		ser_debug("Can't find psoc");
+
+	wlan_serialization_acquire_lock(pdev_q);
+
+	qsize = wlan_serialization_list_size(queue);
+	while (!wlan_serialization_list_empty(queue) && qsize--) {
+		if (wlan_serialization_get_cmd_from_queue(
+					queue, &nnode) != QDF_STATUS_SUCCESS) {
+			ser_err("can't read cmd from queue");
+			status = WLAN_SER_CMD_NOT_FOUND;
+			break;
+		}
+		cmd_list =
+			qdf_container_of(nnode,
+					 struct wlan_serialization_command_list,
+					 pdev_node);
+
+		if (cmd && !wlan_serialization_match_cmd_id_type(
+							nnode, cmd,
+							WLAN_SER_PDEV_NODE)) {
+			pnode = nnode;
+			continue;
+		}
+		if (vdev &&
+		    !wlan_serialization_match_cmd_vdev(nnode,
+						      vdev,
+						      WLAN_SER_PDEV_NODE)) {
+			pnode = nnode;
+			continue;
+		}
+
+		if (pdev &&
+		    !wlan_serialization_match_cmd_pdev(nnode,
+						       pdev,
+						       WLAN_SER_PDEV_NODE)) {
+			pnode = nnode;
+			continue;
+		}
+
+		/*
+		 * active queue can't be removed directly, requester needs to
+		 * wait for active command response and send remove request for
+		 * active command separately
+		 */
+		if (is_active_queue) {
+			if (!psoc || !cmd_list) {
+				ser_err("psoc:0x%pK, cmd_list:0x%pK",
+					psoc, cmd_list);
+				status = WLAN_SER_CMD_NOT_FOUND;
+				break;
+			}
+
+			/* Cancel request received for a cmd in active
+			 * queue which has not been activated yet, we
+			 * should assert here
+			 */
+			if (qdf_atomic_test_bit(CMD_MARKED_FOR_ACTIVATION,
+						&cmd_list->cmd_in_use)) {
+				wlan_serialization_release_lock(pdev_q);
+				status = WLAN_SER_CMD_MARKED_FOR_ACTIVATION;
+				goto error;
+			}
+
+			qdf_status = wlan_serialization_find_and_stop_timer(
+							psoc, &cmd_list->cmd);
+			if (QDF_STATUS_SUCCESS != qdf_status) {
+				ser_err("Can't fix timer for active cmd");
+				status = WLAN_SER_CMD_NOT_FOUND;
+				break;
+			}
+			status = WLAN_SER_CMD_IN_ACTIVE_LIST;
+		}
+
+		qdf_mem_copy(&cmd_bkup, &cmd_list->cmd,
+			     sizeof(struct wlan_serialization_command));
+
+		qdf_status =
+			wlan_serialization_remove_node(queue,
+						       &cmd_list->pdev_node);
+
+		if (qdf_status != QDF_STATUS_SUCCESS) {
+			ser_err("can't remove cmd from pdev queue");
+			status = WLAN_SER_CMD_NOT_FOUND;
+			break;
+		}
+
+		qdf_mem_zero(&cmd_list->cmd,
+			     sizeof(struct wlan_serialization_command));
+
+		qdf_status = wlan_serialization_insert_back(
+			&pdev_q->cmd_pool_list,
+			&cmd_list->pdev_node);
+
+		if (QDF_STATUS_SUCCESS != qdf_status) {
+			ser_err("can't remove cmd from queue");
+			status = WLAN_SER_CMD_NOT_FOUND;
+			break;
+		}
+		nnode = pnode;
+
+		wlan_serialization_release_lock(pdev_q);
+		/*
+		 * call pending cmd's callback to notify that
+		 * it is being removed
+		 */
+		if (cmd_bkup.cmd_cb) {
+			ser_debug("cmd cb: type[%d] id[%d]",
+				  cmd_bkup.cmd_type,
+				  cmd_bkup.cmd_id);
+			ser_debug("reason: WLAN_SER_CB_CANCEL_CMD");
+
+			cmd_bkup.cmd_cb(&cmd_bkup,
+					WLAN_SER_CB_CANCEL_CMD);
+
+			ser_debug("reason: WLAN_SER_CB_RELEASE_MEM_CMD");
+			cmd_bkup.cmd_cb(&cmd_bkup,
+					WLAN_SER_CB_RELEASE_MEM_CMD);
+		}
+
+		wlan_serialization_acquire_lock(pdev_q);
+
+		if (!is_active_queue)
+			status = WLAN_SER_CMD_IN_PENDING_LIST;
+	}
+
+	wlan_serialization_release_lock(pdev_q);
+
+error:
+	ser_exit();
+	return status;
+}
+
+static struct wlan_serialization_command_list*
+wlan_serialization_get_next_scan_active_cmd(
+		struct wlan_ser_pdev_obj *ser_pdev_obj)
+{
+	qdf_list_t *pending_queue;
+	qdf_list_node_t *pending_node = NULL;
+	struct wlan_serialization_command_list *pending_cmd_list = NULL;
+	struct wlan_serialization_pdev_queue *pdev_q;
+	QDF_STATUS status;
+
+	pdev_q = &ser_pdev_obj->pdev_q[SER_PDEV_QUEUE_COMP_SCAN];
+
+	pending_queue = &pdev_q->pending_list;
+
+	if (wlan_serialization_list_empty(pending_queue)) {
+		ser_debug("nothing to move from pend to active que");
+		goto error;
+	}
+
+	status = wlan_serialization_peek_front(pending_queue,
+					       &pending_node);
+	if (QDF_STATUS_SUCCESS != status) {
+		ser_err("can't read from pending queue");
+		goto error;
+	}
+
+	pending_cmd_list =
+		qdf_container_of(pending_node,
+				 struct wlan_serialization_command_list,
+				 pdev_node);
+
+	ser_debug("next active scan cmd found from pending queue");
+error:
+	return pending_cmd_list;
+}
+
+enum wlan_serialization_status wlan_ser_move_scan_pending_to_active(
+		struct wlan_serialization_command_list **pcmd_list,
+		struct wlan_ser_pdev_obj *ser_pdev_obj)
+{
+	struct wlan_serialization_command_list *pending_cmd_list;
+	struct wlan_serialization_command_list *active_cmd_list;
+	struct wlan_serialization_command cmd_to_remove;
+	enum wlan_serialization_status status = WLAN_SER_CMD_DENIED_UNSPECIFIED;
+	QDF_STATUS qdf_status;
+	struct wlan_serialization_pdev_queue *pdev_q;
+
+	pdev_q = &ser_pdev_obj->pdev_q[SER_PDEV_QUEUE_COMP_SCAN];
+
+	ser_enter();
+
+	if (!ser_pdev_obj) {
+		ser_err("Can't find ser_pdev_obj");
+		goto error;
+	}
+
+	pending_cmd_list =
+		wlan_serialization_get_next_scan_active_cmd(ser_pdev_obj);
+
+	if (!pending_cmd_list)
+		goto error;
+
+	qdf_mem_copy(&cmd_to_remove, &pending_cmd_list->cmd,
+		     sizeof(struct wlan_serialization_command));
+
+	qdf_status =
+		wlan_ser_remove_scan_cmd(ser_pdev_obj,
+					 &pending_cmd_list,
+					 &cmd_to_remove, false);
+
+	if (QDF_STATUS_SUCCESS != qdf_status) {
+		ser_err("Can't remove cmd from pendingQ id-%d type-%d",
+			pending_cmd_list->cmd.cmd_id,
+			pending_cmd_list->cmd.cmd_type);
+		QDF_ASSERT(0);
+		status = WLAN_SER_CMD_DENIED_UNSPECIFIED;
+		goto error;
+	}
+
+	active_cmd_list = pending_cmd_list;
+
+	status = wlan_ser_add_scan_cmd(ser_pdev_obj,
+				       active_cmd_list, true);
+
+	if (WLAN_SER_CMD_ACTIVE != status) {
+		wlan_serialization_insert_back(
+			&pdev_q->cmd_pool_list,
+			&active_cmd_list->pdev_node);
+
+		status = WLAN_SER_CMD_DENIED_UNSPECIFIED;
+		ser_err("Can't add cmd to activeQ id-%d type-%d",
+			active_cmd_list->cmd.cmd_id,
+			active_cmd_list->cmd.cmd_type);
+		QDF_ASSERT(0);
+		goto error;
+	}
+
+	qdf_atomic_set_bit(CMD_MARKED_FOR_ACTIVATION,
+			   &active_cmd_list->cmd_in_use);
+
+	*pcmd_list = active_cmd_list;
+
+error:
+	ser_exit();
+	return status;
+}

umac/cmn_services/serialization/src/wlan_serialization_scan_i.h

@@ -0,0 +1,147 @@
+/*
+ * Copyright (c) 2017-2018 The Linux Foundation. All rights reserved.
+ *
+ * Permission to use, copy, modify, and/or distribute this software for
+ * any purpose with or without fee is hereby granted, provided that the
+ * above copyright notice and this permission notice appear in all
+ * copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+ * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+ * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+ * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+ * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ */
+/**
+ * DOC: wlan_serialization_scan.h
+ * This file defines the prototypes for functions which deals with
+ * serialization non scan commands.
+ */
+
+#ifndef __WLAN_SERIALIZATION_SCAN_I_H
+#define __WLAN_SERIALIZATION_SCAN_I_H
+
+#include <wlan_objmgr_vdev_obj.h>
+#include <wlan_objmgr_pdev_obj.h>
+#include <qdf_mc_timer.h>
+#include <wlan_utility.h>
+#include "wlan_serialization_utils_i.h"
+#include "wlan_serialization_main_i.h"
+#include "wlan_serialization_api.h"
+#include "wlan_serialization_queue_i.h"
+#include "wlan_serialization_internal_i.h"
+
+/**
+ * wlan_serialization_active_scan_cmd_count_handler() - count active scan cmds
+ * @psoc: pointer to soc strucutre
+ * @obj : pointer to pdev object
+ * @arg: pointer to argument
+ *
+ * This API will be called while iterating each pdev object and it will count
+ * number of scan commands present in that pdev object's active queue. count
+ * will be updated in *arg
+ *
+ * Return: none
+ */
+void
+wlan_serialization_active_scan_cmd_count_handler(struct wlan_objmgr_psoc *psoc,
+						 void *obj, void *arg);
+
+/**
+ * wlan_serialization_is_active_scan_cmd_allowed() - find if scan cmd allowed
+ * @pdev: pointer to pdev object
+ *
+ * This API will be called to find out if active scan cmd is allowed. It has
+ * to iterate through all pdev to find out total number of active scan cmds.
+ * If total number of active scan cmds reach to allowed threshold then don't
+ * allow more scan cmd.
+ *
+ * Return: true or false
+ */
+bool
+wlan_serialization_is_active_scan_cmd_allowed(
+		struct wlan_serialization_command *cmd);
+
+/**
+ * wlan_ser_match_cmd_scan_id() - Compare the scan id and the vdev to the given
+ *			command
+ * @cmd: Serialization command information
+ * @scan_id: Scan id to be compared
+ * @vdev: Pointer to object manager vdev that needs to compared
+ *
+ * Return: true if match found, else false
+ */
+bool
+wlan_ser_match_cmd_scan_id(qdf_list_node_t *nnode,
+			   struct wlan_serialization_command **cmd,
+			   uint16_t scan_id,
+			   struct wlan_objmgr_vdev *vdev);
+
+/**
+ * wlan_ser_add_scan_cmd() - Add a scan cmd to serialization queue
+ * @ser_pdev_obj: Serialization private pdev object
+ * @cmd_list: Command list with command info that is to be queued
+ * @is_cmd_for_active_queue: If the cmd to be enqueued in active queue or
+ *			pending queue
+ *
+ * Return: Status of the cmd's serialization request
+ */
+enum wlan_serialization_status
+wlan_ser_add_scan_cmd(struct wlan_ser_pdev_obj *ser_pdev_obj,
+		      struct wlan_serialization_command_list *cmd_list,
+		      uint8_t is_cmd_for_active_queue);
+
+/**
+ * wlan_ser_remove_scan_cmd() - Remove a scan cmd from the given queue
+ * @ser_pdev_obj: Serialization private pdev object
+ * @pcmd_list: Pointer to command list containing the command
+ * @cmd: Serialization command information
+ * @is_active_cmd: If the cmd has to be removed from active queue or pending
+ *			queue
+ *
+ * Return: QDF_STATUS_SUCCESS on successfully removing the cmd else
+ *			QDF_STATUS_E_FAILURE
+ */
+QDF_STATUS
+wlan_ser_remove_scan_cmd(struct wlan_ser_pdev_obj *ser_pdev_obj,
+			 struct wlan_serialization_command_list **pcmd_list,
+			 struct wlan_serialization_command *cmd,
+			 uint8_t is_active_cmd);
+
+/**
+ * wlan_ser_cancel_scan_cmd() - Cancel a scan cmd from the given queue
+ * @ser_obj: Serialization private pdev object
+ * @pdev: Pointer to object manager pdev
+ * @vdev: Pointer to object manager vdev
+ * @cmd: Serialization command information
+ * @cmd_type: Serialization command type to be cancelled
+ * @is_active_queue: If the cmd has to be removed from active queue or pending
+ *			queue
+ *
+ * Return: Status specifying the cancel of a command from the given queue
+ */
+enum wlan_serialization_cmd_status
+wlan_ser_cancel_scan_cmd(struct wlan_ser_pdev_obj *ser_obj,
+			 struct wlan_objmgr_pdev *pdev,
+			 struct wlan_objmgr_vdev *vdev,
+			 struct wlan_serialization_command *cmd,
+			 enum wlan_serialization_cmd_type cmd_type,
+			 uint8_t is_active_queue);
+
+/**
+ * wlan_ser_move_scan_pending_to_active() - Move a scan cmd from pending
+ *			queue to active queue
+ * @pcmd_list: Pointer to command list containing the command
+ * @ser_pdev_obj: Serialization private pdev object
+ *
+ * Return: Status of the cmd's serialization request
+ */
+enum wlan_serialization_status
+wlan_ser_move_scan_pending_to_active(
+		struct wlan_serialization_command_list **pcmd_list,
+		struct wlan_ser_pdev_obj *ser_pdev_obj);
+#endif
+

umac/cmn_services/serialization/src/wlan_serialization_utils.c

@@ -20,6 +20,7 @@
  * This file defines the utility helper functions for serialization component.
  */
 
+#ifdef CONFIG_SERIALIZATION_V1
 #include "wlan_serialization_utils_i.h"
 #include "wlan_serialization_main_i.h"
 #include "wlan_serialization_api.h"
@@ -1002,3 +1003,834 @@ wlan_serialization_destroy_lock(struct wlan_serialization_pdev_priv_obj *obj)
 	return QDF_STATUS_SUCCESS;
 }
 #endif
+#else /*New serialization code*/
+#include <wlan_objmgr_vdev_obj.h>
+#include <wlan_objmgr_pdev_obj.h>
+#include <qdf_mc_timer.h>
+#include <wlan_utility.h>
+#include "wlan_serialization_utils_i.h"
+#include "wlan_serialization_main_i.h"
+#include "wlan_serialization_queue_i.h"
+#include "wlan_serialization_api.h"
+
+struct wlan_objmgr_pdev*
+wlan_serialization_get_pdev_from_cmd(struct wlan_serialization_command *cmd)
+{
+	struct wlan_objmgr_pdev *pdev = NULL;
+
+	if (!cmd) {
+		ser_err("invalid cmd");
+		return pdev;
+	}
+	if (!cmd->vdev) {
+		ser_err("invalid cmd->vdev");
+		return pdev;
+	}
+	pdev = wlan_vdev_get_pdev(cmd->vdev);
+
+	return pdev;
+}
+
+struct wlan_objmgr_psoc*
+wlan_serialization_get_psoc_from_cmd(struct wlan_serialization_command *cmd)
+{
+	struct wlan_objmgr_psoc *psoc = NULL;
+
+	if (!cmd) {
+		ser_err("invalid cmd");
+		return psoc;
+	}
+	if (!cmd->vdev) {
+		ser_err("invalid cmd->vdev");
+		return psoc;
+	}
+	psoc = wlan_vdev_get_psoc(cmd->vdev);
+
+	return psoc;
+}
+
+struct wlan_objmgr_vdev*
+wlan_serialization_get_vdev_from_cmd(struct wlan_serialization_command *cmd)
+{
+	struct wlan_objmgr_vdev *vdev = NULL;
+
+	if (!cmd) {
+		ser_err("invalid cmd");
+		goto error;
+	}
+
+	vdev = cmd->vdev;
+
+error:
+	return vdev;
+}
+
+QDF_STATUS
+wlan_serialization_get_cmd_from_queue(qdf_list_t *queue,
+				      qdf_list_node_t **nnode)
+{
+	QDF_STATUS status = QDF_STATUS_E_FAILURE;
+	qdf_list_node_t *pnode;
+
+	if (!queue) {
+		ser_err("input parameters are invalid");
+		goto error;
+	}
+
+	pnode = *nnode;
+	if (!pnode)
+		status = wlan_serialization_peek_front(queue, nnode);
+	else
+		status = wlan_serialization_peek_next(queue, pnode, nnode);
+
+	if (status != QDF_STATUS_SUCCESS)
+		ser_err("can't get next node from queue");
+
+error:
+	return status;
+}
+
+QDF_STATUS wlan_serialization_timer_destroy(
+		struct wlan_serialization_timer *ser_timer)
+{
+	QDF_STATUS qdf_status = QDF_STATUS_SUCCESS;
+
+	if (!ser_timer || !ser_timer->cmd) {
+		ser_debug("Invalid ser_timer");
+		qdf_status =  QDF_STATUS_E_FAILURE;
+		goto error;
+	}
+
+	ser_debug("Destroying the timer");
+	qdf_timer_stop(&ser_timer->timer);
+	ser_timer->cmd = NULL;
+
+error:
+	return qdf_status;
+}
+
+/**
+ * wlan_serialization_stop_timer() - to stop particular timer
+ * @ser_timer: pointer to serialization timer
+ *
+ * This API stops the particular timer
+ *
+ * Return: QDF_STATUS
+ */
+QDF_STATUS
+wlan_serialization_stop_timer(struct wlan_serialization_timer *ser_timer)
+{
+	wlan_serialization_timer_destroy(ser_timer);
+
+	return QDF_STATUS_SUCCESS;
+}
+
+QDF_STATUS wlan_serialization_cleanup_all_timers(
+			struct wlan_ser_psoc_obj *psoc_ser_obj)
+{
+	struct wlan_serialization_timer *ser_timer;
+	QDF_STATUS status = QDF_STATUS_SUCCESS;
+	uint32_t i = 0;
+
+	ser_enter();
+
+	if (!psoc_ser_obj) {
+		ser_err("Invalid psoc_ser_obj");
+		status = QDF_STATUS_E_FAILURE;
+		goto error;
+	}
+
+	for (i = 0; psoc_ser_obj->max_active_cmds > i; i++) {
+		ser_timer = &psoc_ser_obj->timers[i];
+		if (!ser_timer->cmd)
+			continue;
+		status = wlan_serialization_stop_timer(ser_timer);
+		if (QDF_STATUS_SUCCESS != status) {
+			/* lets not break the loop but report error */
+			ser_err("some error in stopping timer");
+		}
+	}
+
+error:
+	ser_exit();
+	return status;
+}
+
+QDF_STATUS wlan_serialization_validate_cmdtype(
+		 enum wlan_serialization_cmd_type cmd_type)
+{
+	if (cmd_type < 0 || cmd_type >= WLAN_SER_CMD_MAX) {
+		ser_err("Invalid cmd or comp passed");
+		return QDF_STATUS_E_INVAL;
+	}
+
+	return QDF_STATUS_SUCCESS;
+}
+
+QDF_STATUS wlan_serialization_validate_cmd(
+		 enum wlan_umac_comp_id comp_id,
+		 enum wlan_serialization_cmd_type cmd_type)
+{
+	QDF_STATUS status = QDF_STATUS_E_INVAL;
+
+	ser_debug("validate cmd_type:%d, comp_id:%d",
+		  cmd_type, comp_id);
+	if (cmd_type < 0 || comp_id < 0 ||
+	    cmd_type >= WLAN_SER_CMD_MAX ||
+	   comp_id >= WLAN_UMAC_COMP_ID_MAX) {
+		ser_err("Invalid cmd or comp passed");
+		goto error;
+	}
+
+	status = QDF_STATUS_SUCCESS;
+error:
+	return status;
+}
+
+QDF_STATUS wlan_serialization_validate_cmd_list(
+		struct wlan_serialization_command_list *cmd_list)
+{
+	QDF_STATUS status = QDF_STATUS_E_INVAL;
+
+	if (!cmd_list->cmd.cmd_cb) {
+		ser_err("no cmd_cb for cmd type:%d, id: %d",
+			cmd_list->cmd.cmd_type, cmd_list->cmd.cmd_id);
+		QDF_ASSERT(0);
+		goto error;
+	}
+
+	if (!cmd_list->cmd.vdev) {
+		ser_err("invalid cmd.vdev");
+		goto error;
+	}
+
+	status = QDF_STATUS_SUCCESS;
+
+error:
+	return status;
+}
+
+static void wlan_serialization_release_pdev_list_cmds(
+		struct wlan_serialization_pdev_queue *pdev_queue)
+{
+	qdf_list_node_t *node = NULL;
+
+	ser_enter();
+
+	while (!wlan_serialization_list_empty(&pdev_queue->active_list)) {
+		wlan_serialization_remove_front(
+				&pdev_queue->pending_list, &node);
+		wlan_serialization_insert_back(
+				&pdev_queue->cmd_pool_list, node);
+	}
+
+	while (!wlan_serialization_list_empty(&pdev_queue->pending_list)) {
+		wlan_serialization_remove_front(
+				&pdev_queue->pending_list, &node);
+		wlan_serialization_insert_back(
+				&pdev_queue->cmd_pool_list, node);
+	}
+
+	ser_exit();
+}
+
+static void wlan_serialization_release_vdev_list_cmds(qdf_list_t *list)
+{
+	qdf_list_node_t *node = NULL;
+
+	ser_enter();
+
+	while (!wlan_serialization_list_empty(list))
+		wlan_serialization_remove_front(list, &node);
+
+	ser_exit();
+}
+
+void wlan_serialization_destroy_pdev_list(
+		struct wlan_serialization_pdev_queue *pdev_queue)
+{
+	ser_enter();
+
+	wlan_serialization_release_pdev_list_cmds(pdev_queue);
+	qdf_list_destroy(&pdev_queue->active_list);
+	qdf_list_destroy(&pdev_queue->pending_list);
+
+	ser_exit();
+}
+
+void wlan_serialization_destroy_vdev_list(qdf_list_t *list)
+{
+	ser_enter();
+
+	wlan_serialization_release_vdev_list_cmds(list);
+	qdf_list_destroy(list);
+
+	ser_exit();
+}
+
+struct wlan_ser_psoc_obj *wlan_serialization_get_psoc_obj(
+		struct wlan_objmgr_psoc *psoc)
+{
+	struct wlan_ser_psoc_obj *ser_soc_obj;
+
+	ser_soc_obj =
+		wlan_objmgr_psoc_get_comp_private_obj(
+				psoc, WLAN_UMAC_COMP_SERIALIZATION);
+
+	return ser_soc_obj;
+}
+
+struct wlan_ser_pdev_obj *wlan_serialization_get_pdev_obj(
+		struct wlan_objmgr_pdev *pdev)
+{
+	struct wlan_ser_pdev_obj *obj;
+
+	obj = wlan_objmgr_pdev_get_comp_private_obj(
+			pdev, WLAN_UMAC_COMP_SERIALIZATION);
+
+	return obj;
+}
+
+struct wlan_ser_vdev_obj *wlan_serialization_get_vdev_obj(
+		struct wlan_objmgr_vdev *vdev)
+{
+	struct wlan_ser_vdev_obj *obj;
+
+	obj = wlan_objmgr_vdev_get_comp_private_obj(
+			vdev, WLAN_UMAC_COMP_SERIALIZATION);
+
+	return obj;
+}
+
+bool wlan_serialization_is_cmd_in_vdev_list(
+		struct wlan_objmgr_vdev *vdev,
+		qdf_list_t *queue,
+		enum wlan_serialization_node node_type)
+{
+	qdf_list_node_t *node = NULL;
+	bool cmd_found = false;
+
+	ser_enter();
+
+	node = wlan_serialization_find_cmd(
+			queue, WLAN_SER_MATCH_VDEV,
+			NULL, 0, NULL, vdev, node_type);
+
+	if (node)
+		cmd_found = true;
+
+	ser_exit();
+	return cmd_found;
+}
+
+bool wlan_serialization_is_cmd_in_pdev_list(
+			struct wlan_objmgr_pdev *pdev,
+			qdf_list_t *queue)
+{
+	qdf_list_node_t *node = NULL;
+	bool cmd_found = false;
+
+	ser_enter();
+
+	node = wlan_serialization_find_cmd(
+			queue, WLAN_SER_MATCH_PDEV,
+			NULL, 0, pdev, NULL,  WLAN_SER_PDEV_NODE);
+
+	if (node)
+		cmd_found = true;
+
+	ser_exit();
+	return cmd_found;
+}
+
+enum wlan_serialization_cmd_status
+wlan_serialization_is_cmd_in_active_pending(bool cmd_in_active,
+					    bool cmd_in_pending)
+{
+	enum wlan_serialization_cmd_status status;
+
+	if (cmd_in_active && cmd_in_pending)
+		status = WLAN_SER_CMDS_IN_ALL_LISTS;
+	else if (cmd_in_active)
+		status = WLAN_SER_CMD_IN_ACTIVE_LIST;
+	else if (cmd_in_pending)
+		status = WLAN_SER_CMD_IN_PENDING_LIST;
+	else
+		status = WLAN_SER_CMD_NOT_FOUND;
+
+	return status;
+}
+
+bool
+wlan_serialization_is_cmd_present_in_given_queue(
+		qdf_list_t *queue,
+		struct wlan_serialization_command *cmd,
+		enum wlan_serialization_node node_type)
+{
+	qdf_list_node_t *node = NULL;
+	bool found = false;
+
+	node = wlan_serialization_find_cmd(
+			queue, WLAN_SER_MATCH_CMD_ID_VDEV,
+			cmd, 0, NULL, cmd->vdev, node_type);
+
+	if (node)
+		found = true;
+
+	return found;
+}
+
+/**
+ * wlan_serialization_remove_cmd_from_queue() - to remove command from
+ *							given queue
+ * @queue: queue from which command needs to be removed
+ * @cmd: command to match in the queue
+ * @ser_pdev_obj: pointer to private pdev serialization object
+ *
+ * This API takes the queue, it matches the provided command from this queue
+ * and removes it. Before removing the command, it will notify the caller
+ * that if it needs to remove any memory allocated by caller.
+ *
+ * Return: none
+ */
+QDF_STATUS
+wlan_serialization_remove_cmd_from_queue(
+		qdf_list_t *queue,
+		struct wlan_serialization_command *cmd,
+		struct wlan_serialization_command_list **pcmd_list,
+		struct wlan_ser_pdev_obj *ser_pdev_obj,
+		enum wlan_serialization_node node_type)
+{
+	struct wlan_serialization_command_list *cmd_list;
+	qdf_list_node_t *node = NULL;
+	QDF_STATUS status = QDF_STATUS_E_FAILURE;
+
+	if (!cmd)
+		goto error;
+
+	if (wlan_serialization_list_empty(queue)) {
+		ser_err("Empty queue");
+		goto error;
+	}
+
+	node = wlan_serialization_find_cmd(queue, WLAN_SER_MATCH_CMD_ID_VDEV,
+					   cmd, 0, NULL, cmd->vdev, node_type);
+
+	if (!node)
+		goto error;
+
+	if (node_type == WLAN_SER_PDEV_NODE)
+		cmd_list =
+			qdf_container_of(node,
+					 struct wlan_serialization_command_list,
+					 pdev_node);
+	else
+		cmd_list =
+			qdf_container_of(node,
+					 struct wlan_serialization_command_list,
+					 vdev_node);
+
+	ser_debug("Matching command found for removal from queue");
+	ser_debug("remove cmd: type[%d] id[%d] prio[%d] blocking[%d]",
+		  cmd_list->cmd.cmd_type,
+			  cmd_list->cmd.cmd_id,
+			  cmd_list->cmd.is_high_priority,
+			  cmd_list->cmd.is_blocking);
+
+	status = wlan_serialization_remove_node(queue, node);
+
+	if (QDF_STATUS_SUCCESS != status)
+		ser_err("Fail to add to free pool type[%d]",
+			cmd->cmd_type);
+
+	*pcmd_list = cmd_list;
+
+error:
+	return status;
+}
+
+enum wlan_serialization_status
+wlan_serialization_add_cmd_to_queue(
+		qdf_list_t *queue,
+		struct wlan_serialization_command_list *cmd_list,
+		struct wlan_ser_pdev_obj *ser_pdev_obj,
+		uint8_t is_cmd_for_active_queue,
+		enum wlan_serialization_node node_type)
+{
+	enum wlan_serialization_status status = WLAN_SER_CMD_DENIED_UNSPECIFIED;
+	QDF_STATUS qdf_status;
+	qdf_list_node_t *node;
+
+	if (!cmd_list || !queue || !ser_pdev_obj) {
+		ser_err("Input arguments are not valid");
+		goto error;
+	}
+
+	if (node_type == WLAN_SER_PDEV_NODE) {
+		node = &cmd_list->pdev_node;
+		ser_debug("pdev_queue: %pK", queue);
+	} else {
+		node = &cmd_list->vdev_node;
+		ser_debug("vdev_queue: %pK", queue);
+	}
+
+	ser_debug("add cmd: type[%d] id[%d] high_priority[%d] blocking[%d]",
+		  cmd_list->cmd.cmd_type,
+		  cmd_list->cmd.cmd_id,
+		  cmd_list->cmd.is_high_priority,
+		  cmd_list->cmd.is_blocking);
+
+	if (qdf_list_size(queue) == qdf_list_max_size(queue)) {
+		status = WLAN_SER_CMD_DENIED_LIST_FULL;
+		goto error;
+	}
+
+	if (cmd_list->cmd.is_high_priority)
+		qdf_status = wlan_serialization_insert_front(queue, node);
+	else
+		qdf_status = wlan_serialization_insert_back(queue, node);
+
+	if (QDF_IS_STATUS_ERROR(qdf_status))
+		goto error;
+
+	ser_debug("adding cmd to node: %pK", node);
+
+	if (is_cmd_for_active_queue)
+		status = WLAN_SER_CMD_ACTIVE;
+	else
+		status = WLAN_SER_CMD_PENDING;
+
+error:
+	return status;
+}
+
+bool wlan_serialization_list_empty(qdf_list_t *queue)
+{
+	bool is_empty;
+
+	if (qdf_list_empty(queue))
+		is_empty = true;
+	else
+		is_empty = false;
+
+	return is_empty;
+}
+
+uint32_t wlan_serialization_list_size(qdf_list_t *queue)
+{
+	uint32_t size;
+
+	size = qdf_list_size(queue);
+
+	return size;
+}
+
+QDF_STATUS wlan_serialization_remove_front(qdf_list_t *list,
+					   qdf_list_node_t **node)
+{
+	QDF_STATUS status;
+
+	if (wlan_serialization_list_empty(list)) {
+		ser_err("The list is empty");
+		status = QDF_STATUS_E_EMPTY;
+		goto error;
+	}
+
+	status = qdf_list_remove_front(list, node);
+error:
+	return status;
+}
+
+QDF_STATUS wlan_serialization_remove_node(qdf_list_t *list,
+					  qdf_list_node_t *node)
+{
+	QDF_STATUS status;
+
+	if (wlan_serialization_list_empty(list)) {
+		ser_err("The list is empty");
+		status = QDF_STATUS_E_EMPTY;
+		goto error;
+	}
+	status = qdf_list_remove_node(list, node);
+
+error:
+	return status;
+}
+
+QDF_STATUS wlan_serialization_insert_front(qdf_list_t *list,
+					   qdf_list_node_t *node)
+{
+	QDF_STATUS status;
+
+	status = qdf_list_insert_front(list, node);
+
+	return status;
+}
+
+QDF_STATUS wlan_serialization_insert_back(qdf_list_t *list,
+					  qdf_list_node_t *node)
+{
+	QDF_STATUS status;
+
+	status = qdf_list_insert_back(list, node);
+
+	return status;
+}
+
+QDF_STATUS wlan_serialization_peek_front(qdf_list_t *list,
+					 qdf_list_node_t **node)
+{
+	QDF_STATUS status;
+
+	status = qdf_list_peek_front(list, node);
+
+	return status;
+}
+
+QDF_STATUS wlan_serialization_peek_next(qdf_list_t *list,
+					qdf_list_node_t *node1,
+					qdf_list_node_t **node2)
+{
+	QDF_STATUS status;
+
+	status = qdf_list_peek_next(list, node1, node2);
+
+	return status;
+}
+
+bool
+wlan_serialization_match_cmd_type(qdf_list_node_t *nnode,
+				  enum wlan_serialization_cmd_type cmd_type,
+				  enum wlan_serialization_node node_type)
+{
+	struct wlan_serialization_command_list *cmd_list = NULL;
+	bool match_found = true;
+
+	if (node_type == WLAN_SER_PDEV_NODE)
+		cmd_list =
+			qdf_container_of(nnode,
+					 struct wlan_serialization_command_list,
+					 pdev_node);
+	else
+		cmd_list =
+			qdf_container_of(nnode,
+					 struct wlan_serialization_command_list,
+					 vdev_node);
+
+	if (cmd_list->cmd.cmd_type != cmd_type)
+		match_found = false;
+
+	return match_found;
+}
+
+bool
+wlan_serialization_match_cmd_id_type(qdf_list_node_t *nnode,
+				     struct wlan_serialization_command *cmd,
+				     enum wlan_serialization_node node_type)
+{
+	struct wlan_serialization_command_list *cmd_list = NULL;
+	bool match_found = true;
+
+	if (!cmd) {
+		match_found = false;
+		goto error;
+	}
+
+	if (node_type == WLAN_SER_PDEV_NODE)
+		cmd_list =
+			qdf_container_of(nnode,
+					 struct wlan_serialization_command_list,
+					 pdev_node);
+	else
+		cmd_list =
+			qdf_container_of(nnode,
+					 struct wlan_serialization_command_list,
+					 vdev_node);
+
+	if ((cmd_list->cmd.cmd_id != cmd->cmd_id) ||
+	    (cmd_list->cmd.cmd_type != cmd->cmd_type)) {
+		match_found = false;
+	};
+
+error:
+	return match_found;
+}
+
+bool wlan_serialization_match_cmd_vdev(qdf_list_node_t *nnode,
+				       struct wlan_objmgr_vdev *vdev,
+				       enum wlan_serialization_node node_type)
+{
+	struct wlan_serialization_command_list *cmd_list = NULL;
+	bool match_found = false;
+
+	if (node_type == WLAN_SER_PDEV_NODE)
+		cmd_list =
+			qdf_container_of(nnode,
+					 struct wlan_serialization_command_list,
+					 pdev_node);
+	else
+		cmd_list =
+			qdf_container_of(nnode,
+					 struct wlan_serialization_command_list,
+					 vdev_node);
+
+	if (cmd_list->cmd.vdev == vdev)
+		match_found = true;
+
+	ser_debug("matching cmd found(vdev:%pK): %d", vdev, match_found);
+	return match_found;
+}
+
+bool wlan_serialization_match_cmd_pdev(qdf_list_node_t *nnode,
+				       struct wlan_objmgr_pdev *pdev,
+				       enum wlan_serialization_node node_type)
+{
+	struct wlan_serialization_command_list *cmd_list = NULL;
+	bool match_found = false;
+	struct wlan_objmgr_pdev *node_pdev = NULL;
+
+	if (node_type == WLAN_SER_PDEV_NODE)
+		cmd_list =
+			qdf_container_of(nnode,
+					 struct wlan_serialization_command_list,
+					 pdev_node);
+	else
+		cmd_list =
+			qdf_container_of(nnode,
+					 struct wlan_serialization_command_list,
+					 vdev_node);
+
+	node_pdev = wlan_vdev_get_pdev(cmd_list->cmd.vdev);
+	if (node_pdev == pdev)
+		match_found = true;
+
+	return match_found;
+}
+
+qdf_list_node_t *
+wlan_serialization_find_cmd(qdf_list_t *queue,
+			    enum wlan_serialization_match_type match_type,
+			    struct wlan_serialization_command *cmd,
+			    enum wlan_serialization_cmd_type cmd_type,
+			    struct wlan_objmgr_pdev *pdev,
+			    struct wlan_objmgr_vdev *vdev,
+			    enum wlan_serialization_node node_type)
+{
+	qdf_list_node_t *cmd_node = NULL;
+	uint32_t queuelen;
+	qdf_list_node_t *nnode = NULL;
+	QDF_STATUS status;
+	bool node_found = 0;
+
+	queuelen = wlan_serialization_list_size(queue);
+
+	if (!queuelen) {
+		ser_debug("queue empty");
+		goto error;
+	}
+
+	while (queuelen--) {
+		status = wlan_serialization_get_cmd_from_queue(queue, &nnode);
+		if (status != QDF_STATUS_SUCCESS)
+			break;
+
+		switch (match_type) {
+		case WLAN_SER_MATCH_PDEV:
+			if (wlan_serialization_match_cmd_pdev(
+					nnode, pdev, WLAN_SER_PDEV_NODE))
+				node_found = 1;
+			break;
+		case WLAN_SER_MATCH_VDEV:
+			if (wlan_serialization_match_cmd_vdev(
+					nnode, vdev, node_type))
+				node_found = 1;
+			break;
+		case WLAN_SER_MATCH_CMD_TYPE:
+			if (wlan_serialization_match_cmd_type(
+					nnode, cmd_type, node_type))
+				node_found = 1;
+			break;
+		case WLAN_SER_MATCH_CMD_ID:
+			if (wlan_serialization_match_cmd_id_type(
+					nnode, cmd, node_type))
+				node_found = 1;
+			break;
+		case WLAN_SER_MATCH_CMD_TYPE_VDEV:
+			if (wlan_serialization_match_cmd_type(
+					nnode, cmd_type, node_type) &&
+			    wlan_serialization_match_cmd_vdev(
+					nnode, vdev, node_type))
+				node_found = 1;
+			break;
+		case WLAN_SER_MATCH_CMD_ID_VDEV:
+			if (wlan_serialization_match_cmd_id_type(
+					nnode, cmd, node_type) &&
+			    wlan_serialization_match_cmd_vdev(
+					nnode, vdev, node_type))
+				node_found = 1;
+			break;
+		default:
+			break;
+		}
+
+		if (node_found) {
+			cmd_node = nnode;
+			break;
+		}
+	}
+error:
+	return cmd_node;
+}
+
+QDF_STATUS
+wlan_serialization_acquire_lock(
+		struct wlan_serialization_pdev_queue *pdev_queue)
+{
+	if (!pdev_queue) {
+		ser_err("invalid object");
+		return QDF_STATUS_E_FAILURE;
+	}
+	qdf_spin_lock_bh(&pdev_queue->pdev_queue_lock);
+
+	return QDF_STATUS_SUCCESS;
+}
+
+QDF_STATUS
+wlan_serialization_release_lock(
+		struct wlan_serialization_pdev_queue *pdev_queue)
+{
+	if (!pdev_queue) {
+		ser_err("invalid object");
+		return QDF_STATUS_E_FAILURE;
+	}
+	qdf_spin_unlock_bh(&pdev_queue->pdev_queue_lock);
+
+	return QDF_STATUS_SUCCESS;
+}
+
+QDF_STATUS
+wlan_serialization_create_lock(
+		struct wlan_serialization_pdev_queue *pdev_queue)
+{
+	if (!pdev_queue) {
+		ser_err("invalid object");
+		return QDF_STATUS_E_FAILURE;
+	}
+	qdf_spinlock_create(&pdev_queue->pdev_queue_lock);
+
+	return QDF_STATUS_SUCCESS;
+}
+
+QDF_STATUS
+wlan_serialization_destroy_lock(
+		struct wlan_serialization_pdev_queue *pdev_queue)
+{
+	if (!pdev_queue) {
+		ser_err("invalid object");
+		return QDF_STATUS_E_FAILURE;
+	}
+	qdf_spinlock_destroy(&pdev_queue->pdev_queue_lock);
+
+	return QDF_STATUS_SUCCESS;
+}
+#endif

umac/cmn_services/serialization/src/wlan_serialization_utils_i.h

@@ -22,6 +22,8 @@
  */
 #ifndef __WLAN_SERIALIZATION_UTILS_I_H
 #define __WLAN_SERIALIZATION_UTILS_I_H
+
+#ifdef CONFIG_SERIALIZATION_V1
 /* Include files */
 #include "qdf_status.h"
 #include "qdf_list.h"
@@ -613,4 +615,629 @@ QDF_STATUS wlan_serialization_peek_next(
 			qdf_list_node_t *node1,
 			qdf_list_node_t **node2,
 			struct wlan_serialization_pdev_priv_obj *ser_pdev_obj);
+#else /*New serialization code*/
+/* Include files */
+#include <qdf_status.h>
+#include <qdf_list.h>
+#include <qdf_mc_timer.h>
+#include <wlan_objmgr_cmn.h>
+#include <wlan_objmgr_global_obj.h>
+#include <wlan_objmgr_psoc_obj.h>
+#include <wlan_scan_ucfg_api.h>
+#include "wlan_serialization_rules_i.h"
+
+/*
+ * Below bit positions are used to identify if a
+ * serialization command is in use or marked for
+ * deletion.
+ * CMD_MARKED_FOR_ACTIVATION - The command is about to be activated
+ * CMD_IS_ACTIVE - The command is active and currently in use
+ */
+#define CMD_MARKED_FOR_ACTIVATION 1
+#define CMD_IS_ACTIVE             2
+/**
+ * struct wlan_serialization_timer - Timer used for serialization
+ * @cmd:      Cmd to which the timer is linked
+ * @timer:    Timer associated with the command
+ *
+ * Timers are allocated statically during init, one each for the
+ * maximum active commands permitted in the system. Once a cmd is
+ * moved from pending list to active list, the timer is activated
+ * and once the cmd is completed, the timer is cancelled. Timer is
+ * also cancelled if the command is aborted
+ *
+ * The timers are maintained per psoc. A timer is associated to
+ * unique combination of pdev, cmd_type and cmd_id.
+ */
+struct wlan_serialization_timer {
+	struct wlan_serialization_command *cmd;
+	qdf_timer_t timer;
+};
+
+/**
+ * enum wlan_serialization_node - Types of available nodes in serialization list
+ * @WLAN_SER_PDEV_NODE: pdev node from the pdev queue
+ * @WLAN_SER_VDEV_NODE: vdev node from the vdev queue
+ */
+enum wlan_serialization_node {
+	WLAN_SER_PDEV_NODE,
+	WLAN_SER_VDEV_NODE,
+};
+
+/**
+ * struct wlan_serialization_command_list - List of commands to be serialized
+ * @pdev_node: PDEV node identifier in the list
+ * @vdev_node: VDEV node identifier in the list
+ * @cmd: Command to be serialized
+ * @cmd_in_use: flag to check if the node/entry is logically active
+ */
+struct wlan_serialization_command_list {
+	qdf_list_node_t pdev_node;
+	qdf_list_node_t vdev_node;
+	struct wlan_serialization_command cmd;
+	unsigned long cmd_in_use;
+};
+
+/**
+ * struct wlan_serialization_pdev_queue - queue data related to pdev
+ * @active_list: list to hold the commands currently being executed
+ * @pending_list: list to hold the commands currently pending
+ * @cmd_pool_list: list to hold the global command pool
+ * @vdev_active_cmd_bitmap: Active cmd bitmap of vdev for the given pdev
+ * @blocking_cmd_active: Indicate if a blocking cmd is in active execution
+ * @blocking_cmd_waiting: Indicate if a blocking cmd is in pending queue
+ * @pdev_queue_lock: pdev lock to protect concurrent operations on the queues
+ */
+struct wlan_serialization_pdev_queue {
+	qdf_list_t active_list;
+	qdf_list_t pending_list;
+	qdf_list_t cmd_pool_list;
+	uint32_t vdev_active_cmd_bitmap;
+	bool blocking_cmd_active;
+	uint16_t blocking_cmd_waiting;
+	qdf_spinlock_t pdev_queue_lock;
+};
+
+/**
+ * struct wlan_serialization_vdev_queue - queue data related to vdev
+ * @active_list: list to hold the commands currently being executed
+ * @pending_list list: to hold the commands currently pending
+ */
+struct wlan_serialization_vdev_queue {
+	qdf_list_t active_list;
+	qdf_list_t pending_list;
+};
+
+/**
+ * enum wlan_serialization_pdev_queue_type - Types of available pdev queues
+ * @QUEUE_COMP_SCAN: Scan queue
+ * @QUEUE_COMP_NON_SCAN: Non Scan queue
+ */
+enum serialization_pdev_queue_type {
+	SER_PDEV_QUEUE_COMP_SCAN,
+	SER_PDEV_QUEUE_COMP_NON_SCAN,
+	SER_PDEV_QUEUE_COMP_MAX,
+};
+
+/**
+ * enum wlan_serialization_vdev_queue_type - Types of available vdev queues
+ * @QUEUE_COMP_NON_SCAN: Non Scan queue
+ */
+enum serialization_vdev_queue_type {
+	SER_VDEV_QUEUE_COMP_NON_SCAN,
+	SER_VDEV_QUEUE_COMP_MAX,
+};
+
+/**
+ * enum wlan_serialization_match_type - Comparison options for a command
+ * @WLAN_SER_MATCH_VDEV: Compare vdev
+ * @WLAN_SER_MATCH_PDEV: Compare pdev
+ * @WLAN_SER_MATCH_CMD_TYPE: Compare command type
+ * @WLAN_SER_MATCH_CMD_TYPE_VDEV: Compare command type and vdev
+ * @WLAN_SER_MATCH_CMD_ID: Compare command id
+ * @WLAN_SER_MATCH_CMD_ID_VDEV: Compare command id and vdev
+ */
+enum wlan_serialization_match_type {
+	WLAN_SER_MATCH_VDEV,
+	WLAN_SER_MATCH_PDEV,
+	WLAN_SER_MATCH_CMD_TYPE,
+	WLAN_SER_MATCH_CMD_TYPE_VDEV,
+	WLAN_SER_MATCH_CMD_ID,
+	WLAN_SER_MATCH_CMD_ID_VDEV,
+	WLAN_SER_MATCH_MAX,
+};
+
+/**
+ * struct wlan_ser_pdev_obj - pdev obj data for serialization
+ * @pdev_q: Array of pdev queues
+ */
+struct wlan_ser_pdev_obj {
+	struct wlan_serialization_pdev_queue pdev_q[SER_PDEV_QUEUE_COMP_MAX];
+};
+
+/**
+ * struct wlan_ser_vdev_priv_obj - Serialization private object of vdev
+ * @vdev_q: Array of vdev queues
+ */
+struct wlan_ser_vdev_obj {
+	struct wlan_serialization_vdev_queue vdev_q[SER_VDEV_QUEUE_COMP_MAX];
+};
+
+/**
+ * struct wlan_ser_psoc_obj - psoc obj data for serialization
+ * @comp_info_cb - module level callback
+ * @apply_rules_cb - pointer to apply rules on the cmd
+ * @timers - Timers associated with the active commands
+ * @max_axtive_cmds - Maximum active commands allowed
+ *
+ * Serialization component takes a command as input and checks whether to
+ * allow/deny the command. It will use the module level callback registered
+ * by each component to fetch the information needed to apply the rules.
+ * Once the information is available, the rules callback registered for each
+ * command internally by serialization will be applied to determine the
+ * checkpoint for the command. If allowed, command will be put into active/
+ * pending list and each active command is associated with a timer.
+ */
+struct wlan_ser_psoc_obj {
+	wlan_serialization_comp_info_cb comp_info_cb[
+		WLAN_SER_CMD_MAX][WLAN_UMAC_COMP_ID_MAX];
+	wlan_serialization_apply_rules_cb apply_rules_cb[WLAN_SER_CMD_MAX];
+	struct wlan_serialization_timer *timers;
+	uint8_t max_active_cmds;
+};
+
+/**
+ * wlan_serialization_remove_cmd_from_queue() - to remove command from
+ *							given queue
+ * @queue: queue from which command needs to be removed
+ * @cmd: command to match in the queue
+ * @pcmd_list: Pointer to command list containing the command
+ * @ser_pdev_obj: pointer to private pdev serialization object
+ * @node_type: Pdev node or vdev node
+ *
+ * This API takes the queue, it matches the provided command from this queue
+ * and removes it. Before removing the command, it will notify the caller
+ * that if it needs to remove any memory allocated by caller.
+ *
+ * Return: QDF_STATUS_SUCCESS on success, error code on failure
+ */
+QDF_STATUS
+wlan_serialization_remove_cmd_from_queue(
+		qdf_list_t *queue,
+		struct wlan_serialization_command *cmd,
+		struct wlan_serialization_command_list **pcmd_list,
+		struct wlan_ser_pdev_obj *ser_pdev_obj,
+		enum wlan_serialization_node node_type);
+
+/**
+ * wlan_serialization_add_cmd_from_queue() - Add a cmd to
+ *							given queue
+ * @queue: queue from which command needs to be removed
+ * @cmd_list: Pointer to command list containing the command
+ * @ser_pdev_obj: pointer to private pdev serialization object
+ * @is_cmd_for_active_queue: Add cmd to active or pending queue
+ * @node_type: Pdev node or vdev node
+ *
+ * Return: Status of the serialization request
+ */
+enum wlan_serialization_status
+wlan_serialization_add_cmd_to_queue(
+		qdf_list_t *queue,
+		struct wlan_serialization_command_list *cmd_list,
+		struct wlan_ser_pdev_obj *ser_pdev_obj,
+		uint8_t is_cmd_for_active_queue,
+		enum wlan_serialization_node node_type);
+
+/**
+ * wlan_serialization_get_psoc_from_cmd() - get psoc from provided cmd
+ * @cmd: pointer to actual command
+ *
+ * This API will get the pointer to psoc through checking type of cmd
+ *
+ * Return: pointer to psoc
+ */
+struct wlan_objmgr_psoc*
+wlan_serialization_get_psoc_from_cmd(struct wlan_serialization_command *cmd);
+
+/**
+ * wlan_serialization_get_pdev_from_cmd() - get pdev from provided cmd
+ * @cmd: pointer to actual command
+ *
+ * This API will get the pointer to pdev through checking type of cmd
+ *
+ * Return: pointer to pdev
+ */
+struct wlan_objmgr_pdev*
+wlan_serialization_get_pdev_from_cmd(struct wlan_serialization_command *cmd);
+
+/**
+ * wlan_serialization_get_vdev_from_cmd() - get vdev from provided cmd
+ * @cmd: pointer to actual command
+ *
+ * This API will get the pointer to vdev through checking type of cmd
+ *
+ * Return: pointer to vdev
+ */
+struct wlan_objmgr_vdev*
+wlan_serialization_get_vdev_from_cmd(struct wlan_serialization_command *cmd);
+
+/**
+ * wlan_serialization_get_cmd_from_queue() - to extract command from given queue
+ * @queue: pointer to queue
+ * @nnode: next node to extract
+ *
+ * This API will try to extract node from queue which is next to prev node. If
+ * no previous node is given then take out the front node of the queue.
+ *
+ * Return: QDF_STATUS
+ */
+QDF_STATUS wlan_serialization_get_cmd_from_queue(
+		qdf_list_t *queue, qdf_list_node_t **nnode);
+
+/**
+ * wlan_serialization_stop_timer() - to stop particular timer
+ * @ser_timer: pointer to serialization timer
+ *
+ * This API stops the particular timer
+ *
+ * Return: QDF_STATUS
+ */
+QDF_STATUS
+wlan_serialization_stop_timer(struct wlan_serialization_timer *ser_timer);
+
+/**
+ * wlan_serialization_cleanup_all_timers() - to clean-up all timers
+ *
+ * @psoc_ser_ob: pointer to serialization psoc private object
+ *
+ * This API is to cleanup all the timers. it can be used when serialization
+ * module is exiting. it will make sure that if timer is running then it will
+ * stop and destroys the timer
+ *
+ * Return: QDF_STATUS
+ */
+QDF_STATUS wlan_serialization_cleanup_all_timers(
+	struct wlan_ser_psoc_obj *psoc_ser_ob);
+
+/**
+ * wlan_serialization_validate_cmd() - Validate the command
+ * @comp_id: Component ID
+ * @cmd_type: Command Type
+ *
+ * Return: QDF_STATUS
+ */
+QDF_STATUS wlan_serialization_validate_cmd(
+		 enum wlan_umac_comp_id comp_id,
+		 enum wlan_serialization_cmd_type cmd_type);
+
+/**
+ * wlan_serialization_validate_cmd_list() - Validate the command list
+ * @cmd_list: Serialization command list
+ *
+ * Return: QDF_STATUS
+ */
+QDF_STATUS wlan_serialization_validate_cmd_list(
+		struct wlan_serialization_command_list *cmd_list);
+
+/**
+ * wlan_serialization_validate_cmdtype() - Validate the command type
+ * @cmd_type: Command Type
+ *
+ * Return: QDF_STATUS
+ */
+QDF_STATUS wlan_serialization_validate_cmdtype(
+		 enum wlan_serialization_cmd_type cmd_type);
+
+/**
+ * wlan_serialization_destroy_pdev_list() - Release the pdev cmds and
+ * destroy list
+ * @pdev_queue: Pointer to the pdev queue
+ *
+ * Return: None
+ */
+void wlan_serialization_destroy_pdev_list(
+		struct wlan_serialization_pdev_queue *pdev_queue);
+
+/**
+ * wlan_serialization_destroy_vdev_list() - Release the vdev cmds and
+ * destroy list
+ * @list: List to be destroyed
+ *
+ * Return: None
+ */
+void wlan_serialization_destroy_vdev_list(qdf_list_t *list);
+
+/**
+ * wlan_serialization_get_psoc_obj() - Return the component private obj
+ * @psoc: Pointer to the PSOC object
+ *
+ * Return: Serialization component's PSOC level private data object
+ */
+struct wlan_ser_psoc_obj *wlan_serialization_get_psoc_obj(
+		struct wlan_objmgr_psoc *psoc);
+
+/**
+ * wlan_serialization_get_pdev_obj() - Return the component private obj
+ * @psoc: Pointer to the PDEV object
+ *
+ * Return: Serialization component's PDEV level private data object
+ */
+struct wlan_ser_pdev_obj *wlan_serialization_get_pdev_obj(
+		struct wlan_objmgr_pdev *pdev);
+
+/**
+ * wlan_serialization_get_vdev_obj() - Return the component private obj
+ * @vdev: Pointer to the VDEV object
+ *
+ * Return: Serialization component's VDEV level private data object
+ */
+struct wlan_ser_vdev_obj *wlan_serialization_get_vdev_obj(
+		struct wlan_objmgr_vdev *vdev);
+
+/**
+ * wlan_serialization_is_cmd_in_vdev_list() - Check Node present in VDEV list
+ * @vdev: Pointer to the VDEV object
+ * @queue: Pointer to the qdf_list_t
+ * @node_type: Pdev node or vdev node
+ *
+ * Return: Boolean true or false
+ */
+bool
+wlan_serialization_is_cmd_in_vdev_list(
+		struct wlan_objmgr_vdev *vdev, qdf_list_t *queue,
+		enum wlan_serialization_node node_type);
+
+/**
+ * wlan_serialization_is_cmd_in_pdev_list() - Check Node present in PDEV list
+ * @pdev: Pointer to the PDEV object
+ * @queue: Pointer to the qdf_list_t
+ *
+ * Return: Boolean true or false
+ */
+bool
+wlan_serialization_is_cmd_in_pdev_list(
+		struct wlan_objmgr_pdev *pdev, qdf_list_t *queue);
+
+/**
+ * wlan_serialization_is_cmd_in_active_pending() - return cmd status
+ *						active/pending queue
+ * @cmd_in_active: CMD in active list
+ * @cmd_in_pending: CMD in pending list
+ *
+ * Return: enum wlan_serialization_cmd_status
+ */
+enum wlan_serialization_cmd_status
+wlan_serialization_is_cmd_in_active_pending(
+		bool cmd_in_active, bool cmd_in_pending);
+
+/**
+ * wlan_serialization_is_cmd_present_in_given_queue() - Check if the cmd is
+ * present in the given queue
+ * @queue: List of commands which has to be searched
+ * @cmd: Serialization command information
+ * @node_type: Pdev node or vdev node
+ *
+ * Return: Boolean true or false
+ */
+bool wlan_serialization_is_cmd_present_in_given_queue(
+		qdf_list_t *queue,
+		struct wlan_serialization_command *cmd,
+		enum wlan_serialization_node node_type);
+
+/**
+ * wlan_serialization_timer_destroy() - destroys the timer
+ * @ser_timer: pointer to particular timer
+ *
+ * This API destroys the memory allocated by timer and assigns cmd member of
+ * that timer structure to NULL
+ *
+ * Return: QDF_STATUS
+ */
+QDF_STATUS wlan_serialization_timer_destroy(
+		struct wlan_serialization_timer *ser_timer);
+
+/**
+ * wlan_serialization_list_empty() - check if the list is empty
+ * @queue: Queue/List that needs to be checked for emptiness
+ *
+ * Return: true if list is empty and false otherwise
+ */
+bool wlan_serialization_list_empty(qdf_list_t *queue);
+
+/**
+ * wlan_serialization_list_size() - Find the size of the provided queue
+ * @queue: Queue/List for which the size/length is to be returned
+ *
+ * Return: size/length of the queue/list
+ */
+uint32_t wlan_serialization_list_size(qdf_list_t *queue);
+
+/**
+ * wlan_serialization_match_cmd_type() - Check for a match on given nnode
+ * @nnode: The node on which the matching has to be done
+ * @cmd_type: Command type that needs to be matched
+ * @node_type: Pdev node or vdev node
+ *
+ * This API will check if the cmd ID and cmd type of the given nnode are
+ * matching with the one's that are being passed to this function.
+ *
+ * Return: True if matched,false otherwise.
+ */
+bool wlan_serialization_match_cmd_type(
+			qdf_list_node_t *nnode,
+			enum wlan_serialization_cmd_type,
+			enum wlan_serialization_node node_type);
+
+/**
+ * wlan_serialization_match_cmd_id_type() - Check for a match on given nnode
+ * @nnode: The node on which the matching has to be done
+ * @cmd: Command that needs to be matched
+ * @node_type: Pdev node or vdev node
+ *
+ * This API will check if the cmd ID and cmd type of the given nnode are
+ * matching with the one's that are being passed to this function.
+ *
+ * Return: True if matched,false otherwise.
+ */
+bool wlan_serialization_match_cmd_id_type(
+			qdf_list_node_t *nnode,
+			struct wlan_serialization_command *cmd,
+			enum wlan_serialization_node node_type);
+
+/**
+ * wlan_serialization_match_cmd_vdev() - Check for a match on given nnode
+ * @nnode: The node on which the matching has to be done
+ * @vdev: VDEV object that needs to be matched
+ * @node_type: Pdev node or vdev node
+ *
+ * This API will check if the VDEV object of the given nnode are
+ * matching with the one's that are being passed to this function.
+ *
+ * Return: True if matched,false otherwise.
+ */
+bool wlan_serialization_match_cmd_vdev(qdf_list_node_t *nnode,
+				       struct wlan_objmgr_vdev *vdev,
+				       enum wlan_serialization_node node_type);
+
+/**
+ * wlan_serialization_match_cmd_pdev() - Check for a match on given nnode
+ * @nnode: The node on which the matching has to be done
+ * @pdev: pdev object that needs to be matched
+ * @node_type: Node type. Pdev node or vdev node
+ *
+ * This API will check if the PDEV object of the given nnode are
+ * matching with the one's that are being passed to this function.
+ *
+ * Return: True if matched,false otherwise.
+ */
+bool wlan_serialization_match_cmd_pdev(qdf_list_node_t *nnode,
+				       struct wlan_objmgr_pdev *pdev,
+				       enum wlan_serialization_node node_type);
+
+/**
+ * wlan_serialization_find_cmd() - Find the cmd matching the given criterias
+ * @cmd: Serialization command information
+ * @cmd_type: Command type to be matched
+ * @pdev: pdev object that needs to be matched
+ * @vdev: vdev object that needs to be matched
+ * @node_type: Node type. Pdev node or vdev node
+ *
+ * Return: Pointer to the node member in the list
+ */
+qdf_list_node_t *
+wlan_serialization_find_cmd(qdf_list_t *queue, uint32_t match_type,
+			    struct wlan_serialization_command *cmd,
+			    enum wlan_serialization_cmd_type cmd_type,
+			    struct wlan_objmgr_pdev *pdev,
+			    struct wlan_objmgr_vdev *vdev,
+			    enum wlan_serialization_node node_type);
+
+/**
+ * wlan_serialization_remove_front() - Remove the front node of the list
+ * @list: List from which the node is to be removed
+ * @node: Pointer to store the node that is removed
+ *
+ * Return: QDF_STATUS Success or Failure
+ */
+QDF_STATUS wlan_serialization_remove_front(
+			qdf_list_t *list,
+			qdf_list_node_t **node);
+
+/**
+ * wlan_serialization_remove_node() - Remove the given node from the list
+ * @list: List from which the node is to be removed
+ * @node: Pointer to the node that is to be removed
+ *
+ * Return: QDF_STATUS Success or Failure
+ */
+QDF_STATUS wlan_serialization_remove_node(
+			qdf_list_t *list,
+			qdf_list_node_t *node);
+
+/**
+ * wlan_serialization_insert_front() - Insert a node into the front of the list
+ * @list: List to which the node is to be inserted
+ * @node: Pointer to the node that is to be inserted
+ *
+ * Return: QDF_STATUS Success or Failure
+ */
+QDF_STATUS wlan_serialization_insert_front(
+			qdf_list_t *list,
+			qdf_list_node_t *node);
+
+/**
+ * wlan_serialization_insert_back() - Insert a node into the back of the list
+ * @list: List to which the node is to be inserted
+ * @node: Pointer to the node that is to be inserted
+ *
+ * Return: QDF_STATUS Success or Failure
+ */
+QDF_STATUS wlan_serialization_insert_back(
+			qdf_list_t *list,
+			qdf_list_node_t *node);
+
+/**
+ * wlan_serialization_peek_front() - Peek the front node of the list
+ * @list: List on which the node is to be peeked
+ * @node: Pointer to the store the node that is being peeked
+ *
+ * Return: QDF_STATUS Success or Failure
+ */
+QDF_STATUS wlan_serialization_peek_front(
+			qdf_list_t *list,
+			qdf_list_node_t **node);
+
+/**
+ * wlan_serialization_peek_next() - Peek the next node of the list
+ * @list: List on which the node is to be peeked
+ * @node1: Pointer to the node1 from where the next node has to be peeked
+ * @node2: Pointer to the store the node that is being peeked
+ *
+ * Return: QDF_STATUS Success or Failure
+ */
+QDF_STATUS wlan_serialization_peek_next(
+			qdf_list_t *list,
+			qdf_list_node_t *node1,
+			qdf_list_node_t **node2);
+
+/**
+ * wlan_serialization_acquire_lock() - Acquire lock to the given queue
+ * @pdev_queue: Pointer to the pdev queue
+ *
+ * Return: QDF_STATUS success or failure
+ */
+QDF_STATUS
+wlan_serialization_acquire_lock(
+		struct wlan_serialization_pdev_queue *pdev_queue);
+
+/**
+ * wlan_serialization_release_lock() - Release lock to the given queue
+ * @pdev_queue: Pointer to the pdev queue
+ *
+ * Return: QDF_STATUS success or failure
+ */
+QDF_STATUS
+wlan_serialization_release_lock(
+		struct wlan_serialization_pdev_queue *pdev_queue);
+
+/**
+ * wlan_serialization_create_lock() - Init the lock to the given queue
+ * @pdev_queue: Pointer to the pdev queue
+ *
+ * Return: QDF_STATUS success or failure
+ */
+QDF_STATUS
+wlan_serialization_create_lock(
+		struct wlan_serialization_pdev_queue *pdev_queue);
+
+/**
+ * wlan_serialization_destroy_lock() - Deinit the lock to the given queue
+ * @pdev_queue: Pointer to the pdev queue
+ *
+ * Return: QDF_STATUS success or failure
+ */
+QDF_STATUS
+wlan_serialization_destroy_lock(
+		struct wlan_serialization_pdev_queue *pdev_queue);
+#endif
 #endif

umac/cp_stats/dispatcher/inc/wlan_cp_stats_ic_dcs_defs.h

@@ -43,14 +43,14 @@
  * @dcs_sec_80_util: secondary 80MHz util
  */
 struct pdev_dcs_chan_stats {
-	uint32_t dcs_total_util;
-	uint32_t dcs_ap_tx_util;
-	uint32_t dcs_ap_rx_util;
-	uint32_t dcs_self_bss_util;
-	uint32_t dcs_obss_util;
-	uint32_t dcs_obss_rx_util;
-	uint32_t dcs_free_medium;
-	uint32_t dcs_non_wifi_util;
+	uint8_t dcs_total_util;
+	uint8_t dcs_ap_tx_util;
+	uint8_t dcs_ap_rx_util;
+	uint8_t dcs_self_bss_util;
+	uint8_t dcs_obss_util;
+	uint8_t dcs_obss_rx_util;
+	uint8_t dcs_free_medium;
+	uint8_t dcs_non_wifi_util;
 	uint32_t dcs_ss_under_util;
 	uint32_t dcs_sec_20_util;
 	uint32_t dcs_sec_40_util;

umac/cp_stats/dispatcher/inc/wlan_cp_stats_ic_ucfg_api.h

@@ -137,60 +137,8 @@ UCFG_PDEV_CP_STATS_GET_FUNCS(wmi_tx_mgmt_completion_err);
 UCFG_PDEV_CP_STATS_GET_FUNCS(tgt_asserts);
 UCFG_PDEV_CP_STATS_GET_FUNCS(rx_phy_err);
 
-#define UCFG_PDEV_CHAN_STATS_SET_FUNCS(field) \
-	static inline void \
-	ucfg_pdev_chan_stats_##field##_inc(struct wlan_objmgr_pdev *_pdev, \
-					 uint64_t _val) \
-	{ \
-		struct pdev_cp_stats *_pdev_cs = \
-			wlan_cp_stats_get_pdev_stats_obj(_pdev); \
-		if (_pdev_cs) { \
-			struct pdev_ic_cp_stats *_pdev_ic = \
-						_pdev_cs->pdev_stats; \
-			if (_pdev_ic) { \
-				_pdev_ic->stats.chan_stats.dcs_##field += _val;\
-			} \
-		} \
-	} \
-	static inline void \
-	ucfg_pdev_chan_stats_##field##_dec(struct wlan_objmgr_pdev *_pdev, \
-					 uint64_t _val) \
-	{ \
-		struct pdev_cp_stats *_pdev_cs = \
-			wlan_cp_stats_get_pdev_stats_obj(_pdev); \
-		if (_pdev_cs) { \
-			struct pdev_ic_cp_stats *_pdev_ic = \
-						_pdev_cs->pdev_stats; \
-			if (_pdev_ic) { \
-				_pdev_ic->stats.chan_stats.dcs_##field -= _val;\
-			} \
-		} \
-	} \
-	static inline void \
-	ucfg_pdev_chan_stats_##field##_update(struct wlan_objmgr_pdev *_pdev, \
-					    uint64_t _val) \
-	{ \
-		struct pdev_cp_stats *_pdev_cs = \
-				wlan_cp_stats_get_pdev_stats_obj(_pdev); \
-		if (_pdev_cs) { \
-			struct pdev_ic_cp_stats *_pdev_ic = \
-						_pdev_cs->pdev_stats; \
-			if (_pdev_ic) { \
-				_pdev_ic->stats.chan_stats.dcs_##field = _val;\
-			} \
-		} \
-	}
-
-UCFG_PDEV_CHAN_STATS_SET_FUNCS(self_bss_util);
-UCFG_PDEV_CHAN_STATS_SET_FUNCS(obss_util);
-UCFG_PDEV_CHAN_STATS_SET_FUNCS(obss_rx_util);
-UCFG_PDEV_CHAN_STATS_SET_FUNCS(ap_rx_util);
-UCFG_PDEV_CHAN_STATS_SET_FUNCS(ap_tx_util);
-UCFG_PDEV_CHAN_STATS_SET_FUNCS(free_medium);
-UCFG_PDEV_CHAN_STATS_SET_FUNCS(non_wifi_util);
-
 #define UCFG_PDEV_CHAN_STATS_GET_FUNCS(field) \
-	static inline uint8_t \
+	static inline uint32_t \
 	ucfg_pdev_chan_stats_##field##_get(struct wlan_objmgr_pdev *_pdev) \
 	{ \
 		struct pdev_cp_stats *_pdev_cs = \
@@ -210,6 +158,10 @@ UCFG_PDEV_CHAN_STATS_GET_FUNCS(ap_rx_util);
 UCFG_PDEV_CHAN_STATS_GET_FUNCS(ap_tx_util);
 UCFG_PDEV_CHAN_STATS_GET_FUNCS(free_medium);
 UCFG_PDEV_CHAN_STATS_GET_FUNCS(non_wifi_util);
+UCFG_PDEV_CHAN_STATS_GET_FUNCS(ss_under_util);
+UCFG_PDEV_CHAN_STATS_GET_FUNCS(sec_20_util);
+UCFG_PDEV_CHAN_STATS_GET_FUNCS(sec_40_util);
+UCFG_PDEV_CHAN_STATS_GET_FUNCS(sec_80_util);
 
 static inline void ucfg_pdev_cp_stats_reset(struct wlan_objmgr_pdev *_pdev)
 {

umac/cp_stats/dispatcher/inc/wlan_cp_stats_ic_utils_api.h

@@ -326,36 +326,8 @@ PDEV_CP_STATS_SET_FUNCS(cycle_count);
 PDEV_CP_STATS_SET_FUNCS(phy_err_count);
 PDEV_CP_STATS_SET_FUNCS(chan_tx_pwr);
 
-#define PDEV_CHAN_STATS_SET_FUNCS(field) \
-	static inline void \
-	pdev_chan_stats_##field##_inc(struct wlan_objmgr_pdev *_pdev, \
-				      uint8_t _val) \
-	{ \
-		ucfg_pdev_chan_stats_##field##_inc(_pdev, _val); \
-	} \
-	static inline void \
-	pdev_chan_stats_##field##_dec(struct wlan_objmgr_pdev *_pdev, \
-				      uint8_t _val) \
-	{ \
-		ucfg_pdev_chan_stats_##field##_dec(_pdev, _val); \
-	} \
-	static inline void \
-	pdev_chan_stats_##field##_update(struct wlan_objmgr_pdev *_pdev, \
-					 uint8_t _val) \
-	{ \
-		ucfg_pdev_chan_stats_##field##_update(_pdev, _val); \
-	}
-
-PDEV_CHAN_STATS_SET_FUNCS(self_bss_util);
-PDEV_CHAN_STATS_SET_FUNCS(obss_util);
-PDEV_CHAN_STATS_SET_FUNCS(obss_rx_util);
-PDEV_CHAN_STATS_SET_FUNCS(ap_rx_util);
-PDEV_CHAN_STATS_SET_FUNCS(ap_tx_util);
-PDEV_CHAN_STATS_SET_FUNCS(free_medium);
-PDEV_CHAN_STATS_SET_FUNCS(non_wifi_util);
-
 #define PDEV_CHAN_STATS_GET_FUNCS(field) \
-	static inline uint8_t \
+	static inline uint32_t \
 	pdev_chan_stats_##field##_get(struct wlan_objmgr_pdev *_pdev) \
 	{ \
 		return ucfg_pdev_chan_stats_##field##_get(_pdev); \
@@ -368,6 +340,10 @@ PDEV_CHAN_STATS_GET_FUNCS(ap_rx_util);
 PDEV_CHAN_STATS_GET_FUNCS(ap_tx_util);
 PDEV_CHAN_STATS_GET_FUNCS(free_medium);
 PDEV_CHAN_STATS_GET_FUNCS(non_wifi_util);
+PDEV_CHAN_STATS_GET_FUNCS(ss_under_util);
+PDEV_CHAN_STATS_GET_FUNCS(sec_20_util);
+PDEV_CHAN_STATS_GET_FUNCS(sec_40_util);
+PDEV_CHAN_STATS_GET_FUNCS(sec_80_util);
 
 #define PDEV_CP_STATS_GET_FUNCS(field) \
 	static inline uint64_t \

umac/cp_stats/dispatcher/src/wlan_cp_stats_mc_ucfg_api.c

@@ -487,6 +487,11 @@ QDF_STATUS ucfg_mc_cp_stats_set_pending_req(struct wlan_objmgr_psoc *psoc,
 		return QDF_STATUS_E_NULL_VALUE;
 	}
 
+	if (type > TYPE_MAX) {
+		cp_stats_err("Invalid type index: %d", type);
+		return QDF_STATUS_E_INVAL;
+	}
+
 	wlan_cp_stats_psoc_obj_lock(psoc_cp_stats_priv);
 	psoc_mc_stats = psoc_cp_stats_priv->obj_stats;
 	psoc_mc_stats->pending.type_map |= (1 << type);
@@ -508,6 +513,11 @@ QDF_STATUS ucfg_mc_cp_stats_reset_pending_req(struct wlan_objmgr_psoc *psoc,
 		return QDF_STATUS_E_NULL_VALUE;
 	}
 
+	if (type > TYPE_MAX) {
+		cp_stats_err("Invalid type index: %d", type);
+		return QDF_STATUS_E_INVAL;
+	}
+
 	wlan_cp_stats_psoc_obj_lock(psoc_cp_stats_priv);
 	psoc_mc_stats = psoc_cp_stats_priv->obj_stats;
 	psoc_mc_stats->pending.type_map &= ~(1 << type);
@@ -531,6 +541,10 @@ QDF_STATUS ucfg_mc_cp_stats_get_pending_req(struct wlan_objmgr_psoc *psoc,
 		return QDF_STATUS_E_NULL_VALUE;
 	}
 
+	if (type > TYPE_MAX) {
+		cp_stats_err("Invalid type index: %d", type);
+		return QDF_STATUS_E_INVAL;
+	}
 	wlan_cp_stats_psoc_obj_lock(psoc_cp_stats_priv);
 	psoc_mc_stats = psoc_cp_stats_priv->obj_stats;
 	*info = psoc_mc_stats->pending.req[type];

umac/dfs/core/src/misc/dfs_nol.c

@@ -126,7 +126,9 @@ static void dfs_nol_elem_free_work_cb(void *context)
 				tmp_nol_entry) {
 			TAILQ_REMOVE(&dfs->dfs_nol_free_list,
 					nol_entry, nolelem_list);
+			WLAN_DFSNOL_UNLOCK(dfs);
 			qdf_timer_free(&nol_entry->nol_timer);
+			WLAN_DFSNOL_LOCK(dfs);
 			qdf_mem_free(nol_entry);
 		}
 	WLAN_DFSNOL_UNLOCK(dfs);

umac/dfs/dispatcher/inc/wlan_dfs_tgt_api.h

@@ -394,4 +394,12 @@ QDF_STATUS tgt_dfs_reset_spoof_test(struct wlan_objmgr_pdev *pdev)
 	return QDF_STATUS_SUCCESS;
 }
 #endif
+
+/**
+ * tgt_dfs_is_pdev_5ghz() - Check if the input pdev is 5GHZ.
+ * @pdev: Pointer to DFS pdev object.
+ *
+ * Return: true if the pdev supports 5GHz, else false.
+ */
+bool tgt_dfs_is_pdev_5ghz(struct wlan_objmgr_pdev *pdev);
 #endif /* _WLAN_DFS_TGT_API_H_ */

umac/dfs/dispatcher/src/wlan_dfs_init_deinit_api.c

@@ -414,10 +414,6 @@ static void dfs_scan_serialization_comp_info_cb(
 {
 	struct wlan_dfs *dfs = NULL;
 	struct wlan_objmgr_pdev *pdev;
-	struct wlan_lmac_if_dfs_tx_ops *dfs_tx_ops;
-	struct wlan_objmgr_psoc *psoc;
-	bool is_5ghz = false;
-	QDF_STATUS status;
 
 	if (!comp_info) {
 		dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS,  "comp_info is NULL");
@@ -437,25 +433,7 @@ static void dfs_scan_serialization_comp_info_cb(
 
 	comp_info->scan_info.is_cac_in_progress = false;
 
-	psoc = wlan_pdev_get_psoc(pdev);
-	if (!psoc) {
-		dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS,  "null psoc");
-		return;
-	}
-
-	dfs_tx_ops = wlan_psoc_get_dfs_txops(psoc);
-	if (!(dfs_tx_ops && dfs_tx_ops->dfs_is_pdev_5ghz)) {
-		dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS,  "dfs_tx_ops is null");
-		return;
-	}
-
-	status = dfs_tx_ops->dfs_is_pdev_5ghz(pdev, &is_5ghz);
-	if (QDF_IS_STATUS_ERROR(status)) {
-		dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS,  "Failed to get is_5ghz value");
-		return;
-	}
-
-	if (!is_5ghz)
+	if (!tgt_dfs_is_pdev_5ghz(pdev))
 		return;
 
 	dfs = wlan_pdev_get_dfs_obj(pdev);

umac/dfs/dispatcher/src/wlan_dfs_tgt_api.c

@@ -38,6 +38,34 @@ wlan_psoc_get_dfs_txops(struct wlan_objmgr_psoc *psoc)
 	return &((psoc->soc_cb.tx_ops.dfs_tx_ops));
 }
 
+bool tgt_dfs_is_pdev_5ghz(struct wlan_objmgr_pdev *pdev)
+{
+	struct wlan_lmac_if_dfs_tx_ops *dfs_tx_ops;
+	struct wlan_objmgr_psoc *psoc;
+	bool is_5ghz = false;
+	QDF_STATUS status;
+
+	psoc = wlan_pdev_get_psoc(pdev);
+	if (!psoc) {
+		dfs_err(NULL, WLAN_DEBUG_DFS_ALWAYS,  "null psoc");
+		return false;
+	}
+
+	dfs_tx_ops = wlan_psoc_get_dfs_txops(psoc);
+	if (!(dfs_tx_ops && dfs_tx_ops->dfs_is_pdev_5ghz)) {
+		dfs_err(NULL, WLAN_DEBUG_DFS_ALWAYS,  "dfs_tx_ops is null");
+		return false;
+	}
+
+	status = dfs_tx_ops->dfs_is_pdev_5ghz(pdev, &is_5ghz);
+	if (QDF_IS_STATUS_ERROR(status)) {
+		dfs_err(NULL, WLAN_DEBUG_DFS_ALWAYS,  "Failed to get is_5ghz value");
+		return false;
+	}
+
+	return is_5ghz;
+}
+
 QDF_STATUS tgt_dfs_set_current_channel(struct wlan_objmgr_pdev *pdev,
 				       uint16_t dfs_ch_freq,
 				       uint64_t dfs_ch_flags,
@@ -48,6 +76,9 @@ QDF_STATUS tgt_dfs_set_current_channel(struct wlan_objmgr_pdev *pdev,
 {
 	struct wlan_dfs *dfs;
 
+	if (!tgt_dfs_is_pdev_5ghz(pdev))
+		return QDF_STATUS_SUCCESS;
+
 	dfs = global_dfs_to_mlme.pdev_get_comp_private_obj(pdev);
 	if (!dfs) {
 		dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "dfs is NULL");
@@ -216,6 +247,9 @@ QDF_STATUS tgt_dfs_is_precac_timer_running(struct wlan_objmgr_pdev *pdev,
 {
 	struct wlan_dfs *dfs;
 
+	if (!tgt_dfs_is_pdev_5ghz(pdev))
+		return QDF_STATUS_SUCCESS;
+
 	dfs = global_dfs_to_mlme.pdev_get_comp_private_obj(pdev);
 	if (!dfs) {
 		dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "dfs is NULL");
@@ -232,6 +266,9 @@ QDF_STATUS tgt_dfs_get_radars(struct wlan_objmgr_pdev *pdev)
 {
 	struct wlan_dfs *dfs;
 
+	if (!tgt_dfs_is_pdev_5ghz(pdev))
+		return QDF_STATUS_SUCCESS;
+
 	dfs = global_dfs_to_mlme.pdev_get_comp_private_obj(pdev);
 	if (!dfs) {
 		dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "dfs is NULL");
@@ -393,6 +430,9 @@ QDF_STATUS tgt_dfs_stop(struct wlan_objmgr_pdev *pdev)
 {
 	struct wlan_dfs *dfs;
 
+	if (!tgt_dfs_is_pdev_5ghz(pdev))
+		return QDF_STATUS_SUCCESS;
+
 	dfs = global_dfs_to_mlme.pdev_get_comp_private_obj(pdev);
 	if (!dfs) {
 		dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "dfs is NULL");
@@ -523,6 +563,9 @@ QDF_STATUS tgt_dfs_reset_spoof_test(struct wlan_objmgr_pdev *pdev)
 {
 	struct wlan_dfs *dfs;
 
+	if (!tgt_dfs_is_pdev_5ghz(pdev))
+		return QDF_STATUS_SUCCESS;
+
 	dfs = global_dfs_to_mlme.pdev_get_comp_private_obj(pdev);
 	if (!dfs) {
 		dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "dfs is NULL");

umac/dfs/dispatcher/src/wlan_dfs_ucfg_api.c

@@ -142,6 +142,9 @@ QDF_STATUS ucfg_dfs_get_precac_enable(struct wlan_objmgr_pdev *pdev,
 {
 	struct wlan_dfs *dfs;
 
+	if (!tgt_dfs_is_pdev_5ghz(pdev))
+		return QDF_STATUS_SUCCESS;
+
 	dfs = global_dfs_to_mlme.pdev_get_comp_private_obj(pdev);
 	if (!dfs) {
 		dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS,  "null dfs");

umac/dfs/dispatcher/src/wlan_dfs_utils_api.c

@@ -1028,9 +1028,12 @@ QDF_STATUS utils_dfs_is_spoof_check_failed(struct wlan_objmgr_pdev *pdev,
 {
 	struct wlan_dfs *dfs;
 
+	if (!tgt_dfs_is_pdev_5ghz(pdev))
+		return QDF_STATUS_SUCCESS;
+
 	dfs = global_dfs_to_mlme.pdev_get_comp_private_obj(pdev);
 	if (!dfs) {
-		dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS,  "null dfs");
+		dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS,  "dfs is null");
 		return  QDF_STATUS_E_FAILURE;
 	}
 

umac/p2p/core/src/wlan_p2p_off_chan_tx.c

@@ -966,6 +966,7 @@ static QDF_STATUS p2p_roc_req_for_tx_action(
 	roc_ctx->roc_state = ROC_STATE_IDLE;
 	roc_ctx->roc_type = OFF_CHANNEL_TX;
 	roc_ctx->tx_ctx = tx_ctx;
+	roc_ctx->id = tx_ctx->id;
 	tx_ctx->roc_cookie = (uintptr_t)roc_ctx;
 
 	p2p_debug("create roc request for off channel tx, tx ctx:%pK, roc ctx:%pK",
@@ -1244,7 +1245,8 @@ static QDF_STATUS p2p_remove_tx_context(
 	}
 
 end:
-	qdf_idr_remove(&p2p_soc_obj->p2p_idr, tx_ctx->id);
+	if (!tx_ctx->roc_cookie)
+		qdf_idr_remove(&p2p_soc_obj->p2p_idr, tx_ctx->id);
 	qdf_mem_free(tx_ctx->buf);
 	qdf_mem_free(tx_ctx);
 
@@ -1885,6 +1887,7 @@ QDF_STATUS p2p_process_mgmt_tx(struct tx_action_context *tx_ctx)
 
 fail:
 	p2p_send_tx_conf(tx_ctx, false);
+	qdf_idr_remove(&p2p_soc_obj->p2p_idr, tx_ctx->id);
 	qdf_mem_free(tx_ctx->buf);
 	qdf_mem_free(tx_ctx);
 

umac/p2p/core/src/wlan_p2p_roc.c

@@ -365,14 +365,20 @@ static QDF_STATUS p2p_execute_roc_req(struct p2p_roc_context *roc_ctx)
 	}
 
 	roc_ctx->roc_state = ROC_STATE_REQUESTED;
-	go_num = policy_mgr_mode_specific_connection_count(
-			p2p_soc_obj->soc, PM_P2P_GO_MODE, NULL);
-	p2p_debug("present go number:%d", go_num);
-	if (go_num)
-		roc_ctx->duration *= P2P_ROC_DURATION_MULTI_GO_PRESENT;
-	else
-		roc_ctx->duration *= P2P_ROC_DURATION_MULTI_GO_ABSENT;
-
+	if (roc_ctx->duration < P2P_MAX_ROC_DURATION) {
+		go_num = policy_mgr_mode_specific_connection_count(
+				p2p_soc_obj->soc, PM_P2P_GO_MODE, NULL);
+		p2p_debug("present go number:%d", go_num);
+		if (go_num)
+			roc_ctx->duration *= P2P_ROC_DURATION_MULTI_GO_PRESENT;
+		else
+			roc_ctx->duration *= P2P_ROC_DURATION_MULTI_GO_ABSENT;
+		/* this is to protect too huge value if some customers
+		 * give a higher value from supplicant
+		 */
+		if (roc_ctx->duration > P2P_MAX_ROC_DURATION)
+			roc_ctx->duration = P2P_MAX_ROC_DURATION;
+	}
 	status = p2p_scan_start(roc_ctx);
 	if (status != QDF_STATUS_SUCCESS) {
 		qdf_mc_timer_destroy(&roc_ctx->roc_timer);

umac/p2p/core/src/wlan_p2p_roc.h

@@ -30,16 +30,11 @@
 #define P2P_EVENT_PROPAGATE_TIME 10
 #define P2P_WAIT_CANCEL_ROC      1000
 #define P2P_WAIT_CLEANUP_ROC     2000
+#define P2P_MAX_ROC_DURATION     1500
 
-#ifdef QCA_WIFI_3_0_EMU
-#define P2P_ROC_DURATION_MULTI_GO_PRESENT   2
-#define P2P_ROC_DURATION_MULTI_GO_ABSENT    3
-#define P2P_ACTION_FRAME_DEFAULT_WAIT       500
-#else
-#define P2P_ROC_DURATION_MULTI_GO_PRESENT   2
-#define P2P_ROC_DURATION_MULTI_GO_ABSENT    5
+#define P2P_ROC_DURATION_MULTI_GO_PRESENT   6
+#define P2P_ROC_DURATION_MULTI_GO_ABSENT    10
 #define P2P_ACTION_FRAME_DEFAULT_WAIT       200
-#endif
 
 struct wlan_objmgr_vdev;
 struct scan_event;

umac/p2p/dispatcher/src/wlan_p2p_ucfg_api.c

@@ -392,10 +392,11 @@ QDF_STATUS ucfg_p2p_mgmt_tx_cancel(struct wlan_objmgr_psoc *soc,
 	}
 
 	if (QDF_STATUS_SUCCESS != qdf_idr_find(&p2p_soc_obj->p2p_idr,
-					       cookie, &tx_ctx)) {
+					       (int32_t)cookie, &tx_ctx)) {
 		p2p_debug("invalid id");
 		return QDF_STATUS_E_INVAL;
 	}
+	qdf_idr_remove(&p2p_soc_obj->p2p_idr, (int32_t)cookie);
 
 	cancel_tx = qdf_mem_malloc(sizeof(*cancel_tx));
 	if (!cancel_tx) {

umac/scan/dispatcher/src/wlan_scan_ucfg_api.c

@@ -324,6 +324,7 @@ ucfg_scan_get_pno_def_params(struct wlan_objmgr_vdev *vdev,
 	pno_def = &scan->pno_cfg;
 	req->active_dwell_time = scan_def->active_dwell;
 	req->passive_dwell_time = scan_def->passive_dwell;
+	req->scan_random.randomize = scan_def->enable_mac_spoofing;
 
 	/*
 	 *  Update active and passive dwell time depending

wmi/inc/wmi_unified_api.h

@@ -2330,6 +2330,33 @@ QDF_STATUS wmi_unified_fils_discovery_send_cmd(void *wmi_hdl,
 					       struct fd_params *param);
 #endif /* WLAN_SUPPORT_FILS */
 
+/**
+ * wmi_unified_send_roam_scan_stats_cmd() - Wrapper to request roam scan stats
+ * @wmi_hdl: wmi handle
+ * @params: request params
+ *
+ * This function is used to send the roam scan stats request command to
+ * firmware.
+ *
+ * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
+ */
+QDF_STATUS
+wmi_unified_send_roam_scan_stats_cmd(void *wmi_hdl,
+				     struct wmi_roam_scan_stats_req *params);
+
+/**
+ * wmi_extract_roam_scan_stats_res_evt() - API to extract roam scan stats res
+ * @wmi: wmi handle
+ * @evt_buf: pointer to the event buffer
+ * @vdev_id: output pointer to hold vdev id
+ * @res_param: output pointer to hold extracted memory
+ *
+ * Return: QDF_STATUS
+ */
+QDF_STATUS
+wmi_extract_roam_scan_stats_res_evt(wmi_unified_t wmi, void *evt_buf,
+				    uint32_t *vdev_id,
+				    struct wmi_roam_scan_stats_res **res_param);
 /**
  * wmi_unified_offload_11k_cmd() - send 11k offload command
  * @wmi_hdl: wmi handle

wmi/inc/wmi_unified_param.h

@@ -5614,6 +5614,7 @@ typedef enum {
 #endif
 	wmi_twt_enable_complete_event_id,
 	wmi_apf_get_vdev_work_memory_resp_event_id,
+	wmi_roam_scan_stats_event_id,
 
 #ifdef OL_ATH_SMART_LOGGING
 	wmi_debug_fatal_condition_eventid,
@@ -7137,6 +7138,8 @@ typedef struct _hp_dcs_mib_stats  {
  *      in mib structure
  * @chan_nf: Channel noise floor (Units are in dBm)
  * @my_bss_rx_cycle_count: BSS rx cycle count
+ * @reg_rxclr_ext40_cnt: extension channel 40Mhz rxclear count
+ * @reg_rxclr_ext80_cnt: extension channel 80Mhz rxclear count
  */
 typedef struct _wmi_host_dcs_im_tgt_stats {
 	uint32_t                     reg_tsf32;
@@ -7147,6 +7150,11 @@ typedef struct _wmi_host_dcs_im_tgt_stats {
 	wmi_host_dcs_mib_stats_t     mib_stats;
 	uint32_t		     chan_nf;
 	uint32_t		     my_bss_rx_cycle_count;
+	/* these fields are added here for backward compatibility instead of
+	 * wmi_host_dcs_mib_stats_t
+	 */
+	uint32_t                     reg_rxclr_ext40_cnt;
+	uint32_t                     reg_rxclr_ext80_cnt;
 } wmi_host_dcs_im_tgt_stats_t;
 
 /**
@@ -8745,4 +8753,82 @@ struct wmi_apf_read_memory_resp_event_params {
 #define WMI_HOST_VDEV_FLAGS_TRANSMIT_AP        0x00000002
 #define WMI_HOST_VDEV_FLAGS_NON_TRANSMIT_AP    0x00000004
 
+/* Begin of roam scan stats definitions */
+
+#define WMI_ROAM_SCAN_STATS_MAX             5
+#define WMI_ROAM_SCAN_STATS_CANDIDATES_MAX  4
+#define WMI_ROAM_SCAN_STATS_CHANNELS_MAX    50
+
+/**
+ * struct wmi_roam_scan_stats_req - Structure to hold roam scan stats request
+ * @vdev_id: interface id
+ */
+struct wmi_roam_scan_stats_req {
+	uint32_t vdev_id;
+};
+
+/**
+ * struct wmi_roam_scan_cand - Roam scan candidates
+ * @score: score of AP
+ * @rssi: rssi of the AP
+ * @freq: center frequency
+ * @bssid: bssid of AP
+ */
+struct wmi_roam_scan_cand {
+	uint32_t score;
+	uint32_t rssi;
+	uint32_t freq;
+	uint8_t  bssid[QDF_MAC_ADDR_SIZE];
+};
+
+/**
+ * struct wmi_roam_scan_stats_params - Roam scan details
+ * @time_stamp: time at which this roam scan happened
+ * @client_id: id of client which triggered this scan
+ * @num_scan_chans: number of channels that were scanned as part of this scan
+ * @scan_freqs: frequencies of the channels that were scanned
+ * @is_roam_successful: whether a successful roaming happened after this scan
+ * @old_bssid: bssid to which STA is connected just before this scan
+ * @new_bssid: bssid to which STA is roamed to in case of successful roaming
+ * @num_roam_candidates: no.of roam candidates that are being reported
+ * @roam_candidate: roam scan candidate details
+ * @trigger_id: reason for triggering this roam or roam scan
+ * @trigger_value: threshold value related to trigger_id
+ */
+struct wmi_roam_scan_stats_params {
+	uint64_t time_stamp;
+	uint32_t client_id;
+	uint32_t num_scan_chans;
+	uint32_t scan_freqs[WMI_ROAM_SCAN_STATS_CHANNELS_MAX];
+	uint32_t is_roam_successful;
+
+	/* Bssid to which STA is connected when the roam scan is triggered */
+	uint8_t  old_bssid[QDF_MAC_ADDR_SIZE];
+
+	/*
+	 * Bssid to which STA is connected after roaming. Will be valid only
+	 * if is_roam_successful is true.
+	 */
+	uint8_t  new_bssid[QDF_MAC_ADDR_SIZE];
+
+	/* Number of roam candidates that are being reported in the stats */
+	uint32_t num_roam_candidates;
+	struct wmi_roam_scan_cand cand[WMI_ROAM_SCAN_STATS_CANDIDATES_MAX];
+	uint32_t trigger_id;
+	uint32_t trigger_value;
+};
+
+/**
+ * struct wmi_roam_scan_stats_res - Roam scan stats response from firmware
+ * @num_roam_scan: number of roam scans triggered
+ * @roam_scan: place holder to indicate the array of
+ *             wmi_roam_scan_stats_params followed by this structure
+ */
+struct wmi_roam_scan_stats_res {
+	uint32_t num_roam_scans;
+	struct wmi_roam_scan_stats_params roam_scan[0];
+};
+
+/* End of roam scan stats definitions */
+
 #endif /* _WMI_UNIFIED_PARAM_H_ */

wmi/inc/wmi_unified_pmo_api.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017 The Linux Foundation. All rights reserved.
+ * Copyright (c) 2017-2018 The Linux Foundation. All rights reserved.
  *
  * Permission to use, copy, modify, and/or distribute this software for
  * any purpose with or without fee is hereby granted, provided that the
@@ -238,6 +238,7 @@ QDF_STATUS wmi_unified_lphb_config_udp_params_cmd(void *wmi_hdl,
 QDF_STATUS wmi_unified_lphb_config_udp_pkt_filter_cmd(void *wmi_hdl,
 		wmi_hb_set_udp_pkt_filter_cmd_fixed_param *lphb_conf_req);
 
+#ifdef WLAN_FEATURE_PACKET_FILTERING
 /**
  * wmi_unified_enable_disable_packet_filter_cmd() - enable/disable packet filter
  * @wmi_handle: wmi handle
@@ -262,5 +263,6 @@ QDF_STATUS wmi_unified_enable_disable_packet_filter_cmd(void *wmi_hdl,
 QDF_STATUS wmi_unified_config_packet_filter_cmd(void *wmi_hdl,
 		uint8_t vdev_id, struct pmo_rcv_pkt_fltr_cfg *rcv_filter_param,
 		uint8_t filter_id, bool enable);
+#endif
 
 #endif /* _WMI_UNIFIED_PMO_API_H_ */

wmi/inc/wmi_unified_priv.h

@@ -634,12 +634,14 @@ QDF_STATUS (*send_lphb_config_udp_params_cmd)(wmi_unified_t wmi_handle,
 QDF_STATUS (*send_lphb_config_udp_pkt_filter_cmd)(wmi_unified_t wmi_handle,
 					wmi_hb_set_udp_pkt_filter_cmd_fixed_param *lphb_conf_req);
 
+#ifdef WLAN_FEATURE_PACKET_FILTERING
 QDF_STATUS (*send_enable_disable_packet_filter_cmd)(wmi_unified_t wmi_handle,
 					uint8_t vdev_id, bool enable);
 
 QDF_STATUS (*send_config_packet_filter_cmd)(wmi_unified_t wmi_handle,
 		uint8_t vdev_id, struct pmo_rcv_pkt_fltr_cfg *rcv_filter_param,
 		uint8_t filter_id, bool enable);
+#endif
 #endif /* end of WLAN_POWER_MANAGEMENT_OFFLOAD */
 #ifdef CONFIG_MCL
 QDF_STATUS (*send_process_dhcp_ind_cmd)(wmi_unified_t wmi_handle,
@@ -1618,6 +1620,17 @@ QDF_STATUS (*extract_swfda_vdev_id)(wmi_unified_t wmi_handle, void *evt_buf,
 QDF_STATUS (*send_fils_discovery_send_cmd)(wmi_unified_t wmi_handle,
 					   struct fd_params *param);
 #endif /* WLAN_SUPPORT_FILS */
+
+QDF_STATUS
+(*send_roam_scan_stats_cmd)(wmi_unified_t wmi_handle,
+			    struct wmi_roam_scan_stats_req *params);
+
+QDF_STATUS
+(*extract_roam_scan_stats_res_evt)(wmi_unified_t wmi_handle,
+				   void *evt_buf,
+				   uint32_t *vdev_id,
+				   struct wmi_roam_scan_stats_res **res_param);
+
 QDF_STATUS (*send_offload_11k_cmd)(wmi_unified_t wmi_handle,
 		struct wmi_11k_offload_params *params);
 

wmi/src/wmi_unified_api.c

@@ -7492,3 +7492,29 @@ QDF_STATUS wmi_extract_smartlog_ev(void *wmi_hdl,
 	return QDF_STATUS_E_FAILURE;
 }
 #endif /* OL_ATH_SMART_LOGGING */
+
+QDF_STATUS
+wmi_unified_send_roam_scan_stats_cmd(void *wmi_hdl,
+				     struct wmi_roam_scan_stats_req *params)
+{
+	wmi_unified_t wmi_handle = (wmi_unified_t)wmi_hdl;
+
+	if (wmi_handle->ops->send_roam_scan_stats_cmd)
+		return wmi_handle->ops->send_roam_scan_stats_cmd(wmi_handle,
+								 params);
+
+	return QDF_STATUS_E_FAILURE;
+}
+
+QDF_STATUS
+wmi_extract_roam_scan_stats_res_evt(wmi_unified_t wmi, void *evt_buf,
+				    uint32_t *vdev_id,
+				    struct wmi_roam_scan_stats_res **res_param)
+{
+	if (wmi->ops->extract_roam_scan_stats_res_evt)
+		return wmi->ops->extract_roam_scan_stats_res_evt(wmi,
+							evt_buf,
+							vdev_id, res_param);
+
+	return QDF_STATUS_E_FAILURE;
+}

wmi/src/wmi_unified_pmo_api.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017 The Linux Foundation. All rights reserved.
+ * Copyright (c) 2017-2018 The Linux Foundation. All rights reserved.
  *
  * Permission to use, copy, modify, and/or distribute this software for
  * any purpose with or without fee is hereby granted, provided that the
@@ -168,6 +168,7 @@ QDF_STATUS wmi_unified_send_gtk_offload_cmd(void *wmi_hdl, uint8_t vdev_id,
 	return QDF_STATUS_E_FAILURE;
 }
 
+#ifdef WLAN_FEATURE_PACKET_FILTERING
 QDF_STATUS wmi_unified_enable_disable_packet_filter_cmd(void *wmi_hdl,
 		uint8_t vdev_id, bool enable)
 {
@@ -192,6 +193,7 @@ QDF_STATUS wmi_unified_config_packet_filter_cmd(void *wmi_hdl,
 
 	return QDF_STATUS_E_FAILURE;
 }
+#endif
 
 QDF_STATUS wmi_unified_enable_arp_ns_offload_cmd(void *wmi_hdl,
 			   struct pmo_arp_offload_params *arp_offload_req,

wmi/src/wmi_unified_tlv.c

@@ -14829,6 +14829,7 @@ static QDF_STATUS send_conf_hw_filter_cmd_tlv(wmi_unified_t wmi,
 	return status;
 }
 
+#ifdef WLAN_FEATURE_PACKET_FILTERING
 /**
  * send_enable_disable_packet_filter_cmd_tlv() - enable/disable packet filter
  * @wmi_handle: wmi handle
@@ -14957,6 +14958,7 @@ static QDF_STATUS send_config_packet_filter_cmd_tlv(wmi_unified_t wmi_handle,
 
 	return QDF_STATUS_SUCCESS;
 }
+#endif /* End of WLAN_FEATURE_PACKET_FILTERING */
 #endif /* End of WLAN_POWER_MANAGEMENT_OFFLOAD */
 
 /**
@@ -18525,6 +18527,11 @@ static QDF_STATUS extract_p2p_noa_ev_param_tlv(
 		(uint8_t) WMI_UNIFIED_NOA_ATTR_CTWIN_GET(wmi_noa_info);
 	descriptors = WMI_UNIFIED_NOA_ATTR_NUM_DESC_GET(wmi_noa_info);
 	param->num_desc = (uint8_t) descriptors;
+	if (param->num_desc > WMI_P2P_MAX_NOA_DESCRIPTORS) {
+		WMI_LOGE("%s: invalid num desc:%d", __func__,
+			 param->num_desc);
+		return QDF_STATUS_E_INVAL;
+	}
 
 	WMI_LOGD("%s:index %u, opps_ps %u, ct_window %u, num_descriptors = %u", __func__,
 		param->index, param->opps_ps, param->ct_window,
@@ -19201,6 +19208,11 @@ static QDF_STATUS extract_pdev_utf_event_tlv(wmi_unified_t wmi_handle,
 	param_buf = (WMI_PDEV_UTF_EVENTID_param_tlvs *)evt_buf;
 	event->data = param_buf->data;
 	event->datalen = param_buf->num_data;
+
+	if (event->datalen < sizeof(struct wmi_host_utf_seg_header_info)) {
+		WMI_LOGE("%s: Invalid datalen: %d ", __func__, event->datalen);
+		return QDF_STATUS_E_INVAL;
+	}
 	seg_hdr = (struct wmi_host_utf_seg_header_info *)param_buf->data;
 	/* Set pdev_id=1 until FW adds support to include pdev_id */
 	event->pdev_id = wmi_handle->ops->convert_pdev_id_target_to_host(
@@ -21412,6 +21424,237 @@ static QDF_STATUS extract_obss_detection_info_tlv(uint8_t *evt_buf,
 	return QDF_STATUS_SUCCESS;
 }
 
+/**
+ * send_roam_scan_stats_cmd_tlv() - Send roam scan stats req command to fw
+ * @wmi_handle: wmi handle
+ * @params: pointer to request structure
+ *
+ * Return: QDF_STATUS
+ */
+static QDF_STATUS
+send_roam_scan_stats_cmd_tlv(wmi_unified_t wmi_handle,
+			     struct wmi_roam_scan_stats_req *params)
+{
+	wmi_buf_t buf;
+	wmi_request_roam_scan_stats_cmd_fixed_param *cmd;
+	WMITLV_TAG_ID tag;
+	uint32_t size;
+	uint32_t len = sizeof(*cmd);
+
+	buf = wmi_buf_alloc(wmi_handle, len);
+	if (!buf) {
+		WMI_LOGE(FL("Failed to allocate wmi buffer"));
+		return QDF_STATUS_E_FAILURE;
+	}
+
+	cmd = (wmi_request_roam_scan_stats_cmd_fixed_param *)wmi_buf_data(buf);
+
+	tag = WMITLV_TAG_STRUC_wmi_request_roam_scan_stats_cmd_fixed_param;
+	size = WMITLV_GET_STRUCT_TLVLEN(
+			wmi_request_roam_scan_stats_cmd_fixed_param);
+	WMITLV_SET_HDR(&cmd->tlv_header, tag, size);
+
+	cmd->vdev_id = params->vdev_id;
+
+	WMI_LOGD(FL("Roam Scan Stats Req vdev_id: %u"), cmd->vdev_id);
+	if (wmi_unified_cmd_send(wmi_handle, buf, len,
+				 WMI_REQUEST_ROAM_SCAN_STATS_CMDID)) {
+		WMI_LOGE("%s: Failed to send WMI_REQUEST_ROAM_SCAN_STATS_CMDID",
+			 __func__);
+		wmi_buf_free(buf);
+		return QDF_STATUS_E_FAILURE;
+	}
+
+	return QDF_STATUS_SUCCESS;
+}
+
+/**
+ * extract_roam_scan_stats_res_evt_tlv() - Extract roam scan stats event
+ * @wmi_handle: wmi handle
+ * @evt_buf: pointer to event buffer
+ * @vdev_id: output pointer to hold vdev id
+ * @res_param: output pointer to hold the allocated response
+ *
+ * Return: QDF_STATUS
+ */
+static QDF_STATUS
+extract_roam_scan_stats_res_evt_tlv(wmi_unified_t wmi_handle, void *evt_buf,
+				    uint32_t *vdev_id,
+				    struct wmi_roam_scan_stats_res **res_param)
+{
+	WMI_ROAM_SCAN_STATS_EVENTID_param_tlvs *param_buf;
+	wmi_roam_scan_stats_event_fixed_param *fixed_param;
+	uint32_t *client_id = NULL;
+	wmi_roaming_timestamp *timestamp = NULL;
+	uint32_t *num_channels = NULL;
+	uint32_t *chan_info = NULL;
+	wmi_mac_addr *old_bssid = NULL;
+	uint32_t *is_roaming_success = NULL;
+	wmi_mac_addr *new_bssid = NULL;
+	uint32_t *num_roam_candidates = NULL;
+	wmi_roam_scan_trigger_reason *roam_reason = NULL;
+	wmi_mac_addr *bssid = NULL;
+	uint32_t *score = NULL;
+	uint32_t *channel = NULL;
+	uint32_t *rssi = NULL;
+	int chan_idx = 0, cand_idx = 0;
+	uint32_t total_len;
+	struct wmi_roam_scan_stats_res *res;
+	uint32_t i, j;
+	uint32_t num_scans;
+
+	*res_param = NULL;
+	*vdev_id = 0xFF; /* Initialize to invalid vdev id */
+	param_buf = (WMI_ROAM_SCAN_STATS_EVENTID_param_tlvs *)evt_buf;
+	if (!param_buf) {
+		WMI_LOGE(FL("Invalid roam scan stats event"));
+		return QDF_STATUS_E_INVAL;
+	}
+
+	fixed_param = param_buf->fixed_param;
+	total_len = sizeof(*res) + fixed_param->num_roam_scans *
+		    sizeof(struct wmi_roam_scan_stats_params);
+
+	*vdev_id = fixed_param->vdev_id;
+	num_scans = fixed_param->num_roam_scans;
+
+	res = qdf_mem_malloc(total_len);
+	if (!res) {
+		WMI_LOGE("Failed to allocate roam scan stats response memory");
+		return QDF_STATUS_E_NOMEM;
+	}
+
+	if (!num_scans) {
+		*res_param = res;
+		return QDF_STATUS_SUCCESS;
+	}
+
+	if (param_buf->client_id &&
+	    param_buf->num_client_id == num_scans)
+		client_id = param_buf->client_id;
+
+	if (param_buf->timestamp &&
+	    param_buf->num_timestamp == num_scans)
+		timestamp = param_buf->timestamp;
+
+	if (param_buf->old_bssid &&
+	    param_buf->num_old_bssid == num_scans)
+		old_bssid = param_buf->old_bssid;
+
+	if (param_buf->new_bssid &&
+	    param_buf->num_new_bssid == num_scans)
+		new_bssid = param_buf->new_bssid;
+
+	if (param_buf->is_roaming_success &&
+	    param_buf->num_is_roaming_success == num_scans)
+		is_roaming_success = param_buf->is_roaming_success;
+
+	if (param_buf->roam_reason &&
+	    param_buf->num_roam_reason == num_scans)
+		roam_reason = param_buf->roam_reason;
+
+	if (param_buf->num_channels &&
+	    param_buf->num_num_channels == num_scans) {
+		uint32_t count, chan_info_sum = 0;
+
+		num_channels = param_buf->num_channels;
+		for (count = 0; count < param_buf->num_num_channels; count++)
+			chan_info_sum += param_buf->num_channels[count];
+
+		if (param_buf->chan_info &&
+		    param_buf->num_chan_info == chan_info_sum)
+			chan_info = param_buf->chan_info;
+	}
+
+	if (param_buf->num_roam_candidates &&
+	    param_buf->num_num_roam_candidates == num_scans) {
+		uint32_t count, roam_cand_sum = 0;
+
+		num_roam_candidates = param_buf->num_roam_candidates;
+		for (count = 0; count < param_buf->num_num_roam_candidates;
+		     count++)
+			roam_cand_sum += param_buf->num_roam_candidates[count];
+
+		if (param_buf->bssid &&
+		    param_buf->num_bssid == roam_cand_sum)
+			bssid = param_buf->bssid;
+
+		if (param_buf->score &&
+		    param_buf->num_score == roam_cand_sum)
+			score = param_buf->score;
+
+		if (param_buf->channel &&
+		    param_buf->num_channel == roam_cand_sum)
+			channel = param_buf->channel;
+
+		if (param_buf->rssi &&
+		    param_buf->num_rssi == roam_cand_sum)
+			rssi = param_buf->rssi;
+	}
+
+	res->num_roam_scans = num_scans;
+	for (i = 0; i < num_scans; i++) {
+		struct wmi_roam_scan_stats_params *roam = &res->roam_scan[i];
+
+		if (timestamp)
+			roam->time_stamp = timestamp[i].lower32bit |
+						(timestamp[i].upper32bit << 31);
+
+		if (client_id)
+			roam->client_id = client_id[i];
+
+		if (num_channels) {
+			roam->num_scan_chans = num_channels[i];
+			if (chan_info) {
+				for (j = 0; j < num_channels[i]; j++)
+					roam->scan_freqs[j] =
+							chan_info[chan_idx++];
+			}
+		}
+
+		if (is_roaming_success)
+			roam->is_roam_successful = is_roaming_success[i];
+
+		if (roam_reason) {
+			roam->trigger_id = roam_reason[i].trigger_id;
+			roam->trigger_value = roam_reason[i].trigger_value;
+		}
+
+		if (num_roam_candidates) {
+			roam->num_roam_candidates = num_roam_candidates[i];
+
+			for (j = 0; j < num_roam_candidates[i]; j++) {
+				if (score)
+					roam->cand[j].score = score[cand_idx];
+				if (rssi)
+					roam->cand[j].rssi = rssi[cand_idx];
+				if (channel)
+					roam->cand[j].freq =
+						channel[cand_idx];
+
+				if (bssid)
+					WMI_MAC_ADDR_TO_CHAR_ARRAY(
+							&bssid[cand_idx],
+							roam->cand[j].bssid);
+
+				cand_idx++;
+			}
+		}
+
+		if (old_bssid)
+			WMI_MAC_ADDR_TO_CHAR_ARRAY(&old_bssid[i],
+						   roam->old_bssid);
+
+		if (new_bssid)
+			WMI_MAC_ADDR_TO_CHAR_ARRAY(&new_bssid[i],
+						   roam->new_bssid);
+	}
+
+	*res_param = res;
+
+	return QDF_STATUS_SUCCESS;
+}
+
 /**
  * send_offload_11k_cmd_tlv() - send wmi cmd with 11k offload params
  * @wmi_handle: wmi handler
@@ -22055,9 +22298,11 @@ struct wmi_ops tlv_ops =  {
 	.send_lphb_config_udp_params_cmd = send_lphb_config_udp_params_cmd_tlv,
 	.send_lphb_config_udp_pkt_filter_cmd =
 		send_lphb_config_udp_pkt_filter_cmd_tlv,
+#ifdef WLAN_FEATURE_PACKET_FILTERING
 	.send_enable_disable_packet_filter_cmd =
 		send_enable_disable_packet_filter_cmd_tlv,
 	.send_config_packet_filter_cmd = send_config_packet_filter_cmd_tlv,
+#endif
 #endif /* End of WLAN_POWER_MANAGEMENT_OFFLOAD */
 #ifdef CONFIG_MCL
 	.send_process_dhcp_ind_cmd = send_process_dhcp_ind_cmd_tlv,
@@ -22401,6 +22646,8 @@ struct wmi_ops tlv_ops =  {
 #endif
 	.extract_esp_estimation_ev_param =
 				extract_esp_estimation_ev_param_tlv,
+	.send_roam_scan_stats_cmd = send_roam_scan_stats_cmd_tlv,
+	.extract_roam_scan_stats_res_evt = extract_roam_scan_stats_res_evt_tlv,
 };
 
 /**
@@ -22696,6 +22943,7 @@ static void populate_tlv_events_id(uint32_t *event_ids)
 		WMI_BPF_GET_VDEV_WORK_MEMORY_RESP_EVENTID;
 	event_ids[wmi_wlan_sar2_result_event_id] = WMI_SAR2_RESULT_EVENTID;
 	event_ids[wmi_esp_estimate_event_id] = WMI_ESP_ESTIMATE_EVENTID;
+	event_ids[wmi_roam_scan_stats_event_id] = WMI_ROAM_SCAN_STATS_EVENTID;
 }
 
 /**