[linux.git] / drivers / net / wireless / rtlwifi / regd.c

/******************************************************************************
 *
 * Copyright(c) 2009-2012  Realtek Corporation.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of version 2 of the GNU General Public License as
 * published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License along with
 * this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
 *
 * The full GNU General Public License is included in this distribution in the
 * file called LICENSE.
 *
 * Contact Information:
 * wlanfae <[email protected]>
 * Realtek Corporation, No. 2, Innovation Road II, Hsinchu Science Park,
 * Hsinchu 300, Taiwan.
 *
 * Larry Finger <[email protected]>
 *
 *****************************************************************************/

#include "wifi.h"
#include "regd.h"

static struct country_code_to_enum_rd allCountries[] = {
	{COUNTRY_CODE_FCC, "US"},
	{COUNTRY_CODE_IC, "US"},
	{COUNTRY_CODE_ETSI, "EC"},
	{COUNTRY_CODE_SPAIN, "EC"},
	{COUNTRY_CODE_FRANCE, "EC"},
	{COUNTRY_CODE_MKK, "JP"},
	{COUNTRY_CODE_MKK1, "JP"},
	{COUNTRY_CODE_ISRAEL, "EC"},
	{COUNTRY_CODE_TELEC, "JP"},
	{COUNTRY_CODE_MIC, "JP"},
	{COUNTRY_CODE_GLOBAL_DOMAIN, "JP"},
	{COUNTRY_CODE_WORLD_WIDE_13, "EC"},
	{COUNTRY_CODE_TELEC_NETGEAR, "EC"},
};

/*
 *Only these channels all allow active
 *scan on all world regulatory domains
 */
#define RTL819x_2GHZ_CH01_11	\
	REG_RULE(2412-10, 2462+10, 40, 0, 20, 0)

/*
 *We enable active scan on these a case
 *by case basis by regulatory domain
 */
#define RTL819x_2GHZ_CH12_13	\
	REG_RULE(2467-10, 2472+10, 40, 0, 20,\
		 NL80211_RRF_NO_IR)

#define RTL819x_2GHZ_CH14	\
	REG_RULE(2484-10, 2484+10, 40, 0, 20, \
		 NL80211_RRF_NO_IR | NL80211_RRF_NO_OFDM)

/* 5G chan 36 - chan 64*/
#define RTL819x_5GHZ_5150_5350	\
	REG_RULE(5150-10, 5350+10, 40, 0, 30, \
		 NL80211_RRF_NO_IR)

/* 5G chan 100 - chan 165*/
#define RTL819x_5GHZ_5470_5850	\
	REG_RULE(5470-10, 5850+10, 40, 0, 30, \
		 NL80211_RRF_NO_IR)

/* 5G chan 149 - chan 165*/
#define RTL819x_5GHZ_5725_5850	\
	REG_RULE(5725-10, 5850+10, 40, 0, 30, \
		 NL80211_RRF_NO_IR)

#define RTL819x_5GHZ_ALL	\
	(RTL819x_5GHZ_5150_5350, RTL819x_5GHZ_5470_5850)

static const struct ieee80211_regdomain rtl_regdom_11 = {
	.n_reg_rules = 1,
	.alpha2 = "99",
	.reg_rules = {
		      RTL819x_2GHZ_CH01_11,
		      }
};

static const struct ieee80211_regdomain rtl_regdom_12_13 = {
	.n_reg_rules = 2,
	.alpha2 = "99",
	.reg_rules = {
		      RTL819x_2GHZ_CH01_11,
			  RTL819x_2GHZ_CH12_13,
		      }
};

static const struct ieee80211_regdomain rtl_regdom_no_midband = {
	.n_reg_rules = 3,
	.alpha2 = "99",
	.reg_rules = {
		      RTL819x_2GHZ_CH01_11,
			  RTL819x_5GHZ_5150_5350,
			  RTL819x_5GHZ_5725_5850,
		      }
};

static const struct ieee80211_regdomain rtl_regdom_60_64 = {
	.n_reg_rules = 3,
	.alpha2 = "99",
	.reg_rules = {
		      RTL819x_2GHZ_CH01_11,
			  RTL819x_2GHZ_CH12_13,
			  RTL819x_5GHZ_5725_5850,
		      }
};

static const struct ieee80211_regdomain rtl_regdom_14_60_64 = {
	.n_reg_rules = 4,
	.alpha2 = "99",
	.reg_rules = {
		      RTL819x_2GHZ_CH01_11,
			  RTL819x_2GHZ_CH12_13,
			  RTL819x_2GHZ_CH14,
			  RTL819x_5GHZ_5725_5850,
		      }
};

static const struct ieee80211_regdomain rtl_regdom_14 = {
	.n_reg_rules = 3,
	.alpha2 = "99",
	.reg_rules = {
		      RTL819x_2GHZ_CH01_11,
			  RTL819x_2GHZ_CH12_13,
			  RTL819x_2GHZ_CH14,
		      }
};

static bool _rtl_is_radar_freq(u16 center_freq)
{
	return (center_freq >= 5260 && center_freq <= 5700);
}

static void _rtl_reg_apply_beaconing_flags(struct wiphy *wiphy,
					   enum nl80211_reg_initiator initiator)
{
	enum ieee80211_band band;
	struct ieee80211_supported_band *sband;
	const struct ieee80211_reg_rule *reg_rule;
	struct ieee80211_channel *ch;
	unsigned int i;

	for (band = 0; band < IEEE80211_NUM_BANDS; band++) {

		if (!wiphy->bands[band])
			continue;

		sband = wiphy->bands[band];

		for (i = 0; i < sband->n_channels; i++) {
			ch = &sband->channels[i];
			if (_rtl_is_radar_freq(ch->center_freq) ||
			    (ch->flags & IEEE80211_CHAN_RADAR))
				continue;
			if (initiator == NL80211_REGDOM_SET_BY_COUNTRY_IE) {
				reg_rule = freq_reg_info(wiphy,
							 MHZ_TO_KHZ(ch->center_freq));
				if (IS_ERR(reg_rule))
					continue;

				/*
				 *If 11d had a rule for this channel ensure
				 *we enable adhoc/beaconing if it allows us to
				 *use it. Note that we would have disabled it
				 *by applying our static world regdomain by
				 *default during init, prior to calling our
				 *regulatory_hint().
				 */

				if (!(reg_rule->flags & NL80211_RRF_NO_IR))
					ch->flags &= ~IEEE80211_CHAN_NO_IR;
			} else {
				if (ch->beacon_found)
					ch->flags &= ~IEEE80211_CHAN_NO_IR;
			}
		}
	}
}

/* Allows active scan scan on Ch 12 and 13 */
static void _rtl_reg_apply_active_scan_flags(struct wiphy *wiphy,
					     enum nl80211_reg_initiator
					     initiator)
{
	struct ieee80211_supported_band *sband;
	struct ieee80211_channel *ch;
	const struct ieee80211_reg_rule *reg_rule;

	if (!wiphy->bands[IEEE80211_BAND_2GHZ])
		return;
	sband = wiphy->bands[IEEE80211_BAND_2GHZ];

	/*
	 *If no country IE has been received always enable active scan
	 *on these channels. This is only done for specific regulatory SKUs
	 */
	if (initiator != NL80211_REGDOM_SET_BY_COUNTRY_IE) {
		ch = &sband->channels[11];	/* CH 12 */
		if (ch->flags & IEEE80211_CHAN_NO_IR)
			ch->flags &= ~IEEE80211_CHAN_NO_IR;
		ch = &sband->channels[12];	/* CH 13 */
		if (ch->flags & IEEE80211_CHAN_NO_IR)
			ch->flags &= ~IEEE80211_CHAN_NO_IR;
		return;
	}

	/*
	 *If a country IE has been received check its rule for this
	 *channel first before enabling active scan. The passive scan
	 *would have been enforced by the initial processing of our
	 *custom regulatory domain.
	 */

	ch = &sband->channels[11];	/* CH 12 */
	reg_rule = freq_reg_info(wiphy, MHZ_TO_KHZ(ch->center_freq));
	if (!IS_ERR(reg_rule)) {
		if (!(reg_rule->flags & NL80211_RRF_NO_IR))
			if (ch->flags & IEEE80211_CHAN_NO_IR)
				ch->flags &= ~IEEE80211_CHAN_NO_IR;
	}

	ch = &sband->channels[12];	/* CH 13 */
	reg_rule = freq_reg_info(wiphy, MHZ_TO_KHZ(ch->center_freq));
	if (!IS_ERR(reg_rule)) {
		if (!(reg_rule->flags & NL80211_RRF_NO_IR))
			if (ch->flags & IEEE80211_CHAN_NO_IR)
				ch->flags &= ~IEEE80211_CHAN_NO_IR;
	}
}

/*
 *Always apply Radar/DFS rules on
 *freq range 5260 MHz - 5700 MHz
 */
static void _rtl_reg_apply_radar_flags(struct wiphy *wiphy)
{
	struct ieee80211_supported_band *sband;
	struct ieee80211_channel *ch;
	unsigned int i;

	if (!wiphy->bands[IEEE80211_BAND_5GHZ])
		return;

	sband = wiphy->bands[IEEE80211_BAND_5GHZ];

	for (i = 0; i < sband->n_channels; i++) {
		ch = &sband->channels[i];
		if (!_rtl_is_radar_freq(ch->center_freq))
			continue;

		/*
		 *We always enable radar detection/DFS on this
		 *frequency range. Additionally we also apply on
		 *this frequency range:
		 *- If STA mode does not yet have DFS supports disable
		 * active scanning
		 *- If adhoc mode does not support DFS yet then disable
		 * adhoc in the frequency.
		 *- If AP mode does not yet support radar detection/DFS
		 *do not allow AP mode
		 */
		if (!(ch->flags & IEEE80211_CHAN_DISABLED))
			ch->flags |= IEEE80211_CHAN_RADAR |
				     IEEE80211_CHAN_NO_IR;
	}
}

static void _rtl_reg_apply_world_flags(struct wiphy *wiphy,
				       enum nl80211_reg_initiator initiator,
				       struct rtl_regulatory *reg)
{
	_rtl_reg_apply_beaconing_flags(wiphy, initiator);
	_rtl_reg_apply_active_scan_flags(wiphy, initiator);
	return;
}

static void _rtl_reg_notifier_apply(struct wiphy *wiphy,
				    struct regulatory_request *request,
				    struct rtl_regulatory *reg)
{
	/* We always apply this */
	_rtl_reg_apply_radar_flags(wiphy);

	switch (request->initiator) {
	case NL80211_REGDOM_SET_BY_DRIVER:
	case NL80211_REGDOM_SET_BY_CORE:
	case NL80211_REGDOM_SET_BY_USER:
		break;
	case NL80211_REGDOM_SET_BY_COUNTRY_IE:
		_rtl_reg_apply_world_flags(wiphy, request->initiator, reg);
		break;
	}
}

static const struct ieee80211_regdomain *_rtl_regdomain_select(
					       struct rtl_regulatory *reg)
{
	switch (reg->country_code) {
	case COUNTRY_CODE_FCC:
		return &rtl_regdom_no_midband;
	case COUNTRY_CODE_IC:
		return &rtl_regdom_11;
	case COUNTRY_CODE_ETSI:
	case COUNTRY_CODE_TELEC_NETGEAR:
		return &rtl_regdom_60_64;
	case COUNTRY_CODE_SPAIN:
	case COUNTRY_CODE_FRANCE:
	case COUNTRY_CODE_ISRAEL:
	case COUNTRY_CODE_WORLD_WIDE_13:
		return &rtl_regdom_12_13;
	case COUNTRY_CODE_MKK:
	case COUNTRY_CODE_MKK1:
	case COUNTRY_CODE_TELEC:
	case COUNTRY_CODE_MIC:
		return &rtl_regdom_14_60_64;
	case COUNTRY_CODE_GLOBAL_DOMAIN:
		return &rtl_regdom_14;
	default:
		return &rtl_regdom_no_midband;
	}
}

static int _rtl_regd_init_wiphy(struct rtl_regulatory *reg,
				struct wiphy *wiphy,
				void (*reg_notifier) (struct wiphy *wiphy,
						      struct regulatory_request *
						      request))
{
	const struct ieee80211_regdomain *regd;

	wiphy->reg_notifier = reg_notifier;

	wiphy->regulatory_flags |= REGULATORY_CUSTOM_REG;
	wiphy->regulatory_flags &= ~REGULATORY_STRICT_REG;
	wiphy->regulatory_flags &= ~REGULATORY_DISABLE_BEACON_HINTS;

	regd = _rtl_regdomain_select(reg);
	wiphy_apply_custom_regulatory(wiphy, regd);
	_rtl_reg_apply_radar_flags(wiphy);
	_rtl_reg_apply_world_flags(wiphy, NL80211_REGDOM_SET_BY_DRIVER, reg);
	return 0;
}

static struct country_code_to_enum_rd *_rtl_regd_find_country(u16 countrycode)
{
	int i;

	for (i = 0; i < ARRAY_SIZE(allCountries); i++) {
		if (allCountries[i].countrycode == countrycode)
			return &allCountries[i];
	}
	return NULL;
}

int rtl_regd_init(struct ieee80211_hw *hw,
		  void (*reg_notifier) (struct wiphy *wiphy,
				       struct regulatory_request *request))
{
	struct rtl_priv *rtlpriv = rtl_priv(hw);
	struct wiphy *wiphy = hw->wiphy;
	struct country_code_to_enum_rd *country = NULL;

	if (wiphy == NULL || &rtlpriv->regd == NULL)
		return -EINVAL;

	/* init country_code from efuse channel plan */
	rtlpriv->regd.country_code = rtlpriv->efuse.channel_plan;

	RT_TRACE(rtlpriv, COMP_REGD, DBG_TRACE,
		 "rtl: EEPROM regdomain: 0x%0x\n", rtlpriv->regd.country_code);

	if (rtlpriv->regd.country_code >= COUNTRY_CODE_MAX) {
		RT_TRACE(rtlpriv, COMP_REGD, DBG_DMESG,
			 "rtl: EEPROM indicates invalid contry code, world wide 13 should be used\n");

		rtlpriv->regd.country_code = COUNTRY_CODE_WORLD_WIDE_13;
	}

	country = _rtl_regd_find_country(rtlpriv->regd.country_code);

	if (country) {
		rtlpriv->regd.alpha2[0] = country->iso_name[0];
		rtlpriv->regd.alpha2[1] = country->iso_name[1];
	} else {
		rtlpriv->regd.alpha2[0] = '0';
		rtlpriv->regd.alpha2[1] = '0';
	}

	RT_TRACE(rtlpriv, COMP_REGD, DBG_TRACE,
		 "rtl: Country alpha2 being used: %c%c\n",
		 rtlpriv->regd.alpha2[0], rtlpriv->regd.alpha2[1]);

	_rtl_regd_init_wiphy(&rtlpriv->regd, wiphy, reg_notifier);

	return 0;
}

void rtl_reg_notifier(struct wiphy *wiphy, struct regulatory_request *request)
{
	struct ieee80211_hw *hw = wiphy_to_ieee80211_hw(wiphy);
	struct rtl_priv *rtlpriv = rtl_priv(hw);

	RT_TRACE(rtlpriv, COMP_REGD, DBG_LOUD, "\n");

	_rtl_reg_notifier_apply(wiphy, request, &rtlpriv->regd);
}
Commit	Line	Data
0c817338 LF	1	/******************************************************************************
0c817338 LF	2	*
a8d76066	3	* Copyright(c) 2009-2012 Realtek Corporation.
0c817338 LF	4	*
	5	* This program is free software; you can redistribute it and/or modify it
	6	* under the terms of version 2 of the GNU General Public License as
	7	* published by the Free Software Foundation.
	8	*
	9	* This program is distributed in the hope that it will be useful, but WITHOUT
	10	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	11	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
	12	* more details.
	13	*
	14	* You should have received a copy of the GNU General Public License along with
	15	* this program; if not, write to the Free Software Foundation, Inc.,
	16	* 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
	17	*
	18	* The full GNU General Public License is included in this distribution in the
	19	* file called LICENSE.
	20	*
	21	* Contact Information:
	22	* wlanfae <[email protected]>
	23	* Realtek Corporation, No. 2, Innovation Road II, Hsinchu Science Park,
	24	* Hsinchu 300, Taiwan.
	25	*
	26	* Larry Finger <[email protected]>
	27	*
	28	*****************************************************************************/
	29
	30	#include "wifi.h"
	31	#include "regd.h"
	32
	33	static struct country_code_to_enum_rd allCountries[] = {
	34	{COUNTRY_CODE_FCC, "US"},
	35	{COUNTRY_CODE_IC, "US"},
	36	{COUNTRY_CODE_ETSI, "EC"},
	37	{COUNTRY_CODE_SPAIN, "EC"},
	38	{COUNTRY_CODE_FRANCE, "EC"},
	39	{COUNTRY_CODE_MKK, "JP"},
	40	{COUNTRY_CODE_MKK1, "JP"},
	41	{COUNTRY_CODE_ISRAEL, "EC"},
	42	{COUNTRY_CODE_TELEC, "JP"},
	43	{COUNTRY_CODE_MIC, "JP"},
	44	{COUNTRY_CODE_GLOBAL_DOMAIN, "JP"},
	45	{COUNTRY_CODE_WORLD_WIDE_13, "EC"},
	46	{COUNTRY_CODE_TELEC_NETGEAR, "EC"},
	47	};
	48
	49	/*
	50	*Only these channels all allow active
	51	*scan on all world regulatory domains
	52	*/
	53	#define RTL819x_2GHZ_CH01_11 \
	54	REG_RULE(2412-10, 2462+10, 40, 0, 20, 0)
	55
	56	/*
	57	*We enable active scan on these a case
	58	*by case basis by regulatory domain
	59	*/
	60	#define RTL819x_2GHZ_CH12_13 \
	61	REG_RULE(2467-10, 2472+10, 40, 0, 20,\
8fe02e16	62	NL80211_RRF_NO_IR)
0c817338 LF	63
	64	#define RTL819x_2GHZ_CH14 \
	65	REG_RULE(2484-10, 2484+10, 40, 0, 20, \
8fe02e16	66	NL80211_RRF_NO_IR \| NL80211_RRF_NO_OFDM)
0c817338	67
81b29045 C	68	/* 5G chan 36 - chan 64*/
	69	#define RTL819x_5GHZ_5150_5350 \
	70	REG_RULE(5150-10, 5350+10, 40, 0, 30, \
8fe02e16	71	NL80211_RRF_NO_IR)
81b29045 C	72
	73	/* 5G chan 100 - chan 165*/
	74	#define RTL819x_5GHZ_5470_5850 \
	75	REG_RULE(5470-10, 5850+10, 40, 0, 30, \
8fe02e16	76	NL80211_RRF_NO_IR)
81b29045 C	77
	78	/* 5G chan 149 - chan 165*/
	79	#define RTL819x_5GHZ_5725_5850 \
	80	REG_RULE(5725-10, 5850+10, 40, 0, 30, \
8fe02e16	81	NL80211_RRF_NO_IR)
81b29045 C	82
	83	#define RTL819x_5GHZ_ALL \
	84	(RTL819x_5GHZ_5150_5350, RTL819x_5GHZ_5470_5850)
	85
0c817338 LF	86	static const struct ieee80211_regdomain rtl_regdom_11 = {
	87	.n_reg_rules = 1,
	88	.alpha2 = "99",
	89	.reg_rules = {
	90	RTL819x_2GHZ_CH01_11,
81b29045 C	91	}
	92	};
	93
	94	static const struct ieee80211_regdomain rtl_regdom_12_13 = {
	95	.n_reg_rules = 2,
	96	.alpha2 = "99",
	97	.reg_rules = {
	98	RTL819x_2GHZ_CH01_11,
	99	RTL819x_2GHZ_CH12_13,
	100	}
0c817338 LF	101	};
0c817338 LF	102
81b29045	103	static const struct ieee80211_regdomain rtl_regdom_no_midband = {
0c817338 LF	104	.n_reg_rules = 3,
	105	.alpha2 = "99",
	106	.reg_rules = {
	107	RTL819x_2GHZ_CH01_11,
81b29045 C	108	RTL819x_5GHZ_5150_5350,
	109	RTL819x_5GHZ_5725_5850,
	110	}
0c817338 LF	111	};
0c817338 LF	112
81b29045 C	113	static const struct ieee80211_regdomain rtl_regdom_60_64 = {
81b29045 C	114	.n_reg_rules = 3,
0c817338 LF	115	.alpha2 = "99",
	116	.reg_rules = {
	117	RTL819x_2GHZ_CH01_11,
81b29045 C	118	RTL819x_2GHZ_CH12_13,
	119	RTL819x_5GHZ_5725_5850,
	120	}
	121	};
	122
	123	static const struct ieee80211_regdomain rtl_regdom_14_60_64 = {
	124	.n_reg_rules = 4,
	125	.alpha2 = "99",
	126	.reg_rules = {
	127	RTL819x_2GHZ_CH01_11,
	128	RTL819x_2GHZ_CH12_13,
	129	RTL819x_2GHZ_CH14,
	130	RTL819x_5GHZ_5725_5850,
	131	}
	132	};
	133
	134	static const struct ieee80211_regdomain rtl_regdom_14 = {
	135	.n_reg_rules = 3,
	136	.alpha2 = "99",
	137	.reg_rules = {
	138	RTL819x_2GHZ_CH01_11,
	139	RTL819x_2GHZ_CH12_13,
	140	RTL819x_2GHZ_CH14,
	141	}
0c817338 LF	142	};
	143
	144	static bool _rtl_is_radar_freq(u16 center_freq)
	145	{
	146	return (center_freq >= 5260 && center_freq <= 5700);
	147	}
	148
	149	static void _rtl_reg_apply_beaconing_flags(struct wiphy *wiphy,
	150	enum nl80211_reg_initiator initiator)
	151	{
	152	enum ieee80211_band band;
	153	struct ieee80211_supported_band *sband;
	154	const struct ieee80211_reg_rule *reg_rule;
	155	struct ieee80211_channel *ch;
	156	unsigned int i;
0c817338 LF	157
	158	for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
	159
	160	if (!wiphy->bands[band])
	161	continue;
	162
	163	sband = wiphy->bands[band];
	164
	165	for (i = 0; i < sband->n_channels; i++) {
	166	ch = &sband->channels[i];
	167	if (_rtl_is_radar_freq(ch->center_freq) \|\|
	168	(ch->flags & IEEE80211_CHAN_RADAR))
	169	continue;
	170	if (initiator == NL80211_REGDOM_SET_BY_COUNTRY_IE) {
856a4ef9 LR	171	reg_rule = freq_reg_info(wiphy,
856a4ef9 LR	172	MHZ_TO_KHZ(ch->center_freq));
361c9c8b	173	if (IS_ERR(reg_rule))
0c817338 LF	174	continue;
	175
	176	/*
	177	*If 11d had a rule for this channel ensure
	178	*we enable adhoc/beaconing if it allows us to
	179	*use it. Note that we would have disabled it
	180	*by applying our static world regdomain by
	181	*default during init, prior to calling our
	182	*regulatory_hint().
	183	*/
	184
8fe02e16 LR	185	if (!(reg_rule->flags & NL80211_RRF_NO_IR))
8fe02e16 LR	186	ch->flags &= ~IEEE80211_CHAN_NO_IR;
0c817338 LF	187	} else {
0c817338 LF	188	if (ch->beacon_found)
8fe02e16	189	ch->flags &= ~IEEE80211_CHAN_NO_IR;
0c817338 LF	190	}
	191	}
	192	}
	193	}
	194
	195	/* Allows active scan scan on Ch 12 and 13 */
	196	static void _rtl_reg_apply_active_scan_flags(struct wiphy *wiphy,
	197	enum nl80211_reg_initiator
	198	initiator)
	199	{
	200	struct ieee80211_supported_band *sband;
	201	struct ieee80211_channel *ch;
	202	const struct ieee80211_reg_rule *reg_rule;
0c817338	203
81b29045 C	204	if (!wiphy->bands[IEEE80211_BAND_2GHZ])
81b29045 C	205	return;
0c817338 LF	206	sband = wiphy->bands[IEEE80211_BAND_2GHZ];
	207
	208	/*
	209	*If no country IE has been received always enable active scan
	210	*on these channels. This is only done for specific regulatory SKUs
	211	*/
	212	if (initiator != NL80211_REGDOM_SET_BY_COUNTRY_IE) {
	213	ch = &sband->channels[11]; /* CH 12 */
8fe02e16 LR	214	if (ch->flags & IEEE80211_CHAN_NO_IR)
8fe02e16 LR	215	ch->flags &= ~IEEE80211_CHAN_NO_IR;
0c817338	216	ch = &sband->channels[12]; /* CH 13 */
8fe02e16 LR	217	if (ch->flags & IEEE80211_CHAN_NO_IR)
8fe02e16 LR	218	ch->flags &= ~IEEE80211_CHAN_NO_IR;
0c817338 LF	219	return;
	220	}
	221
	222	/*
25985edc	223	*If a country IE has been received check its rule for this
0c817338 LF	224	*channel first before enabling active scan. The passive scan
	225	*would have been enforced by the initial processing of our
	226	*custom regulatory domain.
	227	*/
	228
	229	ch = &sband->channels[11]; /* CH 12 */
856a4ef9	230	reg_rule = freq_reg_info(wiphy, MHZ_TO_KHZ(ch->center_freq));
361c9c8b	231	if (!IS_ERR(reg_rule)) {
8fe02e16 LR	232	if (!(reg_rule->flags & NL80211_RRF_NO_IR))
	233	if (ch->flags & IEEE80211_CHAN_NO_IR)
	234	ch->flags &= ~IEEE80211_CHAN_NO_IR;
0c817338 LF	235	}
	236
	237	ch = &sband->channels[12]; /* CH 13 */
856a4ef9	238	reg_rule = freq_reg_info(wiphy, MHZ_TO_KHZ(ch->center_freq));
361c9c8b	239	if (!IS_ERR(reg_rule)) {
8fe02e16 LR	240	if (!(reg_rule->flags & NL80211_RRF_NO_IR))
	241	if (ch->flags & IEEE80211_CHAN_NO_IR)
	242	ch->flags &= ~IEEE80211_CHAN_NO_IR;
0c817338 LF	243	}
	244	}
	245
	246	/*
	247	*Always apply Radar/DFS rules on
	248	*freq range 5260 MHz - 5700 MHz
	249	*/
	250	static void _rtl_reg_apply_radar_flags(struct wiphy *wiphy)
	251	{
	252	struct ieee80211_supported_band *sband;
	253	struct ieee80211_channel *ch;
	254	unsigned int i;
	255
	256	if (!wiphy->bands[IEEE80211_BAND_5GHZ])
	257	return;
	258
	259	sband = wiphy->bands[IEEE80211_BAND_5GHZ];
	260
	261	for (i = 0; i < sband->n_channels; i++) {
	262	ch = &sband->channels[i];
	263	if (!_rtl_is_radar_freq(ch->center_freq))
	264	continue;
	265
	266	/*
	267	*We always enable radar detection/DFS on this
	268	*frequency range. Additionally we also apply on
	269	*this frequency range:
	270	*- If STA mode does not yet have DFS supports disable
	271	* active scanning
	272	*- If adhoc mode does not support DFS yet then disable
	273	* adhoc in the frequency.
	274	*- If AP mode does not yet support radar detection/DFS
	275	*do not allow AP mode
	276	*/
	277	if (!(ch->flags & IEEE80211_CHAN_DISABLED))
	278	ch->flags \|= IEEE80211_CHAN_RADAR \|
8fe02e16	279	IEEE80211_CHAN_NO_IR;
0c817338 LF	280	}
	281	}
	282
	283	static void _rtl_reg_apply_world_flags(struct wiphy *wiphy,
	284	enum nl80211_reg_initiator initiator,
	285	struct rtl_regulatory *reg)
	286	{
	287	_rtl_reg_apply_beaconing_flags(wiphy, initiator);
	288	_rtl_reg_apply_active_scan_flags(wiphy, initiator);
	289	return;
	290	}
	291
0c0280bd LR	292	static void _rtl_reg_notifier_apply(struct wiphy *wiphy,
	293	struct regulatory_request *request,
	294	struct rtl_regulatory *reg)
0c817338 LF	295	{
	296	/* We always apply this */
	297	_rtl_reg_apply_radar_flags(wiphy);
	298
	299	switch (request->initiator) {
	300	case NL80211_REGDOM_SET_BY_DRIVER:
	301	case NL80211_REGDOM_SET_BY_CORE:
	302	case NL80211_REGDOM_SET_BY_USER:
	303	break;
	304	case NL80211_REGDOM_SET_BY_COUNTRY_IE:
	305	_rtl_reg_apply_world_flags(wiphy, request->initiator, reg);
	306	break;
	307	}
0c817338 LF	308	}
	309
	310	static const struct ieee80211_regdomain *_rtl_regdomain_select(
	311	struct rtl_regulatory *reg)
	312	{
	313	switch (reg->country_code) {
	314	case COUNTRY_CODE_FCC:
81b29045	315	return &rtl_regdom_no_midband;
0c817338 LF	316	case COUNTRY_CODE_IC:
	317	return &rtl_regdom_11;
	318	case COUNTRY_CODE_ETSI:
81b29045 C	319	case COUNTRY_CODE_TELEC_NETGEAR:
81b29045 C	320	return &rtl_regdom_60_64;
0c817338 LF	321	case COUNTRY_CODE_SPAIN:
	322	case COUNTRY_CODE_FRANCE:
	323	case COUNTRY_CODE_ISRAEL:
81b29045 C	324	case COUNTRY_CODE_WORLD_WIDE_13:
81b29045 C	325	return &rtl_regdom_12_13;
0c817338 LF	326	case COUNTRY_CODE_MKK:
	327	case COUNTRY_CODE_MKK1:
	328	case COUNTRY_CODE_TELEC:
	329	case COUNTRY_CODE_MIC:
81b29045	330	return &rtl_regdom_14_60_64;
0c817338	331	case COUNTRY_CODE_GLOBAL_DOMAIN:
81b29045	332	return &rtl_regdom_14;
0c817338	333	default:
81b29045	334	return &rtl_regdom_no_midband;
0c817338 LF	335	}
	336	}
	337
	338	static int _rtl_regd_init_wiphy(struct rtl_regulatory *reg,
	339	struct wiphy *wiphy,
0c0280bd LR	340	void (reg_notifier) (struct wiphy wiphy,
	341	struct regulatory_request *
	342	request))
0c817338 LF	343	{
	344	const struct ieee80211_regdomain *regd;
	345
	346	wiphy->reg_notifier = reg_notifier;
81b29045	347
a2f73b6c LR	348	wiphy->regulatory_flags \|= REGULATORY_CUSTOM_REG;
	349	wiphy->regulatory_flags &= ~REGULATORY_STRICT_REG;
	350	wiphy->regulatory_flags &= ~REGULATORY_DISABLE_BEACON_HINTS;
81b29045	351
0c817338 LF	352	regd = _rtl_regdomain_select(reg);
	353	wiphy_apply_custom_regulatory(wiphy, regd);
	354	_rtl_reg_apply_radar_flags(wiphy);
	355	_rtl_reg_apply_world_flags(wiphy, NL80211_REGDOM_SET_BY_DRIVER, reg);
	356	return 0;
	357	}
	358
	359	static struct country_code_to_enum_rd *_rtl_regd_find_country(u16 countrycode)
	360	{
	361	int i;
	362
	363	for (i = 0; i < ARRAY_SIZE(allCountries); i++) {
	364	if (allCountries[i].countrycode == countrycode)
	365	return &allCountries[i];
	366	}
	367	return NULL;
	368	}
	369
	370	int rtl_regd_init(struct ieee80211_hw *hw,
0c0280bd	371	void (reg_notifier) (struct wiphy wiphy,
0c817338 LF	372	struct regulatory_request *request))
	373	{
	374	struct rtl_priv *rtlpriv = rtl_priv(hw);
	375	struct wiphy *wiphy = hw->wiphy;
	376	struct country_code_to_enum_rd *country = NULL;
	377
	378	if (wiphy == NULL \|\| &rtlpriv->regd == NULL)
	379	return -EINVAL;
	380
81b29045 C	381	/* init country_code from efuse channel plan */
81b29045 C	382	rtlpriv->regd.country_code = rtlpriv->efuse.channel_plan;
0c817338 LF	383
0c817338 LF	384	RT_TRACE(rtlpriv, COMP_REGD, DBG_TRACE,
f30d7507	385	"rtl: EEPROM regdomain: 0x%0x\n", rtlpriv->regd.country_code);
0c817338 LF	386
	387	if (rtlpriv->regd.country_code >= COUNTRY_CODE_MAX) {
	388	RT_TRACE(rtlpriv, COMP_REGD, DBG_DMESG,
f30d7507	389	"rtl: EEPROM indicates invalid contry code, world wide 13 should be used\n");
0c817338 LF	390
	391	rtlpriv->regd.country_code = COUNTRY_CODE_WORLD_WIDE_13;
	392	}
	393
	394	country = _rtl_regd_find_country(rtlpriv->regd.country_code);
	395
	396	if (country) {
81b29045 C	397	rtlpriv->regd.alpha2[0] = country->iso_name[0];
81b29045 C	398	rtlpriv->regd.alpha2[1] = country->iso_name[1];
0c817338 LF	399	} else {
	400	rtlpriv->regd.alpha2[0] = '0';
	401	rtlpriv->regd.alpha2[1] = '0';
	402	}
	403
	404	RT_TRACE(rtlpriv, COMP_REGD, DBG_TRACE,
f30d7507 JP	405	"rtl: Country alpha2 being used: %c%c\n",
f30d7507 JP	406	rtlpriv->regd.alpha2[0], rtlpriv->regd.alpha2[1]);
0c817338 LF	407
	408	_rtl_regd_init_wiphy(&rtlpriv->regd, wiphy, reg_notifier);
	409
	410	return 0;
	411	}
	412
0c0280bd	413	void rtl_reg_notifier(struct wiphy wiphy, struct regulatory_request request)
0c817338 LF	414	{
	415	struct ieee80211_hw *hw = wiphy_to_ieee80211_hw(wiphy);
	416	struct rtl_priv *rtlpriv = rtl_priv(hw);
	417
f30d7507	418	RT_TRACE(rtlpriv, COMP_REGD, DBG_LOUD, "\n");
0c817338	419
0c0280bd	420	_rtl_reg_notifier_apply(wiphy, request, &rtlpriv->regd);
0c817338	421	}