/net/wireless/chan.c

   1// SPDX-License-Identifier: GPL-2.0
   2/*
   3 * This file contains helper code to handle channel
   4 * settings and keeping track of what is possible at
   5 * any point in time.
   6 *
   7 * Copyright 2009	Johannes Berg <johannes@sipsolutions.net>
   8 * Copyright 2013-2014  Intel Mobile Communications GmbH
   9 * Copyright 2018       Intel Corporation
  10 */
  11
  12#include <linux/export.h>
  13#include <net/cfg80211.h>
  14#include "core.h"
  15#include "rdev-ops.h"
  16
  17static bool cfg80211_valid_60g_freq(u32 freq)
  18{
  19	return freq >= 58320 && freq <= 70200;
  20}
  21
  22void cfg80211_chandef_create(struct cfg80211_chan_def *chandef,
  23			     struct ieee80211_channel *chan,
  24			     enum nl80211_channel_type chan_type)
  25{
  26	if (WARN_ON(!chan))
  27		return;
  28
  29	chandef->chan = chan;
  30	chandef->center_freq2 = 0;
  31	chandef->edmg.bw_config = 0;
  32	chandef->edmg.channels = 0;
  33
  34	switch (chan_type) {
  35	case NL80211_CHAN_NO_HT:
  36		chandef->width = NL80211_CHAN_WIDTH_20_NOHT;
  37		chandef->center_freq1 = chan->center_freq;
  38		break;
  39	case NL80211_CHAN_HT20:
  40		chandef->width = NL80211_CHAN_WIDTH_20;
  41		chandef->center_freq1 = chan->center_freq;
  42		break;
  43	case NL80211_CHAN_HT40PLUS:
  44		chandef->width = NL80211_CHAN_WIDTH_40;
  45		chandef->center_freq1 = chan->center_freq + 10;
  46		break;
  47	case NL80211_CHAN_HT40MINUS:
  48		chandef->width = NL80211_CHAN_WIDTH_40;
  49		chandef->center_freq1 = chan->center_freq - 10;
  50		break;
  51	default:
  52		WARN_ON(1);
  53	}
  54}
  55EXPORT_SYMBOL(cfg80211_chandef_create);
  56
  57static bool cfg80211_edmg_chandef_valid(const struct cfg80211_chan_def *chandef)
  58{
  59	int max_contiguous = 0;
  60	int num_of_enabled = 0;
  61	int contiguous = 0;
  62	int i;
  63
  64	if (!chandef->edmg.channels || !chandef->edmg.bw_config)
  65		return false;
  66
  67	if (!cfg80211_valid_60g_freq(chandef->chan->center_freq))
  68		return false;
  69
  70	for (i = 0; i < 6; i++) {
  71		if (chandef->edmg.channels & BIT(i)) {
  72			contiguous++;
  73			num_of_enabled++;
  74		} else {
  75			contiguous = 0;
  76		}
  77
  78		max_contiguous = max(contiguous, max_contiguous);
  79	}
  80	/* basic verification of edmg configuration according to
  81	 * IEEE P802.11ay/D4.0 section 9.4.2.251
  82	 */
  83	/* check bw_config against contiguous edmg channels */
  84	switch (chandef->edmg.bw_config) {
  85	case IEEE80211_EDMG_BW_CONFIG_4:
  86	case IEEE80211_EDMG_BW_CONFIG_8:
  87	case IEEE80211_EDMG_BW_CONFIG_12:
  88		if (max_contiguous < 1)
  89			return false;
  90		break;
  91	case IEEE80211_EDMG_BW_CONFIG_5:
  92	case IEEE80211_EDMG_BW_CONFIG_9:
  93	case IEEE80211_EDMG_BW_CONFIG_13:
  94		if (max_contiguous < 2)
  95			return false;
  96		break;
  97	case IEEE80211_EDMG_BW_CONFIG_6:
  98	case IEEE80211_EDMG_BW_CONFIG_10:
  99	case IEEE80211_EDMG_BW_CONFIG_14:
 100		if (max_contiguous < 3)
 101			return false;
 102		break;
 103	case IEEE80211_EDMG_BW_CONFIG_7:
 104	case IEEE80211_EDMG_BW_CONFIG_11:
 105	case IEEE80211_EDMG_BW_CONFIG_15:
 106		if (max_contiguous < 4)
 107			return false;
 108		break;
 109
 110	default:
 111		return false;
 112	}
 113
 114	/* check bw_config against aggregated (non contiguous) edmg channels */
 115	switch (chandef->edmg.bw_config) {
 116	case IEEE80211_EDMG_BW_CONFIG_4:
 117	case IEEE80211_EDMG_BW_CONFIG_5:
 118	case IEEE80211_EDMG_BW_CONFIG_6:
 119	case IEEE80211_EDMG_BW_CONFIG_7:
 120		break;
 121	case IEEE80211_EDMG_BW_CONFIG_8:
 122	case IEEE80211_EDMG_BW_CONFIG_9:
 123	case IEEE80211_EDMG_BW_CONFIG_10:
 124	case IEEE80211_EDMG_BW_CONFIG_11:
 125		if (num_of_enabled < 2)
 126			return false;
 127		break;
 128	case IEEE80211_EDMG_BW_CONFIG_12:
 129	case IEEE80211_EDMG_BW_CONFIG_13:
 130	case IEEE80211_EDMG_BW_CONFIG_14:
 131	case IEEE80211_EDMG_BW_CONFIG_15:
 132		if (num_of_enabled < 4 || max_contiguous < 2)
 133			return false;
 134		break;
 135	default:
 136		return false;
 137	}
 138
 139	return true;
 140}
 141
 142bool cfg80211_chandef_valid(const struct cfg80211_chan_def *chandef)
 143{
 144	u32 control_freq;
 145
 146	if (!chandef->chan)
 147		return false;
 148
 149	control_freq = chandef->chan->center_freq;
 150
 151	switch (chandef->width) {
 152	case NL80211_CHAN_WIDTH_5:
 153	case NL80211_CHAN_WIDTH_10:
 154	case NL80211_CHAN_WIDTH_20:
 155	case NL80211_CHAN_WIDTH_20_NOHT:
 156		if (chandef->center_freq1 != control_freq)
 157			return false;
 158		if (chandef->center_freq2)
 159			return false;
 160		break;
 161	case NL80211_CHAN_WIDTH_40:
 162		if (chandef->center_freq1 != control_freq + 10 &&
 163		    chandef->center_freq1 != control_freq - 10)
 164			return false;
 165		if (chandef->center_freq2)
 166			return false;
 167		break;
 168	case NL80211_CHAN_WIDTH_80P80:
 169		if (chandef->center_freq1 != control_freq + 30 &&
 170		    chandef->center_freq1 != control_freq + 10 &&
 171		    chandef->center_freq1 != control_freq - 10 &&
 172		    chandef->center_freq1 != control_freq - 30)
 173			return false;
 174		if (!chandef->center_freq2)
 175			return false;
 176		/* adjacent is not allowed -- that's a 160 MHz channel */
 177		if (chandef->center_freq1 - chandef->center_freq2 == 80 ||
 178		    chandef->center_freq2 - chandef->center_freq1 == 80)
 179			return false;
 180		break;
 181	case NL80211_CHAN_WIDTH_80:
 182		if (chandef->center_freq1 != control_freq + 30 &&
 183		    chandef->center_freq1 != control_freq + 10 &&
 184		    chandef->center_freq1 != control_freq - 10 &&
 185		    chandef->center_freq1 != control_freq - 30)
 186			return false;
 187		if (chandef->center_freq2)
 188			return false;
 189		break;
 190	case NL80211_CHAN_WIDTH_160:
 191		if (chandef->center_freq1 != control_freq + 70 &&
 192		    chandef->center_freq1 != control_freq + 50 &&
 193		    chandef->center_freq1 != control_freq + 30 &&
 194		    chandef->center_freq1 != control_freq + 10 &&
 195		    chandef->center_freq1 != control_freq - 10 &&
 196		    chandef->center_freq1 != control_freq - 30 &&
 197		    chandef->center_freq1 != control_freq - 50 &&
 198		    chandef->center_freq1 != control_freq - 70)
 199			return false;
 200		if (chandef->center_freq2)
 201			return false;
 202		break;
 203	default:
 204		return false;
 205	}
 206
 207	/* channel 14 is only for IEEE 802.11b */
 208	if (chandef->center_freq1 == 2484 &&
 209	    chandef->width != NL80211_CHAN_WIDTH_20_NOHT)
 210		return false;
 211
 212	if (cfg80211_chandef_is_edmg(chandef) &&
 213	    !cfg80211_edmg_chandef_valid(chandef))
 214		return false;
 215
 216	return true;
 217}
 218EXPORT_SYMBOL(cfg80211_chandef_valid);
 219
 220static void chandef_primary_freqs(const struct cfg80211_chan_def *c,
 221				  u32 *pri40, u32 *pri80)
 222{
 223	int tmp;
 224
 225	switch (c->width) {
 226	case NL80211_CHAN_WIDTH_40:
 227		*pri40 = c->center_freq1;
 228		*pri80 = 0;
 229		break;
 230	case NL80211_CHAN_WIDTH_80:
 231	case NL80211_CHAN_WIDTH_80P80:
 232		*pri80 = c->center_freq1;
 233		/* n_P20 */
 234		tmp = (30 + c->chan->center_freq - c->center_freq1)/20;
 235		/* n_P40 */
 236		tmp /= 2;
 237		/* freq_P40 */
 238		*pri40 = c->center_freq1 - 20 + 40 * tmp;
 239		break;
 240	case NL80211_CHAN_WIDTH_160:
 241		/* n_P20 */
 242		tmp = (70 + c->chan->center_freq - c->center_freq1)/20;
 243		/* n_P40 */
 244		tmp /= 2;
 245		/* freq_P40 */
 246		*pri40 = c->center_freq1 - 60 + 40 * tmp;
 247		/* n_P80 */
 248		tmp /= 2;
 249		*pri80 = c->center_freq1 - 40 + 80 * tmp;
 250		break;
 251	default:
 252		WARN_ON_ONCE(1);
 253	}
 254}
 255
 256static int cfg80211_chandef_get_width(const struct cfg80211_chan_def *c)
 257{
 258	int width;
 259
 260	switch (c->width) {
 261	case NL80211_CHAN_WIDTH_5:
 262		width = 5;
 263		break;
 264	case NL80211_CHAN_WIDTH_10:
 265		width = 10;
 266		break;
 267	case NL80211_CHAN_WIDTH_20:
 268	case NL80211_CHAN_WIDTH_20_NOHT:
 269		width = 20;
 270		break;
 271	case NL80211_CHAN_WIDTH_40:
 272		width = 40;
 273		break;
 274	case NL80211_CHAN_WIDTH_80P80:
 275	case NL80211_CHAN_WIDTH_80:
 276		width = 80;
 277		break;
 278	case NL80211_CHAN_WIDTH_160:
 279		width = 160;
 280		break;
 281	default:
 282		WARN_ON_ONCE(1);
 283		return -1;
 284	}
 285	return width;
 286}
 287
 288const struct cfg80211_chan_def *
 289cfg80211_chandef_compatible(const struct cfg80211_chan_def *c1,
 290			    const struct cfg80211_chan_def *c2)
 291{
 292	u32 c1_pri40, c1_pri80, c2_pri40, c2_pri80;
 293
 294	/* If they are identical, return */
 295	if (cfg80211_chandef_identical(c1, c2))
 296		return c1;
 297
 298	/* otherwise, must have same control channel */
 299	if (c1->chan != c2->chan)
 300		return NULL;
 301
 302	/*
 303	 * If they have the same width, but aren't identical,
 304	 * then they can't be compatible.
 305	 */
 306	if (c1->width == c2->width)
 307		return NULL;
 308
 309	/*
 310	 * can't be compatible if one of them is 5 or 10 MHz,
 311	 * but they don't have the same width.
 312	 */
 313	if (c1->width == NL80211_CHAN_WIDTH_5 ||
 314	    c1->width == NL80211_CHAN_WIDTH_10 ||
 315	    c2->width == NL80211_CHAN_WIDTH_5 ||
 316	    c2->width == NL80211_CHAN_WIDTH_10)
 317		return NULL;
 318
 319	if (c1->width == NL80211_CHAN_WIDTH_20_NOHT ||
 320	    c1->width == NL80211_CHAN_WIDTH_20)
 321		return c2;
 322
 323	if (c2->width == NL80211_CHAN_WIDTH_20_NOHT ||
 324	    c2->width == NL80211_CHAN_WIDTH_20)
 325		return c1;
 326
 327	chandef_primary_freqs(c1, &c1_pri40, &c1_pri80);
 328	chandef_primary_freqs(c2, &c2_pri40, &c2_pri80);
 329
 330	if (c1_pri40 != c2_pri40)
 331		return NULL;
 332
 333	WARN_ON(!c1_pri80 && !c2_pri80);
 334	if (c1_pri80 && c2_pri80 && c1_pri80 != c2_pri80)
 335		return NULL;
 336
 337	if (c1->width > c2->width)
 338		return c1;
 339	return c2;
 340}
 341EXPORT_SYMBOL(cfg80211_chandef_compatible);
 342
 343static void cfg80211_set_chans_dfs_state(struct wiphy *wiphy, u32 center_freq,
 344					 u32 bandwidth,
 345					 enum nl80211_dfs_state dfs_state)
 346{
 347	struct ieee80211_channel *c;
 348	u32 freq;
 349
 350	for (freq = center_freq - bandwidth/2 + 10;
 351	     freq <= center_freq + bandwidth/2 - 10;
 352	     freq += 20) {
 353		c = ieee80211_get_channel(wiphy, freq);
 354		if (!c || !(c->flags & IEEE80211_CHAN_RADAR))
 355			continue;
 356
 357		c->dfs_state = dfs_state;
 358		c->dfs_state_entered = jiffies;
 359	}
 360}
 361
 362void cfg80211_set_dfs_state(struct wiphy *wiphy,
 363			    const struct cfg80211_chan_def *chandef,
 364			    enum nl80211_dfs_state dfs_state)
 365{
 366	int width;
 367
 368	if (WARN_ON(!cfg80211_chandef_valid(chandef)))
 369		return;
 370
 371	width = cfg80211_chandef_get_width(chandef);
 372	if (width < 0)
 373		return;
 374
 375	cfg80211_set_chans_dfs_state(wiphy, chandef->center_freq1,
 376				     width, dfs_state);
 377
 378	if (!chandef->center_freq2)
 379		return;
 380	cfg80211_set_chans_dfs_state(wiphy, chandef->center_freq2,
 381				     width, dfs_state);
 382}
 383
 384static u32 cfg80211_get_start_freq(u32 center_freq,
 385				   u32 bandwidth)
 386{
 387	u32 start_freq;
 388
 389	if (bandwidth <= 20)
 390		start_freq = center_freq;
 391	else
 392		start_freq = center_freq - bandwidth/2 + 10;
 393
 394	return start_freq;
 395}
 396
 397static u32 cfg80211_get_end_freq(u32 center_freq,
 398				 u32 bandwidth)
 399{
 400	u32 end_freq;
 401
 402	if (bandwidth <= 20)
 403		end_freq = center_freq;
 404	else
 405		end_freq = center_freq + bandwidth/2 - 10;
 406
 407	return end_freq;
 408}
 409
 410static int cfg80211_get_chans_dfs_required(struct wiphy *wiphy,
 411					    u32 center_freq,
 412					    u32 bandwidth)
 413{
 414	struct ieee80211_channel *c;
 415	u32 freq, start_freq, end_freq;
 416
 417	start_freq = cfg80211_get_start_freq(center_freq, bandwidth);
 418	end_freq = cfg80211_get_end_freq(center_freq, bandwidth);
 419
 420	for (freq = start_freq; freq <= end_freq; freq += 20) {
 421		c = ieee80211_get_channel(wiphy, freq);
 422		if (!c)
 423			return -EINVAL;
 424
 425		if (c->flags & IEEE80211_CHAN_RADAR)
 426			return 1;
 427	}
 428	return 0;
 429}
 430
 431
 432int cfg80211_chandef_dfs_required(struct wiphy *wiphy,
 433				  const struct cfg80211_chan_def *chandef,
 434				  enum nl80211_iftype iftype)
 435{
 436	int width;
 437	int ret;
 438
 439	if (WARN_ON(!cfg80211_chandef_valid(chandef)))
 440		return -EINVAL;
 441
 442	switch (iftype) {
 443	case NL80211_IFTYPE_ADHOC:
 444	case NL80211_IFTYPE_AP:
 445	case NL80211_IFTYPE_P2P_GO:
 446	case NL80211_IFTYPE_MESH_POINT:
 447		width = cfg80211_chandef_get_width(chandef);
 448		if (width < 0)
 449			return -EINVAL;
 450
 451		ret = cfg80211_get_chans_dfs_required(wiphy,
 452						      chandef->center_freq1,
 453						      width);
 454		if (ret < 0)
 455			return ret;
 456		else if (ret > 0)
 457			return BIT(chandef->width);
 458
 459		if (!chandef->center_freq2)
 460			return 0;
 461
 462		ret = cfg80211_get_chans_dfs_required(wiphy,
 463						      chandef->center_freq2,
 464						      width);
 465		if (ret < 0)
 466			return ret;
 467		else if (ret > 0)
 468			return BIT(chandef->width);
 469
 470		break;
 471	case NL80211_IFTYPE_STATION:
 472	case NL80211_IFTYPE_OCB:
 473	case NL80211_IFTYPE_P2P_CLIENT:
 474	case NL80211_IFTYPE_MONITOR:
 475	case NL80211_IFTYPE_AP_VLAN:
 476	case NL80211_IFTYPE_WDS:
 477	case NL80211_IFTYPE_P2P_DEVICE:
 478	case NL80211_IFTYPE_NAN:
 479		break;
 480	case NL80211_IFTYPE_UNSPECIFIED:
 481	case NUM_NL80211_IFTYPES:
 482		WARN_ON(1);
 483	}
 484
 485	return 0;
 486}
 487EXPORT_SYMBOL(cfg80211_chandef_dfs_required);
 488
 489static int cfg80211_get_chans_dfs_usable(struct wiphy *wiphy,
 490					 u32 center_freq,
 491					 u32 bandwidth)
 492{
 493	struct ieee80211_channel *c;
 494	u32 freq, start_freq, end_freq;
 495	int count = 0;
 496
 497	start_freq = cfg80211_get_start_freq(center_freq, bandwidth);
 498	end_freq = cfg80211_get_end_freq(center_freq, bandwidth);
 499
 500	/*
 501	 * Check entire range of channels for the bandwidth.
 502	 * Check all channels are DFS channels (DFS_USABLE or
 503	 * DFS_AVAILABLE). Return number of usable channels
 504	 * (require CAC). Allow DFS and non-DFS channel mix.
 505	 */
 506	for (freq = start_freq; freq <= end_freq; freq += 20) {
 507		c = ieee80211_get_channel(wiphy, freq);
 508		if (!c)
 509			return -EINVAL;
 510
 511		if (c->flags & IEEE80211_CHAN_DISABLED)
 512			return -EINVAL;
 513
 514		if (c->flags & IEEE80211_CHAN_RADAR) {
 515			if (c->dfs_state == NL80211_DFS_UNAVAILABLE)
 516				return -EINVAL;
 517
 518			if (c->dfs_state == NL80211_DFS_USABLE)
 519				count++;
 520		}
 521	}
 522
 523	return count;
 524}
 525
 526bool cfg80211_chandef_dfs_usable(struct wiphy *wiphy,
 527				 const struct cfg80211_chan_def *chandef)
 528{
 529	int width;
 530	int r1, r2 = 0;
 531
 532	if (WARN_ON(!cfg80211_chandef_valid(chandef)))
 533		return false;
 534
 535	width = cfg80211_chandef_get_width(chandef);
 536	if (width < 0)
 537		return false;
 538
 539	r1 = cfg80211_get_chans_dfs_usable(wiphy, chandef->center_freq1,
 540					  width);
 541
 542	if (r1 < 0)
 543		return false;
 544
 545	switch (chandef->width) {
 546	case NL80211_CHAN_WIDTH_80P80:
 547		WARN_ON(!chandef->center_freq2);
 548		r2 = cfg80211_get_chans_dfs_usable(wiphy,
 549						   chandef->center_freq2,
 550						   width);
 551		if (r2 < 0)
 552			return false;
 553		break;
 554	default:
 555		WARN_ON(chandef->center_freq2);
 556		break;
 557	}
 558
 559	return (r1 + r2 > 0);
 560}
 561
 562/*
 563 * Checks if center frequency of chan falls with in the bandwidth
 564 * range of chandef.
 565 */
 566bool cfg80211_is_sub_chan(struct cfg80211_chan_def *chandef,
 567			  struct ieee80211_channel *chan)
 568{
 569	int width;
 570	u32 freq;
 571
 572	if (chandef->chan->center_freq == chan->center_freq)
 573		return true;
 574
 575	width = cfg80211_chandef_get_width(chandef);
 576	if (width <= 20)
 577		return false;
 578
 579	for (freq = chandef->center_freq1 - width / 2 + 10;
 580	     freq <= chandef->center_freq1 + width / 2 - 10; freq += 20) {
 581		if (chan->center_freq == freq)
 582			return true;
 583	}
 584
 585	if (!chandef->center_freq2)
 586		return false;
 587
 588	for (freq = chandef->center_freq2 - width / 2 + 10;
 589	     freq <= chandef->center_freq2 + width / 2 - 10; freq += 20) {
 590		if (chan->center_freq == freq)
 591			return true;
 592	}
 593
 594	return false;
 595}
 596
 597bool cfg80211_beaconing_iface_active(struct wireless_dev *wdev)
 598{
 599	bool active = false;
 600
 601	ASSERT_WDEV_LOCK(wdev);
 602
 603	if (!wdev->chandef.chan)
 604		return false;
 605
 606	switch (wdev->iftype) {
 607	case NL80211_IFTYPE_AP:
 608	case NL80211_IFTYPE_P2P_GO:
 609		active = wdev->beacon_interval != 0;
 610		break;
 611	case NL80211_IFTYPE_ADHOC:
 612		active = wdev->ssid_len != 0;
 613		break;
 614	case NL80211_IFTYPE_MESH_POINT:
 615		active = wdev->mesh_id_len != 0;
 616		break;
 617	case NL80211_IFTYPE_STATION:
 618	case NL80211_IFTYPE_OCB:
 619	case NL80211_IFTYPE_P2P_CLIENT:
 620	case NL80211_IFTYPE_MONITOR:
 621	case NL80211_IFTYPE_AP_VLAN:
 622	case NL80211_IFTYPE_WDS:
 623	case NL80211_IFTYPE_P2P_DEVICE:
 624	/* Can NAN type be considered as beaconing interface? */
 625	case NL80211_IFTYPE_NAN:
 626		break;
 627	case NL80211_IFTYPE_UNSPECIFIED:
 628	case NUM_NL80211_IFTYPES:
 629		WARN_ON(1);
 630	}
 631
 632	return active;
 633}
 634
 635static bool cfg80211_is_wiphy_oper_chan(struct wiphy *wiphy,
 636					struct ieee80211_channel *chan)
 637{
 638	struct wireless_dev *wdev;
 639
 640	list_for_each_entry(wdev, &wiphy->wdev_list, list) {
 641		wdev_lock(wdev);
 642		if (!cfg80211_beaconing_iface_active(wdev)) {
 643			wdev_unlock(wdev);
 644			continue;
 645		}
 646
 647		if (cfg80211_is_sub_chan(&wdev->chandef, chan)) {
 648			wdev_unlock(wdev);
 649			return true;
 650		}
 651		wdev_unlock(wdev);
 652	}
 653
 654	return false;
 655}
 656
 657bool cfg80211_any_wiphy_oper_chan(struct wiphy *wiphy,
 658				  struct ieee80211_channel *chan)
 659{
 660	struct cfg80211_registered_device *rdev;
 661
 662	ASSERT_RTNL();
 663
 664	if (!(chan->flags & IEEE80211_CHAN_RADAR))
 665		return false;
 666
 667	list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
 668		if (!reg_dfs_domain_same(wiphy, &rdev->wiphy))
 669			continue;
 670
 671		if (cfg80211_is_wiphy_oper_chan(&rdev->wiphy, chan))
 672			return true;
 673	}
 674
 675	return false;
 676}
 677
 678static bool cfg80211_get_chans_dfs_available(struct wiphy *wiphy,
 679					     u32 center_freq,
 680					     u32 bandwidth)
 681{
 682	struct ieee80211_channel *c;
 683	u32 freq, start_freq, end_freq;
 684	bool dfs_offload;
 685
 686	dfs_offload = wiphy_ext_feature_isset(wiphy,
 687					      NL80211_EXT_FEATURE_DFS_OFFLOAD);
 688
 689	start_freq = cfg80211_get_start_freq(center_freq, bandwidth);
 690	end_freq = cfg80211_get_end_freq(center_freq, bandwidth);
 691
 692	/*
 693	 * Check entire range of channels for the bandwidth.
 694	 * If any channel in between is disabled or has not
 695	 * had gone through CAC return false
 696	 */
 697	for (freq = start_freq; freq <= end_freq; freq += 20) {
 698		c = ieee80211_get_channel(wiphy, freq);
 699		if (!c)
 700			return false;
 701
 702		if (c->flags & IEEE80211_CHAN_DISABLED)
 703			return false;
 704
 705		if ((c->flags & IEEE80211_CHAN_RADAR) &&
 706		    (c->dfs_state != NL80211_DFS_AVAILABLE) &&
 707		    !(c->dfs_state == NL80211_DFS_USABLE && dfs_offload))
 708			return false;
 709	}
 710
 711	return true;
 712}
 713
 714static bool cfg80211_chandef_dfs_available(struct wiphy *wiphy,
 715				const struct cfg80211_chan_def *chandef)
 716{
 717	int width;
 718	int r;
 719
 720	if (WARN_ON(!cfg80211_chandef_valid(chandef)))
 721		return false;
 722
 723	width = cfg80211_chandef_get_width(chandef);
 724	if (width < 0)
 725		return false;
 726
 727	r = cfg80211_get_chans_dfs_available(wiphy, chandef->center_freq1,
 728					     width);
 729
 730	/* If any of channels unavailable for cf1 just return */
 731	if (!r)
 732		return r;
 733
 734	switch (chandef->width) {
 735	case NL80211_CHAN_WIDTH_80P80:
 736		WARN_ON(!chandef->center_freq2);
 737		r = cfg80211_get_chans_dfs_available(wiphy,
 738						     chandef->center_freq2,
 739						     width);
 740		break;
 741	default:
 742		WARN_ON(chandef->center_freq2);
 743		break;
 744	}
 745
 746	return r;
 747}
 748
 749static unsigned int cfg80211_get_chans_dfs_cac_time(struct wiphy *wiphy,
 750						    u32 center_freq,
 751						    u32 bandwidth)
 752{
 753	struct ieee80211_channel *c;
 754	u32 start_freq, end_freq, freq;
 755	unsigned int dfs_cac_ms = 0;
 756
 757	start_freq = cfg80211_get_start_freq(center_freq, bandwidth);
 758	end_freq = cfg80211_get_end_freq(center_freq, bandwidth);
 759
 760	for (freq = start_freq; freq <= end_freq; freq += 20) {
 761		c = ieee80211_get_channel(wiphy, freq);
 762		if (!c)
 763			return 0;
 764
 765		if (c->flags & IEEE80211_CHAN_DISABLED)
 766			return 0;
 767
 768		if (!(c->flags & IEEE80211_CHAN_RADAR))
 769			continue;
 770
 771		if (c->dfs_cac_ms > dfs_cac_ms)
 772			dfs_cac_ms = c->dfs_cac_ms;
 773	}
 774
 775	return dfs_cac_ms;
 776}
 777
 778unsigned int
 779cfg80211_chandef_dfs_cac_time(struct wiphy *wiphy,
 780			      const struct cfg80211_chan_def *chandef)
 781{
 782	int width;
 783	unsigned int t1 = 0, t2 = 0;
 784
 785	if (WARN_ON(!cfg80211_chandef_valid(chandef)))
 786		return 0;
 787
 788	width = cfg80211_chandef_get_width(chandef);
 789	if (width < 0)
 790		return 0;
 791
 792	t1 = cfg80211_get_chans_dfs_cac_time(wiphy,
 793					     chandef->center_freq1,
 794					     width);
 795
 796	if (!chandef->center_freq2)
 797		return t1;
 798
 799	t2 = cfg80211_get_chans_dfs_cac_time(wiphy,
 800					     chandef->center_freq2,
 801					     width);
 802
 803	return max(t1, t2);
 804}
 805
 806static bool cfg80211_secondary_chans_ok(struct wiphy *wiphy,
 807					u32 center_freq, u32 bandwidth,
 808					u32 prohibited_flags)
 809{
 810	struct ieee80211_channel *c;
 811	u32 freq, start_freq, end_freq;
 812
 813	start_freq = cfg80211_get_start_freq(center_freq, bandwidth);
 814	end_freq = cfg80211_get_end_freq(center_freq, bandwidth);
 815
 816	for (freq = start_freq; freq <= end_freq; freq += 20) {
 817		c = ieee80211_get_channel(wiphy, freq);
 818		if (!c || c->flags & prohibited_flags)
 819			return false;
 820	}
 821
 822	return true;
 823}
 824
 825/* check if the operating channels are valid and supported */
 826static bool cfg80211_edmg_usable(struct wiphy *wiphy, u8 edmg_channels,
 827				 enum ieee80211_edmg_bw_config edmg_bw_config,
 828				 int primary_channel,
 829				 struct ieee80211_edmg *edmg_cap)
 830{
 831	struct ieee80211_channel *chan;
 832	int i, freq;
 833	int channels_counter = 0;
 834
 835	if (!edmg_channels && !edmg_bw_config)
 836		return true;
 837
 838	if ((!edmg_channels && edmg_bw_config) ||
 839	    (edmg_channels && !edmg_bw_config))
 840		return false;
 841
 842	if (!(edmg_channels & BIT(primary_channel - 1)))
 843		return false;
 844
 845	/* 60GHz channels 1..6 */
 846	for (i = 0; i < 6; i++) {
 847		if (!(edmg_channels & BIT(i)))
 848			continue;
 849
 850		if (!(edmg_cap->channels & BIT(i)))
 851			return false;
 852
 853		channels_counter++;
 854
 855		freq = ieee80211_channel_to_frequency(i + 1,
 856						      NL80211_BAND_60GHZ);
 857		chan = ieee80211_get_channel(wiphy, freq);
 858		if (!chan || chan->flags & IEEE80211_CHAN_DISABLED)
 859			return false;
 860	}
 861
 862	/* IEEE802.11 allows max 4 channels */
 863	if (channels_counter > 4)
 864		return false;
 865
 866	/* check bw_config is a subset of what driver supports
 867	 * (see IEEE P802.11ay/D4.0 section 9.4.2.251, Table 13)
 868	 */
 869	if ((edmg_bw_config % 4) > (edmg_cap->bw_config % 4))
 870		return false;
 871
 872	if (edmg_bw_config > edmg_cap->bw_config)
 873		return false;
 874
 875	return true;
 876}
 877
 878bool cfg80211_chandef_usable(struct wiphy *wiphy,
 879			     const struct cfg80211_chan_def *chandef,
 880			     u32 prohibited_flags)
 881{
 882	struct ieee80211_sta_ht_cap *ht_cap;
 883	struct ieee80211_sta_vht_cap *vht_cap;
 884	struct ieee80211_edmg *edmg_cap;
 885	u32 width, control_freq, cap;
 886
 887	if (WARN_ON(!cfg80211_chandef_valid(chandef)))
 888		return false;
 889
 890	ht_cap = &wiphy->bands[chandef->chan->band]->ht_cap;
 891	vht_cap = &wiphy->bands[chandef->chan->band]->vht_cap;
 892	edmg_cap = &wiphy->bands[chandef->chan->band]->edmg_cap;
 893
 894	if (edmg_cap->channels &&
 895	    !cfg80211_edmg_usable(wiphy,
 896				  chandef->edmg.channels,
 897				  chandef->edmg.bw_config,
 898				  chandef->chan->hw_value,
 899				  edmg_cap))
 900		return false;
 901
 902	control_freq = chandef->chan->center_freq;
 903
 904	switch (chandef->width) {
 905	case NL80211_CHAN_WIDTH_5:
 906		width = 5;
 907		break;
 908	case NL80211_CHAN_WIDTH_10:
 909		prohibited_flags |= IEEE80211_CHAN_NO_10MHZ;
 910		width = 10;
 911		break;
 912	case NL80211_CHAN_WIDTH_20:
 913		if (!ht_cap->ht_supported)
 914			return false;
 915		/* fall through */
 916	case NL80211_CHAN_WIDTH_20_NOHT:
 917		prohibited_flags |= IEEE80211_CHAN_NO_20MHZ;
 918		width = 20;
 919		break;
 920	case NL80211_CHAN_WIDTH_40:
 921		width = 40;
 922		if (!ht_cap->ht_supported)
 923			return false;
 924		if (!(ht_cap->cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40) ||
 925		    ht_cap->cap & IEEE80211_HT_CAP_40MHZ_INTOLERANT)
 926			return false;
 927		if (chandef->center_freq1 < control_freq &&
 928		    chandef->chan->flags & IEEE80211_CHAN_NO_HT40MINUS)
 929			return false;
 930		if (chandef->center_freq1 > control_freq &&
 931		    chandef->chan->flags & IEEE80211_CHAN_NO_HT40PLUS)
 932			return false;
 933		break;
 934	case NL80211_CHAN_WIDTH_80P80:
 935		cap = vht_cap->cap & IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_MASK;
 936		if (cap != IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ)
 937			return false;
 938		/* fall through */
 939	case NL80211_CHAN_WIDTH_80:
 940		if (!vht_cap->vht_supported)
 941			return false;
 942		prohibited_flags |= IEEE80211_CHAN_NO_80MHZ;
 943		width = 80;
 944		break;
 945	case NL80211_CHAN_WIDTH_160:
 946		if (!vht_cap->vht_supported)
 947			return false;
 948		cap = vht_cap->cap & IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_MASK;
 949		if (cap != IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160MHZ &&
 950		    cap != IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ)
 951			return false;
 952		prohibited_flags |= IEEE80211_CHAN_NO_160MHZ;
 953		width = 160;
 954		break;
 955	default:
 956		WARN_ON_ONCE(1);
 957		return false;
 958	}
 959
 960	/*
 961	 * TODO: What if there are only certain 80/160/80+80 MHz channels
 962	 *	 allowed by the driver, or only certain combinations?
 963	 *	 For 40 MHz the driver can set the NO_HT40 flags, but for
 964	 *	 80/160 MHz and in particular 80+80 MHz this isn't really
 965	 *	 feasible and we only have NO_80MHZ/NO_160MHZ so far but
 966	 *	 no way to cover 80+80 MHz or more complex restrictions.
 967	 *	 Note that such restrictions also need to be advertised to
 968	 *	 userspace, for example for P2P channel selection.
 969	 */
 970
 971	if (width > 20)
 972		prohibited_flags |= IEEE80211_CHAN_NO_OFDM;
 973
 974	/* 5 and 10 MHz are only defined for the OFDM PHY */
 975	if (width < 20)
 976		prohibited_flags |= IEEE80211_CHAN_NO_OFDM;
 977
 978
 979	if (!cfg80211_secondary_chans_ok(wiphy, chandef->center_freq1,
 980					 width, prohibited_flags))
 981		return false;
 982
 983	if (!chandef->center_freq2)
 984		return true;
 985	return cfg80211_secondary_chans_ok(wiphy, chandef->center_freq2,
 986					   width, prohibited_flags);
 987}
 988EXPORT_SYMBOL(cfg80211_chandef_usable);
 989
 990/*
 991 * Check if the channel can be used under permissive conditions mandated by
 992 * some regulatory bodies, i.e., the channel is marked with
 993 * IEEE80211_CHAN_IR_CONCURRENT and there is an additional station interface
 994 * associated to an AP on the same channel or on the same UNII band
 995 * (assuming that the AP is an authorized master).
 996 * In addition allow operation on a channel on which indoor operation is
 997 * allowed, iff we are currently operating in an indoor environment.
 998 */
 999static bool cfg80211_ir_permissive_chan(struct wiphy *wiphy,
1000					enum nl80211_iftype iftype,
1001					struct ieee80211_channel *chan)
1002{
1003	struct wireless_dev *wdev;
1004	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
1005
1006	ASSERT_RTNL();
1007
1008	if (!IS_ENABLED(CONFIG_CFG80211_REG_RELAX_NO_IR) ||
1009	    !(wiphy->regulatory_flags & REGULATORY_ENABLE_RELAX_NO_IR))
1010		return false;
1011
1012	/* only valid for GO and TDLS off-channel (station/p2p-CL) */
1013	if (iftype != NL80211_IFTYPE_P2P_GO &&
1014	    iftype != NL80211_IFTYPE_STATION &&
1015	    iftype != NL80211_IFTYPE_P2P_CLIENT)
1016		return false;
1017
1018	if (regulatory_indoor_allowed() &&
1019	    (chan->flags & IEEE80211_CHAN_INDOOR_ONLY))
1020		return true;
1021
1022	if (!(chan->flags & IEEE80211_CHAN_IR_CONCURRENT))
1023		return false;
1024
1025	/*
1026	 * Generally, it is possible to rely on another device/driver to allow
1027	 * the IR concurrent relaxation, however, since the device can further
1028	 * enforce the relaxation (by doing a similar verifications as this),
1029	 * and thus fail the GO instantiation, consider only the interfaces of
1030	 * the current registered device.
1031	 */
1032	list_for_each_entry(wdev, &rdev->wiphy.wdev_list, list) {
1033		struct ieee80211_channel *other_chan = NULL;
1034		int r1, r2;
1035
1036		wdev_lock(wdev);
1037		if (wdev->iftype == NL80211_IFTYPE_STATION &&
1038		    wdev->current_bss)
1039			other_chan = wdev->current_bss->pub.channel;
1040
1041		/*
1042		 * If a GO already operates on the same GO_CONCURRENT channel,
1043		 * this one (maybe the same one) can beacon as well. We allow
1044		 * the operation even if the station we relied on with
1045		 * GO_CONCURRENT is disconnected now. But then we must make sure
1046		 * we're not outdoor on an indoor-only channel.
1047		 */
1048		if (iftype == NL80211_IFTYPE_P2P_GO &&
1049		    wdev->iftype == NL80211_IFTYPE_P2P_GO &&
1050		    wdev->beacon_interval &&
1051		    !(chan->flags & IEEE80211_CHAN_INDOOR_ONLY))
1052			other_chan = wdev->chandef.chan;
1053		wdev_unlock(wdev);
1054
1055		if (!other_chan)
1056			continue;
1057
1058		if (chan == other_chan)
1059			return true;
1060
1061		if (chan->band != NL80211_BAND_5GHZ &&
1062		    chan->band != NL80211_BAND_6GHZ)
1063			continue;
1064
1065		r1 = cfg80211_get_unii(chan->center_freq);
1066		r2 = cfg80211_get_unii(other_chan->center_freq);
1067
1068		if (r1 != -EINVAL && r1 == r2) {
1069			/*
1070			 * At some locations channels 149-165 are considered a
1071			 * bundle, but at other locations, e.g., Indonesia,
1072			 * channels 149-161 are considered a bundle while
1073			 * channel 165 is left out and considered to be in a
1074			 * different bundle. Thus, in case that there is a
1075			 * station interface connected to an AP on channel 165,
1076			 * it is assumed that channels 149-161 are allowed for
1077			 * GO operations. However, having a station interface
1078			 * connected to an AP on channels 149-161, does not
1079			 * allow GO operation on channel 165.
1080			 */
1081			if (chan->center_freq == 5825 &&
1082			    other_chan->center_freq != 5825)
1083				continue;
1084			return true;
1085		}
1086	}
1087
1088	return false;
1089}
1090
1091static bool _cfg80211_reg_can_beacon(struct wiphy *wiphy,
1092				     struct cfg80211_chan_def *chandef,
1093				     enum nl80211_iftype iftype,
1094				     bool check_no_ir)
1095{
1096	bool res;
1097	u32 prohibited_flags = IEEE80211_CHAN_DISABLED |
1098			       IEEE80211_CHAN_RADAR;
1099
1100	trace_cfg80211_reg_can_beacon(wiphy, chandef, iftype, check_no_ir);
1101
1102	if (check_no_ir)
1103		prohibited_flags |= IEEE80211_CHAN_NO_IR;
1104
1105	if (cfg80211_chandef_dfs_required(wiphy, chandef, iftype) > 0 &&
1106	    cfg80211_chandef_dfs_available(wiphy, chandef)) {
1107		/* We can skip IEEE80211_CHAN_NO_IR if chandef dfs available */
1108		prohibited_flags = IEEE80211_CHAN_DISABLED;
1109	}
1110
1111	res = cfg80211_chandef_usable(wiphy, chandef, prohibited_flags);
1112
1113	trace_cfg80211_return_bool(res);
1114	return res;
1115}
1116
1117bool cfg80211_reg_can_beacon(struct wiphy *wiphy,
1118			     struct cfg80211_chan_def *chandef,
1119			     enum nl80211_iftype iftype)
1120{
1121	return _cfg80211_reg_can_beacon(wiphy, chandef, iftype, true);
1122}
1123EXPORT_SYMBOL(cfg80211_reg_can_beacon);
1124
1125bool cfg80211_reg_can_beacon_relax(struct wiphy *wiphy,
1126				   struct cfg80211_chan_def *chandef,
1127				   enum nl80211_iftype iftype)
1128{
1129	bool check_no_ir;
1130
1131	ASSERT_RTNL();
1132
1133	/*
1134	 * Under certain conditions suggested by some regulatory bodies a
1135	 * GO/STA can IR on channels marked with IEEE80211_NO_IR. Set this flag
1136	 * only if such relaxations are not enabled and the conditions are not
1137	 * met.
1138	 */
1139	check_no_ir = !cfg80211_ir_permissive_chan(wiphy, iftype,
1140						   chandef->chan);
1141
1142	return _cfg80211_reg_can_beacon(wiphy, chandef, iftype, check_no_ir);
1143}
1144EXPORT_SYMBOL(cfg80211_reg_can_beacon_relax);
1145
1146int cfg80211_set_monitor_channel(struct cfg80211_registered_device *rdev,
1147				 struct cfg80211_chan_def *chandef)
1148{
1149	if (!rdev->ops->set_monitor_channel)
1150		return -EOPNOTSUPP;
1151	if (!cfg80211_has_monitors_only(rdev))
1152		return -EBUSY;
1153
1154	return rdev_set_monitor_channel(rdev, chandef);
1155}
1156
1157void
1158cfg80211_get_chan_state(struct wireless_dev *wdev,
1159		        struct ieee80211_channel **chan,
1160		        enum cfg80211_chan_mode *chanmode,
1161		        u8 *radar_detect)
1162{
1163	int ret;
1164
1165	*chan = NULL;
1166	*chanmode = CHAN_MODE_UNDEFINED;
1167
1168	ASSERT_WDEV_LOCK(wdev);
1169
1170	if (wdev->netdev && !netif_running(wdev->netdev))
1171		return;
1172
1173	switch (wdev->iftype) {
1174	case NL80211_IFTYPE_ADHOC:
1175		if (wdev->current_bss) {
1176			*chan = wdev->current_bss->pub.channel;
1177			*chanmode = (wdev->ibss_fixed &&
1178				     !wdev->ibss_dfs_possible)
1179				  ? CHAN_MODE_SHARED
1180				  : CHAN_MODE_EXCLUSIVE;
1181
1182			/* consider worst-case - IBSS can try to return to the
1183			 * original user-specified channel as creator */
1184			if (wdev->ibss_dfs_possible)
1185				*radar_detect |= BIT(wdev->chandef.width);
1186			return;
1187		}
1188		break;
1189	case NL80211_IFTYPE_STATION:
1190	case NL80211_IFTYPE_P2P_CLIENT:
1191		if (wdev->current_bss) {
1192			*chan = wdev->current_bss->pub.channel;
1193			*chanmode = CHAN_MODE_SHARED;
1194			return;
1195		}
1196		break;
1197	case NL80211_IFTYPE_AP:
1198	case NL80211_IFTYPE_P2P_GO:
1199		if (wdev->cac_started) {
1200			*chan = wdev->chandef.chan;
1201			*chanmode = CHAN_MODE_SHARED;
1202			*radar_detect |= BIT(wdev->chandef.width);
1203		} else if (wdev->beacon_interval) {
1204			*chan = wdev->chandef.chan;
1205			*chanmode = CHAN_MODE_SHARED;
1206
1207			ret = cfg80211_chandef_dfs_required(wdev->wiphy,
1208							    &wdev->chandef,
1209							    wdev->iftype);
1210			WARN_ON(ret < 0);
1211			if (ret > 0)
1212				*radar_detect |= BIT(wdev->chandef.width);
1213		}
1214		return;
1215	case NL80211_IFTYPE_MESH_POINT:
1216		if (wdev->mesh_id_len) {
1217			*chan = wdev->chandef.chan;
1218			*chanmode = CHAN_MODE_SHARED;
1219
1220			ret = cfg80211_chandef_dfs_required(wdev->wiphy,
1221							    &wdev->chandef,
1222							    wdev->iftype);
1223			WARN_ON(ret < 0);
1224			if (ret > 0)
1225				*radar_detect |= BIT(wdev->chandef.width);
1226		}
1227		return;
1228	case NL80211_IFTYPE_OCB:
1229		if (wdev->chandef.chan) {
1230			*chan = wdev->chandef.chan;
1231			*chanmode = CHAN_MODE_SHARED;
1232			return;
1233		}
1234		break;
1235	case NL80211_IFTYPE_MONITOR:
1236	case NL80211_IFTYPE_AP_VLAN:
1237	case NL80211_IFTYPE_WDS:
1238	case NL80211_IFTYPE_P2P_DEVICE:
1239	case NL80211_IFTYPE_NAN:
1240		/* these interface types don't really have a channel */
1241		return;
1242	case NL80211_IFTYPE_UNSPECIFIED:
1243	case NUM_NL80211_IFTYPES:
1244		WARN_ON(1);
1245	}
1246}