Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 69581755 authored by Amar Singhal's avatar Amar Singhal Committed by Akash Patel
Browse files

qcacld-3.0: More regulatory cleanups 

Remove typedef tPowerdBm. Rename and use linux style for channel
enum, channel state, channel power and country source data
structures.

Change-Id: Iebc59e6f001ccdb403c7445f4cea02c6a8141366
CRs-Fixed: 856727
parent 21767015

core/cds/inc/cds_reg_service.h

+91 −56
Original line number Diff line number Diff line
@@ -41,19 +41,17 @@ 
#define CDS_COUNTRY_CODE_LEN  2

#define CDS_MAC_ADDRESS_LEN 6



#define CDS_CHANNEL_STATE(enum) reg_channels[enum].enabled

#define CDS_CHANNEL_NUM(enum) chan_mapping[enum].chan_num

#define CDS_CHANNEL_FREQ(enum) chan_mapping[enum].center_freq

#define CDS_CHANNEL_STATE(chan_enum) reg_channels[chan_enum].state

#define CDS_CHANNEL_NUM(chan_enum) chan_mapping[chan_enum].chan_num

#define CDS_CHANNEL_FREQ(chan_enum) chan_mapping[chan_enum].center_freq

#define CDS_IS_DFS_CH(chan_num) (cds_get_channel_state((chan_num)) == \

				CHANNEL_STATE_DFS)



#define CDS_IS_PASSIVE_OR_DISABLE_CH(chan_num) \

	(cds_get_channel_state(chan_num) != CHANNEL_STATE_ENABLE)



#define CDS_MIN_24GHZ_CHANNEL_NUMBER			\

	chan_mapping[MIN_24GHZ_CHANNEL].chan_num

#define CDS_MAX_24GHZ_CHANNEL_NUMBER			\

	chan_mapping[MAX_24GHZ_CHANNEL].chan_num

#define CDS_MIN_24GHZ_CHANNEL_NUMBER chan_mapping[MIN_24GHZ_CHANNEL].chan_num

#define CDS_MAX_24GHZ_CHANNEL_NUMBER chan_mapping[MAX_24GHZ_CHANNEL].chan_num

#define CDS_MIN_5GHZ_CHANNEL_NUMBER chan_mapping[MIN_5GHZ_CHANNEL].chan_num

#define CDS_MAX_5GHZ_CHANNEL_NUMBER chan_mapping[MAX_5GHZ_CHANNEL].chan_num
@@ -65,9 +63,9 @@ 
	((chan_num >= CDS_MIN_24GHZ_CHANNEL_NUMBER) && \

	 (chan_num <= CDS_MAX_24GHZ_CHANNEL_NUMBER))



#define CDS_IS_SAME_BAND_CHANNELS(ch1, ch2) \

	(ch1 && ch2 && \

	(CDS_IS_CHANNEL_5GHZ(ch1) == CDS_IS_CHANNEL_5GHZ(ch2)))

#define CDS_IS_SAME_BAND_CHANNELS(chan_num1, chan_num2) \

	(chan_num1 && chan_num2 && \

	(CDS_IS_CHANNEL_5GHZ(chan_num1) == CDS_IS_CHANNEL_5GHZ(chan_num2)))



#define CDS_MIN_11P_CHANNEL chan_mapping[MIN_59GHZ_CHANNEL].chan_num
@@ -79,7 +77,7 @@ typedef enum { 
	REGDOMAIN_COUNT

} v_REGDOMAIN_t;



typedef enum {

enum channel_enum {

	RF_CHAN_1 = 0,

	RF_CHAN_2,

	RF_CHAN_3,
@@ -197,62 +195,104 @@ typedef enum { 


	INVALID_RF_CHANNEL = 0xBAD,

	RF_CHANNEL_INVALID_MAX_FIELD = 0x7FFFFFFF

} eRfChannels;

};



typedef enum {

/**

 * enum channel_state: channel state

 *

 * @CHANNEL_STATE_DISABLE: channel disabled

 * @CHANNEL_STATE_ENABLE: tx/rx enabled

 * @CHANNEL_STATE_DFS: rx enabled, tx DFS

 * @CHANNEL_STATE_INVALID: not a valid channel

 */

enum channel_state {

	CHANNEL_STATE_DISABLE,

	CHANNEL_STATE_ENABLE,

	CHANNEL_STATE_DFS,

	CHANNEL_STATE_INVALID

} CHANNEL_STATE;



typedef int8_t tPowerdBm;

};



/**

 * struct regulatory_channel: regulatory channel

 *

 * @state: channel state

 * @flags: channel flags

 * @pwr_limit: channel tx power limit

 */

struct regulatory_channel {

	uint32_t enabled:4;

	uint32_t state:4;

	uint32_t flags:28;

	tPowerdBm pwr_limit;

	int8_t pwr_limit;

};



/**

 * struct chan_map: channel mapping

 *

 * @center_freq: channel center freq

 * @chan_num: channel number

 */

struct chan_map {

	uint16_t center_freq;

	uint16_t chan_num;

};



typedef struct {

	uint8_t chanId;

	tPowerdBm pwr;

} tChannelListWithPower;



typedef enum {

	COUNTRY_CODE_SET_BY_CORE,

	COUNTRY_CODE_SET_BY_DRIVER,

	COUNTRY_CODE_SET_BY_USER

} COUNTRY_CODE_SOURCE;

/**

 * struct channel_power: channel power

 *

 * @chan_num: channel number

 * @power: tx power

 */

struct channel_power {

	uint8_t chan_num;

	int8_t power;

};



/**

 * enum country_src: country source

 *

 * @SOURCE_QUERY: source query

 * @SOURCE_CORE: source regulatory core

 * @SOURCE_DRIVER: source driver

 * @SOURCE_USERSPACE: source userspace

 * @SOURCE_11D: source 11D

 */

enum country_src {

	SOURCE_QUERY,

	SOURCE_CORE,

	SOURCE_DRIVER,

	SOURCE_USERSPACE,

	SOURCE_11D

};



/**

 * struct regulatory: regulatory information

 *

 * @reg_domain: regulatory domain pair

 * @eeprom_rd_ext: eeprom value

 * @country_code: current country in integer

 * @alpha2: current alpha2

 * @def_country: default country alpha2

 * @def_region: DFS region

 * @ctl_2g: 2G CTL value

 * @ctl_5g: 5G CTL value

 * @reg_pair: pointer to regulatory pair

 * @cc_src: country code src

 * @reg_flags: kernel regulatory flags

 */

struct regulatory {

	uint32_t reg_domain;

	uint32_t eeprom_rd_ext;

	uint16_t country_code;

	uint8_t alpha2[3];

	uint8_t def_country[3];

	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;

	COUNTRY_CODE_SOURCE cc_src;

	enum country_src cc_src;

	uint32_t reg_flags;

};



typedef enum {

	COUNTRY_INIT,

	COUNTRY_IE,

	COUNTRY_USER,

	COUNTRY_QUERY,

	COUNTRY_MAX = COUNTRY_QUERY

} v_CountryInfoSource_t;



/**

 * enum chan_width: channel width

 *
@@ -274,37 +314,32 @@ enum channel_width { 
	CHAN_WIDTH_160MHZ

};



/**

 * @country_code_t : typedef for country code. One extra

 * char for holding null character

 */

typedef uint8_t country_code_t[CDS_COUNTRY_CODE_LEN + 1];



extern struct regulatory_channel reg_channels[NUM_RF_CHANNELS];

extern const struct chan_map chan_mapping[NUM_RF_CHANNELS];



CDF_STATUS cds_get_reg_domain_from_country_code(v_REGDOMAIN_t *pRegDomain,

						const country_code_t countryCode,

						v_CountryInfoSource_t source);

						const uint8_t *country_alpha2,

						enum country_src source);



CDF_STATUS cds_read_default_country(country_code_t default_country);

CDF_STATUS cds_read_default_country(uint8_t *default_country);



CDF_STATUS cds_get_channel_list_with_power(tChannelListWithPower

CDF_STATUS cds_get_channel_list_with_power(struct channel_power

					   *base_channels,

					   uint8_t *num_base_channels,

					   tChannelListWithPower

					   *pChannels40MHz,

					   uint8_t *);

					   struct channel_power

					   *channel_40mhz,

					   uint8_t *num_channels_40mhz);



CDF_STATUS cds_set_reg_domain(void *client_ctxt, v_REGDOMAIN_t reg_domain);



CHANNEL_STATE cds_get_channel_state(uint32_t chan_num);

enum channel_state cds_get_channel_state(uint32_t chan_num);



CDF_STATUS cds_regulatory_init(void);

CDF_STATUS cds_get_dfs_region(uint8_t *dfs_region);

CDF_STATUS cds_set_dfs_region(uint8_t dfs_region);

bool cds_is_dsrc_channel(uint16_t);

CHANNEL_STATE cds_get_bonded_channel_state(uint32_t chan_num,

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);

core/cds/src/cds_reg_service.c

+60 −70
Original line number Diff line number Diff line
@@ -211,33 +211,24 @@ const struct chan_map chan_mapping[NUM_RF_CHANNELS] = { 
	{5815, 163},

};



struct regulatory_channel reg_channels[NUM_RF_CHANNELS];

static bool init_by_driver;

static bool init_by_reg_core;



struct regulatory_channel reg_channels[NUM_RF_CHANNELS];



/**

 * cds_is_wwr_sku() - is regdomain world sku

 * @regd: integer regulatory domain

 *

 * Return: bool

 */

static inline bool cds_is_wwr_sku(u16 regd)

{

	return ((regd & COUNTRY_ERD_FLAG) != COUNTRY_ERD_FLAG) &&

	       (((regd & WORLD_SKU_MASK) == WORLD_SKU_PREFIX) ||

		(regd == WORLD));

}



/**

 * cds_is_world_regdomain() - whether world regdomain

 * @regd: integer regulatory domain

 *

 * Return: bool

 */

bool cds_is_world_regdomain(uint32_t regd)

bool cds_is_world_regdomain(uint32_t reg_domain)

{

	return cds_is_wwr_sku(regd & ~WORLDWIDE_ROAMING_FLAG);

	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));



}
@@ -368,11 +359,11 @@ static void cds_update_regulatory_info(hdd_context_t *hdd_ctx) 
 *

 * Return: CDF_STATUS_SUCCESS

 */

CDF_STATUS cds_get_channel_list_with_power(tChannelListWithPower *

					   base_channels,

CDF_STATUS cds_get_channel_list_with_power(struct channel_power

					   *base_channels,

					   uint8_t *num_base_channels,

					   tChannelListWithPower *

					   channels_40mhz,

					   struct channel_power

					   *channels_40mhz,

					   uint8_t *num_40mhz_channels)

{

	CDF_STATUS status = CDF_STATUS_SUCCESS;
@@ -381,18 +372,18 @@ CDF_STATUS cds_get_channel_list_with_power(tChannelListWithPower * 
	if (base_channels && num_base_channels) {

		count = 0;

		for (i = 0; i <= RF_CHAN_14; i++) {

			if (reg_channels[i].enabled) {

				base_channels[count].chanId =

			if (reg_channels[i].state) {

				base_channels[count].chan_num =

					chan_mapping[i].chan_num;

				base_channels[count++].pwr =

				base_channels[count++].power =

					reg_channels[i].pwr_limit;

			}

		}

		for (i = RF_CHAN_36; i <= RF_CHAN_184; i++) {

			if (reg_channels[i].enabled) {

				base_channels[count].chanId =

			if (reg_channels[i].state) {

				base_channels[count].chan_num =

					chan_mapping[i].chan_num;

				base_channels[count++].pwr =

				base_channels[count++].power =

					reg_channels[i].pwr_limit;

			}

		}
@@ -403,19 +394,19 @@ CDF_STATUS cds_get_channel_list_with_power(tChannelListWithPower * 
		count = 0;



		for (i = RF_CHAN_BOND_3; i <= RF_CHAN_BOND_11; i++) {

			if (reg_channels[i].enabled) {

				channels_40mhz[count].chanId =

			if (reg_channels[i].state) {

				channels_40mhz[count].chan_num =

					chan_mapping[i].chan_num;

				channels_40mhz[count++].pwr =

				channels_40mhz[count++].power =

					reg_channels[i].pwr_limit;

			}

		}



		for (i = RF_CHAN_BOND_38; i <= RF_CHAN_BOND_163; i++) {

			if (reg_channels[i].enabled) {

				channels_40mhz[count].chanId =

			if (reg_channels[i].state) {

				channels_40mhz[count].chan_num =

					chan_mapping[i].chan_num;

				channels_40mhz[count++].pwr =

				channels_40mhz[count++].power =

					reg_channels[i].pwr_limit;

			}

		}
@@ -431,7 +422,7 @@ CDF_STATUS cds_get_channel_list_with_power(tChannelListWithPower * 
 *

 * Return: CDF_STATUS

 */

CDF_STATUS cds_read_default_country(country_code_t default_country)

CDF_STATUS cds_read_default_country(uint8_t *default_country)

{

	hdd_context_t *hdd_ctx;
@@ -444,7 +435,7 @@ CDF_STATUS cds_read_default_country(country_code_t default_country) 


	memcpy(default_country,

	       hdd_ctx->reg.def_country,

	       sizeof(country_code_t));

	       CDS_COUNTRY_CODE_LEN + 1);



	CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_INFO,

		  "default country is %c%c\n",
@@ -460,7 +451,7 @@ CDF_STATUS cds_read_default_country(country_code_t default_country) 
 *

 * Return: enum for the channel

 */

static eRfChannels cds_get_channel_enum(uint32_t chan_num)

static enum channel_enum cds_get_channel_enum(uint32_t chan_num)

{

	uint32_t loop;
@@ -479,17 +470,17 @@ static eRfChannels cds_get_channel_enum(uint32_t chan_num) 
 * cds_get_channel_state() - get the channel state

 * @chan_num: channel number

 *

 * Return: CHANNEL_STATE

 * Return: channel state

 */

CHANNEL_STATE cds_get_channel_state(uint32_t chan_num)

enum channel_state cds_get_channel_state(uint32_t chan_num)

{

	eRfChannels chan_enum;

	enum channel_enum chan_enum;



	chan_enum = cds_get_channel_enum(chan_num);

	if (INVALID_RF_CHANNEL == chan_enum)

		return CHANNEL_STATE_INVALID;

	else

		return reg_channels[chan_enum].enabled;

		return reg_channels[chan_enum].state;

}
@@ -497,19 +488,19 @@ CHANNEL_STATE cds_get_channel_state(uint32_t chan_num) 
 * cds_get_bonded_channel_state() - get the bonded channel state

 * @channel_num: channel number

 *

 * Return: CHANNEL_STATE

 * Return: channel state

 */

CHANNEL_STATE cds_get_bonded_channel_state(uint32_t chan_num,

enum channel_state cds_get_bonded_channel_state(uint32_t chan_num,

					   enum channel_width ch_width)

{

	eRfChannels chan_enum;

	enum channel_enum chan_enum;

	bool bw_enabled = false;



	chan_enum = cds_get_channel_enum(chan_num);

	if (INVALID_RF_CHANNEL == chan_enum)

		return CHANNEL_STATE_INVALID;



	if (reg_channels[chan_enum].enabled) {

	if (reg_channels[chan_enum].state) {

		if (CHAN_WIDTH_5MHZ == ch_width)

			bw_enabled = 1;

		else if (CHAN_WIDTH_10MHZ == ch_width)
@@ -530,7 +521,7 @@ CHANNEL_STATE cds_get_bonded_channel_state(uint32_t chan_num, 
	}



	if (bw_enabled)

		return reg_channels[chan_enum].enabled;

		return reg_channels[chan_enum].state;

	else

		return CHANNEL_STATE_DISABLE;

}
@@ -543,13 +534,13 @@ CHANNEL_STATE cds_get_bonded_channel_state(uint32_t chan_num, 
 */

enum channel_width cds_get_max_channel_bw(uint32_t chan_num)

{

	eRfChannels chan_enum;

	enum channel_enum chan_enum;

	enum channel_width chan_bw = CHAN_WIDTH_0MHZ;



	chan_enum = cds_get_channel_enum(chan_num);



	if ((INVALID_RF_CHANNEL != chan_enum) &&

	    (CHANNEL_STATE_DISABLE != reg_channels[chan_enum].enabled)) {

	    (CHANNEL_STATE_DISABLE != reg_channels[chan_enum].state)) {



		if (!(reg_channels[chan_enum].flags &

		      IEEE80211_CHAN_NO_160MHZ))
@@ -673,9 +664,8 @@ CDF_STATUS cds_get_dfs_region(uint8_t *dfs_region) 
 *         CDF_STATUS_E_EMPTY country table empty

 */

CDF_STATUS cds_get_reg_domain_from_country_code(v_REGDOMAIN_t *reg_domain_ptr,

						const country_code_t

						country_code,

						v_CountryInfoSource_t source)

						const uint8_t *country_alpha2,

						enum country_src source)

{

	hdd_context_t *hdd_ctx = NULL;

	struct wiphy *wiphy = NULL;
@@ -688,10 +678,10 @@ CDF_STATUS cds_get_reg_domain_from_country_code(v_REGDOMAIN_t *reg_domain_ptr, 


	*reg_domain_ptr = 0;



	if (COUNTRY_QUERY == source)

	if (SOURCE_QUERY == source)

		return CDF_STATUS_SUCCESS;



	if (NULL == country_code) {

	if (NULL == country_alpha2) {

		CDF_TRACE(CDF_MODULE_ID_CDF, CDF_TRACE_LEVEL_ERROR,

			  ("Country code array is NULL"));

		return CDF_STATUS_E_FAULT;
@@ -713,16 +703,16 @@ CDF_STATUS cds_get_reg_domain_from_country_code(v_REGDOMAIN_t *reg_domain_ptr, 


	wiphy = hdd_ctx->wiphy;



	if ((COUNTRY_INIT == source) && (false == init_by_reg_core)) {

	if ((SOURCE_DRIVER == source) && (false == init_by_reg_core)) {

		init_by_driver = true;

		if (('0' != country_code[0]) || ('0' != country_code[1])) {

		if (('0' != country_alpha2[0]) || ('0' != country_alpha2[1])) {

			INIT_COMPLETION(hdd_ctx->reg_init);

			regulatory_hint(wiphy, country_code);

			regulatory_hint(wiphy, country_alpha2);

			wait_for_completion_timeout(&hdd_ctx->reg_init,

					       msecs_to_jiffies(REG_WAIT_TIME));

		}

	} else if (COUNTRY_IE == source || COUNTRY_USER == source) {

		regulatory_hint_user(country_code,

	} else if (SOURCE_11D == source || SOURCE_USERSPACE == source) {

		regulatory_hint_user(country_alpha2,

				     NL80211_USER_REG_HINT_USER);

	}
@@ -858,11 +848,11 @@ static int cds_process_regulatory_data(struct wiphy *wiphy, 
			}



			if (chan->flags & IEEE80211_CHAN_DISABLED) {

				temp_chan_k->enabled =

				temp_chan_k->state =

					CHANNEL_STATE_DISABLE;

				temp_chan_k->flags = chan->flags;

				if (n != -1) {

					temp_chan_n->enabled =

					temp_chan_n->state =

						CHANNEL_STATE_DISABLE;

					temp_chan_n->flags = chan->flags;

				}
@@ -881,7 +871,7 @@ static int cds_process_regulatory_data(struct wiphy *wiphy, 
					chan->flags |=

						IEEE80211_CHAN_PASSIVE_SCAN;

#endif

				temp_chan_k->enabled = CHANNEL_STATE_DFS;

				temp_chan_k->state = CHANNEL_STATE_DFS;

				temp_chan_k->pwr_limit =

					chan->max_power;

				temp_chan_k->flags = chan->flags;
@@ -890,10 +880,10 @@ static int cds_process_regulatory_data(struct wiphy *wiphy, 
					if ((chan->flags &

					     IEEE80211_CHAN_NO_HT40) ==

					    IEEE80211_CHAN_NO_HT40) {

						temp_chan_n->enabled =

						temp_chan_n->state =

							CHANNEL_STATE_DISABLE;

					} else {

						temp_chan_n->enabled =

						temp_chan_n->state =

							CHANNEL_STATE_DFS;

						temp_chan_n->pwr_limit =

							 chan->max_power-3;
@@ -904,17 +894,17 @@ static int cds_process_regulatory_data(struct wiphy *wiphy, 
				     IEEE80211_CHAN_NO_80MHZ) == 0)

					hdd_ctx->isVHT80Allowed = 1;

			} else {

				temp_chan_k->enabled = CHANNEL_STATE_ENABLE;

				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->enabled =

						temp_chan_n->state =

							CHANNEL_STATE_DISABLE;

					} else {

						temp_chan_n->enabled =

						temp_chan_n->state =

							CHANNEL_STATE_ENABLE;

						temp_chan_n->pwr_limit =

							chan->max_power - 3;
@@ -931,7 +921,7 @@ static int cds_process_regulatory_data(struct wiphy *wiphy, 
	if (0 == (hdd_ctx->reg.eeprom_rd_ext &

		  (1 << WHAL_REG_EXT_FCC_CH_144))) {

		temp_chan = &(reg_channels[RF_CHAN_144]);

		temp_chan->enabled =

		temp_chan->state =

			CHANNEL_STATE_DISABLE;

	}
@@ -1038,7 +1028,7 @@ void __hdd_reg_notifier(struct wiphy *wiphy, 
		}



		if (NL80211_REGDOM_SET_BY_CORE == request->initiator) {

			hdd_ctx->reg.cc_src = COUNTRY_CODE_SET_BY_CORE;

			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
@@ -1046,9 +1036,9 @@ void __hdd_reg_notifier(struct wiphy *wiphy, 
#endif

				reset = true;

		} else if (NL80211_REGDOM_SET_BY_DRIVER == request->initiator)

			hdd_ctx->reg.cc_src = COUNTRY_CODE_SET_BY_DRIVER;

			hdd_ctx->reg.cc_src = SOURCE_DRIVER;

		else {

			hdd_ctx->reg.cc_src = COUNTRY_CODE_SET_BY_USER;

			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') &&
@@ -1138,7 +1128,7 @@ CDF_STATUS cds_regulatory_init(void) 
		return CDF_STATUS_E_FAULT;

	}



	reg_info->cc_src = COUNTRY_CODE_SET_BY_DRIVER;

	reg_info->cc_src = SOURCE_DRIVER;



	ret_val = cds_fill_some_regulatory_info(reg_info);

	if (ret_val) {

core/hdd/src/wlan_hdd_cfg80211.c

+1 −1
Original line number Diff line number Diff line
@@ -5242,7 +5242,7 @@ struct wiphy *wlan_hdd_cfg80211_wiphy_alloc(int priv_size) 
int wlan_hdd_cfg80211_update_band(struct wiphy *wiphy, eCsrBand eBand)

{

	int i, j;

	CHANNEL_STATE channelEnabledState;

	enum channel_state channelEnabledState;



	ENTER();

core/hdd/src/wlan_hdd_main.c

+1 −1
Original line number Diff line number Diff line
@@ -4706,7 +4706,7 @@ static void hdd_ch_avoid_cb(void *hdd_context, void *indi_param) 
	hdd_context_t *hdd_ctxt;

	tSirChAvoidIndType *ch_avoid_indi;

	uint8_t range_loop;

	eRfChannels channel_loop, start_channel_idx = INVALID_RF_CHANNEL,

	enum channel_enum channel_loop, start_channel_idx = INVALID_RF_CHANNEL,

					end_channel_idx = INVALID_RF_CHANNEL;

	uint16_t start_channel;

	uint16_t end_channel;

core/mac/inc/sir_api.h

+1 −1
Original line number Diff line number Diff line
@@ -2042,7 +2042,7 @@ typedef struct sSirPlmReq { 
	uint16_t measDuration;  /* in TU's,STA goes off-ch */

	/* no of times the STA should cycle through PLM ch list */

	uint8_t burstLen;

	tPowerdBm desiredTxPwr; /* desired tx power */

	int8_t desiredTxPwr; /* desired tx power */

	struct cdf_mac_addr mac_addr;    /* MC dest addr */

	/* no of channels */

	uint8_t plmNumCh;