[GitHub/exynos8895/android_kernel_samsung_universal8895.git] / net / wireless / chan.c

/*
 * This file contains helper code to handle channel
 * settings and keeping track of what is possible at
 * any point in time.
 *
 * Copyright 2009	Johannes Berg <johannes@sipsolutions.net>
 */

#include <linux/export.h>
#include <net/cfg80211.h>
#include "core.h"
#include "rdev-ops.h"

void cfg80211_chandef_create(struct cfg80211_chan_def *chandef,
			     struct ieee80211_channel *chan,
			     enum nl80211_channel_type chan_type)
{
	if (WARN_ON(!chan))
		return;

	chandef->chan = chan;
	chandef->center_freq2 = 0;

	switch (chan_type) {
	case NL80211_CHAN_NO_HT:
		chandef->width = NL80211_CHAN_WIDTH_20_NOHT;
		chandef->center_freq1 = chan->center_freq;
		break;
	case NL80211_CHAN_HT20:
		chandef->width = NL80211_CHAN_WIDTH_20;
		chandef->center_freq1 = chan->center_freq;
		break;
	case NL80211_CHAN_HT40PLUS:
		chandef->width = NL80211_CHAN_WIDTH_40;
		chandef->center_freq1 = chan->center_freq + 10;
		break;
	case NL80211_CHAN_HT40MINUS:
		chandef->width = NL80211_CHAN_WIDTH_40;
		chandef->center_freq1 = chan->center_freq - 10;
		break;
	default:
		WARN_ON(1);
	}
}
EXPORT_SYMBOL(cfg80211_chandef_create);

bool cfg80211_chan_def_valid(const struct cfg80211_chan_def *chandef)
{
	u32 control_freq;

	if (!chandef->chan)
		return false;

	control_freq = chandef->chan->center_freq;

	switch (chandef->width) {
	case NL80211_CHAN_WIDTH_20:
	case NL80211_CHAN_WIDTH_20_NOHT:
		if (chandef->center_freq1 != control_freq)
			return false;
		if (chandef->center_freq2)
			return false;
		break;
	case NL80211_CHAN_WIDTH_40:
		if (chandef->center_freq1 != control_freq + 10 &&
		    chandef->center_freq1 != control_freq - 10)
			return false;
		if (chandef->center_freq2)
			return false;
		break;
	case NL80211_CHAN_WIDTH_80P80:
		if (chandef->center_freq1 != control_freq + 30 &&
		    chandef->center_freq1 != control_freq + 10 &&
		    chandef->center_freq1 != control_freq - 10 &&
		    chandef->center_freq1 != control_freq - 30)
			return false;
		if (!chandef->center_freq2)
			return false;
		break;
	case NL80211_CHAN_WIDTH_80:
		if (chandef->center_freq1 != control_freq + 30 &&
		    chandef->center_freq1 != control_freq + 10 &&
		    chandef->center_freq1 != control_freq - 10 &&
		    chandef->center_freq1 != control_freq - 30)
			return false;
		if (chandef->center_freq2)
			return false;
		break;
	case NL80211_CHAN_WIDTH_160:
		if (chandef->center_freq1 != control_freq + 70 &&
		    chandef->center_freq1 != control_freq + 50 &&
		    chandef->center_freq1 != control_freq + 30 &&
		    chandef->center_freq1 != control_freq + 10 &&
		    chandef->center_freq1 != control_freq - 10 &&
		    chandef->center_freq1 != control_freq - 30 &&
		    chandef->center_freq1 != control_freq - 50 &&
		    chandef->center_freq1 != control_freq - 70)
			return false;
		if (chandef->center_freq2)
			return false;
		break;
	default:
		return false;
	}

	return true;
}

static void chandef_primary_freqs(const struct cfg80211_chan_def *c,
				  int *pri40, int *pri80)
{
	int tmp;

	switch (c->width) {
	case NL80211_CHAN_WIDTH_40:
		*pri40 = c->center_freq1;
		*pri80 = 0;
		break;
	case NL80211_CHAN_WIDTH_80:
	case NL80211_CHAN_WIDTH_80P80:
		*pri80 = c->center_freq1;
		/* n_P20 */
		tmp = (30 + c->chan->center_freq - c->center_freq1)/20;
		/* n_P40 */
		tmp /= 2;
		/* freq_P40 */
		*pri40 = c->center_freq1 - 20 + 40 * tmp;
		break;
	case NL80211_CHAN_WIDTH_160:
		/* n_P20 */
		tmp = (70 + c->chan->center_freq - c->center_freq1)/20;
		/* n_P40 */
		tmp /= 2;
		/* freq_P40 */
		*pri40 = c->center_freq1 - 60 + 40 * tmp;
		/* n_P80 */
		tmp /= 2;
		*pri80 = c->center_freq1 - 40 + 80 * tmp;
		break;
	default:
		WARN_ON_ONCE(1);
	}
}

const struct cfg80211_chan_def *
cfg80211_chandef_compatible(const struct cfg80211_chan_def *c1,
			    const struct cfg80211_chan_def *c2)
{
	u32 c1_pri40, c1_pri80, c2_pri40, c2_pri80;

	/* If they are identical, return */
	if (cfg80211_chandef_identical(c1, c2))
		return c1;

	/* otherwise, must have same control channel */
	if (c1->chan != c2->chan)
		return NULL;

	/*
	 * If they have the same width, but aren't identical,
	 * then they can't be compatible.
	 */
	if (c1->width == c2->width)
		return NULL;

	if (c1->width == NL80211_CHAN_WIDTH_20_NOHT ||
	    c1->width == NL80211_CHAN_WIDTH_20)
		return c2;

	if (c2->width == NL80211_CHAN_WIDTH_20_NOHT ||
	    c2->width == NL80211_CHAN_WIDTH_20)
		return c1;

	chandef_primary_freqs(c1, &c1_pri40, &c1_pri80);
	chandef_primary_freqs(c2, &c2_pri40, &c2_pri80);

	if (c1_pri40 != c2_pri40)
		return NULL;

	WARN_ON(!c1_pri80 && !c2_pri80);
	if (c1_pri80 && c2_pri80 && c1_pri80 != c2_pri80)
		return NULL;

	if (c1->width > c2->width)
		return c1;
	return c2;
}
EXPORT_SYMBOL(cfg80211_chandef_compatible);

bool cfg80211_secondary_chans_ok(struct wiphy *wiphy,
				 u32 center_freq, u32 bandwidth,
				 u32 prohibited_flags)
{
	struct ieee80211_channel *c;
	u32 freq;

	for (freq = center_freq - bandwidth/2 + 10;
	     freq <= center_freq + bandwidth/2 - 10;
	     freq += 20) {
		c = ieee80211_get_channel(wiphy, freq);
		if (!c || c->flags & prohibited_flags)
			return false;
	}

	return true;
}

static bool cfg80211_check_beacon_chans(struct wiphy *wiphy,
					u32 center_freq, u32 bw)
{
	return cfg80211_secondary_chans_ok(wiphy, center_freq, bw,
					   IEEE80211_CHAN_DISABLED |
					   IEEE80211_CHAN_PASSIVE_SCAN |
					   IEEE80211_CHAN_NO_IBSS |
					   IEEE80211_CHAN_RADAR);
}

bool cfg80211_reg_can_beacon(struct wiphy *wiphy,
			     struct cfg80211_chan_def *chandef)
{
	u32 width;
	bool res;

	trace_cfg80211_reg_can_beacon(wiphy, chandef);

	if (WARN_ON(!cfg80211_chan_def_valid(chandef))) {
		trace_cfg80211_return_bool(false);
		return false;
	}

	switch (chandef->width) {
	case NL80211_CHAN_WIDTH_20_NOHT:
	case NL80211_CHAN_WIDTH_20:
		width = 20;
		break;
	case NL80211_CHAN_WIDTH_40:
		width = 40;
		break;
	case NL80211_CHAN_WIDTH_80:
	case NL80211_CHAN_WIDTH_80P80:
		width = 80;
		break;
	case NL80211_CHAN_WIDTH_160:
		width = 160;
		break;
	default:
		WARN_ON_ONCE(1);
		trace_cfg80211_return_bool(false);
		return false;
	}

	res = cfg80211_check_beacon_chans(wiphy, chandef->center_freq1, width);

	if (res && chandef->center_freq2)
		res = cfg80211_check_beacon_chans(wiphy, chandef->center_freq2,
						  width);

	trace_cfg80211_return_bool(res);
	return res;
}
EXPORT_SYMBOL(cfg80211_reg_can_beacon);

int cfg80211_set_monitor_channel(struct cfg80211_registered_device *rdev,
				 struct cfg80211_chan_def *chandef)
{
	if (!rdev->ops->set_monitor_channel)
		return -EOPNOTSUPP;
	if (!cfg80211_has_monitors_only(rdev))
		return -EBUSY;

	return rdev_set_monitor_channel(rdev, chandef);
}

void
cfg80211_get_chan_state(struct wireless_dev *wdev,
		        struct ieee80211_channel **chan,
		        enum cfg80211_chan_mode *chanmode)
{
	*chan = NULL;
	*chanmode = CHAN_MODE_UNDEFINED;

	ASSERT_WDEV_LOCK(wdev);

	if (wdev->netdev && !netif_running(wdev->netdev))
		return;

	switch (wdev->iftype) {
	case NL80211_IFTYPE_ADHOC:
		if (wdev->current_bss) {
			*chan = wdev->current_bss->pub.channel;
			*chanmode = wdev->ibss_fixed
				  ? CHAN_MODE_SHARED
				  : CHAN_MODE_EXCLUSIVE;
			return;
		}
	case NL80211_IFTYPE_STATION:
	case NL80211_IFTYPE_P2P_CLIENT:
		if (wdev->current_bss) {
			*chan = wdev->current_bss->pub.channel;
			*chanmode = CHAN_MODE_SHARED;
			return;
		}
		break;
	case NL80211_IFTYPE_AP:
	case NL80211_IFTYPE_P2P_GO:
		if (wdev->beacon_interval) {
			*chan = wdev->channel;
			*chanmode = CHAN_MODE_SHARED;
		}
		return;
	case NL80211_IFTYPE_MESH_POINT:
		if (wdev->mesh_id_len) {
			*chan = wdev->channel;
			*chanmode = CHAN_MODE_SHARED;
		}
		return;
	case NL80211_IFTYPE_MONITOR:
	case NL80211_IFTYPE_AP_VLAN:
	case NL80211_IFTYPE_WDS:
		/* these interface types don't really have a channel */
		return;
	case NL80211_IFTYPE_P2P_DEVICE:
		if (wdev->wiphy->features &
				NL80211_FEATURE_P2P_DEVICE_NEEDS_CHANNEL)
			*chanmode = CHAN_MODE_EXCLUSIVE;
		return;
	case NL80211_IFTYPE_UNSPECIFIED:
	case NUM_NL80211_IFTYPES:
		WARN_ON(1);
	}

	return;
}
Commit	Line	Data
59bbb6f7 JB	1	/*
	2	* This file contains helper code to handle channel
	3	* settings and keeping track of what is possible at
	4	* any point in time.
	5	*
	6	* Copyright 2009 Johannes Berg <johannes@sipsolutions.net>
	7	*/
	8
54858ee5	9	#include <linux/export.h>
59bbb6f7 JB	10	#include <net/cfg80211.h>
59bbb6f7 JB	11	#include "core.h"
e35e4d28	12	#include "rdev-ops.h"
59bbb6f7	13
3d9d1d66 JB	14	void cfg80211_chandef_create(struct cfg80211_chan_def *chandef,
	15	struct ieee80211_channel *chan,
	16	enum nl80211_channel_type chan_type)
9236d838	17	{
3d9d1d66 JB	18	if (WARN_ON(!chan))
3d9d1d66 JB	19	return;
9236d838	20
3d9d1d66 JB	21	chandef->chan = chan;
3d9d1d66 JB	22	chandef->center_freq2 = 0;
4ee3e063	23
3d9d1d66 JB	24	switch (chan_type) {
	25	case NL80211_CHAN_NO_HT:
	26	chandef->width = NL80211_CHAN_WIDTH_20_NOHT;
	27	chandef->center_freq1 = chan->center_freq;
	28	break;
	29	case NL80211_CHAN_HT20:
	30	chandef->width = NL80211_CHAN_WIDTH_20;
	31	chandef->center_freq1 = chan->center_freq;
	32	break;
9236d838	33	case NL80211_CHAN_HT40PLUS:
3d9d1d66 JB	34	chandef->width = NL80211_CHAN_WIDTH_40;
3d9d1d66 JB	35	chandef->center_freq1 = chan->center_freq + 10;
09a02fdb	36	break;
9236d838	37	case NL80211_CHAN_HT40MINUS:
3d9d1d66 JB	38	chandef->width = NL80211_CHAN_WIDTH_40;
3d9d1d66 JB	39	chandef->center_freq1 = chan->center_freq - 10;
09a02fdb	40	break;
9236d838	41	default:
3d9d1d66 JB	42	WARN_ON(1);
	43	}
	44	}
	45	EXPORT_SYMBOL(cfg80211_chandef_create);
	46
	47	bool cfg80211_chan_def_valid(const struct cfg80211_chan_def *chandef)
	48	{
	49	u32 control_freq;
	50
	51	if (!chandef->chan)
	52	return false;
	53
	54	control_freq = chandef->chan->center_freq;
	55
	56	switch (chandef->width) {
	57	case NL80211_CHAN_WIDTH_20:
	58	case NL80211_CHAN_WIDTH_20_NOHT:
	59	if (chandef->center_freq1 != control_freq)
	60	return false;
	61	if (chandef->center_freq2)
	62	return false;
	63	break;
	64	case NL80211_CHAN_WIDTH_40:
	65	if (chandef->center_freq1 != control_freq + 10 &&
	66	chandef->center_freq1 != control_freq - 10)
	67	return false;
	68	if (chandef->center_freq2)
	69	return false;
	70	break;
	71	case NL80211_CHAN_WIDTH_80P80:
	72	if (chandef->center_freq1 != control_freq + 30 &&
	73	chandef->center_freq1 != control_freq + 10 &&
	74	chandef->center_freq1 != control_freq - 10 &&
	75	chandef->center_freq1 != control_freq - 30)
	76	return false;
	77	if (!chandef->center_freq2)
	78	return false;
	79	break;
	80	case NL80211_CHAN_WIDTH_80:
	81	if (chandef->center_freq1 != control_freq + 30 &&
	82	chandef->center_freq1 != control_freq + 10 &&
	83	chandef->center_freq1 != control_freq - 10 &&
	84	chandef->center_freq1 != control_freq - 30)
	85	return false;
	86	if (chandef->center_freq2)
	87	return false;
	88	break;
	89	case NL80211_CHAN_WIDTH_160:
	90	if (chandef->center_freq1 != control_freq + 70 &&
	91	chandef->center_freq1 != control_freq + 50 &&
	92	chandef->center_freq1 != control_freq + 30 &&
	93	chandef->center_freq1 != control_freq + 10 &&
	94	chandef->center_freq1 != control_freq - 10 &&
	95	chandef->center_freq1 != control_freq - 30 &&
	96	chandef->center_freq1 != control_freq - 50 &&
	97	chandef->center_freq1 != control_freq - 70)
	98	return false;
	99	if (chandef->center_freq2)
	100	return false;
	101	break;
	102	default:
	103	return false;
	104	}
	105
106	return true;
107	}
108
109	static void chandef_primary_freqs(const struct cfg80211_chan_def *c,
110	int pri40, int pri80)
111	{
112	int tmp;
113
114	switch (c->width) {
115	case NL80211_CHAN_WIDTH_40:
116	*pri40 = c->center_freq1;
117	*pri80 = 0;
118	break;
119	case NL80211_CHAN_WIDTH_80:
120	case NL80211_CHAN_WIDTH_80P80:
121	*pri80 = c->center_freq1;
122	/* n_P20 */
123	tmp = (30 + c->chan->center_freq - c->center_freq1)/20;
124	/* n_P40 */
125	tmp /= 2;
126	/* freq_P40 */
127	pri40 = c->center_freq1 - 20 + 40 tmp;
128	break;
129	case NL80211_CHAN_WIDTH_160:
130	/* n_P20 */
131	tmp = (70 + c->chan->center_freq - c->center_freq1)/20;
132	/* n_P40 */
133	tmp /= 2;
134	/* freq_P40 */
135	pri40 = c->center_freq1 - 60 + 40 tmp;
136	/* n_P80 */
137	tmp /= 2;
138	pri80 = c->center_freq1 - 40 + 80 tmp;
139	break;
140	default:
141	WARN_ON_ONCE(1);
142	}
143	}
144
145	const struct cfg80211_chan_def *
146	cfg80211_chandef_compatible(const struct cfg80211_chan_def *c1,
147	const struct cfg80211_chan_def *c2)
148	{
149	u32 c1_pri40, c1_pri80, c2_pri40, c2_pri80;
150
151	/* If they are identical, return */
152	if (cfg80211_chandef_identical(c1, c2))
153	return c1;
154
155	/* otherwise, must have same control channel */
156	if (c1->chan != c2->chan)
157	return NULL;
158
159	/*
160	* If they have the same width, but aren't identical,
161	* then they can't be compatible.
162	*/
163	if (c1->width == c2->width)
164	return NULL;
165
166	if (c1->width == NL80211_CHAN_WIDTH_20_NOHT \|\|
167	c1->width == NL80211_CHAN_WIDTH_20)
168	return c2;
169
170	if (c2->width == NL80211_CHAN_WIDTH_20_NOHT \|\|
171	c2->width == NL80211_CHAN_WIDTH_20)
172	return c1;
173
174	chandef_primary_freqs(c1, &c1_pri40, &c1_pri80);
175	chandef_primary_freqs(c2, &c2_pri40, &c2_pri80);
176
177	if (c1_pri40 != c2_pri40)
178	return NULL;
179
180	WARN_ON(!c1_pri80 && !c2_pri80);
181	if (c1_pri80 && c2_pri80 && c1_pri80 != c2_pri80)
182	return NULL;
183
184	if (c1->width > c2->width)
185	return c1;
186	return c2;
187	}
188	EXPORT_SYMBOL(cfg80211_chandef_compatible);
189
190	bool cfg80211_secondary_chans_ok(struct wiphy *wiphy,
191	u32 center_freq, u32 bandwidth,
192	u32 prohibited_flags)
193	{
194	struct ieee80211_channel *c;
195	u32 freq;
196
197	for (freq = center_freq - bandwidth/2 + 10;
198	freq <= center_freq + bandwidth/2 - 10;
199	freq += 20) {
200	c = ieee80211_get_channel(wiphy, freq);
201	if (!c \|\| c->flags & prohibited_flags)
202	return false;
9236d838 LR	203	}
9236d838 LR	204
3d9d1d66 JB	205	return true;
	206	}
	207
	208	static bool cfg80211_check_beacon_chans(struct wiphy *wiphy,
	209	u32 center_freq, u32 bw)
	210	{
	211	return cfg80211_secondary_chans_ok(wiphy, center_freq, bw,
	212	IEEE80211_CHAN_DISABLED \|
	213	IEEE80211_CHAN_PASSIVE_SCAN \|
	214	IEEE80211_CHAN_NO_IBSS \|
	215	IEEE80211_CHAN_RADAR);
	216	}
	217
	218	bool cfg80211_reg_can_beacon(struct wiphy *wiphy,
	219	struct cfg80211_chan_def *chandef)
	220	{
	221	u32 width;
	222	bool res;
	223
	224	trace_cfg80211_reg_can_beacon(wiphy, chandef);
	225
	226	if (WARN_ON(!cfg80211_chan_def_valid(chandef))) {
4ee3e063	227	trace_cfg80211_return_bool(false);
9236d838	228	return false;
4ee3e063	229	}
9236d838	230
3d9d1d66 JB	231	switch (chandef->width) {
	232	case NL80211_CHAN_WIDTH_20_NOHT:
	233	case NL80211_CHAN_WIDTH_20:
	234	width = 20;
	235	break;
	236	case NL80211_CHAN_WIDTH_40:
	237	width = 40;
	238	break;
	239	case NL80211_CHAN_WIDTH_80:
	240	case NL80211_CHAN_WIDTH_80P80:
	241	width = 80;
	242	break;
	243	case NL80211_CHAN_WIDTH_160:
	244	width = 160;
	245	break;
	246	default:
	247	WARN_ON_ONCE(1);
4ee3e063	248	trace_cfg80211_return_bool(false);
9236d838	249	return false;
4ee3e063	250	}
3d9d1d66 JB	251
	252	res = cfg80211_check_beacon_chans(wiphy, chandef->center_freq1, width);
	253
	254	if (res && chandef->center_freq2)
	255	res = cfg80211_check_beacon_chans(wiphy, chandef->center_freq2,
	256	width);
	257
	258	trace_cfg80211_return_bool(res);
	259	return res;
9236d838	260	}
683b6d3b	261	EXPORT_SYMBOL(cfg80211_reg_can_beacon);
9236d838	262
e8c9bd5b	263	int cfg80211_set_monitor_channel(struct cfg80211_registered_device *rdev,
683b6d3b	264	struct cfg80211_chan_def *chandef)
9588bbd5	265	{
e8c9bd5b	266	if (!rdev->ops->set_monitor_channel)
9588bbd5	267	return -EOPNOTSUPP;
4f03c1ed MK	268	if (!cfg80211_has_monitors_only(rdev))
4f03c1ed MK	269	return -EBUSY;
9588bbd5	270
683b6d3b	271	return rdev_set_monitor_channel(rdev, chandef);
59bbb6f7	272	}
26ab9a0c MK	273
26ab9a0c MK	274	void
8e95ea49	275	cfg80211_get_chan_state(struct wireless_dev *wdev,
26ab9a0c MK	276	struct ieee80211_channel **chan,
	277	enum cfg80211_chan_mode *chanmode)
	278	{
	279	*chan = NULL;
	280	*chanmode = CHAN_MODE_UNDEFINED;
	281
26ab9a0c MK	282	ASSERT_WDEV_LOCK(wdev);
26ab9a0c MK	283
98104fde	284	if (wdev->netdev && !netif_running(wdev->netdev))
26ab9a0c MK	285	return;
	286
	287	switch (wdev->iftype) {
	288	case NL80211_IFTYPE_ADHOC:
	289	if (wdev->current_bss) {
	290	*chan = wdev->current_bss->pub.channel;
	291	*chanmode = wdev->ibss_fixed
	292	? CHAN_MODE_SHARED
	293	: CHAN_MODE_EXCLUSIVE;
	294	return;
	295	}
	296	case NL80211_IFTYPE_STATION:
	297	case NL80211_IFTYPE_P2P_CLIENT:
	298	if (wdev->current_bss) {
	299	*chan = wdev->current_bss->pub.channel;
	300	*chanmode = CHAN_MODE_SHARED;
	301	return;
	302	}
	303	break;
	304	case NL80211_IFTYPE_AP:
	305	case NL80211_IFTYPE_P2P_GO:
f53594a0 FF	306	if (wdev->beacon_interval) {
	307	*chan = wdev->channel;
	308	*chanmode = CHAN_MODE_SHARED;
	309	}
	310	return;
26ab9a0c	311	case NL80211_IFTYPE_MESH_POINT:
f53594a0 FF	312	if (wdev->mesh_id_len) {
	313	*chan = wdev->channel;
	314	*chanmode = CHAN_MODE_SHARED;
	315	}
26ab9a0c MK	316	return;
	317	case NL80211_IFTYPE_MONITOR:
	318	case NL80211_IFTYPE_AP_VLAN:
	319	case NL80211_IFTYPE_WDS:
	320	/* these interface types don't really have a channel */
	321	return;
98104fde JB	322	case NL80211_IFTYPE_P2P_DEVICE:
	323	if (wdev->wiphy->features &
	324	NL80211_FEATURE_P2P_DEVICE_NEEDS_CHANNEL)
	325	*chanmode = CHAN_MODE_EXCLUSIVE;
	326	return;
26ab9a0c MK	327	case NL80211_IFTYPE_UNSPECIFIED:
	328	case NUM_NL80211_IFTYPES:
	329	WARN_ON(1);
	330	}
	331
	332	return;
	333	}