Linux Audio

Check our new training course

Loading...
v3.1
  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
 
  9#include <net/cfg80211.h>
 10#include "core.h"
 
 11
 12struct ieee80211_channel *
 13rdev_freq_to_chan(struct cfg80211_registered_device *rdev,
 14		  int freq, enum nl80211_channel_type channel_type)
 15{
 16	struct ieee80211_channel *chan;
 17	struct ieee80211_sta_ht_cap *ht_cap;
 
 
 
 18
 19	chan = ieee80211_get_channel(&rdev->wiphy, freq);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 20
 21	/* Primary channel not allowed */
 22	if (!chan || chan->flags & IEEE80211_CHAN_DISABLED)
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 23		return NULL;
 24
 25	if (channel_type == NL80211_CHAN_HT40MINUS &&
 26	    chan->flags & IEEE80211_CHAN_NO_HT40MINUS)
 
 
 
 27		return NULL;
 28	else if (channel_type == NL80211_CHAN_HT40PLUS &&
 29		 chan->flags & IEEE80211_CHAN_NO_HT40PLUS)
 
 
 
 
 
 
 
 30		return NULL;
 31
 32	ht_cap = &rdev->wiphy.bands[chan->band]->ht_cap;
 
 
 
 
 
 
 33
 34	if (channel_type != NL80211_CHAN_NO_HT) {
 35		if (!ht_cap->ht_supported)
 36			return NULL;
 37
 38		if (channel_type != NL80211_CHAN_HT20 &&
 39		    (!(ht_cap->cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40) ||
 40		    ht_cap->cap & IEEE80211_HT_CAP_40MHZ_INTOLERANT))
 41			return NULL;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 42	}
 
 43
 44	return chan;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 45}
 46
 47static bool can_beacon_sec_chan(struct wiphy *wiphy,
 48				struct ieee80211_channel *chan,
 49				enum nl80211_channel_type channel_type)
 50{
 51	struct ieee80211_channel *sec_chan;
 52	int diff;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 53
 54	switch (channel_type) {
 55	case NL80211_CHAN_HT40PLUS:
 56		diff = 20;
 57		break;
 58	case NL80211_CHAN_HT40MINUS:
 59		diff = -20;
 
 
 
 
 
 60		break;
 61	default:
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 62		return false;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 63	}
 64
 65	sec_chan = ieee80211_get_channel(wiphy, chan->center_freq + diff);
 66	if (!sec_chan)
 
 
 
 
 
 
 
 
 67		return false;
 68
 69	/* we'll need a DFS capability later */
 70	if (sec_chan->flags & (IEEE80211_CHAN_DISABLED |
 71			       IEEE80211_CHAN_PASSIVE_SCAN |
 72			       IEEE80211_CHAN_NO_IBSS |
 73			       IEEE80211_CHAN_RADAR))
 74		return false;
 75
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 76	return true;
 77}
 78
 79int cfg80211_set_freq(struct cfg80211_registered_device *rdev,
 80		      struct wireless_dev *wdev, int freq,
 81		      enum nl80211_channel_type channel_type)
 82{
 83	struct ieee80211_channel *chan;
 84	int result;
 
 
 
 
 85
 86	if (wdev && wdev->iftype == NL80211_IFTYPE_MONITOR)
 87		wdev = NULL;
 88
 89	if (wdev) {
 90		ASSERT_WDEV_LOCK(wdev);
 91
 92		if (!netif_running(wdev->netdev))
 93			return -ENETDOWN;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 94	}
 95
 96	if (!rdev->ops->set_channel)
 97		return -EOPNOTSUPP;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 98
 99	chan = rdev_freq_to_chan(rdev, freq, channel_type);
100	if (!chan)
101		return -EINVAL;
102
103	/* Both channels should be able to initiate communication */
104	if (wdev && (wdev->iftype == NL80211_IFTYPE_ADHOC ||
105		     wdev->iftype == NL80211_IFTYPE_AP ||
106		     wdev->iftype == NL80211_IFTYPE_AP_VLAN ||
107		     wdev->iftype == NL80211_IFTYPE_MESH_POINT ||
108		     wdev->iftype == NL80211_IFTYPE_P2P_GO)) {
109		switch (channel_type) {
110		case NL80211_CHAN_HT40PLUS:
111		case NL80211_CHAN_HT40MINUS:
112			if (!can_beacon_sec_chan(&rdev->wiphy, chan,
113						 channel_type)) {
114				printk(KERN_DEBUG
115				       "cfg80211: Secondary channel not "
116				       "allowed to initiate communication\n");
117				return -EINVAL;
118			}
119			break;
120		default:
121			break;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
122		}
123	}
124
125	result = rdev->ops->set_channel(&rdev->wiphy,
126					wdev ? wdev->netdev : NULL,
127					chan, channel_type);
128	if (result)
129		return result;
130
131	if (wdev)
132		wdev->channel = chan;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
133
134	return 0;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
135}
v4.6
  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 * Copyright 2013-2014  Intel Mobile Communications GmbH
  8 */
  9
 10#include <linux/export.h>
 11#include <net/cfg80211.h>
 12#include "core.h"
 13#include "rdev-ops.h"
 14
 15void cfg80211_chandef_create(struct cfg80211_chan_def *chandef,
 16			     struct ieee80211_channel *chan,
 17			     enum nl80211_channel_type chan_type)
 18{
 19	if (WARN_ON(!chan))
 20		return;
 21
 22	chandef->chan = chan;
 23	chandef->center_freq2 = 0;
 24
 25	switch (chan_type) {
 26	case NL80211_CHAN_NO_HT:
 27		chandef->width = NL80211_CHAN_WIDTH_20_NOHT;
 28		chandef->center_freq1 = chan->center_freq;
 29		break;
 30	case NL80211_CHAN_HT20:
 31		chandef->width = NL80211_CHAN_WIDTH_20;
 32		chandef->center_freq1 = chan->center_freq;
 33		break;
 34	case NL80211_CHAN_HT40PLUS:
 35		chandef->width = NL80211_CHAN_WIDTH_40;
 36		chandef->center_freq1 = chan->center_freq + 10;
 37		break;
 38	case NL80211_CHAN_HT40MINUS:
 39		chandef->width = NL80211_CHAN_WIDTH_40;
 40		chandef->center_freq1 = chan->center_freq - 10;
 41		break;
 42	default:
 43		WARN_ON(1);
 44	}
 45}
 46EXPORT_SYMBOL(cfg80211_chandef_create);
 47
 48bool cfg80211_chandef_valid(const struct cfg80211_chan_def *chandef)
 49{
 50	u32 control_freq;
 51
 52	if (!chandef->chan)
 53		return false;
 54
 55	control_freq = chandef->chan->center_freq;
 56
 57	switch (chandef->width) {
 58	case NL80211_CHAN_WIDTH_5:
 59	case NL80211_CHAN_WIDTH_10:
 60	case NL80211_CHAN_WIDTH_20:
 61	case NL80211_CHAN_WIDTH_20_NOHT:
 62		if (chandef->center_freq1 != control_freq)
 63			return false;
 64		if (chandef->center_freq2)
 65			return false;
 66		break;
 67	case NL80211_CHAN_WIDTH_40:
 68		if (chandef->center_freq1 != control_freq + 10 &&
 69		    chandef->center_freq1 != control_freq - 10)
 70			return false;
 71		if (chandef->center_freq2)
 72			return false;
 73		break;
 74	case NL80211_CHAN_WIDTH_80P80:
 75		if (chandef->center_freq1 != control_freq + 30 &&
 76		    chandef->center_freq1 != control_freq + 10 &&
 77		    chandef->center_freq1 != control_freq - 10 &&
 78		    chandef->center_freq1 != control_freq - 30)
 79			return false;
 80		if (!chandef->center_freq2)
 81			return false;
 82		/* adjacent is not allowed -- that's a 160 MHz channel */
 83		if (chandef->center_freq1 - chandef->center_freq2 == 80 ||
 84		    chandef->center_freq2 - chandef->center_freq1 == 80)
 85			return false;
 86		break;
 87	case NL80211_CHAN_WIDTH_80:
 88		if (chandef->center_freq1 != control_freq + 30 &&
 89		    chandef->center_freq1 != control_freq + 10 &&
 90		    chandef->center_freq1 != control_freq - 10 &&
 91		    chandef->center_freq1 != control_freq - 30)
 92			return false;
 93		if (chandef->center_freq2)
 94			return false;
 95		break;
 96	case NL80211_CHAN_WIDTH_160:
 97		if (chandef->center_freq1 != control_freq + 70 &&
 98		    chandef->center_freq1 != control_freq + 50 &&
 99		    chandef->center_freq1 != control_freq + 30 &&
100		    chandef->center_freq1 != control_freq + 10 &&
101		    chandef->center_freq1 != control_freq - 10 &&
102		    chandef->center_freq1 != control_freq - 30 &&
103		    chandef->center_freq1 != control_freq - 50 &&
104		    chandef->center_freq1 != control_freq - 70)
105			return false;
106		if (chandef->center_freq2)
107			return false;
108		break;
109	default:
110		return false;
111	}
112
113	return true;
114}
115EXPORT_SYMBOL(cfg80211_chandef_valid);
116
117static void chandef_primary_freqs(const struct cfg80211_chan_def *c,
118				  u32 *pri40, u32 *pri80)
119{
120	int tmp;
121
122	switch (c->width) {
123	case NL80211_CHAN_WIDTH_40:
124		*pri40 = c->center_freq1;
125		*pri80 = 0;
126		break;
127	case NL80211_CHAN_WIDTH_80:
128	case NL80211_CHAN_WIDTH_80P80:
129		*pri80 = c->center_freq1;
130		/* n_P20 */
131		tmp = (30 + c->chan->center_freq - c->center_freq1)/20;
132		/* n_P40 */
133		tmp /= 2;
134		/* freq_P40 */
135		*pri40 = c->center_freq1 - 20 + 40 * tmp;
136		break;
137	case NL80211_CHAN_WIDTH_160:
138		/* n_P20 */
139		tmp = (70 + c->chan->center_freq - c->center_freq1)/20;
140		/* n_P40 */
141		tmp /= 2;
142		/* freq_P40 */
143		*pri40 = c->center_freq1 - 60 + 40 * tmp;
144		/* n_P80 */
145		tmp /= 2;
146		*pri80 = c->center_freq1 - 40 + 80 * tmp;
147		break;
148	default:
149		WARN_ON_ONCE(1);
150	}
151}
152
153static int cfg80211_chandef_get_width(const struct cfg80211_chan_def *c)
154{
155	int width;
156
157	switch (c->width) {
158	case NL80211_CHAN_WIDTH_5:
159		width = 5;
160		break;
161	case NL80211_CHAN_WIDTH_10:
162		width = 10;
163		break;
164	case NL80211_CHAN_WIDTH_20:
165	case NL80211_CHAN_WIDTH_20_NOHT:
166		width = 20;
167		break;
168	case NL80211_CHAN_WIDTH_40:
169		width = 40;
170		break;
171	case NL80211_CHAN_WIDTH_80P80:
172	case NL80211_CHAN_WIDTH_80:
173		width = 80;
174		break;
175	case NL80211_CHAN_WIDTH_160:
176		width = 160;
177		break;
178	default:
179		WARN_ON_ONCE(1);
180		return -1;
181	}
182	return width;
183}
184
185const struct cfg80211_chan_def *
186cfg80211_chandef_compatible(const struct cfg80211_chan_def *c1,
187			    const struct cfg80211_chan_def *c2)
188{
189	u32 c1_pri40, c1_pri80, c2_pri40, c2_pri80;
190
191	/* If they are identical, return */
192	if (cfg80211_chandef_identical(c1, c2))
193		return c1;
194
195	/* otherwise, must have same control channel */
196	if (c1->chan != c2->chan)
197		return NULL;
198
199	/*
200	 * If they have the same width, but aren't identical,
201	 * then they can't be compatible.
202	 */
203	if (c1->width == c2->width)
204		return NULL;
205
206	/*
207	 * can't be compatible if one of them is 5 or 10 MHz,
208	 * but they don't have the same width.
209	 */
210	if (c1->width == NL80211_CHAN_WIDTH_5 ||
211	    c1->width == NL80211_CHAN_WIDTH_10 ||
212	    c2->width == NL80211_CHAN_WIDTH_5 ||
213	    c2->width == NL80211_CHAN_WIDTH_10)
214		return NULL;
215
216	if (c1->width == NL80211_CHAN_WIDTH_20_NOHT ||
217	    c1->width == NL80211_CHAN_WIDTH_20)
218		return c2;
219
220	if (c2->width == NL80211_CHAN_WIDTH_20_NOHT ||
221	    c2->width == NL80211_CHAN_WIDTH_20)
222		return c1;
223
224	chandef_primary_freqs(c1, &c1_pri40, &c1_pri80);
225	chandef_primary_freqs(c2, &c2_pri40, &c2_pri80);
 
226
227	if (c1_pri40 != c2_pri40)
228		return NULL;
229
230	WARN_ON(!c1_pri80 && !c2_pri80);
231	if (c1_pri80 && c2_pri80 && c1_pri80 != c2_pri80)
232		return NULL;
233
234	if (c1->width > c2->width)
235		return c1;
236	return c2;
237}
238EXPORT_SYMBOL(cfg80211_chandef_compatible);
239
240static void cfg80211_set_chans_dfs_state(struct wiphy *wiphy, u32 center_freq,
241					 u32 bandwidth,
242					 enum nl80211_dfs_state dfs_state)
243{
244	struct ieee80211_channel *c;
245	u32 freq;
246
247	for (freq = center_freq - bandwidth/2 + 10;
248	     freq <= center_freq + bandwidth/2 - 10;
249	     freq += 20) {
250		c = ieee80211_get_channel(wiphy, freq);
251		if (!c || !(c->flags & IEEE80211_CHAN_RADAR))
252			continue;
253
254		c->dfs_state = dfs_state;
255		c->dfs_state_entered = jiffies;
256	}
257}
258
259void cfg80211_set_dfs_state(struct wiphy *wiphy,
260			    const struct cfg80211_chan_def *chandef,
261			    enum nl80211_dfs_state dfs_state)
262{
263	int width;
264
265	if (WARN_ON(!cfg80211_chandef_valid(chandef)))
266		return;
267
268	width = cfg80211_chandef_get_width(chandef);
269	if (width < 0)
270		return;
271
272	cfg80211_set_chans_dfs_state(wiphy, chandef->center_freq1,
273				     width, dfs_state);
274
275	if (!chandef->center_freq2)
276		return;
277	cfg80211_set_chans_dfs_state(wiphy, chandef->center_freq2,
278				     width, dfs_state);
279}
280
281static u32 cfg80211_get_start_freq(u32 center_freq,
282				   u32 bandwidth)
 
283{
284	u32 start_freq;
285
286	if (bandwidth <= 20)
287		start_freq = center_freq;
288	else
289		start_freq = center_freq - bandwidth/2 + 10;
290
291	return start_freq;
292}
293
294static u32 cfg80211_get_end_freq(u32 center_freq,
295				 u32 bandwidth)
296{
297	u32 end_freq;
298
299	if (bandwidth <= 20)
300		end_freq = center_freq;
301	else
302		end_freq = center_freq + bandwidth/2 - 10;
303
304	return end_freq;
305}
306
307static int cfg80211_get_chans_dfs_required(struct wiphy *wiphy,
308					    u32 center_freq,
309					    u32 bandwidth)
310{
311	struct ieee80211_channel *c;
312	u32 freq, start_freq, end_freq;
313
314	start_freq = cfg80211_get_start_freq(center_freq, bandwidth);
315	end_freq = cfg80211_get_end_freq(center_freq, bandwidth);
316
317	for (freq = start_freq; freq <= end_freq; freq += 20) {
318		c = ieee80211_get_channel(wiphy, freq);
319		if (!c)
320			return -EINVAL;
321
322		if (c->flags & IEEE80211_CHAN_RADAR)
323			return 1;
324	}
325	return 0;
326}
327
328
329int cfg80211_chandef_dfs_required(struct wiphy *wiphy,
330				  const struct cfg80211_chan_def *chandef,
331				  enum nl80211_iftype iftype)
332{
333	int width;
334	int ret;
335
336	if (WARN_ON(!cfg80211_chandef_valid(chandef)))
337		return -EINVAL;
338
339	switch (iftype) {
340	case NL80211_IFTYPE_ADHOC:
341	case NL80211_IFTYPE_AP:
342	case NL80211_IFTYPE_P2P_GO:
343	case NL80211_IFTYPE_MESH_POINT:
344		width = cfg80211_chandef_get_width(chandef);
345		if (width < 0)
346			return -EINVAL;
347
348		ret = cfg80211_get_chans_dfs_required(wiphy,
349						      chandef->center_freq1,
350						      width);
351		if (ret < 0)
352			return ret;
353		else if (ret > 0)
354			return BIT(chandef->width);
355
356		if (!chandef->center_freq2)
357			return 0;
358
359		ret = cfg80211_get_chans_dfs_required(wiphy,
360						      chandef->center_freq2,
361						      width);
362		if (ret < 0)
363			return ret;
364		else if (ret > 0)
365			return BIT(chandef->width);
366
 
 
 
367		break;
368	case NL80211_IFTYPE_STATION:
369	case NL80211_IFTYPE_OCB:
370	case NL80211_IFTYPE_P2P_CLIENT:
371	case NL80211_IFTYPE_MONITOR:
372	case NL80211_IFTYPE_AP_VLAN:
373	case NL80211_IFTYPE_WDS:
374	case NL80211_IFTYPE_P2P_DEVICE:
375		break;
376	case NL80211_IFTYPE_UNSPECIFIED:
377	case NUM_NL80211_IFTYPES:
378		WARN_ON(1);
379	}
380
381	return 0;
382}
383EXPORT_SYMBOL(cfg80211_chandef_dfs_required);
384
385static int cfg80211_get_chans_dfs_usable(struct wiphy *wiphy,
386					 u32 center_freq,
387					 u32 bandwidth)
388{
389	struct ieee80211_channel *c;
390	u32 freq, start_freq, end_freq;
391	int count = 0;
392
393	start_freq = cfg80211_get_start_freq(center_freq, bandwidth);
394	end_freq = cfg80211_get_end_freq(center_freq, bandwidth);
395
396	/*
397	 * Check entire range of channels for the bandwidth.
398	 * Check all channels are DFS channels (DFS_USABLE or
399	 * DFS_AVAILABLE). Return number of usable channels
400	 * (require CAC). Allow DFS and non-DFS channel mix.
401	 */
402	for (freq = start_freq; freq <= end_freq; freq += 20) {
403		c = ieee80211_get_channel(wiphy, freq);
404		if (!c)
405			return -EINVAL;
406
407		if (c->flags & IEEE80211_CHAN_DISABLED)
408			return -EINVAL;
409
410		if (c->flags & IEEE80211_CHAN_RADAR) {
411			if (c->dfs_state == NL80211_DFS_UNAVAILABLE)
412				return -EINVAL;
413
414			if (c->dfs_state == NL80211_DFS_USABLE)
415				count++;
416		}
417	}
418
419	return count;
420}
421
422bool cfg80211_chandef_dfs_usable(struct wiphy *wiphy,
423				 const struct cfg80211_chan_def *chandef)
424{
425	int width;
426	int r1, r2 = 0;
427
428	if (WARN_ON(!cfg80211_chandef_valid(chandef)))
429		return false;
430
431	width = cfg80211_chandef_get_width(chandef);
432	if (width < 0)
433		return false;
434
435	r1 = cfg80211_get_chans_dfs_usable(wiphy, chandef->center_freq1,
436					  width);
437
438	if (r1 < 0)
439		return false;
440
441	switch (chandef->width) {
442	case NL80211_CHAN_WIDTH_80P80:
443		WARN_ON(!chandef->center_freq2);
444		r2 = cfg80211_get_chans_dfs_usable(wiphy,
445						   chandef->center_freq2,
446						   width);
447		if (r2 < 0)
448			return false;
449		break;
450	default:
451		WARN_ON(chandef->center_freq2);
452		break;
453	}
454
455	return (r1 + r2 > 0);
456}
457
458
459static bool cfg80211_get_chans_dfs_available(struct wiphy *wiphy,
460					     u32 center_freq,
461					     u32 bandwidth)
462{
463	struct ieee80211_channel *c;
464	u32 freq, start_freq, end_freq;
465
466	start_freq = cfg80211_get_start_freq(center_freq, bandwidth);
467	end_freq = cfg80211_get_end_freq(center_freq, bandwidth);
468
469	/*
470	 * Check entire range of channels for the bandwidth.
471	 * If any channel in between is disabled or has not
472	 * had gone through CAC return false
473	 */
474	for (freq = start_freq; freq <= end_freq; freq += 20) {
475		c = ieee80211_get_channel(wiphy, freq);
476		if (!c)
477			return false;
478
479		if (c->flags & IEEE80211_CHAN_DISABLED)
480			return false;
481
482		if ((c->flags & IEEE80211_CHAN_RADAR)  &&
483		    (c->dfs_state != NL80211_DFS_AVAILABLE))
484			return false;
485	}
486
487	return true;
488}
489
490static bool cfg80211_chandef_dfs_available(struct wiphy *wiphy,
491				const struct cfg80211_chan_def *chandef)
492{
493	int width;
494	int r;
495
496	if (WARN_ON(!cfg80211_chandef_valid(chandef)))
497		return false;
498
499	width = cfg80211_chandef_get_width(chandef);
500	if (width < 0)
 
 
 
501		return false;
502
503	r = cfg80211_get_chans_dfs_available(wiphy, chandef->center_freq1,
504					     width);
505
506	/* If any of channels unavailable for cf1 just return */
507	if (!r)
508		return r;
509
510	switch (chandef->width) {
511	case NL80211_CHAN_WIDTH_80P80:
512		WARN_ON(!chandef->center_freq2);
513		r = cfg80211_get_chans_dfs_available(wiphy,
514						     chandef->center_freq2,
515						     width);
516	default:
517		WARN_ON(chandef->center_freq2);
518		break;
519	}
520
521	return r;
522}
523
524static unsigned int cfg80211_get_chans_dfs_cac_time(struct wiphy *wiphy,
525						    u32 center_freq,
526						    u32 bandwidth)
527{
528	struct ieee80211_channel *c;
529	u32 start_freq, end_freq, freq;
530	unsigned int dfs_cac_ms = 0;
531
532	start_freq = cfg80211_get_start_freq(center_freq, bandwidth);
533	end_freq = cfg80211_get_end_freq(center_freq, bandwidth);
534
535	for (freq = start_freq; freq <= end_freq; freq += 20) {
536		c = ieee80211_get_channel(wiphy, freq);
537		if (!c)
538			return 0;
539
540		if (c->flags & IEEE80211_CHAN_DISABLED)
541			return 0;
542
543		if (!(c->flags & IEEE80211_CHAN_RADAR))
544			continue;
545
546		if (c->dfs_cac_ms > dfs_cac_ms)
547			dfs_cac_ms = c->dfs_cac_ms;
548	}
549
550	return dfs_cac_ms;
551}
552
553unsigned int
554cfg80211_chandef_dfs_cac_time(struct wiphy *wiphy,
555			      const struct cfg80211_chan_def *chandef)
556{
557	int width;
558	unsigned int t1 = 0, t2 = 0;
559
560	if (WARN_ON(!cfg80211_chandef_valid(chandef)))
561		return 0;
562
563	width = cfg80211_chandef_get_width(chandef);
564	if (width < 0)
565		return 0;
566
567	t1 = cfg80211_get_chans_dfs_cac_time(wiphy,
568					     chandef->center_freq1,
569					     width);
570
571	if (!chandef->center_freq2)
572		return t1;
573
574	t2 = cfg80211_get_chans_dfs_cac_time(wiphy,
575					     chandef->center_freq2,
576					     width);
577
578	return max(t1, t2);
579}
580
581static bool cfg80211_secondary_chans_ok(struct wiphy *wiphy,
582					u32 center_freq, u32 bandwidth,
583					u32 prohibited_flags)
584{
585	struct ieee80211_channel *c;
586	u32 freq, start_freq, end_freq;
587
588	start_freq = cfg80211_get_start_freq(center_freq, bandwidth);
589	end_freq = cfg80211_get_end_freq(center_freq, bandwidth);
590
591	for (freq = start_freq; freq <= end_freq; freq += 20) {
592		c = ieee80211_get_channel(wiphy, freq);
593		if (!c || c->flags & prohibited_flags)
594			return false;
595	}
596
597	return true;
598}
599
600bool cfg80211_chandef_usable(struct wiphy *wiphy,
601			     const struct cfg80211_chan_def *chandef,
602			     u32 prohibited_flags)
603{
604	struct ieee80211_sta_ht_cap *ht_cap;
605	struct ieee80211_sta_vht_cap *vht_cap;
606	u32 width, control_freq, cap;
607
608	if (WARN_ON(!cfg80211_chandef_valid(chandef)))
609		return false;
610
611	ht_cap = &wiphy->bands[chandef->chan->band]->ht_cap;
612	vht_cap = &wiphy->bands[chandef->chan->band]->vht_cap;
613
614	control_freq = chandef->chan->center_freq;
 
615
616	switch (chandef->width) {
617	case NL80211_CHAN_WIDTH_5:
618		width = 5;
619		break;
620	case NL80211_CHAN_WIDTH_10:
621		prohibited_flags |= IEEE80211_CHAN_NO_10MHZ;
622		width = 10;
623		break;
624	case NL80211_CHAN_WIDTH_20:
625		if (!ht_cap->ht_supported)
626			return false;
627	case NL80211_CHAN_WIDTH_20_NOHT:
628		prohibited_flags |= IEEE80211_CHAN_NO_20MHZ;
629		width = 20;
630		break;
631	case NL80211_CHAN_WIDTH_40:
632		width = 40;
633		if (!ht_cap->ht_supported)
634			return false;
635		if (!(ht_cap->cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40) ||
636		    ht_cap->cap & IEEE80211_HT_CAP_40MHZ_INTOLERANT)
637			return false;
638		if (chandef->center_freq1 < control_freq &&
639		    chandef->chan->flags & IEEE80211_CHAN_NO_HT40MINUS)
640			return false;
641		if (chandef->center_freq1 > control_freq &&
642		    chandef->chan->flags & IEEE80211_CHAN_NO_HT40PLUS)
643			return false;
644		break;
645	case NL80211_CHAN_WIDTH_80P80:
646		cap = vht_cap->cap & IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_MASK;
647		if (cap != IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ)
648			return false;
649	case NL80211_CHAN_WIDTH_80:
650		if (!vht_cap->vht_supported)
651			return false;
652		prohibited_flags |= IEEE80211_CHAN_NO_80MHZ;
653		width = 80;
654		break;
655	case NL80211_CHAN_WIDTH_160:
656		if (!vht_cap->vht_supported)
657			return false;
658		cap = vht_cap->cap & IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_MASK;
659		if (cap != IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160MHZ &&
660		    cap != IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ)
661			return false;
662		prohibited_flags |= IEEE80211_CHAN_NO_160MHZ;
663		width = 160;
664		break;
665	default:
666		WARN_ON_ONCE(1);
667		return false;
668	}
669
670	/*
671	 * TODO: What if there are only certain 80/160/80+80 MHz channels
672	 *	 allowed by the driver, or only certain combinations?
673	 *	 For 40 MHz the driver can set the NO_HT40 flags, but for
674	 *	 80/160 MHz and in particular 80+80 MHz this isn't really
675	 *	 feasible and we only have NO_80MHZ/NO_160MHZ so far but
676	 *	 no way to cover 80+80 MHz or more complex restrictions.
677	 *	 Note that such restrictions also need to be advertised to
678	 *	 userspace, for example for P2P channel selection.
679	 */
680
681	if (width > 20)
682		prohibited_flags |= IEEE80211_CHAN_NO_OFDM;
683
684	/* 5 and 10 MHz are only defined for the OFDM PHY */
685	if (width < 20)
686		prohibited_flags |= IEEE80211_CHAN_NO_OFDM;
687
 
 
 
688
689	if (!cfg80211_secondary_chans_ok(wiphy, chandef->center_freq1,
690					 width, prohibited_flags))
691		return false;
692
693	if (!chandef->center_freq2)
694		return true;
695	return cfg80211_secondary_chans_ok(wiphy, chandef->center_freq2,
696					   width, prohibited_flags);
697}
698EXPORT_SYMBOL(cfg80211_chandef_usable);
699
700/*
701 * Check if the channel can be used under permissive conditions mandated by
702 * some regulatory bodies, i.e., the channel is marked with
703 * IEEE80211_CHAN_IR_CONCURRENT and there is an additional station interface
704 * associated to an AP on the same channel or on the same UNII band
705 * (assuming that the AP is an authorized master).
706 * In addition allow operation on a channel on which indoor operation is
707 * allowed, iff we are currently operating in an indoor environment.
708 */
709static bool cfg80211_ir_permissive_chan(struct wiphy *wiphy,
710					enum nl80211_iftype iftype,
711					struct ieee80211_channel *chan)
712{
713	struct wireless_dev *wdev;
714	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
715
716	ASSERT_RTNL();
717
718	if (!config_enabled(CONFIG_CFG80211_REG_RELAX_NO_IR) ||
719	    !(wiphy->regulatory_flags & REGULATORY_ENABLE_RELAX_NO_IR))
720		return false;
721
722	/* only valid for GO and TDLS off-channel (station/p2p-CL) */
723	if (iftype != NL80211_IFTYPE_P2P_GO &&
724	    iftype != NL80211_IFTYPE_STATION &&
725	    iftype != NL80211_IFTYPE_P2P_CLIENT)
726		return false;
727
728	if (regulatory_indoor_allowed() &&
729	    (chan->flags & IEEE80211_CHAN_INDOOR_ONLY))
730		return true;
731
732	if (!(chan->flags & IEEE80211_CHAN_IR_CONCURRENT))
733		return false;
734
735	/*
736	 * Generally, it is possible to rely on another device/driver to allow
737	 * the IR concurrent relaxation, however, since the device can further
738	 * enforce the relaxation (by doing a similar verifications as this),
739	 * and thus fail the GO instantiation, consider only the interfaces of
740	 * the current registered device.
741	 */
742	list_for_each_entry(wdev, &rdev->wdev_list, list) {
743		struct ieee80211_channel *other_chan = NULL;
744		int r1, r2;
745
746		wdev_lock(wdev);
747		if (wdev->iftype == NL80211_IFTYPE_STATION &&
748		    wdev->current_bss)
749			other_chan = wdev->current_bss->pub.channel;
750
751		/*
752		 * If a GO already operates on the same GO_CONCURRENT channel,
753		 * this one (maybe the same one) can beacon as well. We allow
754		 * the operation even if the station we relied on with
755		 * GO_CONCURRENT is disconnected now. But then we must make sure
756		 * we're not outdoor on an indoor-only channel.
757		 */
758		if (iftype == NL80211_IFTYPE_P2P_GO &&
759		    wdev->iftype == NL80211_IFTYPE_P2P_GO &&
760		    wdev->beacon_interval &&
761		    !(chan->flags & IEEE80211_CHAN_INDOOR_ONLY))
762			other_chan = wdev->chandef.chan;
763		wdev_unlock(wdev);
764
765		if (!other_chan)
766			continue;
767
768		if (chan == other_chan)
769			return true;
770
771		if (chan->band != IEEE80211_BAND_5GHZ)
772			continue;
773
774		r1 = cfg80211_get_unii(chan->center_freq);
775		r2 = cfg80211_get_unii(other_chan->center_freq);
776
777		if (r1 != -EINVAL && r1 == r2) {
778			/*
779			 * At some locations channels 149-165 are considered a
780			 * bundle, but at other locations, e.g., Indonesia,
781			 * channels 149-161 are considered a bundle while
782			 * channel 165 is left out and considered to be in a
783			 * different bundle. Thus, in case that there is a
784			 * station interface connected to an AP on channel 165,
785			 * it is assumed that channels 149-161 are allowed for
786			 * GO operations. However, having a station interface
787			 * connected to an AP on channels 149-161, does not
788			 * allow GO operation on channel 165.
789			 */
790			if (chan->center_freq == 5825 &&
791			    other_chan->center_freq != 5825)
792				continue;
793			return true;
794		}
795	}
796
797	return false;
798}
 
 
 
799
800static bool _cfg80211_reg_can_beacon(struct wiphy *wiphy,
801				     struct cfg80211_chan_def *chandef,
802				     enum nl80211_iftype iftype,
803				     bool check_no_ir)
804{
805	bool res;
806	u32 prohibited_flags = IEEE80211_CHAN_DISABLED |
807			       IEEE80211_CHAN_RADAR;
808
809	trace_cfg80211_reg_can_beacon(wiphy, chandef, iftype, check_no_ir);
810
811	if (check_no_ir)
812		prohibited_flags |= IEEE80211_CHAN_NO_IR;
813
814	if (cfg80211_chandef_dfs_required(wiphy, chandef, iftype) > 0 &&
815	    cfg80211_chandef_dfs_available(wiphy, chandef)) {
816		/* We can skip IEEE80211_CHAN_NO_IR if chandef dfs available */
817		prohibited_flags = IEEE80211_CHAN_DISABLED;
818	}
819
820	res = cfg80211_chandef_usable(wiphy, chandef, prohibited_flags);
821
822	trace_cfg80211_return_bool(res);
823	return res;
824}
825
826bool cfg80211_reg_can_beacon(struct wiphy *wiphy,
827			     struct cfg80211_chan_def *chandef,
828			     enum nl80211_iftype iftype)
829{
830	return _cfg80211_reg_can_beacon(wiphy, chandef, iftype, true);
831}
832EXPORT_SYMBOL(cfg80211_reg_can_beacon);
833
834bool cfg80211_reg_can_beacon_relax(struct wiphy *wiphy,
835				   struct cfg80211_chan_def *chandef,
836				   enum nl80211_iftype iftype)
837{
838	bool check_no_ir;
839
840	ASSERT_RTNL();
841
842	/*
843	 * Under certain conditions suggested by some regulatory bodies a
844	 * GO/STA can IR on channels marked with IEEE80211_NO_IR. Set this flag
845	 * only if such relaxations are not enabled and the conditions are not
846	 * met.
847	 */
848	check_no_ir = !cfg80211_ir_permissive_chan(wiphy, iftype,
849						   chandef->chan);
850
851	return _cfg80211_reg_can_beacon(wiphy, chandef, iftype, check_no_ir);
852}
853EXPORT_SYMBOL(cfg80211_reg_can_beacon_relax);
854
855int cfg80211_set_monitor_channel(struct cfg80211_registered_device *rdev,
856				 struct cfg80211_chan_def *chandef)
857{
858	if (!rdev->ops->set_monitor_channel)
859		return -EOPNOTSUPP;
860	if (!cfg80211_has_monitors_only(rdev))
861		return -EBUSY;
862
863	return rdev_set_monitor_channel(rdev, chandef);
864}
865
866void
867cfg80211_get_chan_state(struct wireless_dev *wdev,
868		        struct ieee80211_channel **chan,
869		        enum cfg80211_chan_mode *chanmode,
870		        u8 *radar_detect)
871{
872	int ret;
873
874	*chan = NULL;
875	*chanmode = CHAN_MODE_UNDEFINED;
876
877	ASSERT_WDEV_LOCK(wdev);
878
879	if (wdev->netdev && !netif_running(wdev->netdev))
880		return;
881
882	switch (wdev->iftype) {
883	case NL80211_IFTYPE_ADHOC:
884		if (wdev->current_bss) {
885			*chan = wdev->current_bss->pub.channel;
886			*chanmode = (wdev->ibss_fixed &&
887				     !wdev->ibss_dfs_possible)
888				  ? CHAN_MODE_SHARED
889				  : CHAN_MODE_EXCLUSIVE;
890
891			/* consider worst-case - IBSS can try to return to the
892			 * original user-specified channel as creator */
893			if (wdev->ibss_dfs_possible)
894				*radar_detect |= BIT(wdev->chandef.width);
895			return;
896		}
897		break;
898	case NL80211_IFTYPE_STATION:
899	case NL80211_IFTYPE_P2P_CLIENT:
900		if (wdev->current_bss) {
901			*chan = wdev->current_bss->pub.channel;
902			*chanmode = CHAN_MODE_SHARED;
903			return;
904		}
905		break;
906	case NL80211_IFTYPE_AP:
907	case NL80211_IFTYPE_P2P_GO:
908		if (wdev->cac_started) {
909			*chan = wdev->chandef.chan;
910			*chanmode = CHAN_MODE_SHARED;
911			*radar_detect |= BIT(wdev->chandef.width);
912		} else if (wdev->beacon_interval) {
913			*chan = wdev->chandef.chan;
914			*chanmode = CHAN_MODE_SHARED;
915
916			ret = cfg80211_chandef_dfs_required(wdev->wiphy,
917							    &wdev->chandef,
918							    wdev->iftype);
919			WARN_ON(ret < 0);
920			if (ret > 0)
921				*radar_detect |= BIT(wdev->chandef.width);
922		}
923		return;
924	case NL80211_IFTYPE_MESH_POINT:
925		if (wdev->mesh_id_len) {
926			*chan = wdev->chandef.chan;
927			*chanmode = CHAN_MODE_SHARED;
928
929			ret = cfg80211_chandef_dfs_required(wdev->wiphy,
930							    &wdev->chandef,
931							    wdev->iftype);
932			WARN_ON(ret < 0);
933			if (ret > 0)
934				*radar_detect |= BIT(wdev->chandef.width);
935		}
936		return;
937	case NL80211_IFTYPE_OCB:
938		if (wdev->chandef.chan) {
939			*chan = wdev->chandef.chan;
940			*chanmode = CHAN_MODE_SHARED;
941			return;
942		}
943		break;
944	case NL80211_IFTYPE_MONITOR:
945	case NL80211_IFTYPE_AP_VLAN:
946	case NL80211_IFTYPE_WDS:
947	case NL80211_IFTYPE_P2P_DEVICE:
948		/* these interface types don't really have a channel */
949		return;
950	case NL80211_IFTYPE_UNSPECIFIED:
951	case NUM_NL80211_IFTYPES:
952		WARN_ON(1);
953	}
954}