qcacld-3.0: Replace channel with frequency in csr_channel

Replace channel ID with frequency in struct csr_channel.

Change-Id: Id86aacfd6dc9b0c65184bf046a7ee27b9c1fb5e5
CRs-Fixed: 2519204

core/mac/inc/sir_api.h

@@ -2021,7 +2021,7 @@ typedef struct {
 	uint8_t encryption;
 	uint8_t mcencryption;
 	uint8_t ChannelCount;
-	uint8_t ChannelCache[SIR_ROAM_MAX_CHANNELS];
+	uint32_t chan_freq_cache[SIR_ROAM_MAX_CHANNELS];
 #ifdef WLAN_FEATURE_11W
 	bool mfp_enabled;
 #endif

core/sap/src/sap_ch_select.c

@@ -589,7 +589,7 @@ static bool sap_chan_sel_init(mac_handle_t mac_handle,
 			      struct sap_context *sap_ctx)
 {
 	tSapSpectChInfo *pSpectCh = NULL;
-	uint8_t *pChans = NULL;
+	uint32_t *pChans = NULL;
 	uint16_t channelnum = 0;
 	struct mac_context *mac = MAC_CONTEXT(mac_handle);
 	bool chSafe = true;
@@ -616,7 +616,7 @@ static bool sap_chan_sel_init(mac_handle_t mac_handle,
 	/* Initialize the pointers in the DfsParams to the allocated memory */
 	pSpectInfoParams->pSpectCh = pSpectCh;
 
-	pChans = mac->scan.base_channels.channelList;
+	pChans = mac->scan.base_channels.channel_freq_list;
 
 #if defined(FEATURE_WLAN_STA_AP_MODE_DFS_DISABLE)
 	if (sap_ctx->dfs_ch_disable == true)
@@ -630,9 +630,12 @@ static bool sap_chan_sel_init(mac_handle_t mac_handle,
 	for (channelnum = 0;
 	     channelnum < pSpectInfoParams->numSpectChans;
 	     channelnum++, pChans++, pSpectCh++) {
+		uint8_t channel;
+
+		channel = wlan_reg_freq_to_chan(mac->pdev, *pChans);
 		chSafe = true;
 
-		pSpectCh->chNum = *pChans;
+		pSpectCh->chNum = channel;
 		/* Initialise for all channels */
 		pSpectCh->rssiAgr = SOFTAP_MIN_RSSI;
 		/* Initialise 20MHz for all the Channels */
@@ -642,22 +645,22 @@ static bool sap_chan_sel_init(mac_handle_t mac_handle,
 
 		/* check if the channel is in NOL blacklist */
 		if (sap_dfs_is_channel_in_nol_list(
-					sap_ctx, *pChans,
+					sap_ctx, channel,
 					PHY_SINGLE_CHANNEL_CENTERED)) {
 			QDF_TRACE(QDF_MODULE_ID_SAP, QDF_TRACE_LEVEL_INFO_HIGH,
 				  "In %s, Ch %d is in NOL list", __func__,
-				  *pChans);
+				  channel);
 			chSafe = false;
 			continue;
 		}
 
 		if (!include_dfs_ch || sta_sap_scc_on_dfs_chan) {
-			if (wlan_reg_is_dfs_ch(mac->pdev, *pChans)) {
+			if (wlan_reg_is_dfs_ch(mac->pdev, channel)) {
 				chSafe = false;
 				QDF_TRACE(QDF_MODULE_ID_SAP,
 					  QDF_TRACE_LEVEL_INFO_HIGH,
 					  "In %s, DFS Ch %d not considered for ACS. include_dfs_ch %u, sta_sap_scc_on_dfs_chan %d",
-					  __func__, *pChans, include_dfs_ch,
+					  __func__, channel, include_dfs_ch,
 					  sta_sap_scc_on_dfs_chan);
 				continue;
 			}
@@ -665,12 +668,12 @@ static bool sap_chan_sel_init(mac_handle_t mac_handle,
 
 #ifdef FEATURE_WLAN_CH_AVOID
 		for (i = 0; i < NUM_CHANNELS; i++) {
-			if ((safe_channels[i].channelNumber == *pChans) &&
+			if ((safe_channels[i].channelNumber == channel) &&
 			    (false == safe_channels[i].isSafe)) {
 				QDF_TRACE(QDF_MODULE_ID_SAP,
 					  QDF_TRACE_LEVEL_INFO_HIGH,
 					  "In %s, Ch %d is not safe", __func__,
-					  *pChans);
+					  channel);
 				chSafe = false;
 				break;
 			}
@@ -678,17 +681,17 @@ static bool sap_chan_sel_init(mac_handle_t mac_handle,
 #endif /* FEATURE_WLAN_CH_AVOID */
 
 		/* OFDM rates are not supported on channel 14 */
-		if (*pChans == 14 &&
+		if (channel == 14 &&
 		    eCSR_DOT11_MODE_11b != sap_ctx->csr_roamProfile.phyMode) {
 			continue;
 		}
 
 		/* Skip DSRC channels */
-		if (wlan_reg_is_dsrc_chan(mac->pdev, *pChans))
+		if (wlan_reg_is_dsrc_chan(mac->pdev, channel))
 			continue;
 
 		if (!mac->mlme_cfg->reg.etsi13_srd_chan_in_master_mode &&
-		    wlan_reg_is_etsi13_srd_chan(mac->pdev, *pChans))
+		    wlan_reg_is_etsi13_srd_chan(mac->pdev, channel))
 			continue;
 
 		if (true == chSafe) {

core/sme/inc/csr_api.h

@@ -266,7 +266,7 @@ typedef struct tagCsrEseCckmIe {
 
 typedef struct sCsrChannel_ {
 	uint8_t numChannels;
-	uint8_t channelList[CFG_VALID_CHANNEL_LIST_LEN];
+	uint32_t channel_freq_list[CFG_VALID_CHANNEL_LIST_LEN];
 } sCsrChannel;
 
 typedef struct tagCsrScanResultFilter {
@@ -321,7 +321,7 @@ typedef struct tagCsrScanResultFilter {
 } tCsrScanResultFilter;
 
 typedef struct sCsrChnPower_ {
-	uint8_t firstChannel;
+	uint8_t first_chan_freq;
 	uint8_t numChannels;
 	uint8_t maxtxPower;
 } sCsrChnPower;

core/sme/inc/csr_internal.h

@@ -199,7 +199,7 @@ enum csr_diagwlan_status_eventreason {
 
 struct csr_channel {
 	uint8_t numChannels;
-	uint8_t channelList[CFG_VALID_CHANNEL_LIST_LEN];
+	uint32_t channel_freq_list[CFG_VALID_CHANNEL_LIST_LEN];
 };
 
 struct bss_config_param {
@@ -980,12 +980,10 @@ bool csr_roam_is_fast_roam_enabled(struct mac_context *mac,
 						uint32_t sessionId);
 bool csr_roam_is_roam_offload_scan_enabled(
 	struct mac_context *mac);
-bool csr_is_channel_present_in_list(uint8_t *pChannelList,
-						   int numChannels,
-						   uint8_t channel);
-QDF_STATUS csr_add_to_channel_list_front(uint8_t *pChannelList,
-							int numChannels,
-		uint8_t channel);
+bool csr_is_channel_present_in_list(uint32_t *pChannelList,
+				    int numChannels, uint32_t chan_freq);
+QDF_STATUS csr_add_to_channel_list_front(uint32_t *pChannelList,
+					 int numChannels, uint32_t chan_freq);
 #if defined(WLAN_FEATURE_HOST_ROAM) || defined(WLAN_FEATURE_ROAM_OFFLOAD)
 QDF_STATUS csr_roam_offload_scan_rsp_hdlr(struct mac_context *mac,
 		struct roam_offload_scan_rsp *scanOffloadRsp);

core/sme/inc/csr_neighbor_roam.h

@@ -206,7 +206,7 @@ QDF_STATUS csr_neighbor_roam_channels_filter_by_current_band(
 		uint8_t *pOutputChannelList,
 		uint8_t *pMergedOutputNumOfChannels);
 QDF_STATUS csr_neighbor_roam_merge_channel_lists(struct mac_context *mac,
-		uint8_t *pInputChannelList,
+		uint32_t *pinput_chan_freq_list,
 		uint8_t inputNumOfChannels,
 		uint8_t *pOutputChannelList,
 		uint8_t outputNumOfChannels,

core/sme/src/common/sme_api.c

@@ -5357,7 +5357,7 @@ sme_search_in_base_ch_lst(struct mac_context *mac_ctx, uint8_t curr_ch)
 
 	ch_lst_info = &mac_ctx->scan.base_channels;
 	for (i = 0; i < ch_lst_info->numChannels; i++) {
-		if (ch_lst_info->channelList[i] == curr_ch)
+		if (ch_lst_info->channel_freq_list[i] == wlan_reg_chan_to_freq(mac_ctx->pdev, curr_ch))
 			return true;
 	}
 
@@ -7343,9 +7343,7 @@ static bool sme_validate_freq_list(mac_handle_t mac_handle,
 	while (i < num_channels) {
 		found = false;
 		for (j = 0; j < ch_lst_info->numChannels; j++) {
-			if (wlan_reg_chan_to_freq(mac_ctx->pdev,
-						  ch_lst_info->channelList[j])
-			    == freq_list[i]) {
+			if (ch_lst_info->channel_freq_list[j] == freq_list[i]) {
 				found = true;
 				break;
 			}
@@ -15291,7 +15289,8 @@ bool sme_validate_channel_list(mac_handle_t mac_handle,
 	while (i < num_channels) {
 		found = false;
 		for (j = 0; j < ch_lst_info->numChannels; j++) {
-			if (ch_lst_info->channelList[j] == chan_list[i]) {
+			if (ch_lst_info->channel_freq_list[j] ==
+				wlan_reg_chan_to_freq(mac_ctx->pdev, chan_list[i])) {
 				found = true;
 				break;
 			}

core/sme/src/csr/csr_api_roam.c

@@ -599,10 +599,10 @@ QDF_STATUS csr_set_channels(struct mac_context *mac,
 		     mac->scan.countryCodeCurrent, CFG_COUNTRY_CODE_LEN);
 	for (index = 0; index < mac->scan.base_channels.numChannels;
 	     index++) {
-		pParam->Csr11dinfo.Channels.channelList[index] =
-			mac->scan.base_channels.channelList[index];
-		pParam->Csr11dinfo.ChnPower[index].firstChannel =
-			mac->scan.base_channels.channelList[index];
+		pParam->Csr11dinfo.Channels.channel_freq_list[index] =
+			mac->scan.base_channels.channel_freq_list[index];
+		pParam->Csr11dinfo.ChnPower[index].first_chan_freq =
+			mac->scan.base_channels.channel_freq_list[index];
 		pParam->Csr11dinfo.ChnPower[index].numChannels = 1;
 		pParam->Csr11dinfo.ChnPower[index].maxtxPower =
 			mac->scan.defaultPowerTable[index].tx_power;
@@ -845,19 +845,19 @@ scan_list_sort_error:
 #define SCAN_CHAN_LIST_5G_LEN 6
 #define SCAN_CHAN_LIST_2G_LEN 3
 static const uint8_t
-csr_scan_chan_list_5g[SCAN_CHAN_LIST_5G_LEN] = { 36, 44, 52, 56, 140, 149 };
+csr_scan_chan_list_5g[SCAN_CHAN_LIST_5G_LEN] = { 5180, 5220, 5260, 5280, 5700, 5745 };
 static const uint8_t
-csr_scan_chan_list_2g[SCAN_CHAN_LIST_2G_LEN] = { 1, 6, 11 };
+csr_scan_chan_list_2g[SCAN_CHAN_LIST_2G_LEN] = { 2412, 2437, 2462 };
 static QDF_STATUS csr_emu_chan_req(uint32_t channel)
 {
 	int i;
 
-	if (WLAN_REG_IS_24GHZ_CH(channel)) {
+	if (WLAN_REG_IS_24GHZ_CH_FREQ(channel)) {
 		for (i = 0; i < QDF_ARRAY_SIZE(csr_scan_chan_list_2g); i++) {
 			if (csr_scan_chan_list_2g[i] == channel)
 				return QDF_STATUS_SUCCESS;
 		}
-	} else if (WLAN_REG_IS_5GHZ_CH(channel)) {
+	} else if (WLAN_REG_IS_5GHZ_CH_FREQ(channel)) {
 		for (i = 0; i < QDF_ARRAY_SIZE(csr_scan_chan_list_5g); i++) {
 			if (csr_scan_chan_list_5g[i] == channel)
 				return QDF_STATUS_SUCCESS;
@@ -979,18 +979,20 @@ QDF_STATUS csr_update_channel_list(struct mac_context *mac)
 		struct csr_sta_roam_policy_params *roam_policy =
 			&mac->roam.configParam.sta_roam_policy;
 		if (QDF_STATUS_SUCCESS !=
-			csr_emu_chan_req(pScan->base_channels.channelList[i]))
+			csr_emu_chan_req(pScan->base_channels.channel_freq_list[i]))
 			continue;
 
+		channel = wlan_reg_freq_to_chan(mac->pdev,
+						pScan->base_channels.channel_freq_list[i]);
+
 		/* Scan is not performed on DSRC channels*/
-		if (wlan_reg_is_dsrc_chan(mac->pdev,
-					  pScan->base_channels.channelList[i]))
+		if (wlan_reg_is_dsrc_chan(mac->pdev, channel))
 			continue;
 
-		channel = pScan->base_channels.channelList[i];
-
-		channel_state = wlan_reg_get_channel_state(mac->pdev,
-				pScan->base_channels.channelList[i]);
+		channel_state =
+			wlan_reg_get_channel_state(mac->pdev,
+				wlan_reg_freq_to_chan(mac->pdev,
+						      pScan->base_channels.channel_freq_list[i]));
 		if ((CHANNEL_STATE_ENABLE == channel_state) ||
 		    mac->scan.fEnableDFSChnlScan) {
 			if ((mac->roam.configParam.sta_roam_policy.dfs_mode ==
@@ -1027,17 +1029,15 @@ QDF_STATUS csr_update_channel_list(struct mac_context *mac)
 				}
 			}
 			pChanList->chanParam[num_channel].freq =
-				wlan_reg_chan_to_freq
-					(mac->pdev,
-					 pScan->base_channels.channelList[i]);
+					pScan->base_channels.channel_freq_list[i];
 			pChanList->chanParam[num_channel].pwr =
 				csr_find_channel_pwr
 					(pScan->defaultPowerTable,
-					 pScan->base_channels.channelList[i]);
+					 wlan_reg_freq_to_chan(mac->pdev, pScan->base_channels.channel_freq_list[i]));
 
 			if (pScan->fcc_constraint) {
-				if (12 ==
-					pScan->base_channels.channelList[i]) {
+				if (2467 ==
+					pScan->base_channels.channel_freq_list[i]) {
 					pChanList->chanParam[num_channel].pwr =
 						MAX_PWR_FCC_CHAN_12;
 					QDF_TRACE(QDF_MODULE_ID_SME,
@@ -1045,8 +1045,8 @@ QDF_STATUS csr_update_channel_list(struct mac_context *mac)
 						  "txpow for channel 12 is %d",
 						  MAX_PWR_FCC_CHAN_12);
 				}
-				if (13 ==
-					pScan->base_channels.channelList[i]) {
+				if (2472 ==
+					pScan->base_channels.channel_freq_list[i]) {
 					pChanList->chanParam[num_channel].pwr =
 						MAX_PWR_FCC_CHAN_13;
 					QDF_TRACE(QDF_MODULE_ID_SME,
@@ -1688,7 +1688,7 @@ QDF_STATUS csr_create_roam_scan_channel_list(struct mac_context *mac,
 	if (mac->scan.occupiedChannels[sessionId].numChannels) {
 		csr_neighbor_roam_merge_channel_lists(mac, &mac->scan.
 						occupiedChannels[sessionId].
-						channelList[0], mac->scan.
+						channel_freq_list[0], mac->scan.
 						occupiedChannels[sessionId].
 						numChannels, in_ptr,
 						inNumChannels,
@@ -1994,8 +1994,7 @@ csr_fetch_ch_lst_from_received_list(struct mac_context *mac_ctx,
 				continue;
 			}
 		}
-		req_buf->ConnectedNetwork.ChannelCache[num_channels++] =
-			wlan_reg_freq_to_chan(mac_ctx->pdev, *freq_lst);
+		req_buf->ConnectedNetwork.chan_freq_cache[num_channels++] = *freq_lst;
 		freq_lst++;
 	}
 	req_buf->ConnectedNetwork.ChannelCount = num_channels;
@@ -2665,15 +2664,15 @@ static void csr_prune_ch_list(struct csr_channel *ch_lst, bool is_24_GHz)
 
 	for ( ; idx < ch_lst->numChannels; idx++) {
 		if (is_24_GHz) {
-			if (WLAN_REG_IS_24GHZ_CH(ch_lst->channelList[idx])) {
-				ch_lst->channelList[num_channels] =
-					ch_lst->channelList[idx];
+			if (WLAN_REG_IS_24GHZ_CH_FREQ(ch_lst->channel_freq_list[idx])) {
+				ch_lst->channel_freq_list[num_channels] =
+					ch_lst->channel_freq_list[idx];
 				num_channels++;
 			}
 		} else {
-			if (WLAN_REG_IS_5GHZ_CH(ch_lst->channelList[idx])) {
-				ch_lst->channelList[num_channels] =
-					ch_lst->channelList[idx];
+			if (WLAN_REG_IS_5GHZ_CH_FREQ(ch_lst->channel_freq_list[idx])) {
+				ch_lst->channel_freq_list[num_channels] =
+					ch_lst->channel_freq_list[idx];
 				num_channels++;
 			}
 		}
@@ -2688,9 +2687,9 @@ static void csr_prune_ch_list(struct csr_channel *ch_lst, bool is_24_GHz)
 	 * channel in the structure.
 	 */
 	if (ch_lst->numChannels > num_channels) {
-		qdf_mem_zero(&ch_lst->channelList[num_channels],
-			    sizeof(ch_lst->channelList[0]) *
-			    (ch_lst->numChannels - num_channels));
+		qdf_mem_zero(&ch_lst->channel_freq_list[num_channels],
+			     sizeof(ch_lst->channel_freq_list[0]) *
+			     (ch_lst->numChannels - num_channels));
 	}
 	ch_lst->numChannels = num_channels;
 }
@@ -2729,7 +2728,8 @@ QDF_STATUS csr_is_valid_channel(struct mac_context *mac, uint8_t chnNum)
 	/* regulatory check */
 	for (index = 0; index < mac->scan.base_channels.numChannels;
 	     index++) {
-		if (mac->scan.base_channels.channelList[index] == chnNum) {
+		if (mac->scan.base_channels.channel_freq_list[index] ==
+				wlan_reg_chan_to_freq(mac->pdev, chnNum)) {
 			status = QDF_STATUS_SUCCESS;
 			break;
 		}
@@ -2765,8 +2765,8 @@ QDF_STATUS csr_get_channel_and_power_list(struct mac_context *mac)
 		/* Move the channel list to the global data */
 		/* structure -- this will be used as the scan list */
 		for (Index = 0; Index < num20MHzChannelsFound; Index++)
-			mac->scan.base_channels.channelList[Index] =
-				mac->scan.defaultPowerTable[Index].chan_num;
+			mac->scan.base_channels.channel_freq_list[Index] =
+				wlan_reg_chan_to_freq(mac->pdev, mac->scan.defaultPowerTable[Index].chan_num);
 		mac->scan.base_channels.numChannels =
 			num20MHzChannelsFound;
 	}
@@ -2805,8 +2805,8 @@ static QDF_STATUS csr_init11d_info(struct mac_context *mac, tCsr11dinfo *ps11din
 		ps11dinfo->Channels.numChannels)) {
 		mac->scan.base_channels.numChannels =
 			ps11dinfo->Channels.numChannels;
-		qdf_mem_copy(mac->scan.base_channels.channelList,
-			     ps11dinfo->Channels.channelList,
+		qdf_mem_copy(mac->scan.base_channels.channel_freq_list,
+			     ps11dinfo->Channels.channel_freq_list,
 			     ps11dinfo->Channels.numChannels);
 	} else {
 		/* No change */
@@ -2833,9 +2833,7 @@ static QDF_STATUS csr_init11d_info(struct mac_context *mac, tCsr11dinfo *ps11din
 		pChanInfoStart = pChanInfo;
 		for (index = 0; index < ps11dinfo->Channels.numChannels;
 		     index++) {
-			pChanInfo->first_freq =
-					wlan_reg_chan_to_freq(mac->pdev,
-							      ps11dinfo->ChnPower[index].firstChannel);
+			pChanInfo->first_freq = ps11dinfo->ChnPower[index].first_chan_freq;
 			pChanInfo->numChannels =
 				ps11dinfo->ChnPower[index].numChannels;
 			pChanInfo->maxTxPower =
@@ -2897,9 +2895,7 @@ QDF_STATUS csr_init_channel_power_list(struct mac_context *mac,
 
 		for (index = 0; index < ps11dinfo->Channels.numChannels;
 		     index++) {
-			pChanInfo->first_freq =
-					wlan_reg_chan_to_freq(mac->pdev,
-							      ps11dinfo->ChnPower[index].firstChannel);
+			pChanInfo->first_freq = ps11dinfo->ChnPower[index].first_chan_freq;
 			pChanInfo->numChannels =
 				ps11dinfo->ChnPower[index].numChannels;
 			pChanInfo->maxTxPower =
@@ -17776,9 +17772,8 @@ csr_populate_roam_chan_list(struct mac_context *mac_ctx,
 
 	num_channels = dst->ChannelCount;
 	for (i = 0; i < src->numOfChannels; i++) {
-		if (csr_is_channel_present_in_list(dst->ChannelCache,
-						   num_channels,
-			wlan_reg_freq_to_chan(mac_ctx->pdev, *freq_lst)))
+		if (csr_is_channel_present_in_list(dst->chan_freq_cache,
+						   num_channels, *freq_lst))
 			continue;
 		if (!csr_check_band_freq_match(
 			band, *freq_lst))
@@ -17819,8 +17814,7 @@ csr_populate_roam_chan_list(struct mac_context *mac_ctx,
 				continue;
 			}
 		}
-		dst->ChannelCache[num_channels++] =
-			wlan_reg_freq_to_chan(mac_ctx->pdev, *freq_lst);
+		dst->chan_freq_cache[num_channels++] = *freq_lst;
 		freq_lst++;
 	}
 	dst->ChannelCount = num_channels;
@@ -17880,8 +17874,8 @@ csr_fetch_ch_lst_from_occupied_lst(struct mac_context *mac_ctx,
 {
 	uint8_t i = 0;
 	uint8_t num_channels = 0;
-	uint8_t *ch_lst =
-		mac_ctx->scan.occupiedChannels[session_id].channelList;
+	uint32_t *ch_lst =
+		mac_ctx->scan.occupiedChannels[session_id].channel_freq_list;
 	uint16_t  unsafe_chan[NUM_CHANNELS];
 	uint16_t  unsafe_chan_cnt = 0;
 	uint16_t  cnt = 0;
@@ -17905,9 +17899,10 @@ csr_fetch_ch_lst_from_occupied_lst(struct mac_context *mac_ctx,
 			 ROAMING_DFS_CHANNEL_DISABLED) ||
 		     (mac_ctx->roam.configParam.sta_roam_policy.dfs_mode ==
 			 CSR_STA_ROAM_POLICY_DFS_DISABLED)) &&
-		    (wlan_reg_is_dfs_ch(mac_ctx->pdev, *ch_lst))) {
+			 (wlan_reg_is_dfs_ch(mac_ctx->pdev,
+				wlan_reg_freq_to_chan(mac_ctx->pdev, *ch_lst)))) {
 			QDF_TRACE(QDF_MODULE_ID_SME, QDF_TRACE_LEVEL_DEBUG,
-				("ignoring dfs channel %d"), *ch_lst);
+				("ignoring dfs channel freq %d"), *ch_lst);
 			ch_lst++;
 			continue;
 		}
@@ -17917,7 +17912,7 @@ csr_fetch_ch_lst_from_occupied_lst(struct mac_context *mac_ctx,
 				unsafe_chan_cnt) {
 			is_unsafe_chan = false;
 			for (cnt = 0; cnt < unsafe_chan_cnt; cnt++) {
-				if (unsafe_chan[cnt] == *ch_lst) {
+				if (unsafe_chan[cnt] == wlan_reg_freq_to_chan(mac_ctx->pdev, *ch_lst)) {
 					is_unsafe_chan = true;
 					break;
 				}
@@ -17925,20 +17920,19 @@ csr_fetch_ch_lst_from_occupied_lst(struct mac_context *mac_ctx,
 			if (is_unsafe_chan) {
 				QDF_TRACE(QDF_MODULE_ID_SME,
 						QDF_TRACE_LEVEL_DEBUG,
-					("ignoring unsafe channel %d"),
+					("ignoring unsafe channel freq %d"),
 					*ch_lst);
 				ch_lst++;
 				continue;
 			}
 		}
-		req_buf->ConnectedNetwork.ChannelCache[num_channels++] =
-			*ch_lst;
+		req_buf->ConnectedNetwork.chan_freq_cache[num_channels++] = *ch_lst;
 		if (*ch_lst)
 			QDF_TRACE(QDF_MODULE_ID_SME, QDF_TRACE_LEVEL_DEBUG,
-				"DFSRoam=%d, ChnlState=%d, Chnl=%d, num_ch=%d",
+				"DFSRoam=%d, ChnlState=%d, Chnl freq=%d, num_ch=%d",
 				mac_ctx->mlme_cfg->lfr.roaming_dfs_channel,
 				wlan_reg_get_channel_state(mac_ctx->pdev,
-					*ch_lst),
+					wlan_reg_freq_to_chan(mac_ctx->pdev, *ch_lst)),
 				*ch_lst,
 				num_channels);
 		ch_lst++;
@@ -18045,8 +18039,8 @@ csr_fetch_valid_ch_lst(struct mac_context *mac_ctx,
 				continue;
 			}
 		}
-		req_buf->ConnectedNetwork.ChannelCache[num_channels++] =
-			*ch_lst;
+		req_buf->ConnectedNetwork.chan_freq_cache[num_channels++] =
+			wlan_reg_chan_to_freq(mac_ctx->pdev, *ch_lst);
 		ch_lst++;
 	}
 	req_buf->ChannelCacheType = CHANNEL_LIST_DYNAMIC;
@@ -18312,7 +18306,7 @@ csr_create_roam_scan_offload_request(struct mac_context *mac_ctx,
 			j += snprintf(ch_cache_str + j,
 				      sizeof(ch_cache_str) - j, " %d",
 				      req_buf->ConnectedNetwork.
-				      ChannelCache[i]);
+				      chan_freq_cache[i]);
 		} else
 			break;
 	}
@@ -20560,10 +20554,10 @@ csr_update_op_class_array(struct mac_context *mac_ctx,
 			ch_bandwidth++) {
 			class = wlan_reg_dmn_get_opclass_from_channel(
 					mac_ctx->scan.countryCodeCurrent,
-					channel_info->channelList[idx],
+					wlan_reg_freq_to_chan(mac_ctx->pdev, channel_info->channel_freq_list[idx]),
 					ch_bandwidth);
-			sme_debug("for chan %d, op class: %d",
-				channel_info->channelList[idx], class);
+			sme_debug("for chan freq %d, op class: %d",
+				  channel_info->channel_freq_list[idx], class);
 
 			found = false;
 			for (j = 0; j < REG_MAX_SUPP_OPER_CLASSES - 1;

core/sme/src/csr/csr_api_scan.c

@@ -52,7 +52,7 @@
 #include "wlan_blm_api.h"
 
 static void csr_set_cfg_valid_channel_list(struct mac_context *mac,
-					   uint8_t *pChannelList,
+					   uint32_t *pchan_freq_list,
 					   uint8_t NumChannels);
 
 static void csr_save_tx_power_to_cfg(struct mac_context *mac,
@@ -341,17 +341,17 @@ static void csr_add_to_occupied_channels(struct mac_context *mac,
 {
 	QDF_STATUS status;
 	uint8_t num_occupied_ch = occupied_ch->numChannels;
-	uint8_t *occupied_ch_lst = occupied_ch->channelList;
+	uint32_t *occupied_ch_lst = occupied_ch->channel_freq_list;
 
 	if (is_init_list)
 		mac->scan.roam_candidate_count[sessionId]++;
 
 	if (csr_is_channel_present_in_list(occupied_ch_lst,
-					   num_occupied_ch, ch))
+					   num_occupied_ch, wlan_reg_chan_to_freq(mac->pdev, ch)))
 		return;
 
 	status = csr_add_to_channel_list_front(occupied_ch_lst,
-					       num_occupied_ch, ch);
+					       num_occupied_ch, wlan_reg_chan_to_freq(mac->pdev, ch));
 	if (QDF_IS_STATUS_SUCCESS(status)) {
 		occupied_ch->numChannels++;
 		sme_debug("Added channel %d to the list (count=%d)",
@@ -606,13 +606,13 @@ void csr_apply_channel_power_info_to_fw(struct mac_context *mac_ctx,
 		tempNumChannels = QDF_MIN(ch_lst->numChannels,
 					  CFG_VALID_CHANNEL_LIST_LEN);
 		for (i = 0; i < tempNumChannels; i++) {
-			tmp_ch_lst.channelList[num_ch] = ch_lst->channelList[i];
+			tmp_ch_lst.channel_freq_list[num_ch] = ch_lst->channel_freq_list[i];
 			num_ch++;
 		}
 		tmp_ch_lst.numChannels = num_ch;
 		/* Store the channel+power info in the global place: Cfg */
 		csr_apply_power2_current(mac_ctx);
-		csr_set_cfg_valid_channel_list(mac_ctx, tmp_ch_lst.channelList,
+		csr_set_cfg_valid_channel_list(mac_ctx, tmp_ch_lst.channel_freq_list,
 					       tmp_ch_lst.numChannels);
 	} else {
 		sme_err("11D channel list is empty");
@@ -636,12 +636,11 @@ static void csr_diag_reset_country_information(struct mac_context *mac)
 	qdf_mem_copy(p11dLog->countryCode, mac->scan.countryCodeCurrent, 3);
 	p11dLog->numChannel = mac->scan.base_channels.numChannels;
 	if (p11dLog->numChannel <= HOST_LOG_MAX_NUM_CHANNEL) {
-		qdf_mem_copy(p11dLog->Channels,
-			     mac->scan.base_channels.channelList,
-			     p11dLog->numChannel);
 		for (Index = 0;
 		     Index < mac->scan.base_channels.numChannels;
 		     Index++) {
+			p11dLog->Channels[Index] =
+				wlan_reg_freq_to_chan(mac->pdev, mac->scan.base_channels.channel_freq_list[Index]);
 			p11dLog->TxPwr[Index] = QDF_MIN(
 				mac->scan.defaultPowerTable[Index].tx_power,
 				mac->mlme_cfg->power.max_tx_power);
@@ -715,6 +714,7 @@ static void csr_diag_apply_country_info(struct mac_context *mac_ctx)
 	host_log_802_11d_pkt_type *p11dLog;
 	struct channel_power chnPwrInfo[CFG_VALID_CHANNEL_LIST_LEN];
 	uint32_t nChnInfo = CFG_VALID_CHANNEL_LIST_LEN, nTmp;
+	uint8_t i;
 
 	WLAN_HOST_DIAG_LOG_ALLOC(p11dLog, host_log_802_11d_pkt_type,
 				 LOG_WLAN_80211D_C);
@@ -727,9 +727,10 @@ static void csr_diag_apply_country_info(struct mac_context *mac_ctx)
 	if (p11dLog->numChannel > HOST_LOG_MAX_NUM_CHANNEL)
 		goto diag_end;
 
-	qdf_mem_copy(p11dLog->Channels,
-		     mac_ctx->scan.channels11d.channelList,
-		     p11dLog->numChannel);
+	for (i = 0; i < p11dLog->numChannel; i++)
+		p11dLog->Channels[i] =
+		wlan_reg_freq_to_chan(mac_ctx->pdev,
+				      mac_ctx->scan.channels11d.channel_freq_list[i]);
 	csr_get_channel_power_info(mac_ctx,
 				&mac_ctx->scan.channelPowerInfoList24,
 				&nChnInfo, chnPwrInfo);
@@ -853,8 +854,8 @@ bool csr_is_supported_channel(struct mac_context *mac, uint8_t channelId)
 	uint32_t i;
 
 	for (i = 0; i < mac->scan.base_channels.numChannels; i++) {
-		if (channelId ==
-		    mac->scan.base_channels.channelList[i]) {
+		if (wlan_reg_chan_to_freq(mac->pdev, channelId) ==
+		    mac->scan.base_channels.channel_freq_list[i]) {
 			fRet = true;
 			break;
 		}
@@ -1454,7 +1455,7 @@ error:
 }
 
 static void csr_set_cfg_valid_channel_list(struct mac_context *mac,
-					   uint8_t *pChannelList,
+					   uint32_t *pchan_freq_list,
 					   uint8_t NumChannels)
 {
 	QDF_STATUS status;
@@ -1464,10 +1465,9 @@ static void csr_set_cfg_valid_channel_list(struct mac_context *mac,
 		  "%s: dump valid channel list(NumChannels(%d))",
 		  __func__, NumChannels);
 	QDF_TRACE_HEX_DUMP(QDF_MODULE_ID_SME, QDF_TRACE_LEVEL_DEBUG,
-			   pChannelList, NumChannels);
+			   pchan_freq_list, NumChannels);
 	for (i = 0; i < NumChannels; i++) {
-		mac->mlme_cfg->reg.valid_channel_freq_list[i] =
-			wlan_reg_chan_to_freq(mac->pdev, pChannelList[i]);
+		mac->mlme_cfg->reg.valid_channel_freq_list[i] = pchan_freq_list[i];
 	}
 
 	mac->mlme_cfg->reg.valid_channel_list_num = NumChannels;

core/sme/src/csr/csr_neighbor_roam.c

@@ -552,9 +552,8 @@ QDF_STATUS csr_neighbor_roam_channels_filter_by_current_band(struct mac_context
  * csr_neighbor_roam_channels_filter_by_current_band()
  *
  * @mac_ctx: Pointer to Global MAC structure
- * @session_id: Session ID
- * @input_ch_list: The additional channels to merge in to the
- *			"merged" channels list.
+ * @pinput_chan_freq_list: The additional channels to merge in
+ *          to the "merged" channels list.
  * @input_num_of_ch: The number of additional channels.
  * @output_ch_list: The place to put the "merged" channel list.
  * @output_num_of_ch: The original number of channels in the
@@ -570,7 +569,7 @@ QDF_STATUS csr_neighbor_roam_channels_filter_by_current_band(struct mac_context
  * Return: QDF_STATUS_SUCCESS on success, QDF_STATUS_E_FAILURE otherwise
  */
 QDF_STATUS csr_neighbor_roam_merge_channel_lists(struct mac_context *mac,
-						 uint8_t *pInputChannelList,
+						 uint32_t *pinput_chan_freq_list,
 						 uint8_t inputNumOfChannels,
 						 uint8_t *pOutputChannelList,
 						 uint8_t outputNumOfChannels,
@@ -582,7 +581,7 @@ QDF_STATUS csr_neighbor_roam_merge_channel_lists(struct mac_context *mac,
 	uint8_t numChannels = outputNumOfChannels;
 
 	/* Check for NULL pointer */
-	if (!pInputChannelList)
+	if (!pinput_chan_freq_list)
 		return QDF_STATUS_E_INVAL;
 
 	/* Check for NULL pointer */
@@ -606,17 +605,18 @@ QDF_STATUS csr_neighbor_roam_merge_channel_lists(struct mac_context *mac,
 	 */
 	for (i = 0; i < inputNumOfChannels; i++) {
 		for (j = 0; j < outputNumOfChannels; j++) {
-			if (pInputChannelList[i] == pOutputChannelList[j])
+			if (wlan_reg_freq_to_chan(mac->pdev, pinput_chan_freq_list[i])
+				== pOutputChannelList[j])
 				break;
 		}
 		if (j == outputNumOfChannels) {
-			if (pInputChannelList[i]) {
+			if (pinput_chan_freq_list[i]) {
 				QDF_TRACE(QDF_MODULE_ID_SME,
 					  QDF_TRACE_LEVEL_DEBUG,
 					  "%s: [INFOLOG] Adding extra %d to Neighbor channel list",
-					  __func__, pInputChannelList[i]);
+					  __func__, pinput_chan_freq_list[i]);
 				pOutputChannelList[numChannels] =
-					pInputChannelList[i];
+					wlan_reg_freq_to_chan(mac->pdev, pinput_chan_freq_list[i]);
 				numChannels++;
 			}
 		}

core/sme/src/csr/csr_util.c

@@ -6253,8 +6253,8 @@ void csr_clear_channel_status(struct mac_context *mac)
 	return;
 }
 
-bool csr_is_channel_present_in_list(uint8_t *pChannelList,
-				    int numChannels, uint8_t channel)
+bool csr_is_channel_present_in_list(uint32_t *pChannelList,
+				    int numChannels, uint32_t chan_freq)
 {
 	int i = 0;
 
@@ -6265,7 +6265,7 @@ bool csr_is_channel_present_in_list(uint8_t *pChannelList,
 	/* Look for the channel in the list */
 	for (i = 0; (i < numChannels) &&
 	     (i < CFG_VALID_CHANNEL_LIST_LEN); i++) {
-		if (pChannelList[i] == channel)
+		if (pChannelList[i] == chan_freq)
 			return true;
 	}
 
@@ -6291,8 +6291,8 @@ const char *sme_bss_type_to_string(const uint8_t bss_type)
 	}
 }
 
-QDF_STATUS csr_add_to_channel_list_front(uint8_t *pChannelList,
-					 int numChannels, uint8_t channel)
+QDF_STATUS csr_add_to_channel_list_front(uint32_t *pChannelList,
+					 int numChannels, uint32_t chan_freq)
 {
 	int i = 0;
 
@@ -6305,7 +6305,7 @@ QDF_STATUS csr_add_to_channel_list_front(uint8_t *pChannelList,
 		pChannelList[i] = pChannelList[i - 1];
 
 	/* Now add the NEW channel...at the front */
-	pChannelList[0] = channel;
+	pChannelList[0] = chan_freq;
 
 	return QDF_STATUS_SUCCESS;
 }

core/wma/inc/wma_internal.h

@@ -270,7 +270,7 @@ QDF_STATUS wma_roam_scan_offload_rssi_change(tp_wma_handle wma_handle,
 
 QDF_STATUS wma_roam_scan_offload_chan_list(tp_wma_handle wma_handle,
 					   uint8_t chan_count,
-					   uint8_t *chan_list,
+					   uint32_t *chan_freq_list,
 					   uint8_t list_type, uint32_t vdev_id);
 
 A_UINT32 e_csr_auth_type_to_rsn_authmode(enum csr_akm_type authtype,

core/wma/src/wma_scan_roam.c

@@ -695,7 +695,7 @@ QDF_STATUS wma_roam_scan_offload_rssi_change(tp_wma_handle wma_handle,
  * wma_roam_scan_offload_chan_list() - set roam offload channel list
  * @wma_handle: wma handle
  * @chan_count: channel count
- * @chan_list: channel list
+ * @chan_freq_list: channel list
  * @list_type: list type
  * @vdev_id: vdev id
  *
@@ -705,7 +705,7 @@ QDF_STATUS wma_roam_scan_offload_rssi_change(tp_wma_handle wma_handle,
  */
 QDF_STATUS wma_roam_scan_offload_chan_list(tp_wma_handle wma_handle,
 					   uint8_t chan_count,
-					   uint8_t *chan_list,
+					   uint32_t *chan_freq_list,
 					   uint8_t list_type, uint32_t vdev_id)
 {
 	QDF_STATUS status;
@@ -729,7 +729,7 @@ QDF_STATUS wma_roam_scan_offload_chan_list(tp_wma_handle wma_handle,
 
 	for (i = 0; ((i < chan_count) &&
 		     (i < SIR_ROAM_MAX_CHANNELS)); i++) {
-		chan_list_mhz[i] = cds_chan_to_freq(chan_list[i]);
+		chan_list_mhz[i] = chan_freq_list[i];
 		WMA_LOGD("%d,", chan_list_mhz[i]);
 	}
 
@@ -1805,7 +1805,7 @@ QDF_STATUS wma_process_roaming_config(tp_wma_handle wma_handle,
 
 		qdf_status = wma_roam_scan_offload_chan_list(wma_handle,
 				roam_req->ConnectedNetwork.ChannelCount,
-				&roam_req->ConnectedNetwork.ChannelCache[0],
+				&roam_req->ConnectedNetwork.chan_freq_cache[0],
 				roam_req->ChannelCacheType,
 				roam_req->sessionId);
 		if ((qdf_status != QDF_STATUS_SUCCESS) &&
@@ -2038,7 +2038,7 @@ QDF_STATUS wma_process_roaming_config(tp_wma_handle wma_handle,
 		 */
 		qdf_status = wma_roam_scan_offload_chan_list(wma_handle,
 			     roam_req->ConnectedNetwork.ChannelCount,
-			     &roam_req->ConnectedNetwork.ChannelCache[0],
+			     &roam_req->ConnectedNetwork.chan_freq_cache[0],
 			     roam_req->ChannelCacheType,
 			     roam_req->sessionId);
 		/*