qcacld-3.0: Use policy manager frequency APIs

For 6GHz support and to remove channel number ambiguity use policy
manager APIs updated for frequency in other modules. This change
covers following APIs:
policy_mgr_get_pcl
policy_mgr_update_with_safe_channel_list
policy_mgr_get_valid_chans_from_range
policy_mgr_get_valid_chans
policy_mgr_set_sap_mandatory_channels
policy_mgr_get_pcl_for_existing_conn
policy_mgr_get_mode_specific_conn_info

Change-Id: Ia21829345be2746cd3fc1f2337cfc90abf0c53f4
CRs-fixed: 2550092

components/cmn_services/policy_mgr/inc/wlan_policy_mgr_api.h

@@ -608,13 +608,9 @@ uint32_t policy_mgr_get_channel(struct wlan_objmgr_psoc *psoc,
  *
  * Return: QDF_STATUS
  */
-QDF_STATUS policy_mgr_get_pcl_int(struct wlan_objmgr_psoc *psoc,
-				  enum policy_mgr_con_mode mode,
-				  uint32_t *pcl_channels, uint32_t *len,
-				  uint8_t *pcl_weight, uint32_t weight_len);
 QDF_STATUS policy_mgr_get_pcl(struct wlan_objmgr_psoc *psoc,
 			      enum policy_mgr_con_mode mode,
-			      uint8_t *pcl_channels, uint32_t *len,
+			      uint32_t *pcl_channels, uint32_t *len,
 			      uint8_t *pcl_weight, uint32_t weight_len);
 
 /**
@@ -631,14 +627,8 @@ QDF_STATUS policy_mgr_get_pcl(struct wlan_objmgr_psoc *psoc,
  *
  * Return: None
  */
-void policy_mgr_update_with_safe_channel_list_int(struct wlan_objmgr_psoc *psoc,
-						  uint32_t *pcl_channels,
-						  uint32_t *len,
-						  uint8_t *weight_list,
-						  uint32_t weight_len);
-
 void policy_mgr_update_with_safe_channel_list(struct wlan_objmgr_psoc *psoc,
-					      uint8_t *pcl_channels,
+					      uint32_t *pcl_channels,
 					      uint32_t *len,
 					      uint8_t *weight_list,
 					      uint32_t weight_len);
@@ -1746,13 +1736,8 @@ bool policy_mgr_list_has_24GHz_channel(uint32_t *ch_freq_list,
  *
  * Return: QDF_STATUS
  */
-QDF_STATUS policy_mgr_get_valid_chans_from_range_int(
-						 struct wlan_objmgr_psoc *psoc,
-						 uint32_t *ch_freq_list,
-						 uint32_t *ch_cnt,
-						 enum policy_mgr_con_mode mode);
 QDF_STATUS policy_mgr_get_valid_chans_from_range(struct wlan_objmgr_psoc *psoc,
-						 uint8_t *ch_list,
+						 uint32_t *ch_list,
 						 uint32_t *ch_cnt,
 						 enum policy_mgr_con_mode mode);
 /**
@@ -1765,11 +1750,9 @@ QDF_STATUS policy_mgr_get_valid_chans_from_range(struct wlan_objmgr_psoc *psoc,
  *
  * Return: QDF_STATUS
  */
-QDF_STATUS policy_mgr_get_valid_chans_int(struct wlan_objmgr_psoc *psoc,
-					  uint32_t *ch_freq_list,
-					  uint32_t *list_len);
 QDF_STATUS policy_mgr_get_valid_chans(struct wlan_objmgr_psoc *psoc,
-				      uint8_t *chan_list, uint32_t *list_len);
+				      uint32_t *ch_freq_list,
+				      uint32_t *list_len);
 
 /**
  * policy_mgr_get_nss_for_vdev() - Get the allowed nss value for the
@@ -1811,12 +1794,8 @@ policy_mgr_get_sap_mandatory_channel(struct wlan_objmgr_psoc *psoc,
  *
  * Return: QDF_STATUS
  */
-QDF_STATUS policy_mgr_set_sap_mandatory_channels_int(
-						 struct wlan_objmgr_psoc *psoc,
-						 uint32_t *ch_freq_list,
-						 uint32_t len);
 QDF_STATUS policy_mgr_set_sap_mandatory_channels(struct wlan_objmgr_psoc *psoc,
-						 uint8_t *ch_list,
+						 uint32_t *ch_freq_list,
 						 uint32_t len);
 
 /**
@@ -1905,18 +1884,13 @@ uint32_t policy_mgr_get_mcc_operating_channel(struct wlan_objmgr_psoc *psoc,
  *
  * Return: None
  */
-QDF_STATUS policy_mgr_get_pcl_for_existing_conn_int(
+QDF_STATUS policy_mgr_get_pcl_for_existing_conn(
 		struct wlan_objmgr_psoc *psoc,
 		enum policy_mgr_con_mode mode,
 		uint32_t *pcl_ch, uint32_t *len,
 		uint8_t *pcl_weight, uint32_t weight_len,
 		bool all_matching_cxn_to_del);
 
-QDF_STATUS policy_mgr_get_pcl_for_existing_conn(struct wlan_objmgr_psoc *psoc,
-		enum policy_mgr_con_mode mode,
-		uint8_t *pcl_ch, uint32_t *len,
-		uint8_t *weight_list, uint32_t weight_len,
-		bool all_matching_cxn_to_del);
 /**
  * policy_mgr_get_valid_chan_weights() - Get the weightage for
  * all valid channels
@@ -3137,12 +3111,8 @@ QDF_STATUS policy_mgr_update_nan_vdev_mac_info(struct wlan_objmgr_psoc *psoc,
  *
  * Return: number of connection found as per given mode
  */
-uint32_t policy_mgr_get_mode_specific_conn_info_int(
-		struct wlan_objmgr_psoc *psoc,
-		uint32_t *ch_freq_list, uint8_t *vdev_id,
-		enum policy_mgr_con_mode mode);
 uint32_t policy_mgr_get_mode_specific_conn_info(struct wlan_objmgr_psoc *psoc,
-						uint8_t *ch_list,
+						uint32_t *ch_freq_list,
 						uint8_t *vdev_id,
 						enum policy_mgr_con_mode mode);
 #endif /* __WLAN_POLICY_MGR_API_H */

components/cmn_services/policy_mgr/src/wlan_policy_mgr_action.c

@@ -654,7 +654,7 @@ policy_mgr_get_preferred_dbs_action_table(
 					 vdev_pri_id);
 			goto NEXT;
 		}
-		vdev_count = policy_mgr_get_mode_specific_conn_info_int(
+		vdev_count = policy_mgr_get_mode_specific_conn_info(
 				psoc, ch_freq_list, vdev_list, pri_conn_mode);
 		/**
 		 * Take care of duplication case, the vdev id may
@@ -1357,17 +1357,15 @@ bool policy_mgr_is_sap_restart_required_after_sta_disconnect(
 		if (policy_mgr_get_connection_count(psoc) > 1)
 			return false;
 
-	cc_count = policy_mgr_get_mode_specific_conn_info_int(
-					psoc,
-					&op_ch_freq_list[0],
-					&vdev_id[0],
-					PM_SAP_MODE);
+	cc_count = policy_mgr_get_mode_specific_conn_info(psoc,
+							  &op_ch_freq_list[0],
+							  &vdev_id[0],
+							  PM_SAP_MODE);
 	go_index_start = cc_count;
 	if (cc_count < MAX_NUMBER_OF_CONC_CONNECTIONS)
-		cc_count += policy_mgr_get_mode_specific_conn_info_int(psoc,
-					&op_ch_freq_list[cc_count],
-					&vdev_id[cc_count],
-					PM_P2P_GO_MODE);
+		cc_count += policy_mgr_get_mode_specific_conn_info(
+					psoc, &op_ch_freq_list[cc_count],
+					&vdev_id[cc_count], PM_P2P_GO_MODE);
 
 	for (i = 0 ; i < cc_count; i++) {
 		if (sap_vdev_id != INVALID_VDEV_ID &&
@@ -1408,9 +1406,9 @@ bool policy_mgr_is_sap_restart_required_after_sta_disconnect(
 	/* Add the user config ch as first condidate */
 	pcl_channels[0] = pm_ctx->user_config_sap_ch_freq;
 	pcl_weight[0] = 0;
-	status = policy_mgr_get_pcl_int(psoc, mode, &pcl_channels[1], &pcl_len,
-					&pcl_weight[1],
-					QDF_ARRAY_SIZE(pcl_weight) - 1);
+	status = policy_mgr_get_pcl(psoc, mode, &pcl_channels[1], &pcl_len,
+				    &pcl_weight[1],
+				    QDF_ARRAY_SIZE(pcl_weight) - 1);
 	if (status == QDF_STATUS_SUCCESS)
 		pcl_len++;
 	else
@@ -1762,14 +1760,14 @@ static void __policy_mgr_check_sta_ap_concurrent_ch_intf(void *data)
 	if (!policy_mgr_is_restart_sap_allowed(psoc, mcc_to_scc_switch))
 		goto end;
 
-	cc_count = policy_mgr_get_mode_specific_conn_info_int(
+	cc_count = policy_mgr_get_mode_specific_conn_info(
 				psoc, &op_ch_freq_list[cc_count],
 				&vdev_id[cc_count], PM_SAP_MODE);
 	policy_mgr_debug("Number of concurrent SAP: %d", cc_count);
 	go_index_start = cc_count;
 	if (cc_count < MAX_NUMBER_OF_CONC_CONNECTIONS)
 		cc_count = cc_count +
-				policy_mgr_get_mode_specific_conn_info_int(
+				policy_mgr_get_mode_specific_conn_info(
 					psoc, &op_ch_freq_list[cc_count],
 					&vdev_id[cc_count], PM_P2P_GO_MODE);
 	policy_mgr_debug("Number of beaconing entities (SAP + GO):%d",
@@ -1999,7 +1997,7 @@ void policy_mgr_check_concurrent_intf_and_restart_sap(
 	/*
 	 * force SCC with STA+STA+SAP will need some additional logic
 	 */
-	cc_count = policy_mgr_get_mode_specific_conn_info_int(
+	cc_count = policy_mgr_get_mode_specific_conn_info(
 				psoc, &op_ch_freq_list[cc_count],
 				&vdev_id[cc_count], PM_STA_MODE);
 	if (!cc_count) {

components/cmn_services/policy_mgr/src/wlan_policy_mgr_core.c

@@ -1361,10 +1361,10 @@ QDF_STATUS policy_mgr_pdev_get_pcl(struct wlan_objmgr_psoc *psoc,
 
 	policy_mgr_debug("get pcl to set it to the FW");
 
-	status = policy_mgr_get_pcl_int(psoc, con_mode,
-					pcl->pcl_list, &pcl->pcl_len,
-					pcl->weight_list,
-					QDF_ARRAY_SIZE(pcl->weight_list));
+	status = policy_mgr_get_pcl(psoc, con_mode,
+				    pcl->pcl_list, &pcl->pcl_len,
+				    pcl->weight_list,
+				    QDF_ARRAY_SIZE(pcl->weight_list));
 	if (status != QDF_STATUS_SUCCESS)
 		policy_mgr_err("Unable to set PCL to FW, Get PCL failed");
 
@@ -2050,8 +2050,8 @@ QDF_STATUS policy_mgr_get_channel_list(struct wlan_objmgr_psoc *psoc,
 	}
 
 	/* get the channel list for current domain */
-	status = policy_mgr_get_valid_chans_int(psoc, channel_list,
-						&num_channels);
+	status = policy_mgr_get_valid_chans(psoc, channel_list,
+					    &num_channels);
 	if (QDF_IS_STATUS_ERROR(status)) {
 		policy_mgr_err("Error in getting valid channels");
 		goto end;
@@ -2447,9 +2447,9 @@ QDF_STATUS policy_mgr_get_channel_list(struct wlan_objmgr_psoc *psoc,
 
 	/* check the channel avoidance list for beaconing entities */
 	if ((mode == PM_SAP_MODE) || (mode == PM_P2P_GO_MODE))
-		policy_mgr_update_with_safe_channel_list_int(psoc, pcl_channels,
-							     len, pcl_weights,
-							     weight_len);
+		policy_mgr_update_with_safe_channel_list(psoc, pcl_channels,
+							 len, pcl_weights,
+							 weight_len);
 
 	policy_mgr_set_weight_of_dfs_passive_channels_to_zero(psoc,
 			pcl_channels, len, pcl_weights, weight_len);
@@ -3231,7 +3231,7 @@ void  policy_mgr_init_sap_mandatory_2g_chan(struct wlan_objmgr_psoc *psoc)
 		return;
 	}
 
-	status = policy_mgr_get_valid_chans_int(psoc, ch_freq_list, &len);
+	status = policy_mgr_get_valid_chans(psoc, ch_freq_list, &len);
 	if (QDF_IS_STATUS_ERROR(status)) {
 		policy_mgr_err("Error in getting valid channels");
 		return;

components/cmn_services/policy_mgr/src/wlan_policy_mgr_get_set_utils.c

@@ -1959,7 +1959,7 @@ bool policy_mgr_is_ibss_conn_exist(struct wlan_objmgr_psoc *psoc,
 	return status;
 }
 
-uint32_t policy_mgr_get_mode_specific_conn_info_int(
+uint32_t policy_mgr_get_mode_specific_conn_info(
 		struct wlan_objmgr_psoc *psoc,
 		uint32_t *ch_freq_list, uint8_t *vdev_id,
 		enum policy_mgr_con_mode mode)
@@ -2003,21 +2003,6 @@ uint32_t policy_mgr_get_mode_specific_conn_info_int(
 	return count;
 }
 
-uint32_t
-policy_mgr_get_mode_specific_conn_info(struct wlan_objmgr_psoc *psoc,
-				       uint8_t *channels, uint8_t *vdev_id,
-				       enum policy_mgr_con_mode mode)
-{
-	uint32_t count, i, ch_freq_list[MAX_NUMBER_OF_CONC_CONNECTIONS];
-
-	count = policy_mgr_get_mode_specific_conn_info_int(psoc, ch_freq_list,
-							   vdev_id, mode);
-	for (i = 0; i < count; i++)
-		channels[i] = wlan_freq_to_chan(ch_freq_list[i]);
-
-	return count;
-}
-
 bool policy_mgr_max_concurrent_connections_reached(
 		struct wlan_objmgr_psoc *psoc)
 {
@@ -2390,9 +2375,9 @@ bool policy_mgr_allow_concurrency(struct wlan_objmgr_psoc *psoc,
 	bool allowed;
 
 	qdf_mem_zero(&pcl, sizeof(pcl));
-	status = policy_mgr_get_pcl_int(psoc, mode, pcl.pcl_list, &pcl.pcl_len,
-					pcl.weight_list,
-					QDF_ARRAY_SIZE(pcl.weight_list));
+	status = policy_mgr_get_pcl(psoc, mode, pcl.pcl_list, &pcl.pcl_len,
+				    pcl.weight_list,
+				    QDF_ARRAY_SIZE(pcl.weight_list));
 	if (QDF_IS_STATUS_ERROR(status)) {
 		policy_mgr_err("disallow connection:%d", status);
 		return false;
@@ -3400,14 +3385,14 @@ QDF_STATUS policy_mgr_is_chan_ok_for_dnbs(struct wlan_objmgr_psoc *psoc,
 		return QDF_STATUS_E_INVAL;
 	}
 
-	cc_count = policy_mgr_get_mode_specific_conn_info_int(
+	cc_count = policy_mgr_get_mode_specific_conn_info(
 			psoc, &op_ch_freq_list[cc_count],
 			&vdev_id[cc_count], PM_SAP_MODE);
 	policy_mgr_debug("Number of SAP modes: %d", cc_count);
 
 	if (cc_count < MAX_NUMBER_OF_CONC_CONNECTIONS)
 		cc_count = cc_count +
-			   policy_mgr_get_mode_specific_conn_info_int(
+			   policy_mgr_get_mode_specific_conn_info(
 					psoc, &op_ch_freq_list[cc_count],
 					&vdev_id[cc_count], PM_P2P_GO_MODE);
 	policy_mgr_debug("Number of beaconing entities (SAP + GO):%d",

components/cmn_services/policy_mgr/src/wlan_policy_mgr_pcl.c

@@ -62,7 +62,7 @@ policy_mgr_next_action_two_connection_table_type
 policy_mgr_next_action_three_connection_table_type
 		*next_action_three_connection_2x2_2g_1x1_5g_table;
 
-QDF_STATUS policy_mgr_get_pcl_for_existing_conn_int(
+QDF_STATUS policy_mgr_get_pcl_for_existing_conn(
 		struct wlan_objmgr_psoc *psoc,
 		enum policy_mgr_con_mode mode,
 		uint32_t *pcl_ch, uint32_t *len,
@@ -89,8 +89,8 @@ QDF_STATUS policy_mgr_get_pcl_for_existing_conn_int(
 		policy_mgr_store_and_del_conn_info(psoc, mode,
 				all_matching_cxn_to_del, info, &num_cxn_del);
 		/* Get the PCL */
-		status = policy_mgr_get_pcl_int(psoc, mode, pcl_ch, len,
-						pcl_weight, weight_len);
+		status = policy_mgr_get_pcl(psoc, mode, pcl_ch, len,
+					    pcl_weight, weight_len);
 		policy_mgr_debug("Get PCL to FW for mode:%d", mode);
 		/* Restore the connection info */
 		policy_mgr_restore_deleted_conn_info(psoc, info, num_cxn_del);
@@ -100,25 +100,6 @@ QDF_STATUS policy_mgr_get_pcl_for_existing_conn_int(
 	return status;
 }
 
-QDF_STATUS policy_mgr_get_pcl_for_existing_conn(struct wlan_objmgr_psoc *psoc,
-						enum policy_mgr_con_mode mode,
-						uint8_t *pcl_ch, uint32_t *len,
-						uint8_t *pcl_weight,
-						uint32_t weight_len,
-						bool all_matching_cxn_to_del)
-{
-	uint32_t i, pcl_freqs[QDF_MAX_NUM_CHAN] = {0};
-	QDF_STATUS status;
-
-	status = policy_mgr_get_pcl_for_existing_conn_int(psoc, mode, pcl_freqs,
-							  len, pcl_weight,
-							  weight_len,
-						  all_matching_cxn_to_del);
-	for (i = 0; i < *len; i++)
-		pcl_ch[i] = wlan_freq_to_chan(pcl_freqs[i]);
-	return status;
-}
-
 void policy_mgr_decr_session_set_pcl(struct wlan_objmgr_psoc *psoc,
 						enum QDF_OPMODE mode,
 						uint8_t session_id)
@@ -230,11 +211,11 @@ policy_mgr_reg_chan_change_callback(struct wlan_objmgr_psoc *psoc,
 			 pm_ctx->unsafe_channel_count);
 }
 
-void policy_mgr_update_with_safe_channel_list_int(struct wlan_objmgr_psoc *psoc,
-						  uint32_t *pcl_channels,
-						  uint32_t *len,
-						  uint8_t *weight_list,
-						  uint32_t weight_len)
+void policy_mgr_update_with_safe_channel_list(struct wlan_objmgr_psoc *psoc,
+					      uint32_t *pcl_channels,
+					      uint32_t *len,
+					      uint8_t *weight_list,
+					      uint32_t weight_len)
 {
 	uint32_t current_channel_list[QDF_MAX_NUM_CHAN];
 	uint8_t org_weight_list[QDF_MAX_NUM_CHAN];
@@ -304,24 +285,6 @@ void policy_mgr_update_with_safe_channel_list_int(struct wlan_objmgr_psoc *psoc,
 	return;
 }
 
-void policy_mgr_update_with_safe_channel_list(struct wlan_objmgr_psoc *psoc,
-					      uint8_t *pcl_channels,
-					      uint32_t *len,
-					      uint8_t *weight_list,
-					      uint32_t weight_len)
-{
-	uint32_t i, pcl_freqs[QDF_MAX_NUM_CHAN];
-
-	for (i = 0; i < *len; i++)
-		pcl_freqs[i] = wlan_chan_to_freq(pcl_channels[i]);
-
-	policy_mgr_update_with_safe_channel_list_int(psoc, pcl_freqs, len,
-						     weight_list, weight_len);
-
-	for (i = 0; i < *len; i++)
-		pcl_channels[i] = wlan_freq_to_chan(pcl_freqs[i]);
-}
-
 static QDF_STATUS policy_mgr_modify_pcl_based_on_enabled_channels(
 					struct policy_mgr_psoc_priv_obj *pm_ctx,
 					uint32_t *pcl_list_org,
@@ -757,10 +720,10 @@ static inline enum policy_mgr_pcl_type policy_mgr_get_pcl_4_port(
 {return PM_MAX_PCL_TYPE; }
 #endif
 
-QDF_STATUS policy_mgr_get_pcl_int(struct wlan_objmgr_psoc *psoc,
-				  enum policy_mgr_con_mode mode,
-				  uint32_t *pcl_channels, uint32_t *len,
-				  uint8_t *pcl_weight, uint32_t weight_len)
+QDF_STATUS policy_mgr_get_pcl(struct wlan_objmgr_psoc *psoc,
+			      enum policy_mgr_con_mode mode,
+			      uint32_t *pcl_channels, uint32_t *len,
+			      uint8_t *pcl_weight, uint32_t weight_len)
 {
 	QDF_STATUS status = QDF_STATUS_E_FAILURE;
 	uint32_t num_connections = 0, i;
@@ -889,23 +852,6 @@ QDF_STATUS policy_mgr_get_pcl_int(struct wlan_objmgr_psoc *psoc,
 	return QDF_STATUS_SUCCESS;
 }
 
-QDF_STATUS policy_mgr_get_pcl(struct wlan_objmgr_psoc *psoc,
-			      enum policy_mgr_con_mode mode,
-			      uint8_t *pcl_channels, uint32_t *len,
-			      uint8_t *pcl_weight, uint32_t weight_len)
-{
-	uint32_t i, pcl_freqs[QDF_MAX_NUM_CHAN] = {0};
-	QDF_STATUS status;
-
-	status = policy_mgr_get_pcl_int(psoc, mode, pcl_freqs, len, pcl_weight,
-					weight_len);
-
-	for (i = 0; i < *len; i++)
-		pcl_channels[i] = wlan_freq_to_chan(pcl_freqs[i]);
-
-	return status;
-}
-
 enum policy_mgr_conc_priority_mode
 		policy_mgr_get_first_connection_pcl_table_index(
 		struct wlan_objmgr_psoc *psoc)
@@ -1987,14 +1933,14 @@ policy_mgr_get_nondfs_preferred_channel(struct wlan_objmgr_psoc *psoc,
 			return non_dfs_freq;
 
 		if (QDF_STATUS_SUCCESS !=
-				policy_mgr_get_pcl_for_existing_conn_int(
+				policy_mgr_get_pcl_for_existing_conn(
 					psoc, mode,
 					pcl_channels, &pcl_len,
 					pcl_weight, QDF_ARRAY_SIZE(pcl_weight),
 					false))
 			return freq;
 	} else {
-		if (QDF_STATUS_SUCCESS != policy_mgr_get_pcl_int(
+		if (QDF_STATUS_SUCCESS != policy_mgr_get_pcl(
 		    psoc, mode, pcl_channels, &pcl_len, pcl_weight,
 		    QDF_ARRAY_SIZE(pcl_weight)))
 			return freq;
@@ -2030,7 +1976,7 @@ static void policy_mgr_remove_dsrc_channels(uint32_t *ch_freq_list,
 	*num_channels = num_chan_temp;
 }
 
-QDF_STATUS policy_mgr_get_valid_chans_from_range_int(
+QDF_STATUS policy_mgr_get_valid_chans_from_range(
 		struct wlan_objmgr_psoc *psoc, uint32_t *ch_freq_list,
 		uint32_t *ch_cnt, enum policy_mgr_con_mode mode)
 {
@@ -2051,7 +1997,7 @@ QDF_STATUS policy_mgr_get_valid_chans_from_range_int(
 
 	/* check the channel avoidance list for beaconing entities */
 	if (mode == PM_SAP_MODE || mode == PM_P2P_GO_MODE)
-		policy_mgr_update_with_safe_channel_list_int(
+		policy_mgr_update_with_safe_channel_list(
 			psoc, ch_freq_list, ch_cnt, ch_weight_list,
 			ch_weight_len);
 
@@ -2074,28 +2020,9 @@ QDF_STATUS policy_mgr_get_valid_chans_from_range_int(
 	return status;
 }
 
-QDF_STATUS policy_mgr_get_valid_chans_from_range(struct wlan_objmgr_psoc *psoc,
-						 uint8_t *ch_list,
-						 uint32_t *ch_cnt,
-						 enum policy_mgr_con_mode mode)
-{
-	uint32_t i, ch_freq_list[QDF_MAX_NUM_CHAN];
-	QDF_STATUS status;
-
-	for (i = 0; i < *ch_cnt; i++)
-		ch_freq_list[i] = wlan_chan_to_freq(ch_list[i]);
-
-	status = policy_mgr_get_valid_chans_from_range_int(psoc, ch_freq_list,
-							   ch_cnt, mode);
-
-	for (i = 0; i < *ch_cnt; i++)
-		ch_list[i] = wlan_freq_to_chan(ch_freq_list[i]);
-	return status;
-}
-
-QDF_STATUS policy_mgr_get_valid_chans_int(struct wlan_objmgr_psoc *psoc,
-					  uint32_t *ch_freq_list,
-					  uint32_t *list_len)
+QDF_STATUS policy_mgr_get_valid_chans(struct wlan_objmgr_psoc *psoc,
+				      uint32_t *ch_freq_list,
+				      uint32_t *list_len)
 {
 	struct policy_mgr_psoc_priv_obj *pm_ctx;
 
@@ -2121,19 +2048,6 @@ QDF_STATUS policy_mgr_get_valid_chans_int(struct wlan_objmgr_psoc *psoc,
 	return QDF_STATUS_SUCCESS;
 }
 
-QDF_STATUS policy_mgr_get_valid_chans(struct wlan_objmgr_psoc *psoc,
-				      uint8_t *ch_list, uint32_t *list_len)
-{
-	uint32_t i, ch_freq_list[QDF_MAX_NUM_CHAN] = {0};
-	QDF_STATUS status;
-
-	status = policy_mgr_get_valid_chans_int(psoc, ch_freq_list, list_len);
-	for (i = 0; i < *list_len; i++)
-		ch_list[i] = wlan_freq_to_chan(ch_freq_list[i]);
-
-	return status;
-}
-
 bool policy_mgr_list_has_24GHz_channel(uint32_t *ch_freq_list,
 				       uint32_t list_len)
 {
@@ -2148,8 +2062,8 @@ bool policy_mgr_list_has_24GHz_channel(uint32_t *ch_freq_list,
 }
 
 QDF_STATUS
-policy_mgr_set_sap_mandatory_channels_int(struct wlan_objmgr_psoc *psoc,
-					  uint32_t *ch_freq_list, uint32_t len)
+policy_mgr_set_sap_mandatory_channels(struct wlan_objmgr_psoc *psoc,
+				      uint32_t *ch_freq_list, uint32_t len)
 {
 	uint32_t i;
 	struct policy_mgr_psoc_priv_obj *pm_ctx;
@@ -2183,22 +2097,6 @@ policy_mgr_set_sap_mandatory_channels_int(struct wlan_objmgr_psoc *psoc,
 	return QDF_STATUS_SUCCESS;
 }
 
-QDF_STATUS policy_mgr_set_sap_mandatory_channels(struct wlan_objmgr_psoc *psoc,
-						 uint8_t *ch_list,
-						 uint32_t len)
-{
-	uint32_t i, ch_freq_list[QDF_MAX_NUM_CHAN] = {0};
-	QDF_STATUS status;
-
-	for (i = 0; i < len; i++)
-		ch_freq_list[i] = wlan_chan_to_freq(ch_list[i]);
-
-	status = policy_mgr_set_sap_mandatory_channels_int(psoc, ch_freq_list,
-							   len);
-
-	return status;
-}
-
 bool policy_mgr_is_sap_mandatory_channel_set(struct wlan_objmgr_psoc *psoc)
 {
 	struct policy_mgr_psoc_priv_obj *pm_ctx;
@@ -2273,7 +2171,7 @@ QDF_STATUS policy_mgr_get_sap_mandatory_channel(struct wlan_objmgr_psoc *psoc,
 
 	qdf_mem_zero(&pcl, sizeof(pcl));
 
-	status = policy_mgr_get_pcl_for_existing_conn_int(
+	status = policy_mgr_get_pcl_for_existing_conn(
 			psoc, PM_SAP_MODE, pcl.pcl_list, &pcl.pcl_len,
 			pcl.weight_list, QDF_ARRAY_SIZE(pcl.weight_list),
 			false);
@@ -2290,7 +2188,7 @@ QDF_STATUS policy_mgr_get_sap_mandatory_channel(struct wlan_objmgr_psoc *psoc,
 	if (!pcl.pcl_len && !policy_mgr_mode_specific_connection_count(psoc,
 	    PM_SAP_MODE, NULL)) {
 		policy_mgr_debug("policy_mgr_get_pcl_for_existing_conn returned no pcl");
-		status = policy_mgr_get_pcl_int(
+		status = policy_mgr_get_pcl(
 				psoc, PM_SAP_MODE,
 				pcl.pcl_list, &pcl.pcl_len,
 				pcl.weight_list,
@@ -2436,7 +2334,7 @@ uint32_t policy_mgr_get_alternate_channel_for_sap(
 	policy_mgr_store_and_del_conn_info_by_vdev_id(psoc, sap_vdev_id,
 						      &info, &num_cxn_del);
 
-	if (QDF_STATUS_SUCCESS == policy_mgr_get_pcl_int(
+	if (QDF_STATUS_SUCCESS == policy_mgr_get_pcl(
 	    psoc, PM_SAP_MODE, pcl_channels, &pcl_len,
 	    pcl_weight, QDF_ARRAY_SIZE(pcl_weight))) {
 		for (i = 0; i < pcl_len; i++) {

core/hdd/src/wlan_hdd_cfg80211.c

@@ -2279,6 +2279,7 @@ static int wlan_hdd_sap_get_valid_channellist(struct hdd_adapter *adapter,
 	struct sap_config *sap_config;
 	struct hdd_context *hdd_ctx = WLAN_HDD_GET_CTX(adapter);
 	uint8_t tmp_chan_list[QDF_MAX_NUM_CHAN] = {0};
+	uint32_t pcl_freqs[QDF_MAX_NUM_CHAN] = {0};
 	uint32_t chan_count;
 	uint8_t i;
 	QDF_STATUS status;
@@ -2287,14 +2288,15 @@ static int wlan_hdd_sap_get_valid_channellist(struct hdd_adapter *adapter,
 
 	sap_config = &adapter->session.ap.sap_config;
 
-	status =
-		policy_mgr_get_valid_chans(hdd_ctx->psoc,
-					   tmp_chan_list,
-					   &chan_count);
+	status = policy_mgr_get_valid_chans(hdd_ctx->psoc,
+					    pcl_freqs,
+					    &chan_count);
 	if (QDF_IS_STATUS_ERROR(status)) {
 		hdd_err("Failed to get channel list");
 		return -EINVAL;
 	}
+	for (i = 0; i < chan_count; i++)
+		tmp_chan_list[i] = wlan_freq_to_chan(pcl_freqs[i]);
 
 	for (i = 0; i < chan_count; i++) {
 		tmp_chan = tmp_chan_list[i];
@@ -2717,6 +2719,7 @@ static int __wlan_hdd_cfg80211_do_acs(struct wiphy *wiphy,
 	bool etsi13_srd_chan;
 	bool go_11ac_override = 0;
 	bool sap_11ac_override = 0;
+	uint32_t pcl_freq_list[QDF_MAX_NUM_CHAN] = {0};
 
 	/* ***Note*** Donot set SME config related to ACS operation here because
 	 * ACS operation is not synchronouse and ACS for Second AP may come when
@@ -2936,14 +2939,18 @@ static int __wlan_hdd_cfg80211_do_acs(struct wiphy *wiphy,
 	      policy_mgr_convert_device_mode_to_qdf_type(adapter->device_mode);
 	/* consult policy manager to get PCL */
 	qdf_status = policy_mgr_get_pcl(hdd_ctx->psoc, pm_mode,
-					sap_config->acs_cfg.pcl_channels,
+					pcl_freq_list,
 					&sap_config->acs_cfg.pcl_ch_count,
 					sap_config->acs_cfg.
 					pcl_channels_weight_list,
 					QDF_MAX_NUM_CHAN);
-	if (qdf_status != QDF_STATUS_SUCCESS)
+	if (qdf_status != QDF_STATUS_SUCCESS) {
 		hdd_err("Get PCL failed");
-
+	} else {
+		for (i = 0; i < sap_config->acs_cfg.pcl_ch_count; i++)
+			sap_config->acs_cfg.pcl_channels[i] =
+				 wlan_freq_to_chan(pcl_freq_list[i]);
+	}
 	if (sap_config->acs_cfg.pcl_ch_count) {
 		hdd_debug("ACS config PCL: len: %d",
 			  sap_config->acs_cfg.pcl_ch_count);
@@ -9630,7 +9637,7 @@ static int __wlan_hdd_cfg80211_get_preferred_freq_list(struct wiphy *wiphy,
 	if (!chan_weights)
 		return -ENOMEM;
 
-	status = policy_mgr_get_pcl_int(
+	status = policy_mgr_get_pcl(
 			hdd_ctx->psoc, intf_mode, chan_weights->pcl_list,
 			&chan_weights->pcl_len, chan_weights->weight_list,
 			QDF_ARRAY_SIZE(chan_weights->weight_list));
@@ -10635,7 +10642,6 @@ __wlan_hdd_cfg80211_sap_configuration_set(struct wiphy *wiphy,
 	if (tb[QCA_WLAN_VENDOR_ATTR_SAP_MANDATORY_FREQUENCY_LIST]) {
 		uint32_t freq_len, i;
 		uint32_t *freq;
-		uint8_t chans[QDF_MAX_NUM_CHAN];
 
 		hdd_debug("setting mandatory freq/chan list");
 
@@ -10654,12 +10660,11 @@ __wlan_hdd_cfg80211_sap_configuration_set(struct wiphy *wiphy,
 		hdd_debug("freq_len=%d", freq_len);
 
 		for (i = 0; i < freq_len; i++) {
-			chans[i] = ieee80211_frequency_to_channel(freq[i]);
 			hdd_debug("freq[%d]=%d", i, freq[i]);
 		}
 
 		status = policy_mgr_set_sap_mandatory_channels(
-			hdd_ctx->psoc, chans, freq_len);
+			hdd_ctx->psoc, freq, freq_len);
 		if (QDF_IS_STATUS_ERROR(status))
 			return -EINVAL;
 	}

core/hdd/src/wlan_hdd_conc_ut.c

@@ -624,7 +624,7 @@ void wlan_hdd_one_connection_scenario(struct hdd_context *hdd_ctx)
 	enum policy_mgr_con_mode sub_type;
 	uint8_t pcl[QDF_MAX_NUM_CHAN] = {0},
 		weight_list[QDF_MAX_NUM_CHAN] = {0};
-	uint32_t pcl_len = 0;
+	uint32_t pcl_len = 0, i, pcl_freqs[QDF_MAX_NUM_CHAN] = {0};
 	bool status = false;
 	enum policy_mgr_pcl_type pcl_type;
 	char reason[20] = {0};
@@ -654,8 +654,11 @@ void wlan_hdd_one_connection_scenario(struct hdd_context *hdd_ctx)
 			sub_type, system_pref);
 
 		/* check PCL value for second connection is correct or no */
-		policy_mgr_get_pcl(hdd_ctx->psoc, sub_type, pcl, &pcl_len,
-				weight_list, QDF_ARRAY_SIZE(weight_list));
+		policy_mgr_get_pcl(hdd_ctx->psoc, sub_type, pcl_freqs, &pcl_len,
+				   weight_list, QDF_ARRAY_SIZE(weight_list));
+		for (i = 0; i < pcl_len; i++)
+			pcl[i] = wlan_freq_to_chan(pcl_freqs[i]);
+
 		status = wlan_hdd_validate_pcl(hdd_ctx,
 				pcl_type, pcl, pcl_len, 0, 0,
 				reason, sizeof(reason));
@@ -677,7 +680,7 @@ void wlan_hdd_two_connections_scenario(struct hdd_context *hdd_ctx,
 	uint8_t type = WMI_VDEV_TYPE_STA, channel_id = first_chnl, mac_id = 1;
 	uint8_t pcl[QDF_MAX_NUM_CHAN] = {0},
 			weight_list[QDF_MAX_NUM_CHAN] = {0};
-	uint32_t pcl_len = 0;
+	uint32_t pcl_len = 0, i, pcl_freqs[QDF_MAX_NUM_CHAN];
 	enum policy_mgr_chain_mode chain_mask = first_chain_mask;
 	enum policy_mgr_con_mode sub_type, next_sub_type, dummy_type;
 	enum policy_mgr_pcl_type pcl_type;
@@ -734,8 +737,11 @@ void wlan_hdd_two_connections_scenario(struct hdd_context *hdd_ctx,
 					hdd_ctx->psoc));
 			/* check PCL for second connection is correct or no */
 			policy_mgr_get_pcl(hdd_ctx->psoc,
-				next_sub_type, pcl, &pcl_len,
-				weight_list, QDF_ARRAY_SIZE(weight_list));
+					   next_sub_type, pcl_freqs, &pcl_len,
+					   weight_list,
+					   QDF_ARRAY_SIZE(weight_list));
+			for (i = 0; i < pcl_len; i++)
+				pcl[i] = wlan_freq_to_chan(pcl_freqs[i]);
 			status = wlan_hdd_validate_pcl(hdd_ctx,
 					pcl_type, pcl, pcl_len, channel_id, 0,
 					reason, sizeof(reason));
@@ -762,7 +768,7 @@ void wlan_hdd_three_connections_scenario(struct hdd_context *hdd_ctx,
 	uint8_t mac_id_1, mac_id_2;
 	uint8_t type_1 = WMI_VDEV_TYPE_STA, type_2 = WMI_VDEV_TYPE_STA;
 	uint8_t pcl[MAX_NUM_CHAN] = {0}, weight_list[MAX_NUM_CHAN] = {0};
-	uint32_t pcl_len = 0;
+	uint32_t pcl_len = 0, i, pcl_freqs[QDF_MAX_NUM_CHAN];
 	enum policy_mgr_chain_mode chain_mask_1;
 	enum policy_mgr_chain_mode chain_mask_2;
 	enum policy_mgr_con_mode sub_type_1, sub_type_2, next_sub_type;
@@ -857,11 +863,13 @@ void wlan_hdd_three_connections_scenario(struct hdd_context *hdd_ctx,
 					system_pref,
 					policy_mgr_is_hw_dbs_capable(
 					hdd_ctx->psoc));
-				policy_mgr_get_pcl(hdd_ctx->psoc,
-					next_sub_type,
-					pcl, &pcl_len,
-					weight_list,
+				policy_mgr_get_pcl(
+					hdd_ctx->psoc, next_sub_type,
+					pcl_freqs, &pcl_len, weight_list,
 					QDF_ARRAY_SIZE(weight_list));
+				for (i = 0; i < pcl_len; i++)
+					pcl[i] =
+						wlan_freq_to_chan(pcl_freqs[i]);
 				status = wlan_hdd_validate_pcl(hdd_ctx,
 					pcl_type, pcl, pcl_len,
 					channel_id_1, channel_id_2,

core/hdd/src/wlan_hdd_hostapd.c

@@ -6038,6 +6038,7 @@ wlan_hdd_ap_ap_force_scc_override(struct hdd_adapter *adapter,
 	struct hdd_context *hdd_ctx = WLAN_HDD_GET_CTX(adapter);
 	uint32_t cc_count, i;
 	uint8_t op_ch[MAX_NUMBER_OF_CONC_CONNECTIONS];
+	uint32_t op_freq[MAX_NUMBER_OF_CONC_CONNECTIONS];
 	uint8_t vdev_id[MAX_NUMBER_OF_CONC_CONNECTIONS];
 	struct ch_params ch_params;
 	enum nl80211_channel_type channel_type;
@@ -6065,17 +6066,19 @@ wlan_hdd_ap_ap_force_scc_override(struct hdd_adapter *adapter,
 	    (mcc_to_scc_switch != QDF_MCC_TO_SCC_WITH_PREFERRED_BAND))
 		return false;
 	cc_count = policy_mgr_get_mode_specific_conn_info(hdd_ctx->psoc,
-							  &op_ch[0],
+							  &op_freq[0],
 							  &vdev_id[0],
 							  PM_SAP_MODE);
 	if (cc_count < MAX_NUMBER_OF_CONC_CONNECTIONS)
 		cc_count = cc_count +
 				policy_mgr_get_mode_specific_conn_info(
 					hdd_ctx->psoc,
-					&op_ch[cc_count],
+					&op_freq[cc_count],
 					&vdev_id[cc_count],
 					PM_P2P_GO_MODE);
 	for (i = 0 ; i < cc_count; i++) {
+		op_ch[i] = wlan_freq_to_chan(op_freq[i]);
+
 		if (channel == op_ch[i])
 			continue;
 		if (!policy_mgr_is_hw_dbs_capable(hdd_ctx->psoc))

core/hdd/src/wlan_hdd_sap_cond_chan_switch.c

@@ -100,8 +100,8 @@ static int wlan_hdd_validate_and_get_pre_cac_ch(struct hdd_context *hdd_ctx,
 	QDF_STATUS status;
 	uint32_t weight_len = 0;
 	uint32_t len = CFG_VALID_CHANNEL_LIST_LEN;
-	uint8_t channel_list[QDF_MAX_NUM_CHAN] = {0};
-	uint8_t pcl_weights[QDF_MAX_NUM_CHAN] = {0};
+	uint32_t freq_list[NUM_CHANNELS] = {0};
+	uint8_t pcl_weights[NUM_CHANNELS] = {0};
 	mac_handle_t mac_handle;
 
 	if (channel == 0) {
@@ -113,19 +113,20 @@ static int wlan_hdd_validate_and_get_pre_cac_ch(struct hdd_context *hdd_ctx,
 		 * first channel from the valid channel list.
 		 */
 		status = policy_mgr_get_valid_chans(hdd_ctx->psoc,
-						    channel_list, &len);
+						    freq_list, &len);
 		if (QDF_IS_STATUS_ERROR(status)) {
 			hdd_err("Failed to get channel list");
 			return -EINVAL;
 		}
 		policy_mgr_update_with_safe_channel_list(hdd_ctx->psoc,
-							 channel_list, &len,
+							 freq_list, &len,
 							 pcl_weights,
 							 weight_len);
 		for (i = 0; i < len; i++) {
-			if (wlan_reg_is_dfs_ch(hdd_ctx->pdev,
-					       channel_list[i])) {
-				*pre_cac_chan = channel_list[i];
+			if (wlan_reg_is_dfs_for_freq(hdd_ctx->pdev,
+						     freq_list[i])) {
+				*pre_cac_chan =
+					wlan_freq_to_chan(freq_list[i]);
 				break;
 			}
 		}

core/hdd/src/wlan_hdd_wext.c

@@ -7591,7 +7591,7 @@ static int iw_get_policy_manager_ut_ops(struct hdd_context *hdd_ctx,
 
 	case WE_POLICY_MANAGER_PCL_CMD:
 	{
-		uint8_t pcl[QDF_MAX_NUM_CHAN] = {0};
+		uint32_t pcl[QDF_MAX_NUM_CHAN] = {0};
 		uint8_t weight_list[QDF_MAX_NUM_CHAN] = {0};
 		uint32_t pcl_len = 0, i = 0;
 
@@ -7602,9 +7602,9 @@ static int iw_get_policy_manager_ut_ops(struct hdd_context *hdd_ctx,
 			return 0;
 		}
 		policy_mgr_get_pcl(hdd_ctx->psoc, apps_args[0],
-				pcl, &pcl_len,
-				weight_list, QDF_ARRAY_SIZE(weight_list));
-		hdd_debug("PCL list for role[%d] is {", apps_args[0]);
+				   pcl, &pcl_len,
+				   weight_list, QDF_ARRAY_SIZE(weight_list));
+		hdd_debug("PCL Freq list for role[%d] is {", apps_args[0]);
 		for (i = 0 ; i < pcl_len; i++)
 			hdd_debug(" %d, ", pcl[i]);
 		hdd_debug("}--------->\n");

core/sap/src/sap_module.c

@@ -2917,6 +2917,7 @@ wlansap_get_safe_channel(struct sap_context *sap_ctx)
 {
 	struct mac_context *mac;
 	struct sir_pcl_list pcl = {0};
+	uint32_t i, pcl_freqs[QDF_MAX_NUM_CHAN];
 	QDF_STATUS status;
 	mac_handle_t mac_handle;
 
@@ -2934,13 +2935,14 @@ wlansap_get_safe_channel(struct sap_context *sap_ctx)
 
 	/* get the channel list for current domain */
 	status = policy_mgr_get_valid_chans(mac->psoc,
-					    pcl.pcl_list,
+					    pcl_freqs,
 					    &pcl.pcl_len);
 	if (QDF_IS_STATUS_ERROR(status)) {
 		sap_err("Error in getting valid channels");
 		return INVALID_CHANNEL_ID;
 	}
-
+	for (i = 0; i < pcl.pcl_len; i++)
+		pcl.pcl_list[i] = wlan_freq_to_chan(pcl_freqs[i]);
 	status = wlansap_filter_ch_based_acs(sap_ctx,
 					     pcl.pcl_list,
 					     &pcl.pcl_len);
@@ -2948,10 +2950,12 @@ wlansap_get_safe_channel(struct sap_context *sap_ctx)
 		sap_err("failed to filter ch from acs %d", status);
 		return INVALID_CHANNEL_ID;
 	}
+	for (i = 0; i < pcl.pcl_len; i++)
+		pcl_freqs[i] = wlan_chan_to_freq(pcl.pcl_list[i]);
 
 	if (pcl.pcl_len) {
 		status = policy_mgr_get_valid_chans_from_range(mac->psoc,
-							       pcl.pcl_list,
+							       pcl_freqs,
 							       &pcl.pcl_len,
 							       PM_SAP_MODE);
 		if (QDF_IS_STATUS_ERROR(status)) {
@@ -2961,8 +2965,8 @@ wlansap_get_safe_channel(struct sap_context *sap_ctx)
 
 		if (pcl.pcl_len) {
 			sap_debug("select %d from valid channel list",
-				  pcl.pcl_list[0]);
-			return pcl.pcl_list[0];
+				  pcl_freqs[0]);
+			return wlan_freq_to_chan(pcl_freqs[0]);
 		}
 	}
 
@@ -2991,6 +2995,7 @@ wlansap_get_safe_channel_from_pcl_and_acs_range(struct sap_context *sap_ctx)
 {
 	struct mac_context *mac;
 	struct sir_pcl_list pcl = {0};
+	uint32_t i, pcl_freqs[QDF_MAX_NUM_CHAN] = {0};
 	QDF_STATUS status;
 	mac_handle_t mac_handle;
 
@@ -3007,13 +3012,15 @@ wlansap_get_safe_channel_from_pcl_and_acs_range(struct sap_context *sap_ctx)
 	mac_handle = MAC_HANDLE(mac);
 
 	status = policy_mgr_get_pcl_for_existing_conn(
-			mac->psoc, PM_SAP_MODE, pcl.pcl_list, &pcl.pcl_len,
+			mac->psoc, PM_SAP_MODE, pcl_freqs, &pcl.pcl_len,
 			pcl.weight_list, QDF_ARRAY_SIZE(pcl.weight_list),
 			false);
 	if (QDF_IS_STATUS_ERROR(status)) {
 		sap_err("Get PCL failed");
 		return INVALID_CHANNEL_ID;
 	}
+	for (i = 0; i < pcl.pcl_len; i++)
+		pcl.pcl_list[i] = wlan_freq_to_chan(pcl_freqs[i]);
 
 	if (pcl.pcl_len) {
 		status = wlansap_filter_ch_based_acs(sap_ctx,

core/sme/src/csr/csr_api_roam.c

@@ -11140,7 +11140,7 @@ void csr_update_connect_n_roam_cmn_filter(struct mac_context *mac_ctx,
 					  enum QDF_OPMODE opmode)
 {
 	enum policy_mgr_con_mode pm_mode;
-	uint32_t len = 0;
+	uint32_t len = 0, i, pcl_freq_list[NUM_CHANNELS] = {0};
 	QDF_STATUS status;
 
 	/* enable bss scoring for only STA mode */
@@ -11154,11 +11154,16 @@ void csr_update_connect_n_roam_cmn_filter(struct mac_context *mac_ctx,
 
 	if (policy_mgr_map_concurrency_mode(&opmode, &pm_mode)) {
 		status = policy_mgr_get_pcl(mac_ctx->psoc, pm_mode,
-					    filter->pcl_channel_list, &len,
+					    pcl_freq_list, &len,
 					    filter->pcl_weight_list,
 					    QDF_MAX_NUM_CHAN);
 		if (QDF_IS_STATUS_ERROR(status))
 			return;
+		for (i = 0; i < len; i++) {
+			filter->pcl_channel_list[i] =
+				wlan_reg_freq_to_chan(mac_ctx->pdev,
+						      pcl_freq_list[i]);
+		}
 		filter->num_of_pcl_channels = len;
 	}
 }
@@ -22093,7 +22098,7 @@ csr_roam_update_cfg(struct mac_context *mac, uint8_t vdev_id, uint8_t reason)
 QDF_STATUS
 csr_enable_roaming_on_connected_sta(struct mac_context *mac, uint8_t vdev_id)
 {
-	uint8_t op_ch[MAX_NUMBER_OF_CONC_CONNECTIONS];
+	uint32_t op_ch_freq_list[MAX_NUMBER_OF_CONC_CONNECTIONS];
 	uint8_t vdev_id_list[MAX_NUMBER_OF_CONC_CONNECTIONS];
 	uint32_t sta_vdev_id = WLAN_INVALID_VDEV_ID;
 	struct csr_roam_session *session;
@@ -22104,7 +22109,8 @@ csr_enable_roaming_on_connected_sta(struct mac_context *mac, uint8_t vdev_id)
 	if (sta_vdev_id != WLAN_UMAC_VDEV_ID_MAX)
 		return QDF_STATUS_E_FAILURE;
 
-	count = policy_mgr_get_mode_specific_conn_info(mac->psoc, op_ch,
+	count = policy_mgr_get_mode_specific_conn_info(mac->psoc,
+						       op_ch_freq_list,
 						       vdev_id_list,
 						       PM_STA_MODE);