samsung-sm8650/android_kernel_samsung_sm8650-modules
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

qcacmn: Remove wlan_reg_set_channel_params

Browse Source 
- Remove wlan_reg_set_channel_params and the callers
 associated code.
- Clean up part of CONFIG_CHAN_NUM_API functions.

Change-Id: If9583e674752d6f47de8d7d6bc946909509957b5
CRs-Fixed: 2883773
This commit is contained in:
Amruta Kulkarni
2021-02-23 13:55:58 -08:00
committed by AnjaneeDevi Kapparapu
parent 14d38b77fb
commit 7fe3773331
6 changed files with 5 additions and 814 deletions
Download Patch File Download Diff File Expand all files Collapse all files

36
umac/dfs/core/src/dfs_random_chan_sel.h
View File

@@ -1,5 +1,5 @@
/*
* Copyright (c) 2012-2020 The Linux Foundation. All rights reserved.
* Copyright (c) 2012-2021 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
@@ -244,38 +244,8 @@ QDF_STATUS dfs_mark_leaking_chan_for_freq(struct wlan_dfs *dfs,
#endif
/**
* dfs_prepare_random_channel() - This function picks a random channel from
* the list of available channels.
* @dfs: dfs handler.
* @ch_list: channel list.
* @ch_count: Number of channels in given list.
* @flags: DFS_RANDOM_CH_FLAG_*
* @ch_wd: input channel width, used same variable to return new ch width.
* @cur_chan: current channel.
* @dfs_region: DFS region.
* @acs_info: acs channel range information.
*
* Function used to find random channel selection from a given list.
* First this function removes channels based on flags and then uses final
* list to find channel based on requested bandwidth, if requested bandwidth
* not available, it chooses next lower bandwidth and try.
*
* Return: channel number, else zero.
*/
#ifdef CONFIG_CHAN_NUM_API
uint8_t dfs_prepare_random_channel(struct wlan_dfs *dfs,
struct dfs_channel *ch_list,
uint32_t ch_count,
uint32_t flags,
uint8_t *ch_wd,
struct dfs_channel *cur_chan,
uint8_t dfs_region,
struct dfs_acs_info *acs_info);
#endif
/**
* dfs_prepare_random_channel() - This function picks a random channel from
* the list of available channels.
* dfs_prepare_random_channel_for_freq() - This function picks a random channel
* from the list of available channels.
* @dfs: dfs handler.
* @chan_list: channel list.
* @ch_count: Number of channels in given list.

615
umac/dfs/core/src/misc/dfs_random_chan_sel.c
View File

@@ -1,5 +1,5 @@
/*
* Copyright (c) 2012-2020 The Linux Foundation. All rights reserved.
* Copyright (c) 2012-2021 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
@@ -1007,49 +1007,6 @@ dfs_mark_leaking_chan_for_freq(struct wlan_dfs *dfs,
#endif
#endif
/**
* dfs_populate_80mhz_available_channels()- Populate channels for 80MHz using
* bitmap
* @dfs: Pointer to DFS structure.
* @bitmap: bitmap
* @avail_freq_list: prepared channel list
*
* Prepare 80MHz channels from the bitmap.
*
* Return: channel count
*/
#ifdef CONFIG_CHAN_NUM_API
static uint8_t dfs_populate_80mhz_available_channels(
struct wlan_dfs *dfs,
struct chan_bonding_bitmap *bitmap,
uint8_t *avail_chnl)
{
uint8_t i = 0;
uint8_t chnl_count = 0;
uint8_t start_chan = 0;
for (i = 0; i < DFS_MAX_80MHZ_BANDS; i++) {
start_chan = bitmap->chan_bonding_set[i].start_chan;
if (bitmap->chan_bonding_set[i].chan_map ==
DFS_80MHZ_MASK) {
avail_chnl[chnl_count++] = start_chan +
(DFS_NEXT_5GHZ_CHANNEL * 0);
avail_chnl[chnl_count++] = start_chan +
(DFS_NEXT_5GHZ_CHANNEL * 1);
avail_chnl[chnl_count++] = start_chan +
(DFS_NEXT_5GHZ_CHANNEL * 2);
avail_chnl[chnl_count++] = start_chan +
(DFS_NEXT_5GHZ_CHANNEL * 3);
}
}
dfs_info(dfs, WLAN_DEBUG_DFS_RANDOM_CHAN,
"channel count %d", chnl_count);
return chnl_count;
}
#endif
/*
* dfs_populate_80mhz_available_channel_for_freq() - Populate 80MHZ channels
* available for selection.
@@ -1089,52 +1046,6 @@ static uint8_t dfs_populate_80mhz_available_channel_for_freq(
}
#endif
/**
* dfs_populate_40mhz_available_channels()- Populate channels for 40MHz using
* bitmap
* @dfs: Pointer to DFS structure.
* @bitmap: bitmap
* @avail_chnl: prepared channel list
*
* Prepare 40MHz channels from the bitmap.
*
* Return: channel count
*/
#ifdef CONFIG_CHAN_NUM_API
static uint8_t dfs_populate_40mhz_available_channels(
struct wlan_dfs *dfs,
struct chan_bonding_bitmap *bitmap,
uint8_t *avail_chnl)
{
uint8_t i = 0;
uint8_t chnl_count = 0;
uint8_t start_chan = 0;
for (i = 0; i < DFS_MAX_80MHZ_BANDS; i++) {
start_chan = bitmap->chan_bonding_set[i].start_chan;
if ((bitmap->chan_bonding_set[i].chan_map &
DFS_40MHZ_MASK_L) == DFS_40MHZ_MASK_L) {
avail_chnl[chnl_count++] = start_chan +
(DFS_NEXT_5GHZ_CHANNEL * 0);
avail_chnl[chnl_count++] = start_chan +
(DFS_NEXT_5GHZ_CHANNEL * 1);
}
if ((bitmap->chan_bonding_set[i].chan_map &
DFS_40MHZ_MASK_H) == DFS_40MHZ_MASK_H) {
avail_chnl[chnl_count++] = start_chan +
(DFS_NEXT_5GHZ_CHANNEL * 2);
avail_chnl[chnl_count++] = start_chan +
(DFS_NEXT_5GHZ_CHANNEL * 3);
}
}
dfs_info(dfs, WLAN_DEBUG_DFS_RANDOM_CHAN,
"channel count %d", chnl_count);
return chnl_count;
}
#endif
#ifdef CONFIG_CHAN_FREQ_API
static uint8_t
dfs_populate_40mhz_available_channel_for_freq(struct wlan_dfs *dfs,
@@ -1170,44 +1081,6 @@ dfs_populate_40mhz_available_channel_for_freq(struct wlan_dfs *dfs,
}
#endif
/**
* dfs_populate_available_channels()- Populate channels based on width and
* bitmap
* @dfs: Pointer to DFS structure.
* @bitmap: bitmap
* @ch_width: channel width
* @avail_chnl: prepared channel list
*
* Prepare channel list based on width and channel bitmap.
*
* Return: channel count
*/
#ifdef CONFIG_CHAN_NUM_API
static uint8_t dfs_populate_available_channels(
struct wlan_dfs *dfs,
struct chan_bonding_bitmap *bitmap,
uint8_t ch_width,
uint8_t *avail_chnl)
{
switch (ch_width) {
case DFS_CH_WIDTH_160MHZ:
case DFS_CH_WIDTH_80P80MHZ:
case DFS_CH_WIDTH_80MHZ:
return dfs_populate_80mhz_available_channels(
dfs, bitmap, avail_chnl);
case DFS_CH_WIDTH_40MHZ:
return dfs_populate_40mhz_available_channels(
dfs, bitmap, avail_chnl);
default:
dfs_err(dfs, WLAN_DEBUG_DFS_RANDOM_CHAN,
"Invalid ch_width %d", ch_width);
break;
}
return 0;
}
#endif
/**
* dfs_populate_available_channel_for_freq()- Populate channels based on width
* and bitmap.
@@ -1248,42 +1121,6 @@ dfs_populate_available_channel_for_freq(struct wlan_dfs *dfs,
}
#endif
/**
* dfs_get_rand_from_lst()- Get random channel from a given channel list
* @dfs: Pointer to DFS structure.
* @ch_lst: channel list
* @num_ch: number of channels
*
* Get random channel from given channel list.
*
* Return: channel number
*/
#ifdef CONFIG_CHAN_NUM_API
static uint8_t dfs_get_rand_from_lst(
struct wlan_dfs *dfs,
uint8_t *ch_lst,
uint8_t num_ch)
{
uint8_t i;
uint32_t rand_byte = 0;
if (!num_ch || !ch_lst) {
dfs_err(NULL, WLAN_DEBUG_DFS_ALWAYS,
"invalid param ch_lst %pK, num_ch = %d",
ch_lst, num_ch);
return 0;
}
get_random_bytes((uint8_t *)&rand_byte, 1);
i = (rand_byte + qdf_mc_timer_get_system_ticks()) % num_ch;
dfs_info(dfs, WLAN_DEBUG_DFS_RANDOM_CHAN,
"random channel %d", ch_lst[i]);
return ch_lst[i];
}
#endif
/**
* dfs_get_rand_from_lst_for_freq()- Get random channel from a given channel
* list.
@@ -1321,41 +1158,6 @@ static uint16_t dfs_get_rand_from_lst_for_freq(struct wlan_dfs *dfs,
}
#endif
/**
* dfs_random_channel_sel_set_bitmap()- Set channel bit in bitmap based
* on given channel number
* @dfs: Pointer to DFS structure.
* @bitmap: bitmap
* @channel: channel number
*
* Set channel bit in bitmap based on given channel number.
*
* Return: None
*/
#ifdef CONFIG_CHAN_NUM_API
static void dfs_random_channel_sel_set_bitmap(
struct wlan_dfs *dfs,
struct chan_bonding_bitmap *bitmap,
uint8_t channel)
{
int i = 0;
int start_chan = 0;
for (i = 0; i < DFS_MAX_80MHZ_BANDS; i++) {
start_chan = bitmap->chan_bonding_set[i].start_chan;
if (channel >= start_chan && channel <= start_chan + 12) {
bitmap->chan_bonding_set[i].chan_map |=
(1 << ((channel - start_chan) /
DFS_80_NUM_SUB_CHANNEL));
return;
}
}
dfs_debug(dfs, WLAN_DEBUG_DFS_RANDOM_CHAN,
"Channel=%d is not in the bitmap", channel);
}
#endif
/**
* dfs_random_channel_sel_set_bitmap()- Set channel bit in bitmap based
* on given channel number
@@ -1394,156 +1196,6 @@ dfs_random_channel_sel_set_bitmap_for_freq(struct wlan_dfs *dfs,
}
#endif
/**
* dfs_find_ch_with_fallback()- find random channel
* @dfs: Pointer to DFS structure.
* @ch_wd: channel width
* @center_freq_seg1: center frequency of secondary segment.
* @ch_lst: list of available channels.
* @num_ch: number of channels in the list.
*
* Find random channel based on given channel width and channel list,
* fallback to lower width if requested channel width not available.
*
* Return: channel number
*/
#ifdef CONFIG_CHAN_NUM_API
static uint8_t dfs_find_ch_with_fallback(
struct wlan_dfs *dfs,
uint8_t *ch_wd,
uint8_t *center_freq_seg1,
uint8_t *ch_lst,
uint32_t num_ch)
{
bool flag = false;
uint32_t rand_byte = 0;
struct chan_bonding_bitmap ch_map = { { {0} } };
uint8_t count = 0, i, index = 0, final_cnt = 0, target_channel = 0;
uint8_t primary_seg_start_ch = 0, sec_seg_ch = 0, new_160_start_ch = 0;
uint8_t final_lst[NUM_CHANNELS] = {0};
/* initialize ch_map for all 80 MHz bands: we have 6 80MHz bands */
ch_map.chan_bonding_set[0].start_chan = 36;
ch_map.chan_bonding_set[1].start_chan = 52;
ch_map.chan_bonding_set[2].start_chan = 100;
ch_map.chan_bonding_set[3].start_chan = 116;
ch_map.chan_bonding_set[4].start_chan = 132;
ch_map.chan_bonding_set[5].start_chan = 149;
for (i = 0; i < num_ch; i++) {
dfs_debug(dfs, WLAN_DEBUG_DFS_RANDOM_CHAN,
"channel = %d added to bitmap", ch_lst[i]);
dfs_random_channel_sel_set_bitmap(dfs, &ch_map, ch_lst[i]);
}
/* populate available channel list from bitmap */
final_cnt = dfs_populate_available_channels(dfs, &ch_map,
*ch_wd, final_lst);
/* If no valid ch bonding found, fallback */
if (final_cnt == 0) {
if ((*ch_wd == DFS_CH_WIDTH_160MHZ) ||
(*ch_wd == DFS_CH_WIDTH_80P80MHZ) ||
(*ch_wd == DFS_CH_WIDTH_80MHZ)) {
dfs_info(dfs, WLAN_DEBUG_DFS_RANDOM_CHAN,
"from [%d] to 40Mhz", *ch_wd);
*ch_wd = DFS_CH_WIDTH_40MHZ;
} else if (*ch_wd == DFS_CH_WIDTH_40MHZ) {
dfs_info(dfs, WLAN_DEBUG_DFS_RANDOM_CHAN,
"from 40Mhz to 20MHz");
*ch_wd = DFS_CH_WIDTH_20MHZ;
}
return 0;
}
/* ch count should be > 8 to switch new channel in 160Mhz band */
if (((*ch_wd == DFS_CH_WIDTH_160MHZ) ||
(*ch_wd == DFS_CH_WIDTH_80P80MHZ)) &&
(final_cnt < DFS_MAX_20M_SUB_CH)) {
dfs_info(dfs, WLAN_DEBUG_DFS_RANDOM_CHAN,
"from [%d] to 80Mhz", *ch_wd);
*ch_wd = DFS_CH_WIDTH_80MHZ;
return 0;
}
if (*ch_wd == DFS_CH_WIDTH_160MHZ) {
/*
* Only 2 blocks for 160Mhz bandwidth i.e 36-64 & 100-128
* and all the channels in these blocks are continuous
* and separated by 4Mhz.
*/
for (i = 1; ((i < final_cnt)); i++) {
if ((final_lst[i] - final_lst[i-1]) ==
DFS_NEXT_5GHZ_CHANNEL)
count++;
else
count = 0;
if (count == DFS_MAX_20M_SUB_CH - 1) {
flag = true;
new_160_start_ch = final_lst[i - count];
break;
}
}
} else if (*ch_wd == DFS_CH_WIDTH_80P80MHZ) {
flag = true;
}
if ((flag == false) && (*ch_wd > DFS_CH_WIDTH_80MHZ)) {
dfs_info(dfs, WLAN_DEBUG_DFS_RANDOM_CHAN,
"from [%d] to 80Mhz", *ch_wd);
*ch_wd = DFS_CH_WIDTH_80MHZ;
return 0;
}
if (*ch_wd == DFS_CH_WIDTH_160MHZ) {
get_random_bytes((uint8_t *)&rand_byte, 1);
rand_byte = (rand_byte + qdf_mc_timer_get_system_ticks())
% DFS_MAX_20M_SUB_CH;
target_channel = new_160_start_ch + (rand_byte *
DFS_80_NUM_SUB_CHANNEL);
} else if (*ch_wd == DFS_CH_WIDTH_80P80MHZ) {
get_random_bytes((uint8_t *)&rand_byte, 1);
index = (rand_byte + qdf_mc_timer_get_system_ticks()) %
final_cnt;
target_channel = final_lst[index];
index -= (index % DFS_80_NUM_SUB_CHANNEL);
primary_seg_start_ch = final_lst[index];
/* reset channels associate with primary 80Mhz */
for (i = 0; i < DFS_80_NUM_SUB_CHANNEL; i++)
final_lst[i + index] = 0;
/* select and calculate center freq for secondary segment */
for (i = 0; i < final_cnt / DFS_80_NUM_SUB_CHANNEL; i++) {
if (final_lst[i * DFS_80_NUM_SUB_CHANNEL] &&
(abs(primary_seg_start_ch -
final_lst[i * DFS_80_NUM_SUB_CHANNEL]) >
(DFS_MAX_20M_SUB_CH * 2))) {
sec_seg_ch =
final_lst[i * DFS_80_NUM_SUB_CHANNEL] +
DFS_80MHZ_START_CENTER_CH_DIFF;
break;
}
}
if (!sec_seg_ch && (final_cnt == DFS_MAX_20M_SUB_CH))
*ch_wd = DFS_CH_WIDTH_160MHZ;
else if (!sec_seg_ch)
*ch_wd = DFS_CH_WIDTH_80MHZ;
*center_freq_seg1 = sec_seg_ch;
dfs_info(dfs, WLAN_DEBUG_DFS_RANDOM_CHAN,
"Center frequency seg1 = %d", sec_seg_ch);
} else {
target_channel = dfs_get_rand_from_lst(dfs,
final_lst, final_cnt);
}
dfs_info(dfs, WLAN_DEBUG_DFS_RANDOM_CHAN,
"target channel = %d", target_channel);
return target_channel;
}
#endif
#ifdef CONFIG_BAND_6GHZ
/**
* dfs_assign_6g_channels()- Assign the center frequency of the first 20 MHZ
@@ -1750,160 +1402,6 @@ bool dfs_is_freq_in_nol(struct wlan_dfs *dfs, uint32_t freq)
return false;
}
/**
* dfs_apply_rules()- prepare channel list based on flags
* @dfs: dfs handler
* @flags: channel flags
* @random_chan_list: output channel list
* @random_chan_cnt: output channel count
* @ch_list: input channel list
* @ch_cnt: input channel count
* @dfs_region: dfs region
* @acs_info: acs channel range information
*
* prepare channel list based on flags
*
* return: none
*/
#ifdef CONFIG_CHAN_NUM_API
static void dfs_apply_rules(struct wlan_dfs *dfs,
uint32_t flags,
uint8_t *random_chan_list,
uint32_t *random_chan_cnt,
struct dfs_channel *ch_list,
uint32_t ch_cnt,
uint8_t dfs_region,
struct dfs_acs_info *acs_info)
{
struct dfs_channel *chan;
bool flag_no_weather = 0;
bool flag_no_lower_5g = 0;
bool flag_no_upper_5g = 0;
bool flag_no_dfs_chan = 0;
bool flag_no_2g_chan = 0;
bool flag_no_5g_chan = 0;
bool flag_no_japan_w53 = 0;
int i;
bool found = false;
uint16_t j;
dfs_debug(dfs, WLAN_DEBUG_DFS_RANDOM_CHAN, "flags %d", flags);
flag_no_weather = (dfs_region == DFS_ETSI_REGION_VAL) ?
flags & DFS_RANDOM_CH_FLAG_NO_WEATHER_CH : 0;
if (dfs_region == DFS_MKK_REGION_VAL) {
flag_no_lower_5g = flags & DFS_RANDOM_CH_FLAG_NO_LOWER_5G_CH;
flag_no_upper_5g = flags & DFS_RANDOM_CH_FLAG_NO_UPEER_5G_CH;
flag_no_japan_w53 = flags & DFS_RANDOM_CH_FLAG_NO_JAPAN_W53_CH;
}
flag_no_dfs_chan = flags & DFS_RANDOM_CH_FLAG_NO_DFS_CH;
flag_no_2g_chan = flags & DFS_RANDOM_CH_FLAG_NO_2GHZ_CH;
flag_no_5g_chan = flags & DFS_RANDOM_CH_FLAG_NO_5GHZ_CH;
for (i = 0; i < ch_cnt; i++) {
chan = &ch_list[i];
if ((chan->dfs_ch_ieee == 0) ||
(chan->dfs_ch_ieee > MAX_CHANNEL_NUM)) {
dfs_debug(dfs, WLAN_DEBUG_DFS_RANDOM_CHAN,
"invalid channel %d", chan->dfs_ch_ieee);
continue;
}
if (flags & DFS_RANDOM_CH_FLAG_NO_CURR_OPE_CH) {
/* TODO : Skip all HT20 channels in the given mode */
if (chan->dfs_ch_ieee ==
dfs->dfs_curchan->dfs_ch_ieee) {
dfs_debug(dfs, WLAN_DEBUG_DFS_RANDOM_CHAN,
"skip %d current operating channel",
chan->dfs_ch_ieee);
continue;
}
}
if (acs_info && acs_info->acs_mode) {
for (j = 0; j < acs_info->num_of_channel; j++) {
if (acs_info->chan_freq_list[j] ==
chan->dfs_ch_freq){
found = true;
break;
}
}
if (!found) {
dfs_debug(dfs, WLAN_DEBUG_DFS_RANDOM_CHAN,
"skip ch %d not in acs range",
chan->dfs_ch_ieee);
continue;
}
found = false;
}
if (flag_no_2g_chan &&
chan->dfs_ch_ieee <= DFS_MAX_24GHZ_CHANNEL) {
dfs_debug(dfs, WLAN_DEBUG_DFS_RANDOM_CHAN,
"skip 2.4 GHz channel=%d", chan->dfs_ch_ieee);
continue;
}
if (flag_no_5g_chan &&
chan->dfs_ch_ieee > DFS_MAX_24GHZ_CHANNEL) {
dfs_debug(dfs, WLAN_DEBUG_DFS_RANDOM_CHAN,
"skip 5 GHz channel=%d", chan->dfs_ch_ieee);
continue;
}
if (flag_no_weather) {
if (DFS_IS_CHANNEL_WEATHER_RADAR(chan->dfs_ch_freq)) {
dfs_debug(dfs, WLAN_DEBUG_DFS_RANDOM_CHAN,
"skip weather channel=%d",
chan->dfs_ch_ieee);
continue;
}
}
if (flag_no_lower_5g &&
DFS_IS_CHAN_JAPAN_INDOOR(chan->dfs_ch_ieee)) {
dfs_debug(dfs, WLAN_DEBUG_DFS_RANDOM_CHAN,
"skip indoor channel=%d", chan->dfs_ch_ieee);
continue;
}
if (flag_no_upper_5g &&
DFS_IS_CHAN_JAPAN_OUTDOOR(chan->dfs_ch_ieee)) {
dfs_debug(dfs, WLAN_DEBUG_DFS_RANDOM_CHAN,
"skip outdoor channel=%d", chan->dfs_ch_ieee);
continue;
}
if (flag_no_dfs_chan &&
(chan->dfs_ch_flagext & WLAN_CHAN_DFS)) {
dfs_debug(dfs, WLAN_DEBUG_DFS_RANDOM_CHAN,
"skip dfs channel=%d", chan->dfs_ch_ieee);
continue;
}
if (flag_no_japan_w53 &&
DFS_IS_CHAN_JAPAN_W53(chan->dfs_ch_ieee)) {
dfs_debug(dfs, WLAN_DEBUG_DFS_RANDOM_CHAN,
"skip japan W53 channel=%d",
chan->dfs_ch_ieee);
continue;
}
if (dfs_is_freq_in_nol(dfs, chan->dfs_ch_freq)) {
dfs_debug(dfs, WLAN_DEBUG_DFS_RANDOM_CHAN,
"skip nol channel=%d", chan->dfs_ch_ieee);
continue;
}
random_chan_list[*random_chan_cnt] = chan->dfs_ch_ieee;
*random_chan_cnt += 1;
}
}
#endif
/**
* dfs_apply_rules_for_freq()- prepare channel list based on flags
* @dfs: dfs handler
@@ -2081,117 +1579,6 @@ static void dfs_apply_rules_for_freq(struct wlan_dfs *dfs,
}
#endif
#ifdef CONFIG_CHAN_NUM_API
uint8_t dfs_prepare_random_channel(struct wlan_dfs *dfs,
struct dfs_channel *ch_list,
uint32_t ch_cnt,
uint32_t flags,
uint8_t *ch_wd,
struct dfs_channel *cur_chan,
uint8_t dfs_region,
struct dfs_acs_info *acs_info)
{
int i = 0;
uint8_t final_cnt = 0;
uint8_t target_ch = 0;
uint8_t *random_chan_list = NULL;
uint32_t random_chan_cnt = 0;
uint16_t flag_no_weather = 0;
uint8_t *leakage_adjusted_lst;
uint8_t final_lst[NUM_CHANNELS] = {0};
if (!ch_list || !ch_cnt) {
dfs_info(dfs, WLAN_DEBUG_DFS_RANDOM_CHAN,
"Invalid params %pK, ch_cnt=%d",
ch_list, ch_cnt);
return 0;
}
if (*ch_wd < DFS_CH_WIDTH_20MHZ || *ch_wd > DFS_CH_WIDTH_80P80MHZ) {
dfs_info(dfs, WLAN_DEBUG_DFS_RANDOM_CHAN,
"Invalid ch_wd %d", *ch_wd);
return 0;
}
random_chan_list = qdf_mem_malloc(ch_cnt * sizeof(*random_chan_list));
if (!random_chan_list)
return 0;
dfs_apply_rules(dfs, flags, random_chan_list, &random_chan_cnt,
ch_list, ch_cnt, dfs_region, acs_info);
flag_no_weather = (dfs_region == DFS_ETSI_REGION_VAL) ?
flags & DFS_RANDOM_CH_FLAG_NO_WEATHER_CH : 0;
/* list adjusted after leakage has been marked */
leakage_adjusted_lst = qdf_mem_malloc(random_chan_cnt);
if (!leakage_adjusted_lst) {
qdf_mem_free(random_chan_list);
return 0;
}
do {
qdf_mem_copy(leakage_adjusted_lst, random_chan_list,
random_chan_cnt);
if (QDF_IS_STATUS_ERROR(dfs_mark_leaking_ch(dfs, *ch_wd,
random_chan_cnt,
leakage_adjusted_lst))) {
qdf_mem_free(random_chan_list);
qdf_mem_free(leakage_adjusted_lst);
return 0;
}
if (*ch_wd == DFS_CH_WIDTH_20MHZ) {
/*
* PASS: 3 - from leakage_adjusted_lst, prepare valid
* ch list and use random number from that
*/
for (i = 0; i < random_chan_cnt; i++) {
if (leakage_adjusted_lst[i] == 0)
continue;
dfs_debug(dfs, WLAN_DEBUG_DFS_RANDOM_CHAN,
"dfs: Channel=%d added to available list",
leakage_adjusted_lst[i]);
final_lst[final_cnt] = leakage_adjusted_lst[i];
final_cnt++;
}
target_ch = dfs_get_rand_from_lst(
dfs, final_lst, final_cnt);
break;
}
target_ch = dfs_find_ch_with_fallback(dfs, ch_wd,
&cur_chan->dfs_ch_vhtop_ch_freq_seg2,
leakage_adjusted_lst,
random_chan_cnt);
/*
* When flag_no_weather is set, avoid usage of Adjacent
* weather radar channel in HT40 mode as extension channel
* will be on 5600.
*/
if (flag_no_weather &&
(target_ch ==
DFS_ADJACENT_WEATHER_RADAR_CHANNEL_NUM) &&
(*ch_wd == DFS_CH_WIDTH_40MHZ)) {
dfs_debug(dfs, WLAN_DEBUG_DFS_RANDOM_CHAN,
"skip weather adjacent ch=%d\n",
target_ch);
continue;
}
if (target_ch)
break;
} while (true);
qdf_mem_free(random_chan_list);
qdf_mem_free(leakage_adjusted_lst);
dfs_info(dfs, WLAN_DEBUG_DFS_RANDOM_CHAN, "target_ch = %d", target_ch);
return target_ch;
}
#endif
#ifdef CONFIG_CHAN_FREQ_API
uint16_t dfs_prepare_random_channel_for_freq(struct wlan_dfs *dfs,
struct dfs_channel *chan_list,

46
umac/dfs/dispatcher/inc/wlan_dfs_utils_api.h
View File

@@ -450,27 +450,6 @@ QDF_STATUS utils_dfs_get_nol_chfreq_and_chwidth(struct wlan_objmgr_pdev *pdev,
uint32_t *nol_chwidth,
int index);
/**
* utils_dfs_get_random_channel() - Get random channel.
* @pdev: Pointer to DFS pdev object.
* @flags: random channel selection flags.
* @ch_params: current channel params.
* @hw_mode: current operating mode.
* @target_chan: Pointer to target_chan.
* @acs_info: acs range info.
*
* wrapper function for get_random_chan(). this
* function called from outside of dfs component.
*
* Return: QDF_STATUS
*/
#ifdef CONFIG_CHAN_NUM_API
QDF_STATUS utils_dfs_get_random_channel(struct wlan_objmgr_pdev *pdev,
uint16_t flags, struct ch_params *ch_params,
uint32_t *hw_mode, uint8_t *target_chan,
struct dfs_acs_info *acs_info);
#endif
/**
* utils_dfs_get_random_channel_for_freq() - Get random channel.
* @pdev: Pointer to DFS pdev object.
@@ -495,29 +474,7 @@ utils_dfs_get_random_channel_for_freq(struct wlan_objmgr_pdev *pdev,
#endif
/**
* utils_dfs_get_vdev_random_channel() - Get random channel for vdev
* @pdev: Pointer to DFS pdev object.
* @vdev: vdev of the request
* @flags: random channel selection flags.
* @ch_params: current channel params.
* @hw_mode: current operating mode.
* @target_chan: Pointer to target_chan.
* @acs_info: acs range info.
*
* Get random channel based on vdev interface type. If the vdev is null,
* the function will get random channel by SAP interface type.
*
* Return: QDF_STATUS
*/
#ifdef CONFIG_CHAN_NUM_API
QDF_STATUS utils_dfs_get_vdev_random_channel(
struct wlan_objmgr_pdev *pdev, struct wlan_objmgr_vdev *vdev,
uint16_t flags, struct ch_params *ch_params, uint32_t *hw_mode,
uint8_t *target_chan, struct dfs_acs_info *acs_info);
#endif
/**
* utils_dfs_get_vdev_random_channel() - Get random channel for vdev
* utils_dfs_get_vdev_random_channel_for_freq() - Get random channel for vdev
* @pdev: Pointer to DFS pdev object.
* @vdev: vdev of the request
* @flags: random channel selection flags.
@@ -531,7 +488,6 @@ QDF_STATUS utils_dfs_get_vdev_random_channel(
*
* Return: QDF_STATUS
*/
#ifdef CONFIG_CHAN_FREQ_API
QDF_STATUS utils_dfs_get_vdev_random_channel_for_freq(
struct wlan_objmgr_pdev *pdev, struct wlan_objmgr_vdev *vdev,

91
umac/dfs/dispatcher/src/wlan_dfs_utils_api.c
View File

@@ -931,81 +931,6 @@ bool utils_dfs_can_ignore_radar_event(struct wlan_objmgr_pdev *pdev)
}
#endif
#ifdef CONFIG_CHAN_NUM_API
QDF_STATUS utils_dfs_get_vdev_random_channel(
struct wlan_objmgr_pdev *pdev, struct wlan_objmgr_vdev *vdev,
uint16_t flags, struct ch_params *ch_params, uint32_t *hw_mode,
uint8_t *target_chan, struct dfs_acs_info *acs_info)
{
uint32_t dfs_reg;
uint32_t num_chan = NUM_CHANNELS;
struct wlan_dfs *dfs = NULL;
struct wlan_objmgr_psoc *psoc;
struct dfs_channel *chan_list = NULL;
struct dfs_channel cur_chan;
QDF_STATUS status = QDF_STATUS_E_FAILURE;
*target_chan = 0;
psoc = wlan_pdev_get_psoc(pdev);
if (!psoc) {
dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "null psoc");
goto random_chan_error;
}
dfs = wlan_pdev_get_dfs_obj(pdev);
if (!dfs) {
dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "null dfs");
goto random_chan_error;
}
wlan_reg_get_dfs_region(pdev, &dfs_reg);
chan_list = qdf_mem_malloc(num_chan * sizeof(*chan_list));
if (!chan_list)
goto random_chan_error;
utils_dfs_get_channel_list(pdev, vdev, chan_list, &num_chan);
if (!num_chan) {
dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "zero channels");
goto random_chan_error;
}
cur_chan.dfs_ch_vhtop_ch_freq_seg1 = ch_params->center_freq_seg0;
cur_chan.dfs_ch_vhtop_ch_freq_seg2 = ch_params->center_freq_seg1;
if (!ch_params->ch_width)
utils_dfs_get_max_sup_width(pdev,
(uint8_t *)&ch_params->ch_width);
*target_chan = dfs_prepare_random_channel(dfs, chan_list,
num_chan, flags, (uint8_t *)&ch_params->ch_width,
&cur_chan, (uint8_t)dfs_reg, acs_info);
ch_params->center_freq_seg0 = cur_chan.dfs_ch_vhtop_ch_freq_seg1;
ch_params->center_freq_seg1 = cur_chan.dfs_ch_vhtop_ch_freq_seg2;
dfs_info(dfs, WLAN_DEBUG_DFS_RANDOM_CHAN,
"input width=%d", ch_params->ch_width);
if (*target_chan) {
wlan_reg_set_channel_params(pdev,
*target_chan, 0, ch_params);
utils_dfs_get_max_phy_mode(pdev, hw_mode);
status = QDF_STATUS_SUCCESS;
}
dfs_info(dfs, WLAN_DEBUG_DFS_RANDOM_CHAN,
"ch=%d, seg0=%d, seg1=%d, width=%d",
*target_chan, ch_params->center_freq_seg0,
ch_params->center_freq_seg1, ch_params->ch_width);
random_chan_error:
qdf_mem_free(chan_list);
return status;
}
qdf_export_symbol(utils_dfs_get_vdev_random_channel);
#endif
#ifdef CONFIG_CHAN_FREQ_API
QDF_STATUS utils_dfs_get_vdev_random_channel_for_freq(
struct wlan_objmgr_pdev *pdev, struct wlan_objmgr_vdev *vdev,
@@ -1075,22 +1000,6 @@ random_chan_error:
qdf_export_symbol(utils_dfs_get_vdev_random_channel_for_freq);
#endif
#ifdef CONFIG_CHAN_NUM_API
QDF_STATUS utils_dfs_get_random_channel(
struct wlan_objmgr_pdev *pdev,
uint16_t flags,
struct ch_params *ch_params,
uint32_t *hw_mode,
uint8_t *target_chan,
struct dfs_acs_info *acs_info)
{
return utils_dfs_get_vdev_random_channel(
pdev, NULL, flags, ch_params, hw_mode, target_chan,
acs_info);
}
qdf_export_symbol(utils_dfs_get_random_channel);
#endif
#ifdef CONFIG_CHAN_FREQ_API
QDF_STATUS utils_dfs_get_random_channel_for_freq(
struct wlan_objmgr_pdev *pdev,

13
umac/regulatory/dispatcher/inc/wlan_reg_services_api.h
View File

@@ -559,19 +559,6 @@ enum channel_state wlan_reg_get_5g_bonded_channel_state(
enum channel_state wlan_reg_get_2g_bonded_channel_state(
struct wlan_objmgr_pdev *pdev, uint8_t ch,
uint8_t sec_ch, enum phy_ch_width bw);
/**
* wlan_reg_set_channel_params () - Sets channel parameteres for given bandwidth
* @pdev: The physical dev to program country code or regdomain
* @ch: channel number.
* @sec_ch_2g: Secondary channel.
* @ch_params: pointer to the channel parameters.
*
* Return: None
*/
void wlan_reg_set_channel_params(struct wlan_objmgr_pdev *pdev, uint8_t ch,
uint8_t sec_ch_2g,
struct ch_params *ch_params);
#endif /* CONFIG_CHAN_NUM_API */
/**
* wlan_reg_get_dfs_region () - Get the current dfs region

18
umac/regulatory/dispatcher/src/wlan_reg_services_api.c
View File

@@ -125,24 +125,6 @@ enum channel_state wlan_reg_get_2g_bonded_channel_state(
*/
return reg_get_2g_bonded_channel_state(pdev, ch, sec_ch, bw);
}
/**
* wlan_reg_set_channel_params() - Sets channel parameteres for given bandwidth
* @ch: channel number.
* @ch_params: pointer to the channel parameters.
*
* Return: None
*/
void wlan_reg_set_channel_params(struct wlan_objmgr_pdev *pdev, uint8_t ch,
uint8_t sec_ch_2g,
struct ch_params *ch_params)
{
/*
* Set channel parameters like center frequency for a bonded channel
* state. Also return the maximum bandwidth supported by the channel.
*/
reg_set_channel_params(pdev, ch, sec_ch_2g, ch_params);
}
#endif /* CONFIG_CHAN_NUM_API */
/**