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

qcacld-3.0: Re-arrange regulatory code.

Browse Source 
Re-arrange core regulatory code between HDD and CDS
layers. Move the OS dependent code to HDD.

Change-Id: I8ac26a48d0e8d613b2f6c23fd764e5cf94365c39
CRs-Fixed: 856727
This commit is contained in:
Amar Singhal 2015-10-21 14:36:56 -07:00 committed by Vishwajith Upendra
parent d004abc6f3
commit e4f28eedfd
37 changed files with 1005 additions and 903 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Kbuild
View File

@ -296,6 +296,7 @@ HDD_OBJS := $(HDD_SRC_DIR)/wlan_hdd_assoc.o \
$(HDD_SRC_DIR)/wlan_hdd_ocb.o \
$(HDD_SRC_DIR)/wlan_hdd_oemdata.o \
$(HDD_SRC_DIR)/wlan_hdd_power.o \
$(HDD_SRC_DIR)/wlan_hdd_regulatory.o \
$(HDD_SRC_DIR)/wlan_hdd_scan.o \
$(HDD_SRC_DIR)/wlan_hdd_softap_tx_rx.o \
$(HDD_SRC_DIR)/wlan_hdd_tx_rx.o \
@ -304,6 +305,7 @@ HDD_OBJS := $(HDD_SRC_DIR)/wlan_hdd_assoc.o \
$(HDD_SRC_DIR)/wlan_hdd_wmm.o \
$(HDD_SRC_DIR)/wlan_hdd_wowl.o
ifeq ($(CONFIG_WLAN_LRO), y)
HDD_OBJS += $(HDD_SRC_DIR)/wlan_hdd_lro.o
endif

15
core/cds/inc/cds_reg_service.h
View File

@ -284,8 +284,6 @@ struct regulatory {
uint32_t eeprom_rd_ext;
uint16_t country_code;
uint8_t alpha2[CDS_COUNTRY_CODE_LEN + 1];
uint8_t def_country[CDS_COUNTRY_CODE_LEN + 1];
uint8_t dfs_region;
uint8_t ctl_2g;
uint8_t ctl_5g;
const void *regpair;
@ -314,9 +312,8 @@ enum channel_width {
CHAN_WIDTH_160MHZ
};
extern struct regulatory_channel reg_channels[NUM_RF_CHANNELS];
extern const struct chan_map chan_mapping[NUM_RF_CHANNELS];
extern struct regulatory_channel reg_channels[NUM_RF_CHANNELS];
QDF_STATUS cds_get_reg_domain_from_country_code(v_REGDOMAIN_t *pRegDomain,
const uint8_t *country_alpha2,
@ -331,16 +328,16 @@ QDF_STATUS cds_get_channel_list_with_power(struct channel_power
*channel_40mhz,
uint8_t *num_channels_40mhz);
QDF_STATUS cds_set_reg_domain(void *client_ctxt, v_REGDOMAIN_t reg_domain);
enum channel_state cds_get_channel_state(uint32_t chan_num);
QDF_STATUS cds_regulatory_init(void);
QDF_STATUS cds_get_dfs_region(uint8_t *dfs_region);
QDF_STATUS cds_set_dfs_region(uint8_t dfs_region);
QDF_STATUS cds_put_dfs_region(uint8_t dfs_region);
bool cds_is_dsrc_channel(uint16_t);
enum channel_state cds_get_bonded_channel_state(uint32_t chan_num,
enum channel_width chan_width);
enum channel_width cds_get_max_channel_bw(uint32_t chan_num);
QDF_STATUS cds_set_reg_domain(void *client_ctxt, v_REGDOMAIN_t reg_domain);
QDF_STATUS cds_put_default_country(uint8_t *def_country);
#endif /* __CDS_REG_SERVICE_H */

38
core/cds/inc/cds_regdomain.h
View File

@ -1070,13 +1070,47 @@ enum CountryCode {
CTRY_BELGIUM2 = 5002 /* Belgium/Cisco implementation */
};
/**
* enum ch_width - channel width
* @CH_WIDTH_20MHZ: channel width 20 MHz
* @CH_WIDTH_40MHZ: channel width 40 MHz
* @CH_WIDTH_80MHZ: channel width 80MHz
* @CH_WIDTH_160MHZ: channel width 160 MHz
* @CH_WIDTH_80P80MHZ: channel width 160MHz(80+80)
*/
enum ch_width {
CH_WIDTH_20MHZ = 0,
CH_WIDTH_40MHZ = 1,
CH_WIDTH_80MHZ = 2,
CH_WIDTH_160MHZ = 3,
CH_WIDTH_80P80MHZ = 4,
CH_WIDTH_MAX
};
/**
* struct ch_params_s
*
* @ch_width: channel width
* @sec_ch_offset: secondary channel offset
* @center_freq_seg0: center freq for segment 0
* @center_freq_seg1: center freq for segment 1
*/
struct ch_params_s {
enum ch_width ch_width;
uint8_t sec_ch_offset;
uint8_t center_freq_seg0;
uint8_t center_freq_seg1;
};
int32_t cds_fill_some_regulatory_info(struct regulatory *reg);
void cds_fill_and_send_ctl_to_fw(struct regulatory *reg);
int32_t cds_get_country_from_alpha2(uint8_t *alpha2);
void cds_fill_send_ctl_info_to_fw(struct regulatory *reg, uint32_t modesAvail,
uint32_t modeSelect);
void cds_set_wma_dfs_region(struct regulatory *reg);
void cds_set_wma_dfs_region(uint8_t dfs_region);
void cds_set_ch_params(uint8_t ch, uint32_t phy_mode,
chan_params_t *ch_params);
struct ch_params_s *ch_params);
#endif /* REGULATORY_H */

798
core/cds/src/cds_reg_service.c
View File

@ -36,92 +36,9 @@
#include "cds_reg_service.h"
#include "qdf_trace.h"
#include "sme_api.h"
#include "wlan_hdd_main.h"
#include "cds_api.h"
#include "cds_reg_service.h"
#include "cds_regdomain.h"
#include "cds_regdomain_common.h"
#define WORLD_SKU_MASK 0x00F0
#define WORLD_SKU_PREFIX 0x0060
#define REG_WAIT_TIME 50
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 14, 0)) || defined(WITH_BACKPORTS)
#define IEEE80211_CHAN_PASSIVE_SCAN IEEE80211_CHAN_NO_IR
#define IEEE80211_CHAN_NO_IBSS IEEE80211_CHAN_NO_IR
#endif
#define REG_RULE_2412_2462 REG_RULE(2412-10, 2462+10, 40, 0, 20, 0)
#define REG_RULE_2467_2472 REG_RULE(2467-10, 2472+10, 40, 0, 20, \
NL80211_RRF_PASSIVE_SCAN)
#define REG_RULE_2484 REG_RULE(2484-10, 2484+10, 40, 0, 20, \
NL80211_RRF_PASSIVE_SCAN | NL80211_RRF_NO_OFDM)
#define REG_RULE_5180_5320 REG_RULE(5180-10, 5320+10, 80, 0, 20, \
NL80211_RRF_PASSIVE_SCAN | NL80211_RRF_NO_IBSS)
#define REG_RULE_5500_5720 REG_RULE(5500-10, 5720+10, 80, 0, 20, \
NL80211_RRF_PASSIVE_SCAN | NL80211_RRF_NO_IBSS)
#define REG_RULE_5745_5925 REG_RULE(5745-10, 5925+10, 80, 0, 20, \
NL80211_RRF_PASSIVE_SCAN | NL80211_RRF_NO_IBSS)
static const struct ieee80211_regdomain cds_world_regdom_60_61_62 = {
.n_reg_rules = 6,
.alpha2 = "00",
.reg_rules = {
REG_RULE_2412_2462,
REG_RULE_2467_2472,
REG_RULE_2484,
REG_RULE_5180_5320,
REG_RULE_5500_5720,
REG_RULE_5745_5925,
}
};
static const struct ieee80211_regdomain cds_world_regdom_63_65 = {
.n_reg_rules = 4,
.alpha2 = "00",
.reg_rules = {
REG_RULE_2412_2462,
REG_RULE_2467_2472,
REG_RULE_5180_5320,
REG_RULE_5745_5925,
}
};
static const struct ieee80211_regdomain cds_world_regdom_64 = {
.n_reg_rules = 3,
.alpha2 = "00",
.reg_rules = {
REG_RULE_2412_2462,
REG_RULE_5180_5320,
REG_RULE_5745_5925,
}
};
static const struct ieee80211_regdomain cds_world_regdom_66_69 = {
.n_reg_rules = 4,
.alpha2 = "00",
.reg_rules = {
REG_RULE_2412_2462,
REG_RULE_5180_5320,
REG_RULE_5500_5720,
REG_RULE_5745_5925,
}
};
static const struct ieee80211_regdomain cds_world_regdom_67_68_6A_6C = {
.n_reg_rules = 5,
.alpha2 = "00",
.reg_rules = {
REG_RULE_2412_2462,
REG_RULE_2467_2472,
REG_RULE_5180_5320,
REG_RULE_5500_5720,
REG_RULE_5745_5925,
}
};
const struct chan_map chan_mapping[NUM_RF_CHANNELS] = {
{2412, 1},
@ -212,143 +129,8 @@ const struct chan_map chan_mapping[NUM_RF_CHANNELS] = {
};
struct regulatory_channel reg_channels[NUM_RF_CHANNELS];
static bool init_by_driver;
static bool init_by_reg_core;
/**
* cds_is_world_regdomain() - whether world regdomain
* @regd: integer regulatory domain
*
* Return: bool
*/
bool cds_is_world_regdomain(uint32_t reg_domain)
{
uint32_t temp_regd = reg_domain & ~WORLDWIDE_ROAMING_FLAG;
return ((temp_regd & COUNTRY_ERD_FLAG) != COUNTRY_ERD_FLAG) &&
(((temp_regd & WORLD_SKU_MASK) == WORLD_SKU_PREFIX) ||
(temp_regd == WORLD));
}
/**
* cds_world_regdomain() - which constant world regdomain
* @reg: regulatory data
*
* Return: regdomain ptr
*/
static const struct ieee80211_regdomain
*cds_world_regdomain(struct regulatory *reg)
{
REG_DMN_PAIR_MAPPING *regpair =
(REG_DMN_PAIR_MAPPING *)reg->regpair;
switch (regpair->regDmnEnum) {
case 0x60:
case 0x61:
case 0x62:
return &cds_world_regdom_60_61_62;
case 0x63:
case 0x65:
return &cds_world_regdom_63_65;
case 0x64:
return &cds_world_regdom_64;
case 0x66:
case 0x69:
return &cds_world_regdom_66_69;
case 0x67:
case 0x68:
case 0x6A:
case 0x6C:
return &cds_world_regdom_67_68_6A_6C;
default:
WARN_ON(1);
return &cds_world_regdom_60_61_62;
}
}
/**
* cds_regulatory_wiphy_init() - regulatory wiphy init
* @hdd_ctx: hdd context
* @reg: regulatory data
* @wiphy: wiphy structure
*
* Return: int
*/
static int cds_regulatory_wiphy_init(hdd_context_t *hdd_ctx,
struct regulatory *reg,
struct wiphy *wiphy)
{
const struct ieee80211_regdomain *reg_domain;
if (cds_is_world_regdomain(reg->reg_domain)) {
reg_domain = cds_world_regdomain(reg);
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 14, 0)) || defined(WITH_BACKPORTS)
wiphy->regulatory_flags |= REGULATORY_CUSTOM_REG;
#else
wiphy->flags |= WIPHY_FLAG_CUSTOM_REGULATORY;
#endif
} else if (hdd_ctx->config->fRegChangeDefCountry) {
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 14, 0)) || defined(WITH_BACKPORTS)
wiphy->regulatory_flags |= REGULATORY_CUSTOM_REG;
#else
wiphy->flags |= WIPHY_FLAG_CUSTOM_REGULATORY;
#endif
reg_domain = &cds_world_regdom_60_61_62;
} else {
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 14, 0)) || defined(WITH_BACKPORTS)
wiphy->regulatory_flags |= REGULATORY_STRICT_REG;
#else
wiphy->flags |= WIPHY_FLAG_STRICT_REGULATORY;
#endif
reg_domain = &cds_world_regdom_60_61_62;
}
/*
* save the original driver regulatory flags
*/
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 14, 0)) || defined(WITH_BACKPORTS)
hdd_ctx->reg.reg_flags = wiphy->regulatory_flags;
#else
hdd_ctx->reg.reg_flags = wiphy->flags;
#endif
wiphy_apply_custom_regulatory(wiphy, reg_domain);
/*
* restore the driver regulatory flags since
* wiphy_apply_custom_regulatory may have
* changed them
*/
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 14, 0)) || defined(WITH_BACKPORTS)
wiphy->regulatory_flags = hdd_ctx->reg.reg_flags;
#else
wiphy->flags = hdd_ctx->reg.reg_flags;
#endif
return 0;
}
/**
* cds_update_regulatory_info() - update regulatory info
* @hdd_ctx: hdd context
*
* Return: QDF_STATUS
*/
static void cds_update_regulatory_info(hdd_context_t *hdd_ctx)
{
uint32_t country_code;
country_code = cds_get_country_from_alpha2(hdd_ctx->reg.alpha2);
hdd_ctx->reg.reg_domain = COUNTRY_ERD_FLAG;
hdd_ctx->reg.reg_domain |= country_code;
cds_fill_some_regulatory_info(&hdd_ctx->reg);
return;
}
uint8_t default_country[CDS_COUNTRY_CODE_LEN + 1];
uint8_t dfs_region;
/**
* cds_get_channel_list_with_power() - retrieve channel list with power
@ -418,29 +200,20 @@ QDF_STATUS cds_get_channel_list_with_power(struct channel_power
/**
* cds_read_default_country() - set the default country
* @default_country: default country
* @def_ctry: default country
*
* Return: QDF_STATUS
*/
QDF_STATUS cds_read_default_country(uint8_t *default_country)
QDF_STATUS cds_read_default_country(uint8_t *def_ctry)
{
hdd_context_t *hdd_ctx;
hdd_ctx = cds_get_context(QDF_MODULE_ID_HDD);
if (!hdd_ctx) {
QDF_TRACE(QDF_MODULE_ID_QDF, QDF_TRACE_LEVEL_ERROR,
"invalid hdd_ctx pointer");
return QDF_STATUS_E_FAULT;
}
memcpy(default_country,
hdd_ctx->reg.def_country,
memcpy(def_ctry,
default_country,
CDS_COUNTRY_CODE_LEN + 1);
QDF_TRACE(QDF_MODULE_ID_QDF, QDF_TRACE_LEVEL_INFO,
"default country is %c%c\n",
default_country[0],
default_country[1]);
def_ctry[0],
def_ctry[1]);
return QDF_STATUS_SUCCESS;
}
@ -565,90 +338,15 @@ enum channel_width cds_get_max_channel_bw(uint32_t chan_num)
}
static int cds_bw20_ch_index_to_bw40_ch_index(int k)
{
int m = -1;
if (k >= RF_CHAN_1 && k <= RF_CHAN_13) {
/*
* Channel bonding is not valid for channel 14,
* Hence don't consider it
*/
m = k - RF_CHAN_1 + RF_CHAN_BOND_3;
if (m > RF_CHAN_BOND_11)
m = RF_CHAN_BOND_11;
} else if (k >= RF_CHAN_36 && k <= RF_CHAN_64) {
m = k - RF_CHAN_36 + RF_CHAN_BOND_38;
if (m > RF_CHAN_BOND_62)
m = RF_CHAN_BOND_62;
} else if (k >= RF_CHAN_100 && k <= RF_CHAN_144) {
m = k - RF_CHAN_100 + RF_CHAN_BOND_102;
if (m > RF_CHAN_BOND_142)
m = RF_CHAN_BOND_142;
} else if (k >= RF_CHAN_149 && k <= RF_CHAN_165) {
m = k - RF_CHAN_149 + RF_CHAN_BOND_151;
if (m > RF_CHAN_BOND_163)
m = RF_CHAN_BOND_163;
}
return m;
}
/**
* cds_set_dfs_region() - set the dfs_region
* @dfs_region: the dfs_region to set
*
* Return: QDF_STATUS_SUCCESS if dfs_region set correctly
* QDF_STATUS_E_EXISTS if hdd context not found
*/
QDF_STATUS cds_set_dfs_region(uint8_t dfs_region)
{
hdd_context_t *hdd_ctx;
hdd_ctx = cds_get_context(QDF_MODULE_ID_HDD);
if (NULL == hdd_ctx)
return QDF_STATUS_E_EXISTS;
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 14, 0)) || defined(WITH_BACKPORTS)
hdd_ctx->reg.dfs_region = dfs_region;
#else
/* remap the ctl code to dfs region code */
switch (hdd_ctx->reg.ctl_5g) {
case FCC:
hdd_ctx->reg.dfs_region = DFS_FCC_DOMAIN;
break;
case ETSI:
hdd_ctx->reg.dfs_region = DFS_ETSI_DOMAIN;
break;
case MKK:
hdd_ctx->reg.dfs_region = DFS_MKK4_DOMAIN;
break;
default:
/* set default dfs_region to FCC */
hdd_ctx->reg.dfs_region = DFS_FCC_DOMAIN;
break;
}
#endif
return QDF_STATUS_SUCCESS;
}
/**
* cds_get_dfs_region() - get the dfs_region
* @dfs_region: the dfs_region to return
*
* Return: QDF_STATUS_SUCCESS if dfs_region set correctly
* QDF_STATUS_E_EXISTS if hdd context not found
* Return: QDF_STATUS
*/
QDF_STATUS cds_get_dfs_region(uint8_t *dfs_region)
QDF_STATUS cds_get_dfs_region(uint8_t *dfs_reg)
{
hdd_context_t *hdd_ctx;
hdd_ctx = cds_get_context(QDF_MODULE_ID_HDD);
if (NULL == hdd_ctx)
return QDF_STATUS_E_EXISTS;
*dfs_region = hdd_ctx->reg.dfs_region;
*dfs_reg = dfs_region;
return QDF_STATUS_SUCCESS;
}
@ -665,12 +363,9 @@ QDF_STATUS cds_get_reg_domain_from_country_code(v_REGDOMAIN_t *reg_domain_ptr,
const uint8_t *country_alpha2,
enum country_src source)
{
hdd_context_t *hdd_ctx = NULL;
struct wiphy *wiphy = NULL;
if (NULL == reg_domain_ptr) {
QDF_TRACE(QDF_MODULE_ID_QDF, QDF_TRACE_LEVEL_ERROR,
("Invalid reg domain pointer"));
"Invalid reg domain pointer");
return QDF_STATUS_E_FAULT;
}
@ -681,7 +376,7 @@ QDF_STATUS cds_get_reg_domain_from_country_code(v_REGDOMAIN_t *reg_domain_ptr,
if (NULL == country_alpha2) {
QDF_TRACE(QDF_MODULE_ID_QDF, QDF_TRACE_LEVEL_ERROR,
("Country code array is NULL"));
"Country code array is NULL");
return QDF_STATUS_E_FAULT;
}
@ -691,28 +386,9 @@ QDF_STATUS cds_get_reg_domain_from_country_code(v_REGDOMAIN_t *reg_domain_ptr,
return QDF_STATUS_SUCCESS;
}
hdd_ctx = cds_get_context(QDF_MODULE_ID_HDD);
if (NULL == hdd_ctx) {
QDF_TRACE(QDF_MODULE_ID_QDF, QDF_TRACE_LEVEL_ERROR,
("Invalid pHddCtx pointer"));
return QDF_STATUS_E_FAULT;
}
wiphy = hdd_ctx->wiphy;
if ((SOURCE_DRIVER == source) && (false == init_by_reg_core)) {
init_by_driver = true;
if (('0' != country_alpha2[0]) || ('0' != country_alpha2[1])) {
INIT_COMPLETION(hdd_ctx->reg_init);
regulatory_hint(wiphy, country_alpha2);
wait_for_completion_timeout(&hdd_ctx->reg_init,
msecs_to_jiffies(REG_WAIT_TIME));
}
} else if (SOURCE_11D == source || SOURCE_USERSPACE == source) {
if (SOURCE_11D == source || SOURCE_USERSPACE == source)
regulatory_hint_user(country_alpha2,
NL80211_USER_REG_HINT_USER);
}
return QDF_STATUS_SUCCESS;
}
@ -733,417 +409,6 @@ bool cds_is_dsrc_channel(uint16_t center_freq)
return 0;
}
/**
* cds_process_regulatory_data() - process regulatory data
* @wiphy: wiphy
* @band_capability: band_capability
*
* Return: int
*/
static int cds_process_regulatory_data(struct wiphy *wiphy,
uint8_t band_capability,
bool reset)
{
int i, j, m;
int k = 0, n = 0;
hdd_context_t *hdd_ctx;
const struct ieee80211_reg_rule *reg_rule;
struct ieee80211_channel *chan;
struct regulatory_channel *temp_chan_k, *temp_chan_n, *temp_chan;
hdd_ctx = cds_get_context(QDF_MODULE_ID_HDD);
if (NULL == hdd_ctx) {
QDF_TRACE(QDF_MODULE_ID_QDF, QDF_TRACE_LEVEL_ERROR,
"invalid hdd_ctx pointer");
return QDF_STATUS_E_FAULT;
}
hdd_ctx->isVHT80Allowed = 0;
if (band_capability == eCSR_BAND_24)
QDF_TRACE(QDF_MODULE_ID_QDF, QDF_TRACE_LEVEL_INFO,
"band capability is set to 2G only");
for (i = 0, m = 0; i < IEEE80211_NUM_BANDS; i++) {
if (i == IEEE80211_BAND_2GHZ && band_capability == eCSR_BAND_5G)
continue;
else if (i == IEEE80211_BAND_5GHZ
&& band_capability == eCSR_BAND_24)
continue;
if (wiphy->bands[i] == NULL)
continue;
if (i == 0)
m = 0;
else
m = wiphy->bands[i-1]->n_channels + m;
for (j = 0; j < wiphy->bands[i]->n_channels; j++) {
k = m + j;
n = cds_bw20_ch_index_to_bw40_ch_index(k);
chan = &(wiphy->bands[i]->channels[j]);
temp_chan_k = &(reg_channels[k]);
temp_chan_n = &(reg_channels[n]);
if ((!reset) &&
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 14, 0)) || defined(WITH_BACKPORTS)
(wiphy->regulatory_flags &
REGULATORY_CUSTOM_REG)) {
#else
(wiphy->flags &
WIPHY_FLAG_CUSTOM_REGULATORY)) {
#endif
reg_rule = freq_reg_info(wiphy,
MHZ_TO_KHZ(chan->
center_freq));
if (!IS_ERR(reg_rule)) {
chan->flags &=
~IEEE80211_CHAN_DISABLED;
if (!(reg_rule->flags &
NL80211_RRF_DFS)) {
QDF_TRACE(QDF_MODULE_ID_QDF,
QDF_TRACE_LEVEL_INFO,
"%s: Remove passive scan restriction for %u",
__func__,
chan->center_freq);
chan->flags &=
~IEEE80211_CHAN_RADAR;
}
if (!(reg_rule->flags &
NL80211_RRF_PASSIVE_SCAN)) {
QDF_TRACE(QDF_MODULE_ID_QDF,
QDF_TRACE_LEVEL_INFO,
"%s: Remove passive scan restriction for %u",
__func__,
chan->center_freq);
chan->flags &=
~IEEE80211_CHAN_PASSIVE_SCAN;
}
if (!(reg_rule->flags &
NL80211_RRF_NO_IBSS)) {
QDF_TRACE(QDF_MODULE_ID_QDF,
QDF_TRACE_LEVEL_INFO,
"%s: Remove no ibss restriction for %u",
__func__,
chan->center_freq);
chan->flags &=
~IEEE80211_CHAN_NO_IBSS;
}
chan->max_power = MBM_TO_DBM(reg_rule->
power_rule.
max_eirp);
}
}
if (chan->flags & IEEE80211_CHAN_DISABLED) {
temp_chan_k->state =
CHANNEL_STATE_DISABLE;
temp_chan_k->flags = chan->flags;
if (n != -1) {
temp_chan_n->state =
CHANNEL_STATE_DISABLE;
temp_chan_n->flags = chan->flags;
}
} else if (chan->flags &
(IEEE80211_CHAN_RADAR |
IEEE80211_CHAN_PASSIVE_SCAN
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 16, 0))
|
IEEE80211_CHAN_INDOOR_ONLY
#endif
)) {
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 16, 0))
if (chan->flags &
IEEE80211_CHAN_INDOOR_ONLY)
chan->flags |=
IEEE80211_CHAN_PASSIVE_SCAN;
#endif
temp_chan_k->state = CHANNEL_STATE_DFS;
temp_chan_k->pwr_limit =
chan->max_power;
temp_chan_k->flags = chan->flags;
if (n != -1) {
if ((chan->flags &
IEEE80211_CHAN_NO_HT40) ==
IEEE80211_CHAN_NO_HT40) {
temp_chan_n->state =
CHANNEL_STATE_DISABLE;
} else {
temp_chan_n->state =
CHANNEL_STATE_DFS;
temp_chan_n->pwr_limit =
chan->max_power-3;
}
temp_chan_n->flags = chan->flags;
}
if ((chan->flags &
IEEE80211_CHAN_NO_80MHZ) == 0)
hdd_ctx->isVHT80Allowed = 1;
} else {
temp_chan_k->state = CHANNEL_STATE_ENABLE;
temp_chan_k->pwr_limit = chan->max_power;
temp_chan_k->flags = chan->flags;
if (n != -1) {
if ((chan->flags &
IEEE80211_CHAN_NO_HT40) ==
IEEE80211_CHAN_NO_HT40) {
temp_chan_n->state =
CHANNEL_STATE_DISABLE;
} else {
temp_chan_n->state =
CHANNEL_STATE_ENABLE;
temp_chan_n->pwr_limit =
chan->max_power - 3;
}
temp_chan_n->flags = chan->flags;
}
if ((chan->flags &
IEEE80211_CHAN_NO_80MHZ) == 0)
hdd_ctx->isVHT80Allowed = 1;
}
}
}
if (0 == (hdd_ctx->reg.eeprom_rd_ext &
(1 << WHAL_REG_EXT_FCC_CH_144))) {
temp_chan = &(reg_channels[RF_CHAN_144]);
temp_chan->state =
CHANNEL_STATE_DISABLE;
}
if (k == 0)
return -1;
return QDF_STATUS_SUCCESS;
}
#if (LINUX_VERSION_CODE < KERNEL_VERSION(3, 14, 0)) && !defined(WITH_BACKPORTS)
/**
* restore_custom_reg_settings() - restore custom reg settings
* @wiphy: wiphy structure
*
* Return: void
*/
static void restore_custom_reg_settings(struct wiphy *wiphy)
{
struct ieee80211_supported_band *sband;
enum ieee80211_band band;
struct ieee80211_channel *chan;
int i;
for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
sband = wiphy->bands[band];
if (!sband)
continue;
for (i = 0; i < sband->n_channels; i++) {
chan = &sband->channels[i];
chan->flags = chan->orig_flags;
chan->max_antenna_gain = chan->orig_mag;
chan->max_power = chan->orig_mpwr;
}
}
}
#endif
/**
* __hdd_reg_notifier() - regulatory notifier
* @wiphy: wiphy
* @request: regulatory request
*
* Return: void or int
*/
void __hdd_reg_notifier(struct wiphy *wiphy,
struct regulatory_request *request)
{
hdd_context_t *hdd_ctx = wiphy_priv(wiphy);
eCsrBand band_capability = eCSR_BAND_ALL;
bool vht80_allowed;
bool reset = false;
QDF_TRACE(QDF_MODULE_ID_QDF, QDF_TRACE_LEVEL_INFO,
FL("country: %c%c, initiator %d, dfs_region: %d"),
request->alpha2[0],
request->alpha2[1],
request->initiator,
request->dfs_region);
if (NULL == hdd_ctx) {
QDF_TRACE(QDF_MODULE_ID_QDF, QDF_TRACE_LEVEL_ERROR,
("Invalid pHddCtx pointer"));
return;
}
if (cds_is_driver_unloading() || cds_is_driver_recovering()) {
QDF_TRACE(QDF_MODULE_ID_QDF, QDF_TRACE_LEVEL_ERROR,
"%s: Unloading or SSR in Progress, Ignore!!!",
__func__);
return;
}
sme_get_freq_band(hdd_ctx->hHal, &band_capability);
/* first check if this callback is in response to the driver callback */
switch (request->initiator) {
case NL80211_REGDOM_SET_BY_DRIVER:
case NL80211_REGDOM_SET_BY_CORE:
case NL80211_REGDOM_SET_BY_USER:
if ((false == init_by_driver) &&
(false == init_by_reg_core)) {
if (NL80211_REGDOM_SET_BY_CORE == request->initiator) {
return;
}
init_by_reg_core = true;
}
if ((NL80211_REGDOM_SET_BY_DRIVER == request->initiator) &&
(true == init_by_driver)) {
/*
* restore the driver regulatory flags since
* regulatory_hint may have
* changed them
*/
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 14, 0)) || defined(WITH_BACKPORTS)
wiphy->regulatory_flags = hdd_ctx->reg.reg_flags;
#else
wiphy->flags = hdd_ctx->reg.reg_flags;
#endif
}
if (NL80211_REGDOM_SET_BY_CORE == request->initiator) {
hdd_ctx->reg.cc_src = SOURCE_CORE;
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 14, 0)) || defined(WITH_BACKPORTS)
if (wiphy->regulatory_flags & REGULATORY_CUSTOM_REG)
#else
if (wiphy->flags & WIPHY_FLAG_CUSTOM_REGULATORY)
#endif
reset = true;
} else if (NL80211_REGDOM_SET_BY_DRIVER == request->initiator)
hdd_ctx->reg.cc_src = SOURCE_DRIVER;
else {
hdd_ctx->reg.cc_src = SOURCE_USERSPACE;
#if (LINUX_VERSION_CODE < KERNEL_VERSION(3, 14, 0)) && !defined(WITH_BACKPORTS)
if ((request->alpha2[0] == '0') &&
(request->alpha2[1] == '0') &&
(wiphy->flags & WIPHY_FLAG_CUSTOM_REGULATORY)) {
restore_custom_reg_settings(wiphy);
reset = true;
}
#endif
}
hdd_ctx->reg.alpha2[0] = request->alpha2[0];
hdd_ctx->reg.alpha2[1] = request->alpha2[1];
cds_update_regulatory_info(hdd_ctx);
vht80_allowed = hdd_ctx->isVHT80Allowed;
if (cds_process_regulatory_data(wiphy, band_capability,
reset) == 0) {
QDF_TRACE(QDF_MODULE_ID_QDF, QDF_TRACE_LEVEL_INFO,
(" regulatory entry created"));
}
if (hdd_ctx->isVHT80Allowed != vht80_allowed)
hdd_checkandupdate_phymode(hdd_ctx);
if (NL80211_REGDOM_SET_BY_DRIVER == request->initiator)
complete(&hdd_ctx->reg_init);
sme_generic_change_country_code(hdd_ctx->hHal,
hdd_ctx->reg.alpha2);
cds_fill_and_send_ctl_to_fw(&hdd_ctx->reg);
cds_set_dfs_region(request->dfs_region);
cds_set_wma_dfs_region(&hdd_ctx->reg);
default:
break;
}
return;
}
/**
* hdd_reg_notifier() - regulatory notifier
* @wiphy: wiphy
* @request: regulatory request
*
* Return: void or int
*/
void hdd_reg_notifier(struct wiphy *wiphy,
struct regulatory_request *request)
{
cds_ssr_protect(__func__);
__hdd_reg_notifier(wiphy, request);
cds_ssr_unprotect(__func__);
}
/**
* cds_regulatory_init() - regulatory_init
* Return: QDF_STATUS
*/
QDF_STATUS cds_regulatory_init(void)
{
hdd_context_t *hdd_ctx = NULL;
struct wiphy *wiphy = NULL;
int ret_val = 0;
struct regulatory *reg_info;
hdd_ctx = cds_get_context(QDF_MODULE_ID_HDD);
if (!hdd_ctx) {
QDF_TRACE(QDF_MODULE_ID_QDF, QDF_TRACE_LEVEL_ERROR,
"invalid hdd_ctx pointer");
return QDF_STATUS_E_FAULT;
}
wiphy = hdd_ctx->wiphy;
reg_info = &hdd_ctx->reg;
cds_regulatory_wiphy_init(hdd_ctx, reg_info, wiphy);
if (cds_process_regulatory_data(wiphy,
hdd_ctx->config->
nBandCapability, true) != 0) {
QDF_TRACE(QDF_MODULE_ID_QDF, QDF_TRACE_LEVEL_ERROR,
("Error while creating regulatory entry"));
return QDF_STATUS_E_FAULT;
}
reg_info->cc_src = SOURCE_DRIVER;
ret_val = cds_fill_some_regulatory_info(reg_info);
if (ret_val) {
qdf_print(KERN_ERR "Error in getting country code\n");
return ret_val;
}
hdd_ctx->reg.def_country[0] = reg_info->alpha2[0];
hdd_ctx->reg.def_country[1] = reg_info->alpha2[1];
init_completion(&hdd_ctx->reg_init);
cds_fill_and_send_ctl_to_fw(reg_info);
return QDF_STATUS_SUCCESS;
}
/**
* cds_set_reg_domain() - set regulatory domain
* @client_ctxt: client context
@ -1154,7 +419,7 @@ QDF_STATUS cds_regulatory_init(void)
QDF_STATUS cds_set_reg_domain(void *client_ctxt, v_REGDOMAIN_t reg_domain)
{
if (reg_domain >= REGDOMAIN_COUNT) {
QDF_TRACE(QDF_MODULE_ID_QDF, QDF_TRACE_LEVEL_ERROR,
QDF_TRACE(QDF_MODULE_ID_QDF_DEVICE, QDF_TRACE_LEVEL_ERROR,
"CDS set reg domain, invalid REG domain ID %d",
reg_domain);
return QDF_STATUS_E_INVAL;
@ -1163,6 +428,33 @@ QDF_STATUS cds_set_reg_domain(void *client_ctxt, v_REGDOMAIN_t reg_domain)
return QDF_STATUS_SUCCESS;
}
/**
* cds_put_dfs_region() - save dfs region
* @dfs_reg: dfs region
*
* Return: QDF_STATUS
*/
QDF_STATUS cds_put_dfs_region(uint8_t dfs_reg)
{
dfs_region = dfs_reg;
return QDF_STATUS_SUCCESS;
}
/**
* cds_put_default_country() - save the default country
* @dfs_country: default country
*
* Return: QDF_STATUS
*/
QDF_STATUS cds_put_default_country(uint8_t *def_country)
{
default_country[0] = def_country[0];
default_country[1] = def_country[1];
return QDF_STATUS_SUCCESS;
}
/**
* cds_set_ch_params() - set channel parameters
* @ch: channel
@ -1172,7 +464,7 @@ QDF_STATUS cds_set_reg_domain(void *client_ctxt, v_REGDOMAIN_t reg_domain)
* Return: None
*/
void cds_set_ch_params(uint8_t ch, uint32_t phy_mode,
chan_params_t *ch_params)
struct ch_params_s *ch_params)
{
tHalHandle *hal_ctx = cds_get_context(QDF_MODULE_ID_PE);
if (!hal_ctx) {

6
core/cds/src/cds_regdomain.c
View File

@ -557,7 +557,7 @@ void cds_fill_send_ctl_info_to_fw(struct regulatory *reg, uint32_t modesAvail,
*
* Return: none
*/
void cds_set_wma_dfs_region(struct regulatory *reg)
void cds_set_wma_dfs_region(uint8_t dfs_region)
{
tp_wma_handle wma = cds_get_context(QDF_MODULE_ID_WMA);
@ -566,8 +566,8 @@ void cds_set_wma_dfs_region(struct regulatory *reg)
return;
}
qdf_print("%s: dfs_region: %d", __func__, reg->dfs_region);
wma_set_dfs_region(wma, reg->dfs_region);
qdf_print("%s: dfs_region: %d", __func__, dfs_region);
wma_set_dfs_region(wma, dfs_region);
}
void cds_fill_and_send_ctl_to_fw(struct regulatory *reg)

4
core/hdd/inc/wlan_hdd_main.h
View File

@ -1344,7 +1344,7 @@ struct hdd_context_s {
-------------------------------------------------------------------------*/
int hdd_validate_channel_and_bandwidth(hdd_adapter_t *adapter,
uint32_t chan_number,
phy_ch_width chan_bw);
enum ch_width chan_bw);
#ifdef FEATURE_WLAN_MCC_TO_SCC_SWITCH
void wlan_hdd_check_sta_ap_concurrent_ch_intf(void *sta_pAdapter);
#endif
@ -1530,7 +1530,7 @@ const char *hdd_get_fwpath(void);
void hdd_indicate_mgmt_frame(tSirSmeMgmtFrameInd *frame_ind);
hdd_adapter_t *hdd_get_adapter_by_sme_session_id(hdd_context_t *hdd_ctx,
uint32_t sme_session_id);
phy_ch_width hdd_map_nl_chan_width(enum nl80211_chan_width ch_width);
enum ch_width hdd_map_nl_chan_width(enum nl80211_chan_width ch_width);
uint8_t wlan_hdd_find_opclass(tHalHandle hal, uint8_t channel,
uint8_t bw_offset);
void hdd_update_config(hdd_context_t *hdd_ctx);

41
core/hdd/inc/wlan_hdd_regulatory.h Normal file
View File

@ -0,0 +1,41 @@
/*
* Copyright (c) 2016 The Linux Foundation. All rights reserved.
*
* Previously licensed under the ISC license by Qualcomm Atheros, Inc.
*
*
* 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.
*/
/*
* This file was originally distributed by Qualcomm Atheros, Inc.
* under proprietary terms before Copyright ownership was assigned
* to the Linux Foundation.
*/
#if !defined __HDD_REGULATORY_H
#define __HDD_REGULATORY_H
/**
* DOC: wlan_hdd_regulatory.h
*
* HDD Regulatory prototype implementation
*/
int hdd_regulatory_init(hdd_context_t *hdd_ctx, struct wiphy *wiphy);
void hdd_program_country_code(hdd_context_t *hdd_ctx);
#endif

4
core/hdd/src/wlan_hdd_cfg80211.c
View File

@ -7776,7 +7776,7 @@ void hdd_select_cbmode(hdd_adapter_t *pAdapter, uint8_t operationChannel)
{
uint8_t iniDot11Mode = (WLAN_HDD_GET_CTX(pAdapter))->config->dot11Mode;
eHddDot11Mode hddDot11Mode = iniDot11Mode;
chan_params_t ch_params;
struct ch_params_s ch_params;
ch_params.ch_width =
(WLAN_HDD_GET_CTX(pAdapter))->config->vhtChannelWidth;
@ -11166,7 +11166,7 @@ static int __wlan_hdd_cfg80211_channel_switch(struct wiphy *wiphy,
uint8_t channel;
uint16_t freq;
int ret;
phy_ch_width ch_width;
enum ch_width ch_width;
hddLog(LOG1, FL("Set Freq %d"),
csa_params->chandef.chan->center_freq);

2
core/hdd/src/wlan_hdd_hostapd.c
View File

@ -2005,7 +2005,7 @@ int hdd_softap_unpack_ie(tHalHandle halHandle,
* Return: 0 for success, non zero for failure
*/
int hdd_softap_set_channel_change(struct net_device *dev, int target_channel,
phy_ch_width target_bw)
enum ch_width target_bw)
{
QDF_STATUS status;
int ret = 0;

4
core/hdd/src/wlan_hdd_hostapd.h
View File

@ -58,8 +58,8 @@ eCsrAuthType
hdd_translate_rsn_to_csr_auth_type(uint8_t auth_suite[4]);
int hdd_softap_set_channel_change(struct net_device *dev,
int target_channel,
phy_ch_width target_bw);
int target_channel,
enum ch_width target_bw);
eCsrEncryptionType
hdd_translate_rsn_to_csr_encryption_type(uint8_t cipher_suite[4]);

2
core/hdd/src/wlan_hdd_ioctl.c
View File

@ -6022,7 +6022,7 @@ static int drv_cmd_set_channel_switch(hdd_adapter_t *adapter,
int status;
uint32_t chan_number = 0, chan_bw = 0;
uint8_t *value = command;
phy_ch_width width;
enum ch_width width;
if ((adapter->device_mode != WLAN_HDD_P2P_GO) &&
(adapter->device_mode != WLAN_HDD_SOFTAP)) {

37
core/hdd/src/wlan_hdd_main.c
View File

@ -106,6 +106,7 @@
#include "wlan_hdd_green_ap.h"
#include "platform_icnss.h"
#include "bmi.h"
#include <wlan_hdd_regulatory.h>
#ifdef MODULE
#define WLAN_MODULE_NAME module_name(THIS_MODULE)
@ -245,7 +246,7 @@ const char *hdd_device_mode_to_string(uint8_t device_mode)
*/
int hdd_validate_channel_and_bandwidth(hdd_adapter_t *adapter,
uint32_t chan_number,
phy_ch_width chan_bw)
enum ch_width chan_bw)
{
uint8_t chan[WNI_CFG_VALID_CHANNEL_LIST_LEN];
uint32_t len = WNI_CFG_VALID_CHANNEL_LIST_LEN, i;
@ -432,7 +433,7 @@ static int curr_con_mode;
* Return: Converted channel width. In case of non matching NL channel width,
* CH_WIDTH_MAX will be returned.
*/
phy_ch_width hdd_map_nl_chan_width(enum nl80211_chan_width ch_width)
enum ch_width hdd_map_nl_chan_width(enum nl80211_chan_width ch_width)
{
switch (ch_width) {
case NL80211_CHAN_WIDTH_20_NOHT:
@ -4163,10 +4164,10 @@ bool hdd_is_5g_supported(hdd_context_t *hdd_ctx)
return true;
}
static QDF_STATUS wlan_hdd_regulatory_init(hdd_context_t *hdd_ctx)
static int hdd_wiphy_init(hdd_context_t *hdd_ctx)
{
struct wiphy *wiphy;
QDF_STATUS status = QDF_STATUS_SUCCESS;
int ret_val;
wiphy = hdd_ctx->wiphy;
@ -4174,11 +4175,10 @@ static QDF_STATUS wlan_hdd_regulatory_init(hdd_context_t *hdd_ctx)
* The channel information in
* wiphy needs to be initialized before wiphy registration
*/
status = cds_regulatory_init();
if (!QDF_IS_STATUS_SUCCESS(status)) {
hddLog(QDF_TRACE_LEVEL_FATAL,
FL("cds_init_wiphy failed"));
return status;
ret_val = hdd_regulatory_init(hdd_ctx, wiphy);
if (ret_val) {
hdd_alert("regulatory init failed");
return ret_val;
}
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 11, 0))
@ -4200,12 +4200,11 @@ static QDF_STATUS wlan_hdd_regulatory_init(hdd_context_t *hdd_ctx)
#endif
/* registration of wiphy dev with cfg80211 */
if (0 > wlan_hdd_cfg80211_register(wiphy)) {
hddLog(QDF_TRACE_LEVEL_ERROR, FL("wiphy register failed"));
status = QDF_STATUS_E_FAILURE;
}
ret_val = wlan_hdd_cfg80211_register(wiphy);
if (0 > ret_val)
hdd_err("wiphy registration failed");
return status;
return ret_val;
}
#ifdef MSM_PLATFORM
@ -5468,6 +5467,7 @@ int hdd_wlan_startup(struct device *dev, void *hif_sc)
tSirTxPowerLimit hddtxlimit;
bool rtnl_held;
tSirRetStatus hal_status;
int ret_val;
ENTER();
@ -5516,11 +5516,10 @@ int hdd_wlan_startup(struct device *dev, void *hif_sc)
ol_txrx_register_pause_cb(wlan_hdd_txrx_pause_cb);
status = wlan_hdd_regulatory_init(hdd_ctx);
ret_val = hdd_wiphy_init(hdd_ctx);
if (status != QDF_STATUS_SUCCESS) {
hddLog(QDF_TRACE_LEVEL_FATAL,
FL("Failed to init channel list"));
if (ret_val) {
hdd_alert("failed to initialize wiphy");
goto err_cds_close;
}
@ -5554,6 +5553,8 @@ int hdd_wlan_startup(struct device *dev, void *hif_sc)
__func__, ret);
}
hdd_program_country_code(hdd_ctx);
status = hdd_set_sme_chan_list(hdd_ctx);
if (status != QDF_STATUS_SUCCESS) {
hddLog(QDF_TRACE_LEVEL_FATAL,

766
core/hdd/src/wlan_hdd_regulatory.c Normal file
View File

@ -0,0 +1,766 @@
/*
* Copyright (c) 2014-2016 The Linux Foundation. All rights reserved.
*
* Previously licensed under the ISC license by Qualcomm Atheros, Inc.
*
*
* 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.
*/
/*
* This file was originally distributed by Qualcomm Atheros, Inc.
* under proprietary terms before Copyright ownership was assigned
* to the Linux Foundation.
*/
/**
* DOC: wlan_hdd_regulatory.c
*
* hdd regulatory implementation
*/
#include "qdf_types.h"
#include "cds_reg_service.h"
#include "qdf_trace.h"
#include "sme_api.h"
#include "wlan_hdd_main.h"
#include "cds_regdomain.h"
#include "cds_regdomain_common.h"
#include "wlan_hdd_regulatory.h"
#define WORLD_SKU_MASK 0x00F0
#define WORLD_SKU_PREFIX 0x0060
#define REG_WAIT_TIME 50
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 14, 0)) || defined(WITH_BACKPORTS)
#define IEEE80211_CHAN_PASSIVE_SCAN IEEE80211_CHAN_NO_IR
#define IEEE80211_CHAN_NO_IBSS IEEE80211_CHAN_NO_IR
#endif
#define REG_RULE_2412_2462 REG_RULE(2412-10, 2462+10, 40, 0, 20, 0)
#define REG_RULE_2467_2472 REG_RULE(2467-10, 2472+10, 40, 0, 20, \
NL80211_RRF_PASSIVE_SCAN)
#define REG_RULE_2484 REG_RULE(2484-10, 2484+10, 40, 0, 20, \
NL80211_RRF_PASSIVE_SCAN | NL80211_RRF_NO_OFDM)
#define REG_RULE_5180_5320 REG_RULE(5180-10, 5320+10, 80, 0, 20, \
NL80211_RRF_PASSIVE_SCAN | NL80211_RRF_NO_IBSS)
#define REG_RULE_5500_5720 REG_RULE(5500-10, 5720+10, 80, 0, 20, \
NL80211_RRF_PASSIVE_SCAN | NL80211_RRF_NO_IBSS)
#define REG_RULE_5745_5925 REG_RULE(5745-10, 5925+10, 80, 0, 20, \
NL80211_RRF_PASSIVE_SCAN | NL80211_RRF_NO_IBSS)
static bool init_by_driver;
static bool init_by_reg_core;
static const struct ieee80211_regdomain
hdd_world_regrules_60_61_62 = {
.n_reg_rules = 6,
.alpha2 = "00",
.reg_rules = {
REG_RULE_2412_2462,
REG_RULE_2467_2472,
REG_RULE_2484,
REG_RULE_5180_5320,
REG_RULE_5500_5720,
REG_RULE_5745_5925,
}
};
static const struct ieee80211_regdomain
hdd_world_regrules_63_65 = {
.n_reg_rules = 4,
.alpha2 = "00",
.reg_rules = {
REG_RULE_2412_2462,
REG_RULE_2467_2472,
REG_RULE_5180_5320,
REG_RULE_5745_5925,
}
};
static const struct ieee80211_regdomain
hdd_world_regrules_64 = {
.n_reg_rules = 3,
.alpha2 = "00",
.reg_rules = {
REG_RULE_2412_2462,
REG_RULE_5180_5320,
REG_RULE_5745_5925,
}
};
static const struct ieee80211_regdomain
hdd_world_regrules_66_69 = {
.n_reg_rules = 4,
.alpha2 = "00",
.reg_rules = {
REG_RULE_2412_2462,
REG_RULE_5180_5320,
REG_RULE_5500_5720,
REG_RULE_5745_5925,
}
};
static const struct ieee80211_regdomain
hdd_world_regrules_67_68_6A_6C = {
.n_reg_rules = 5,
.alpha2 = "00",
.reg_rules = {
REG_RULE_2412_2462,
REG_RULE_2467_2472,
REG_RULE_5180_5320,
REG_RULE_5500_5720,
REG_RULE_5745_5925,
}
};
/**
* hdd_get_world_regrules() - get the appropriate world regrules
* @reg: regulatory data
*
* Return: regulatory rules ptr
*/
static const struct ieee80211_regdomain *hdd_get_world_regrules(
struct regulatory *reg)
{
REG_DMN_PAIR_MAPPING *regpair =
(REG_DMN_PAIR_MAPPING *)reg->regpair;
switch (regpair->regDmnEnum) {
case 0x60:
case 0x61:
case 0x62:
return &hdd_world_regrules_60_61_62;
case 0x63:
case 0x65:
return &hdd_world_regrules_63_65;
case 0x64:
return &hdd_world_regrules_64;
case 0x66:
case 0x69:
return &hdd_world_regrules_66_69;
case 0x67:
case 0x68:
case 0x6A:
case 0x6C:
return &hdd_world_regrules_67_68_6A_6C;
default:
hdd_warn("invalid world mode in BDF");
return &hdd_world_regrules_60_61_62;
}
}
/**
* hdd_is_world_regdomain() - whether world regdomain
* @reg_domain: integer regulatory domain
*
* Return: bool
*/
bool hdd_is_world_regdomain(uint32_t reg_domain)
{
uint32_t temp_regd = reg_domain & ~WORLDWIDE_ROAMING_FLAG;
return ((temp_regd & COUNTRY_ERD_FLAG) != COUNTRY_ERD_FLAG) &&
(((temp_regd & WORLD_SKU_MASK) == WORLD_SKU_PREFIX) ||
(temp_regd == WORLD));
}
/**
* hdd_update_regulatory_info() - update regulatory info
* @hdd_ctx: hdd context
*
* Return: void
*/
static void hdd_update_regulatory_info(hdd_context_t *hdd_ctx)
{
uint32_t country_code;
country_code = cds_get_country_from_alpha2(hdd_ctx->reg.alpha2);
hdd_ctx->reg.reg_domain = COUNTRY_ERD_FLAG;
hdd_ctx->reg.reg_domain |= country_code;
cds_fill_some_regulatory_info(&hdd_ctx->reg);
}
/**
* hdd_regulatory_wiphy_init() - regulatory wiphy init
* @hdd_ctx: hdd context
* @reg: regulatory data
* @wiphy: wiphy structure
*
* Return: void
*/
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 14, 0)) || defined(WITH_BACKPORTS)
static void hdd_regulatory_wiphy_init(hdd_context_t *hdd_ctx,
struct regulatory *reg,
struct wiphy *wiphy)
{
const struct ieee80211_regdomain *reg_rules;
if (hdd_is_world_regdomain(reg->reg_domain)) {
reg_rules = hdd_get_world_regrules(reg);
wiphy->regulatory_flags |= REGULATORY_CUSTOM_REG;
} else if (hdd_ctx->config->fRegChangeDefCountry) {
wiphy->regulatory_flags |= REGULATORY_CUSTOM_REG;
reg_rules = &hdd_world_regrules_60_61_62;
} else {
wiphy->regulatory_flags |= REGULATORY_STRICT_REG;
reg_rules = &hdd_world_regrules_60_61_62;
}
/*
* save the original driver regulatory flags
*/
hdd_ctx->reg.reg_flags = wiphy->regulatory_flags;
wiphy_apply_custom_regulatory(wiphy, reg_rules);
/*
* restore the driver regulatory flags since
* wiphy_apply_custom_regulatory may have
* changed them
*/
wiphy->regulatory_flags = hdd_ctx->reg.reg_flags;
}
#else
static void hdd_regulatory_wiphy_init(hdd_context_t *hdd_ctx,
struct regulatory *reg,
struct wiphy *wiphy)
{
const struct ieee80211_regdomain *reg_rules;
if (hdd_is_world_regdomain(reg->reg_domain)) {
reg_rules = hdd_get_world_regrules(reg);
wiphy->flags |= WIPHY_FLAG_CUSTOM_REGULATORY;
} else if (hdd_ctx->config->fRegChangeDefCountry) {
wiphy->flags |= WIPHY_FLAG_CUSTOM_REGULATORY;
reg_rules = &hdd_world_regrules_60_61_62;
} else {
wiphy->flags |= WIPHY_FLAG_STRICT_REGULATORY;
reg_rules = &hdd_world_regrules_60_61_62;
}
/*
* save the original driver regulatory flags
*/
hdd_ctx->reg.reg_flags = wiphy->flags;
wiphy_apply_custom_regulatory(wiphy, reg_rules);
/*
* restore the driver regulatory flags since
* wiphy_apply_custom_regulatory may have
* changed them
*/
wiphy->flags = hdd_ctx->reg.reg_flags;
}
#endif
/**
* hdd_bw20_ch_index_to_() - convert 20 mhhz channel index to 40 mhz index
* @k: 20 mhz channel index
*
* Return: void
*/
static int hdd_bw20_ch_index_to_bw40_ch_index(int k)
{
int m = -1;
if (k >= RF_CHAN_1 && k <= RF_CHAN_14) {
m = k - RF_CHAN_1 + RF_CHAN_BOND_3;
if (m > RF_CHAN_BOND_11)
m = RF_CHAN_BOND_11;
} else if (k >= RF_CHAN_36 && k <= RF_CHAN_64) {
m = k - RF_CHAN_36 + RF_CHAN_BOND_38;
if (m > RF_CHAN_BOND_62)
m = RF_CHAN_BOND_62;
} else if (k >= RF_CHAN_100 && k <= RF_CHAN_144) {
m = k - RF_CHAN_100 + RF_CHAN_BOND_102;
if (m > RF_CHAN_BOND_142)
m = RF_CHAN_BOND_142;
} else if (k >= RF_CHAN_149 && k <= RF_CHAN_165) {
m = k - RF_CHAN_149 + RF_CHAN_BOND_151;
if (m > RF_CHAN_BOND_163)
m = RF_CHAN_BOND_163;
}
return m;
}
/**
* is_wiphy_custom_regulatory() - is custom regulatory defined
* @wiphy: wiphy
*
* Return: int
*/
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 14, 0)) || defined(WITH_BACKPORTS)
static int is_wiphy_custom_regulatory(struct wiphy *wiphy)
{
return wiphy->regulatory_flags & REGULATORY_CUSTOM_REG;
}
#else
static int is_wiphy_custom_regulatory(struct wiphy *wiphy)
{
return wiphy->flags & WIPHY_FLAG_CUSTOM_REGULATORY;
}
#endif
/**
* hdd_modify_wiphy() - modify wiphy
* @wiphy: wiphy
* @chan: channel structure
*
* Return: void
*/
static void hdd_modify_wiphy(struct wiphy *wiphy,
struct ieee80211_channel *chan)
{
const struct ieee80211_reg_rule *reg_rule;
if (is_wiphy_custom_regulatory(wiphy)) {
reg_rule = freq_reg_info(wiphy, MHZ_TO_KHZ(chan->center_freq));
if (!IS_ERR(reg_rule)) {
chan->flags &= ~IEEE80211_CHAN_DISABLED;
if (!(reg_rule->flags & NL80211_RRF_DFS)) {
hdd_info("%s: remove dfs restriction for %u",
__func__, chan->center_freq);
chan->flags &= ~IEEE80211_CHAN_RADAR;
}
if (!(reg_rule->flags & NL80211_RRF_PASSIVE_SCAN)) {
hdd_info("%s: remove passive restriction for %u",
__func__, chan->center_freq);
chan->flags &= ~IEEE80211_CHAN_PASSIVE_SCAN;
}
if (!(reg_rule->flags & NL80211_RRF_NO_IBSS)) {
hdd_info("%s: remove no ibss restriction for %u",
__func__, chan->center_freq);
chan->flags &= ~IEEE80211_CHAN_NO_IBSS;
}
chan->max_power =
MBM_TO_DBM(reg_rule->power_rule.max_eirp);
}
}
}
/**
* hdd_process_regulatory_data() - process regulatory data
* @hdd_ctx: hdd context
* @wiphy: wiphy
* @reset: whether to reset channel data
*
* Return: void
*/
static void hdd_process_regulatory_data(hdd_context_t *hdd_ctx,
struct wiphy *wiphy,
bool reset)
{
int i, j, m;
int k = 0, n = 0;
struct ieee80211_channel *chan;
struct regulatory_channel *temp_chan_k, *temp_chan_n, *temp_chan;
uint8_t band_capability;
band_capability = hdd_ctx->config->nBandCapability;
hdd_ctx->isVHT80Allowed = 0;
if (band_capability == eCSR_BAND_24)
hdd_info("band capability is set to 2G only");
for (i = 0, m = 0; i < IEEE80211_NUM_BANDS; i++) {
if (i == IEEE80211_BAND_2GHZ &&
band_capability == eCSR_BAND_5G)
continue;
else if (i == IEEE80211_BAND_5GHZ &&
band_capability == eCSR_BAND_24)
continue;
if (wiphy->bands[i] == NULL) {
hdd_info("wiphy band no %d is NULL", i);
continue;
}
if (i == 0)
m = 0;
else
m = wiphy->bands[i-1]->n_channels + m;
for (j = 0; j < wiphy->bands[i]->n_channels; j++) {
k = m + j;
n = hdd_bw20_ch_index_to_bw40_ch_index(k);
chan = &(wiphy->bands[i]->channels[j]);
temp_chan_k = &(reg_channels[k]);
temp_chan_n = &(reg_channels[n]);
if (!reset)
hdd_modify_wiphy(wiphy, chan);
if (chan->flags & IEEE80211_CHAN_DISABLED) {
temp_chan_k->state =
CHANNEL_STATE_DISABLE;
temp_chan_k->flags = chan->flags;
if (n != -1) {
temp_chan_n->state =
CHANNEL_STATE_DISABLE;
temp_chan_n->flags = chan->flags;
}
} else if (chan->flags &
(IEEE80211_CHAN_RADAR |
IEEE80211_CHAN_PASSIVE_SCAN |
IEEE80211_CHAN_INDOOR_ONLY)) {
if (chan->flags &
IEEE80211_CHAN_INDOOR_ONLY)
chan->flags |=
IEEE80211_CHAN_PASSIVE_SCAN;
temp_chan_k->state = CHANNEL_STATE_DFS;
temp_chan_k->pwr_limit =
chan->max_power;
temp_chan_k->flags = chan->flags;
if (n != -1) {
if ((chan->flags &
IEEE80211_CHAN_NO_HT40) ==
IEEE80211_CHAN_NO_HT40) {
temp_chan_n->state =
CHANNEL_STATE_DISABLE;
} else {
temp_chan_n->state =
CHANNEL_STATE_DFS;
temp_chan_n->pwr_limit =
chan->max_power-3;
}
temp_chan_n->flags = chan->flags;
}
if ((chan->flags &
IEEE80211_CHAN_NO_80MHZ) == 0)
hdd_ctx->isVHT80Allowed = 1;
} else {
temp_chan_k->state = CHANNEL_STATE_ENABLE;
temp_chan_k->pwr_limit = chan->max_power;
temp_chan_k->flags = chan->flags;
if (n != -1) {
if ((chan->flags &
IEEE80211_CHAN_NO_HT40) ==
IEEE80211_CHAN_NO_HT40) {
temp_chan_n->state =
CHANNEL_STATE_DISABLE;
} else {
temp_chan_n->state =
CHANNEL_STATE_ENABLE;
temp_chan_n->pwr_limit =
chan->max_power - 3;
}
temp_chan_n->flags = chan->flags;
}
if ((chan->flags &
IEEE80211_CHAN_NO_80MHZ) == 0)
hdd_ctx->isVHT80Allowed = 1;
}
}
}
if (0 == (hdd_ctx->reg.eeprom_rd_ext &
(1 << WHAL_REG_EXT_FCC_CH_144))) {
temp_chan = &(reg_channels[RF_CHAN_144]);
temp_chan->state =
CHANNEL_STATE_DISABLE;
}
}
/**
* hdd_regulatory_init() - regulatory_init
* @hdd_ctx: hdd context
* @wiphy: wiphy
*
* Return: int
*/
int hdd_regulatory_init(hdd_context_t *hdd_ctx, struct wiphy *wiphy)
{
int ret_val;
struct regulatory *reg_info;
reg_info = &hdd_ctx->reg;
hdd_regulatory_wiphy_init(hdd_ctx, reg_info, wiphy);
hdd_process_regulatory_data(hdd_ctx, wiphy, true);
reg_info->cc_src = SOURCE_DRIVER;
ret_val = cds_fill_some_regulatory_info(reg_info);
if (ret_val) {
hdd_err("incorrect BDF regulatory data");
return ret_val;
}
cds_put_default_country(reg_info->alpha2);
init_completion(&hdd_ctx->reg_init);
cds_fill_and_send_ctl_to_fw(reg_info);
return 0;
}
/**
* hdd_program_country_code() - process channel information from country code
* @hdd_ctx: hddc context
*
* Return: void
*/
void hdd_program_country_code(hdd_context_t *hdd_ctx)
{
struct wiphy *wiphy = hdd_ctx->wiphy;
uint8_t *country_alpha2 = hdd_ctx->reg.alpha2;
if (false == init_by_reg_core) {
init_by_driver = true;
if (('0' != country_alpha2[0]) ||
('0' != country_alpha2[1])) {
INIT_COMPLETION(hdd_ctx->reg_init);
regulatory_hint(wiphy, country_alpha2);
wait_for_completion_timeout(&hdd_ctx->reg_init,
msecs_to_jiffies(REG_WAIT_TIME));
}
}
}
/**
* hdd_set_dfs_region() - set the dfs_region
* @dfs_region: the dfs_region to set
*
* Return: void
*/
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 14, 0)) || defined(WITH_BACKPORTS)
static void hdd_set_dfs_region(hdd_context_t *hdd_ctx,
uint8_t dfs_reg)
{
cds_put_dfs_region(dfs_reg);
}
#else
static void hdd_set_dfs_region(hdd_context_t *hdd_ctx,
uint8_t dfs_reg)
{
/* remap the ctl code to dfs region code */
switch (hdd_ctx->reg.ctl_5g) {
case FCC:
cds_put_dfs_region(DFS_FCC_DOMAIN);
break;
case ETSI:
cds_put_dfs_region(DFS_ETSI_DOMAIN);
break;
case MKK:
cds_put_dfs_region(DFS_MKK4_DOMAIN);
break;
default:
/* set default dfs_region to FCC */
cds_put_dfs_region(DFS_FCC_DOMAIN);
break;
}
}
#endif
/**
* hdd_restore_custom_reg_settings() - restore custom reg settings
* @wiphy: wiphy structure
* @country_alpha2: alpha2 of the country
* @reset: whether wiphy is reset
*
* Return: void
*/
#if (LINUX_VERSION_CODE > KERNEL_VERSION(3, 14, 0)) || defined(WITH_BACKPORTS)
static void hdd_restore_custom_reg_settings(struct wiphy *wiphy,
uint8_t *country_alpha2,
bool *reset)
{
}
#else
static void hdd_restore_custom_reg_settings(struct wiphy *wiphy,
uint8_t *country_alpha2,
bool *reset)
{
struct ieee80211_supported_band *sband;
enum ieee80211_band band;
struct ieee80211_channel *chan;
int i;
if ((country_alpha2[0] == '0') &&
(country_alpha2[1] == '0') &&
(wiphy->flags & WIPHY_FLAG_CUSTOM_REGULATORY)) {
for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
sband = wiphy->bands[band];
if (!sband)
continue;
for (i = 0; i < sband->n_channels; i++) {
chan = &sband->channels[i];
chan->flags = chan->orig_flags;
chan->max_antenna_gain = chan->orig_mag;
chan->max_power = chan->orig_mpwr;
}
}
*reset = true;
}
}
#endif
/**
* hdd_restore_reg_flags() - restore regulatory flags
* @flags: regulatory flags
*
* Return: void
*/
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 14, 0)) || defined(WITH_BACKPORTS)
static void hdd_restore_reg_flags(struct wiphy *wiphy, uint32_t flags)
{
wiphy->regulatory_flags = flags;
}
#else
static void hdd_restore_reg_flags(struct wiphy *wiphy, uint32_t flags)
{
wiphy->flags = flags;
}
#endif
/**
* hdd_reg_notifier() - regulatory notifier
* @wiphy: wiphy
* @request: regulatory request
*
* Return: void
*/
void hdd_reg_notifier(struct wiphy *wiphy,
struct regulatory_request *request)
{
hdd_context_t *hdd_ctx = wiphy_priv(wiphy);
eCsrBand band_capability = eCSR_BAND_ALL;
bool vht80_allowed;
bool reset = false;
uint8_t dfs_reg;
hdd_info("country: %c%c, initiator %d, dfs_region: %d",
request->alpha2[0],
request->alpha2[1],
request->initiator,
request->dfs_region);
if (NULL == hdd_ctx) {
hdd_err("invalid hdd_ctx pointer");
return;
}
if (cds_is_driver_unloading() || cds_is_driver_recovering()) {
hdd_err("%s: unloading or ssr in progress, ignore",
__func__);
return;
}
sme_get_freq_band(hdd_ctx->hHal, &band_capability);
/* first check if this callback is in response to the driver callback */
switch (request->initiator) {
case NL80211_REGDOM_SET_BY_DRIVER:
case NL80211_REGDOM_SET_BY_CORE:
case NL80211_REGDOM_SET_BY_USER:
if ((false == init_by_driver) &&
(false == init_by_reg_core)) {
if (NL80211_REGDOM_SET_BY_CORE == request->initiator)
return;
init_by_reg_core = true;
}
if ((NL80211_REGDOM_SET_BY_DRIVER == request->initiator) &&
(true == init_by_driver)) {
/*
* restore the driver regulatory flags since
* regulatory_hint may have
* changed them
*/
hdd_restore_reg_flags(wiphy, hdd_ctx->reg.reg_flags);
}
if (NL80211_REGDOM_SET_BY_CORE == request->initiator) {
hdd_ctx->reg.cc_src = SOURCE_CORE;
if (is_wiphy_custom_regulatory(wiphy))
reset = true;
} else if (NL80211_REGDOM_SET_BY_DRIVER == request->initiator)
hdd_ctx->reg.cc_src = SOURCE_DRIVER;
else {
hdd_ctx->reg.cc_src = SOURCE_USERSPACE;
hdd_restore_custom_reg_settings(wiphy,
request->alpha2,
&reset);
}
hdd_ctx->reg.alpha2[0] = request->alpha2[0];
hdd_ctx->reg.alpha2[1] = request->alpha2[1];
hdd_update_regulatory_info(hdd_ctx);
vht80_allowed = hdd_ctx->isVHT80Allowed;
hdd_process_regulatory_data(hdd_ctx, wiphy, reset);
if (hdd_ctx->isVHT80Allowed != vht80_allowed)
hdd_checkandupdate_phymode(hdd_ctx);
if (NL80211_REGDOM_SET_BY_DRIVER == request->initiator)
complete(&hdd_ctx->reg_init);
sme_generic_change_country_code(hdd_ctx->hHal,
hdd_ctx->reg.alpha2);
cds_fill_and_send_ctl_to_fw(&hdd_ctx->reg);
hdd_set_dfs_region(hdd_ctx, request->dfs_region);
cds_get_dfs_region(&dfs_reg);
cds_set_wma_dfs_region(dfs_reg);
break;
default:
break;
}
}

36
core/mac/inc/sir_api.h
View File

@ -38,6 +38,9 @@
#ifndef __SIR_API_H
#define __SIR_API_H
#include "qdf_types.h"
#include "cds_reg_service.h"
#include "cds_regdomain.h"
#include "sir_types.h"
#include "sir_mac_prot_def.h"
#include "ani_system_defs.h"
@ -288,37 +291,6 @@ struct rrm_config_param {
uint8_t max_randn_interval;
uint8_t rm_capability[RMENABLEDCAP_MAX_LEN];
};
/**
* typedef ch_width - channel width
* @CH_WIDTH_20MHZ: channel width 20 MHz
* @CH_WIDTH_40MHZ: channel width 40 MHz
* @CH_WIDTH_80MHZ: channel width 80MHz
* @CH_WIDTH_160MHZ: channel width 160 MHz
* @CH_WIDTH_80P80MHZ: channel width 160MHz(80+80)
*/
typedef enum ch_width {
CH_WIDTH_20MHZ = 0,
CH_WIDTH_40MHZ = 1,
CH_WIDTH_80MHZ = 2,
CH_WIDTH_160MHZ = 3,
CH_WIDTH_80P80MHZ = 4,
CH_WIDTH_MAX
} phy_ch_width;
/**
* struct ch_params_s
*
* @ch_width: channel width
* @sec_ch_offset: secondary channel offset
* @center_freq_seg0: center freq for segment 0
* @center_freq_seg1: center freq for segment 1
*/
typedef struct ch_params_s {
enum ch_width ch_width;
uint8_t sec_ch_offset;
uint8_t center_freq_seg0;
uint8_t center_freq_seg1;
} chan_params_t;
/* each station added has a rate mode which specifies the sta attributes */
typedef enum eStaRateMode {
@ -3838,7 +3810,7 @@ typedef struct sSirChanChangeRequest {
uint16_t messageLen;
uint8_t targetChannel;
uint8_t sec_ch_offset;
phy_ch_width ch_width;
enum ch_width ch_width;
uint8_t center_freq_seg_0;
uint8_t center_freq_seg_1;
uint8_t bssid[QDF_MAC_ADDR_SIZE];

2
core/mac/src/pe/include/lim_global.h
View File

@ -506,7 +506,7 @@ typedef struct sLimChannelSwitchInfo {
uint8_t ch_center_freq_seg0;
uint8_t ch_center_freq_seg1;
uint8_t sec_ch_offset;
phy_ch_width ch_width;
enum ch_width ch_width;
int8_t switchCount;
uint32_t switchTimeoutValue;
uint8_t switchMode;

2
core/mac/src/pe/include/lim_session.h
View File

@ -313,7 +313,7 @@ typedef struct sPESession /* Added to Support BT-AMP */
tLimOperatingModeInfo gLimOperatingMode;
uint8_t vhtCapabilityPresentInBeacon;
uint8_t ch_center_freq_seg0;
phy_ch_width ch_width;
enum ch_width ch_width;
uint8_t ch_center_freq_seg1;
uint8_t txBFIniFeatureEnabled;
uint8_t txbf_csn_value;

2
core/mac/src/pe/lim/lim_process_mlm_req_messages.c
View File

@ -2888,7 +2888,7 @@ void lim_complete_mlm_scan(tpAniSirGlobal mac_ctx, tSirResultCodes ret_code)
*/
void lim_set_channel(tpAniSirGlobal mac_ctx, uint8_t channel,
uint8_t ch_center_freq_seg0, uint8_t ch_center_freq_seg1,
phy_ch_width ch_width, int8_t max_tx_power,
enum ch_width ch_width, int8_t max_tx_power,
uint8_t pe_session_id)
{
tpPESession pe_session;

2
core/mac/src/pe/lim/lim_send_messages.c
View File

@ -207,7 +207,7 @@ tSirRetStatus lim_send_switch_chnl_params(tpAniSirGlobal pMac,
uint8_t chnlNumber,
uint8_t ch_center_freq_seg0,
uint8_t ch_center_freq_seg1,
phy_ch_width ch_width,
enum ch_width ch_width,
int8_t maxTxPower,
uint8_t peSessionId,
uint8_t is_restart)

3
core/mac/src/pe/lim/lim_send_messages.h
View File

@ -67,10 +67,11 @@ tSirRetStatus lim_send_switch_chnl_params(tpAniSirGlobal pMac,
uint8_t chnlNumber,
uint8_t ch_center_freq_seg0,
uint8_t ch_center_freq_seg1,
phy_ch_width ch_width,
enum ch_width ch_width,
int8_t maxTxPower,
uint8_t peSessionId,
uint8_t is_restart);
tSirRetStatus lim_send_edca_params(tpAniSirGlobal pMac,
tSirMacEdcaParamRecord *pUpdatedEdcaParams,
uint16_t bssIdx);

2
core/mac/src/pe/lim/lim_send_sme_rsp_messages.c
View File

@ -2023,7 +2023,7 @@ void lim_handle_csa_offload_msg(tpAniSirGlobal mac_ctx, tpSirMsgQ msg)
uint8_t session_id;
uint16_t aid = 0;
uint16_t chan_space = 0;
chan_params_t ch_params;
struct ch_params_s ch_params;
tLimWiderBWChannelSwitchInfo *chnl_switch_info = NULL;
tLimChannelSwitchInfo *lim_ch_switch = NULL;

2
core/mac/src/pe/lim/lim_types.h
View File

@ -552,7 +552,7 @@ uint32_t lim_defer_msg(tpAniSirGlobal, tSirMsgQ *);
/* / Function that Switches the Channel and sets the CB Mode */
void lim_set_channel(tpAniSirGlobal pMac, uint8_t channel,
uint8_t ch_center_freq_seg0, uint8_t ch_center_freq_seg1,
phy_ch_width ch_width, int8_t maxTxPower,
enum ch_width ch_width, int8_t maxTxPower,
uint8_t peSessionId);

2
core/mac/src/pe/lim/lim_utils.c
View File

@ -2727,7 +2727,7 @@ void lim_switch_primary_secondary_channel(tpAniSirGlobal pMac,
uint8_t newChannel,
uint8_t ch_center_freq_seg0,
uint8_t ch_center_freq_seg1,
phy_ch_width ch_width)
enum ch_width ch_width)
{
uint8_t subband = 0;

2
core/mac/src/pe/lim/lim_utils.h
View File

@ -219,7 +219,7 @@ void lim_switch_primary_secondary_channel(tpAniSirGlobal pMac,
uint8_t newChannel,
uint8_t ch_center_freq_seg0,
uint8_t ch_center_freq_seg1,
phy_ch_width ch_width);
enum ch_width ch_width);
void limUpdateStaRunTimeHTSwtichChnlParams(tpAniSirGlobal pMac,
tDot11fIEHTInfo *pRcvdHTInfo,
uint8_t bssIdx);

13
core/sap/inc/sap_api.h
View File

@ -507,7 +507,7 @@ typedef struct sap_Config {
struct qdf_mac_addr self_macaddr; /* self macaddress or BSSID */
uint8_t channel; /* Operation channel */
uint8_t sec_ch;
chan_params_t ch_params;
struct ch_params_s ch_params;
uint32_t ch_width_orig;
uint8_t max_num_sta; /* maximum number of STAs in station table */
uint8_t dtim_period; /* dtim interval */
@ -621,9 +621,9 @@ typedef struct sSapDfsInfo {
* New channel width and new channel bonding mode
* will only be updated via channel fallback mechanism
*/
phy_ch_width orig_chanWidth;
phy_ch_width new_chanWidth;
chan_params_t new_ch_params;
enum ch_width orig_chanWidth;
enum ch_width new_chanWidth;
struct ch_params_s new_ch_params;
/*
* INI param to enable/disable SAP W53
@ -827,9 +827,8 @@ QDF_STATUS wlansap_disassoc_sta(void *p_cds_gctx,
QDF_STATUS wlansap_deauth_sta(void *p_cds_gctx,
struct tagCsrDelStaParams *pDelStaParams);
QDF_STATUS wlansap_set_channel_change_with_csa(void *p_cds_gctx,
uint32_t targetChannel, phy_ch_width target_bw);
QDF_STATUS wlansap_set_key_sta(void *p_cds_gctx,
tCsrRoamSetKey *pSetKeyInfo);
uint32_t targetChannel, enum ch_width target_bw);
QDF_STATUS wlansap_set_key_sta(void *p_cds_gctx, tCsrRoamSetKey *pSetKeyInfo);
QDF_STATUS wlansap_get_assoc_stations(void *p_cds_gctx,
QDF_MODULE_ID module, tpSap_AssocMacAddr pAssocStas);
QDF_STATUS wlansap_remove_wps_session_overlap(void *p_cds_gctx,

2
core/sap/src/sap_api_link_cntl.c
View File

@ -238,7 +238,7 @@ void sap_config_acs_result(tHalHandle hal, ptSapContext sap_ctx,
uint32_t sec_ch)
{
uint32_t channel = sap_ctx->acs_cfg->pri_ch;
chan_params_t ch_params = {0};
struct ch_params_s ch_params = {0};
ch_params.ch_width = sap_ctx->acs_cfg->ch_width;
sme_set_ch_params(hal, sap_ctx->csr_roamProfile.phyMode, channel,

8
core/sap/src/sap_fsm.c
View File

@ -890,7 +890,7 @@ static inline void sap_event_init(ptWLAN_SAPEvent sapEvent)
*/
bool
sap_find_target_channel_in_channel_matrix(ptSapContext sapContext,
phy_ch_width ch_width,
enum ch_width ch_width,
uint8_t NOL_channel,
tSapTxLeakInfo **pTarget_chnl_mtrx)
{
@ -955,7 +955,7 @@ sap_find_target_channel_in_channel_matrix(ptSapContext sapContext,
QDF_STATUS
sap_mark_channels_leaking_into_nol(ptSapContext sap_ctx,
phy_ch_width ch_width,
enum ch_width ch_width,
tSapDfsNolInfo *nol,
uint8_t temp_ch_lst_sz,
uint8_t *temp_ch_lst)
@ -1069,7 +1069,7 @@ static void sap_set_bitmap(chan_bonding_bitmap *pBitmap, uint8_t channel)
* Return: number of channels found
*/
static uint8_t sap_populate_available_channels(chan_bonding_bitmap *bitmap,
phy_ch_width ch_width,
enum ch_width ch_width,
uint8_t *avail_chnl)
{
uint8_t i = 0;
@ -1246,7 +1246,7 @@ static uint8_t sap_random_channel_sel(ptSapContext sapContext)
uint8_t channelID;
tHalHandle hHal = CDS_GET_HAL_CB(sapContext->p_cds_gctx);
tpAniSirGlobal pMac;
phy_ch_width ch_width;
enum ch_width ch_width;
uint8_t *tmp_ch_lst = NULL;
uint8_t dfs_region;

2
core/sap/src/sap_internal.h
View File

@ -212,7 +212,7 @@ typedef struct sSapContext {
uint8_t *channelList;
tSapChannelListInfo SapChnlList;
uint16_t ch_width_orig;
chan_params_t ch_params;
struct ch_params_s ch_params;
/* session to scan */
bool isScanSessionOpen;

4
core/sap/src/sap_module.c
View File

@ -1437,7 +1437,7 @@ static QDF_STATUS wlansap_update_csa_channel_params(ptSapContext sap_context,
*/
QDF_STATUS
wlansap_set_channel_change_with_csa(void *p_cds_gctx, uint32_t targetChannel,
phy_ch_width target_bw)
enum ch_width target_bw)
{
ptSapContext sapContext = NULL;
@ -2246,7 +2246,7 @@ wlansap_channel_change_request(void *pSapCtx, uint8_t target_channel)
void *hHal = NULL;
tpAniSirGlobal mac_ctx = NULL;
eCsrPhyMode phy_mode;
chan_params_t ch_params;
struct ch_params_s ch_params;
sapContext = (ptSapContext) pSapCtx;
if (NULL == sapContext) {

2
core/sme/inc/csr_api.h
View File

@ -876,7 +876,7 @@ typedef struct tagCsrRoamProfile {
eCsrCBChoice CBMode;
tCsrChannelInfo ChannelInfo;
uint8_t operationChannel;
chan_params_t ch_params;
struct ch_params_s ch_params;
/* If this is 0, SME will fill in for caller. */
uint16_t beaconInterval;
/*

22
core/sme/inc/csr_internal.h
View File

@ -333,7 +333,7 @@ typedef struct tagCsrRoamStartBssParams {
tSirMacRateSet operationalRateSet;
tSirMacRateSet extendedRateSet;
uint8_t operationChn;
chan_params_t ch_params;
struct ch_params_s ch_params;
eCsrCfgDot11Mode uCfgDot11Mode;
uint8_t privacy;
bool fwdWPSPBCProbeReq;
@ -1323,21 +1323,21 @@ QDF_STATUS csr_handoff_request(tpAniSirGlobal pMac, uint8_t sessionId,
bool csr_roam_is_sta_mode(tpAniSirGlobal pMac, uint32_t sessionId);
/* Post Channel Change Indication */
QDF_STATUS csr_roam_channel_change_req(tpAniSirGlobal pMac,
struct qdf_mac_addr bssid, chan_params_t *ch_params,
tCsrRoamProfile *profile);
QDF_STATUS csr_roam_channel_change_req(tpAniSirGlobal pMac, struct qdf_mac_addr
bssid, struct ch_params_s *ch_params,
tCsrRoamProfile *profile);
/* Post Beacon Tx Start Indication */
QDF_STATUS csr_roam_start_beacon_req(tpAniSirGlobal pMac,
struct qdf_mac_addr bssid, uint8_t dfsCacWaitStatus);
QDF_STATUS
csr_roam_send_chan_sw_ie_request(tpAniSirGlobal pMac, struct qdf_mac_addr bssid,
uint8_t targetChannel, uint8_t csaIeReqd,
chan_params_t *ch_params);
QDF_STATUS
csr_roam_modify_add_ies(tpAniSirGlobal pMac,
tSirModifyIE *pModifyIE, eUpdateIEsType updateType);
QDF_STATUS csr_roam_send_chan_sw_ie_request(tpAniSirGlobal pMac,
struct qdf_mac_addr bssid,
uint8_t targetChannel,
uint8_t csaIeReqd,
struct ch_params_s *ch_params);
QDF_STATUS csr_roam_modify_add_ies(tpAniSirGlobal pMac, tSirModifyIE *pModifyIE,
eUpdateIEsType updateType);
QDF_STATUS
csr_roam_update_add_ies(tpAniSirGlobal pMac,
tSirUpdateIE *pUpdateIE, eUpdateIEsType updateType);

20
core/sme/inc/sme_api.h
View File

@ -693,9 +693,11 @@ eCsrPhyMode sme_get_phy_mode(tHalHandle hHal);
* SME API to determine the channel bonding mode
*/
QDF_STATUS sme_set_ch_params(tHalHandle hHal, eCsrPhyMode eCsrPhyMode,
uint8_t channel, uint8_t ht_sec_ch, chan_params_t *ch_params);
uint8_t channel, uint8_t ht_sec_ch,
struct ch_params_s *ch_params);
QDF_STATUS sme_handoff_request(tHalHandle hHal, uint8_t sessionId,
tCsrHandoffRequest *pHandoffInfo);
tCsrHandoffRequest *pHandoffInfo);
QDF_STATUS sme_is_sta_p2p_client_connected(tHalHandle hHal);
#ifdef FEATURE_WLAN_LPHB
QDF_STATUS sme_lphb_config_req(tHalHandle hHal,
@ -769,15 +771,19 @@ QDF_STATUS sme_set_auto_shutdown_cb(tHalHandle hHal, void (*pCallbackfn)(void));
QDF_STATUS sme_set_auto_shutdown_timer(tHalHandle hHal, uint32_t timer_value);
#endif
QDF_STATUS sme_roam_channel_change_req(tHalHandle hHal,
struct qdf_mac_addr bssid, chan_params_t *ch_params,
tCsrRoamProfile *profile);
struct qdf_mac_addr bssid,
struct ch_params_s *ch_params,
tCsrRoamProfile *profile);
QDF_STATUS sme_roam_start_beacon_req(tHalHandle hHal,
struct qdf_mac_addr bssid, uint8_t dfsCacWaitStatus);
QDF_STATUS sme_roam_csa_ie_request(tHalHandle hHal, struct qdf_mac_addr bssid,
uint8_t targetChannel, uint8_t csaIeReqd,
chan_params_t *ch_params);
uint8_t targetChannel, uint8_t csaIeReqd,
struct ch_params_s *ch_params);
QDF_STATUS sme_init_thermal_info(tHalHandle hHal,
tSmeThermalParams thermalParam);
tSmeThermalParams thermalParam);
QDF_STATUS sme_set_thermal_level(tHalHandle hHal, uint8_t level);
QDF_STATUS sme_txpower_limit(tHalHandle hHal, tSirTxPowerLimit *psmetx);
QDF_STATUS sme_get_link_speed(tHalHandle hHal, tSirLinkSpeedInfo *lsReq,

16
core/sme/src/common/sme_api.c
View File

@ -10150,7 +10150,7 @@ QDF_STATUS sme_check_ch_in_band(tpAniSirGlobal mac_ctx, uint8_t start_ch,
}
void sme_set_160bw_params(tpAniSirGlobal mac_ctx, uint8_t channel,
chan_params_t *ch_params)
struct ch_params_s *ch_params)
{
uint8_t start_ch = 0;
QDF_STATUS status = QDF_STATUS_SUCCESS;
@ -10173,7 +10173,7 @@ void sme_set_160bw_params(tpAniSirGlobal mac_ctx, uint8_t channel,
}
void sme_set_80bw_params(tpAniSirGlobal mac_ctx, uint8_t channel,
chan_params_t *ch_params)
struct ch_params_s *ch_params)
{
uint8_t start_ch = 0;
QDF_STATUS status = QDF_STATUS_SUCCESS;
@ -10208,7 +10208,7 @@ void sme_set_80bw_params(tpAniSirGlobal mac_ctx, uint8_t channel,
}
void sme_set_40bw_params(tpAniSirGlobal mac_ctx, uint8_t channel,
chan_params_t *ch_params, uint8_t is_11ac_mode)
struct ch_params_s *ch_params, uint8_t is_11ac_mode)
{
uint8_t tmp;
uint8_t center_freq = 0;
@ -10246,7 +10246,8 @@ void sme_set_40bw_params(tpAniSirGlobal mac_ctx, uint8_t channel,
* SME API to determine the channel bonding mode
*/
QDF_STATUS sme_set_ch_params(tHalHandle hHal, eCsrPhyMode eCsrPhyMode,
uint8_t channel, uint8_t ht_sec_ch, chan_params_t *ch_params)
uint8_t channel, uint8_t ht_sec_ch,
struct ch_params_s *ch_params)
{
tpAniSirGlobal mac_ctx = PMAC_STRUCT(hHal);
int is_11ac_mode = CSR_IS_PHY_MODE_11ac(eCsrPhyMode);
@ -11894,8 +11895,9 @@ QDF_STATUS sme_set_mas(uint32_t val)
* Return: QDF_STATUS
*/
QDF_STATUS sme_roam_channel_change_req(tHalHandle hHal,
struct qdf_mac_addr bssid, chan_params_t *ch_params,
tCsrRoamProfile *profile)
struct qdf_mac_addr bssid,
struct ch_params_s *ch_params,
tCsrRoamProfile *profile)
{
QDF_STATUS status = QDF_STATUS_E_FAILURE;
tpAniSirGlobal pMac = PMAC_STRUCT(hHal);
@ -12004,7 +12006,7 @@ QDF_STATUS sme_roam_start_beacon_req(tHalHandle hHal, struct qdf_mac_addr bssid,
*/
QDF_STATUS sme_roam_csa_ie_request(tHalHandle hHal, struct qdf_mac_addr bssid,
uint8_t targetChannel, uint8_t csaIeReqd,
chan_params_t *ch_params)
struct ch_params_s *ch_params)
{
QDF_STATUS status = QDF_STATUS_E_FAILURE;
tpAniSirGlobal pMac = PMAC_STRUCT(hHal);

35
core/sme/src/csr/csr_api_roam.c
View File

@ -48,6 +48,7 @@
#include "cds_reg_service.h"
#include "mac_trace.h"
#include "csr_neighbor_roam.h"
#include "cds_regdomain.h"
#include "cds_regdomain_common.h"
#include "cds_utils.h"
#include "sir_types.h"
@ -340,8 +341,6 @@ QDF_STATUS csr_open(tpAniSirGlobal pMac)
QDF_STATUS csr_init_chan_list(tpAniSirGlobal mac, uint8_t *alpha2)
{
QDF_STATUS status;
v_REGDOMAIN_t reg_id;
enum country_src source = SOURCE_DRIVER;
mac->scan.countryCodeDefault[0] = alpha2[0];
mac->scan.countryCodeDefault[1] = alpha2[1];
@ -350,21 +349,9 @@ QDF_STATUS csr_init_chan_list(tpAniSirGlobal mac, uint8_t *alpha2)
sms_log(mac, LOGE, FL("init time country code %.2s"),
mac->scan.countryCodeDefault);
status = csr_get_regulatory_domain_for_country(mac,
mac->scan.countryCodeDefault,
&reg_id, source);
if (status != QDF_STATUS_SUCCESS) {
sms_log(mac, LOGE,
FL("csr_get_regulatory_domain_for_country failed"));
return status;
}
mac->scan.domainIdDefault = 0;
mac->scan.domainIdCurrent = 0;
if (cds_set_reg_domain(mac, reg_id) != QDF_STATUS_SUCCESS) {
sms_log(mac, LOGE, FL("cds_set_reg_domain failed"));
return QDF_STATUS_E_FAILURE;
}
mac->scan.domainIdDefault = reg_id;
mac->scan.domainIdCurrent = mac->scan.domainIdDefault;
qdf_mem_copy(mac->scan.countryCodeCurrent,
mac->scan.countryCodeDefault, WNI_CFG_COUNTRY_CODE_LEN);
qdf_mem_copy(mac->scan.countryCodeElected,
@ -18014,8 +18001,9 @@ QDF_STATUS csr_roam_read_tsf(tpAniSirGlobal pMac, uint8_t *pTimestamp,
* Return: QDF_STATUS
*/
QDF_STATUS csr_roam_channel_change_req(tpAniSirGlobal pMac,
struct qdf_mac_addr bssid,
chan_params_t *ch_params, tCsrRoamProfile *profile)
struct qdf_mac_addr bssid,
struct ch_params_s *ch_params,
tCsrRoamProfile *profile)
{
QDF_STATUS status = QDF_STATUS_SUCCESS;
tSirChanChangeRequest *pMsg;
@ -18245,10 +18233,11 @@ QDF_STATUS csr_send_ext_change_channel(tpAniSirGlobal mac_ctx, uint32_t channel,
*
* Return: success or failure
**/
QDF_STATUS
csr_roam_send_chan_sw_ie_request(tpAniSirGlobal mac_ctx,
struct qdf_mac_addr bssid, uint8_t target_channel,
uint8_t csa_ie_reqd, chan_params_t *ch_params)
QDF_STATUS csr_roam_send_chan_sw_ie_request(tpAniSirGlobal mac_ctx,
struct qdf_mac_addr bssid,
uint8_t target_channel,
uint8_t csa_ie_reqd,
struct ch_params_s *ch_params)
{
QDF_STATUS status = QDF_STATUS_SUCCESS;
tSirDfsCsaIeRequest *msg;
@ -18265,7 +18254,7 @@ csr_roam_send_chan_sw_ie_request(tpAniSirGlobal mac_ctx,
msg->targetChannel = target_channel;
msg->csaIeRequired = csa_ie_reqd;
qdf_mem_copy(msg->bssid, bssid.bytes, QDF_MAC_ADDR_SIZE);
qdf_mem_copy(&msg->ch_params, ch_params, sizeof(chan_params_t));
qdf_mem_copy(&msg->ch_params, ch_params, sizeof(struct ch_params_s));
status = cds_send_mb_message_to_mac(msg);

2
core/wma/inc/wma.h
View File

@ -1493,7 +1493,7 @@ struct wma_vdev_start_req {
uint32_t beacon_intval;
uint32_t dtim_period;
int32_t max_txpow;
phy_ch_width chan_width;
enum ch_width chan_width;
bool is_dfs;
uint8_t vdev_id;
uint8_t chan;

4
core/wma/inc/wma_if.h
View File

@ -498,7 +498,7 @@ typedef struct {
uint8_t halPersona;
uint8_t bSpectrumMgtEnabled;
uint8_t vhtCapable;
phy_ch_width ch_width;
enum ch_width ch_width;
uint8_t ch_center_freq_seg0;
uint8_t ch_center_freq_seg1;
uint8_t reassocReq; /* Set only during roaming reassociation */
@ -912,7 +912,7 @@ typedef struct {
uint16_t smpsMode;
uint8_t isDfsChannel;
uint8_t vhtCapable;
phy_ch_width ch_width;
enum ch_width ch_width;
uint8_t ch_center_freq_seg0;
uint8_t ch_center_freq_seg1;
uint8_t dot11_mode;

2
core/wma/inc/wma_internal.h
View File

@ -891,7 +891,7 @@ QDF_STATUS wma_process_lphb_conf_req(tp_wma_handle wma_handle,
QDF_STATUS wma_process_dhcp_ind(tp_wma_handle wma_handle,
tAniDHCPInd *ta_dhcp_ind);
WLAN_PHY_MODE wma_chan_to_mode(u8 chan, phy_ch_width chan_width,
WLAN_PHY_MODE wma_chan_to_mode(u8 chan, enum ch_width chan_width,
u8 vht_capable, u8 dot11_mode);
QDF_STATUS wma_get_link_speed(WMA_HANDLE handle, tSirLinkSpeedInfo *pLinkSpeed);

2
core/wma/src/wma_features.c
View File

@ -677,7 +677,7 @@ QDF_STATUS wma_process_dhcp_ind(tp_wma_handle wma_handle,
*
* Return: return phy mode
*/
WLAN_PHY_MODE wma_chan_to_mode(u8 chan, phy_ch_width chan_width,
WLAN_PHY_MODE wma_chan_to_mode(u8 chan, enum ch_width chan_width,
u8 vht_capable, u8 dot11_mode)
{
WLAN_PHY_MODE phymode = MODE_UNKNOWN;