cfg.c 111.7 KB
Newer Older
1
// SPDX-License-Identifier: GPL-2.0-only
2 3 4
/*
 * mac80211 configuration hooks for cfg80211
 *
5
 * Copyright 2006-2010	Johannes Berg <johannes@sipsolutions.net>
6
 * Copyright 2013-2015  Intel Mobile Communications GmbH
7
 * Copyright (C) 2015-2017 Intel Deutschland GmbH
8
 * Copyright (C) 2018-2020 Intel Corporation
9 10
 */

11
#include <linux/ieee80211.h>
12 13
#include <linux/nl80211.h>
#include <linux/rtnetlink.h>
14
#include <linux/slab.h>
15
#include <net/net_namespace.h>
16
#include <linux/rcupdate.h>
17
#include <linux/fips.h>
18
#include <linux/if_ether.h>
19 20
#include <net/cfg80211.h>
#include "ieee80211_i.h"
21
#include "driver-ops.h"
J
Johannes Berg 已提交
22
#include "rate.h"
23
#include "mesh.h"
24
#include "wme.h"
25

26 27
static void ieee80211_set_mu_mimo_follow(struct ieee80211_sub_if_data *sdata,
					 struct vif_params *params)
28 29 30 31 32 33 34 35 36
{
	bool mu_mimo_groups = false;
	bool mu_mimo_follow = false;

	if (params->vht_mumimo_groups) {
		u64 membership;

		BUILD_BUG_ON(sizeof(membership) != WLAN_MEMBERSHIP_LEN);

37
		memcpy(sdata->vif.bss_conf.mu_group.membership,
38
		       params->vht_mumimo_groups, WLAN_MEMBERSHIP_LEN);
39
		memcpy(sdata->vif.bss_conf.mu_group.position,
40 41
		       params->vht_mumimo_groups + WLAN_MEMBERSHIP_LEN,
		       WLAN_USER_POSITION_LEN);
42
		ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_MU_GROUPS);
43 44 45 46 47 48 49 50 51
		/* don't care about endianness - just check for 0 */
		memcpy(&membership, params->vht_mumimo_groups,
		       WLAN_MEMBERSHIP_LEN);
		mu_mimo_groups = membership != 0;
	}

	if (params->vht_mumimo_follow_addr) {
		mu_mimo_follow =
			is_valid_ether_addr(params->vht_mumimo_follow_addr);
52
		ether_addr_copy(sdata->u.mntr.mu_follow_addr,
53 54 55
				params->vht_mumimo_follow_addr);
	}

56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109
	sdata->vif.mu_mimo_owner = mu_mimo_groups || mu_mimo_follow;
}

static int ieee80211_set_mon_options(struct ieee80211_sub_if_data *sdata,
				     struct vif_params *params)
{
	struct ieee80211_local *local = sdata->local;
	struct ieee80211_sub_if_data *monitor_sdata;

	/* check flags first */
	if (params->flags && ieee80211_sdata_running(sdata)) {
		u32 mask = MONITOR_FLAG_COOK_FRAMES | MONITOR_FLAG_ACTIVE;

		/*
		 * Prohibit MONITOR_FLAG_COOK_FRAMES and
		 * MONITOR_FLAG_ACTIVE to be changed while the
		 * interface is up.
		 * Else we would need to add a lot of cruft
		 * to update everything:
		 *	cooked_mntrs, monitor and all fif_* counters
		 *	reconfigure hardware
		 */
		if ((params->flags & mask) != (sdata->u.mntr.flags & mask))
			return -EBUSY;
	}

	/* also validate MU-MIMO change */
	monitor_sdata = rtnl_dereference(local->monitor_sdata);

	if (!monitor_sdata &&
	    (params->vht_mumimo_groups || params->vht_mumimo_follow_addr))
		return -EOPNOTSUPP;

	/* apply all changes now - no failures allowed */

	if (monitor_sdata)
		ieee80211_set_mu_mimo_follow(monitor_sdata, params);

	if (params->flags) {
		if (ieee80211_sdata_running(sdata)) {
			ieee80211_adjust_monitor_flags(sdata, -1);
			sdata->u.mntr.flags = params->flags;
			ieee80211_adjust_monitor_flags(sdata, 1);

			ieee80211_configure_filter(local);
		} else {
			/*
			 * Because the interface is down, ieee80211_do_stop
			 * and ieee80211_do_open take care of "everything"
			 * mentioned in the comment above.
			 */
			sdata->u.mntr.flags = params->flags;
		}
	}
110 111 112 113

	return 0;
}

114 115
static struct wireless_dev *ieee80211_add_iface(struct wiphy *wiphy,
						const char *name,
116
						unsigned char name_assign_type,
117 118
						enum nl80211_iftype type,
						struct vif_params *params)
119 120
{
	struct ieee80211_local *local = wiphy_priv(wiphy);
121
	struct wireless_dev *wdev;
122 123
	struct ieee80211_sub_if_data *sdata;
	int err;
124

125
	err = ieee80211_if_add(local, name, name_assign_type, &wdev, type, params);
126 127
	if (err)
		return ERR_PTR(err);
128

129 130 131
	sdata = IEEE80211_WDEV_TO_SUB_IF(wdev);

	if (type == NL80211_IFTYPE_MONITOR) {
132
		err = ieee80211_set_mon_options(sdata, params);
133 134 135 136
		if (err) {
			ieee80211_if_remove(sdata);
			return NULL;
		}
137 138
	}

139
	return wdev;
140 141
}

142
static int ieee80211_del_iface(struct wiphy *wiphy, struct wireless_dev *wdev)
143
{
144
	ieee80211_if_remove(IEEE80211_WDEV_TO_SUB_IF(wdev));
145

146
	return 0;
147 148
}

149 150
static int ieee80211_change_iface(struct wiphy *wiphy,
				  struct net_device *dev,
151
				  enum nl80211_iftype type,
152
				  struct vif_params *params)
153
{
154
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
155
	int ret;
156

157
	ret = ieee80211_if_change_type(sdata, type);
158 159
	if (ret)
		return ret;
160

161
	if (type == NL80211_IFTYPE_AP_VLAN && params->use_4addr == 0) {
162
		RCU_INIT_POINTER(sdata->u.vlan.sta, NULL);
J
Johannes Berg 已提交
163
		ieee80211_check_fast_rx_iface(sdata);
164
	} else if (type == NL80211_IFTYPE_STATION && params->use_4addr >= 0) {
165
		sdata->u.mgd.use_4addr = params->use_4addr;
J
Johannes Berg 已提交
166
	}
167

168
	if (sdata->vif.type == NL80211_IFTYPE_MONITOR) {
169 170 171
		ret = ieee80211_set_mon_options(sdata, params);
		if (ret)
			return ret;
172
	}
173

174 175 176
	return 0;
}

177 178 179
static int ieee80211_start_p2p_device(struct wiphy *wiphy,
				      struct wireless_dev *wdev)
{
180 181 182 183 184 185 186 187 188
	struct ieee80211_sub_if_data *sdata = IEEE80211_WDEV_TO_SUB_IF(wdev);
	int ret;

	mutex_lock(&sdata->local->chanctx_mtx);
	ret = ieee80211_check_combinations(sdata, NULL, 0, 0);
	mutex_unlock(&sdata->local->chanctx_mtx);
	if (ret < 0)
		return ret;

189 190 191 192 193 194 195 196 197
	return ieee80211_do_open(wdev, true);
}

static void ieee80211_stop_p2p_device(struct wiphy *wiphy,
				      struct wireless_dev *wdev)
{
	ieee80211_sdata_stop(IEEE80211_WDEV_TO_SUB_IF(wdev));
}

198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218
static int ieee80211_start_nan(struct wiphy *wiphy,
			       struct wireless_dev *wdev,
			       struct cfg80211_nan_conf *conf)
{
	struct ieee80211_sub_if_data *sdata = IEEE80211_WDEV_TO_SUB_IF(wdev);
	int ret;

	mutex_lock(&sdata->local->chanctx_mtx);
	ret = ieee80211_check_combinations(sdata, NULL, 0, 0);
	mutex_unlock(&sdata->local->chanctx_mtx);
	if (ret < 0)
		return ret;

	ret = ieee80211_do_open(wdev, true);
	if (ret)
		return ret;

	ret = drv_start_nan(sdata->local, sdata, conf);
	if (ret)
		ieee80211_sdata_stop(sdata);

219 220
	sdata->u.nan.conf = *conf;

221 222 223 224 225 226 227 228 229 230 231 232
	return ret;
}

static void ieee80211_stop_nan(struct wiphy *wiphy,
			       struct wireless_dev *wdev)
{
	struct ieee80211_sub_if_data *sdata = IEEE80211_WDEV_TO_SUB_IF(wdev);

	drv_stop_nan(sdata->local, sdata);
	ieee80211_sdata_stop(sdata);
}

233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252
static int ieee80211_nan_change_conf(struct wiphy *wiphy,
				     struct wireless_dev *wdev,
				     struct cfg80211_nan_conf *conf,
				     u32 changes)
{
	struct ieee80211_sub_if_data *sdata = IEEE80211_WDEV_TO_SUB_IF(wdev);
	struct cfg80211_nan_conf new_conf;
	int ret = 0;

	if (sdata->vif.type != NL80211_IFTYPE_NAN)
		return -EOPNOTSUPP;

	if (!ieee80211_sdata_running(sdata))
		return -ENETDOWN;

	new_conf = sdata->u.nan.conf;

	if (changes & CFG80211_NAN_CONF_CHANGED_PREF)
		new_conf.master_pref = conf->master_pref;

L
Luca Coelho 已提交
253 254
	if (changes & CFG80211_NAN_CONF_CHANGED_BANDS)
		new_conf.bands = conf->bands;
255 256 257 258 259 260 261 262

	ret = drv_nan_change_conf(sdata->local, sdata, &new_conf, changes);
	if (!ret)
		sdata->u.nan.conf = new_conf;

	return ret;
}

263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340
static int ieee80211_add_nan_func(struct wiphy *wiphy,
				  struct wireless_dev *wdev,
				  struct cfg80211_nan_func *nan_func)
{
	struct ieee80211_sub_if_data *sdata = IEEE80211_WDEV_TO_SUB_IF(wdev);
	int ret;

	if (sdata->vif.type != NL80211_IFTYPE_NAN)
		return -EOPNOTSUPP;

	if (!ieee80211_sdata_running(sdata))
		return -ENETDOWN;

	spin_lock_bh(&sdata->u.nan.func_lock);

	ret = idr_alloc(&sdata->u.nan.function_inst_ids,
			nan_func, 1, sdata->local->hw.max_nan_de_entries + 1,
			GFP_ATOMIC);
	spin_unlock_bh(&sdata->u.nan.func_lock);

	if (ret < 0)
		return ret;

	nan_func->instance_id = ret;

	WARN_ON(nan_func->instance_id == 0);

	ret = drv_add_nan_func(sdata->local, sdata, nan_func);
	if (ret) {
		spin_lock_bh(&sdata->u.nan.func_lock);
		idr_remove(&sdata->u.nan.function_inst_ids,
			   nan_func->instance_id);
		spin_unlock_bh(&sdata->u.nan.func_lock);
	}

	return ret;
}

static struct cfg80211_nan_func *
ieee80211_find_nan_func_by_cookie(struct ieee80211_sub_if_data *sdata,
				  u64 cookie)
{
	struct cfg80211_nan_func *func;
	int id;

	lockdep_assert_held(&sdata->u.nan.func_lock);

	idr_for_each_entry(&sdata->u.nan.function_inst_ids, func, id) {
		if (func->cookie == cookie)
			return func;
	}

	return NULL;
}

static void ieee80211_del_nan_func(struct wiphy *wiphy,
				  struct wireless_dev *wdev, u64 cookie)
{
	struct ieee80211_sub_if_data *sdata = IEEE80211_WDEV_TO_SUB_IF(wdev);
	struct cfg80211_nan_func *func;
	u8 instance_id = 0;

	if (sdata->vif.type != NL80211_IFTYPE_NAN ||
	    !ieee80211_sdata_running(sdata))
		return;

	spin_lock_bh(&sdata->u.nan.func_lock);

	func = ieee80211_find_nan_func_by_cookie(sdata, cookie);
	if (func)
		instance_id = func->instance_id;

	spin_unlock_bh(&sdata->u.nan.func_lock);

	if (instance_id)
		drv_del_nan_func(sdata->local, sdata, instance_id);
}

341 342 343 344 345 346 347
static int ieee80211_set_noack_map(struct wiphy *wiphy,
				  struct net_device *dev,
				  u16 noack_map)
{
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);

	sdata->noack_map = noack_map;
J
Johannes Berg 已提交
348 349 350

	ieee80211_check_fast_xmit_iface(sdata);

351 352 353
	return 0;
}

354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383
static int ieee80211_set_tx(struct ieee80211_sub_if_data *sdata,
			    const u8 *mac_addr, u8 key_idx)
{
	struct ieee80211_local *local = sdata->local;
	struct ieee80211_key *key;
	struct sta_info *sta;
	int ret = -EINVAL;

	if (!wiphy_ext_feature_isset(local->hw.wiphy,
				     NL80211_EXT_FEATURE_EXT_KEY_ID))
		return -EINVAL;

	sta = sta_info_get_bss(sdata, mac_addr);

	if (!sta)
		return -EINVAL;

	if (sta->ptk_idx == key_idx)
		return 0;

	mutex_lock(&local->key_mtx);
	key = key_mtx_dereference(local, sta->ptk[key_idx]);

	if (key && key->conf.flags & IEEE80211_KEY_FLAG_NO_AUTO_TX)
		ret = ieee80211_set_tx_key(key);

	mutex_unlock(&local->key_mtx);
	return ret;
}

384
static int ieee80211_add_key(struct wiphy *wiphy, struct net_device *dev,
385
			     u8 key_idx, bool pairwise, const u8 *mac_addr,
386 387
			     struct key_params *params)
{
388
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
389
	struct ieee80211_local *local = sdata->local;
390
	struct sta_info *sta = NULL;
391
	const struct ieee80211_cipher_scheme *cs = NULL;
392
	struct ieee80211_key *key;
393
	int err;
394

395
	if (!ieee80211_sdata_running(sdata))
J
Johannes Berg 已提交
396 397
		return -ENETDOWN;

398 399 400
	if (pairwise && params->mode == NL80211_KEY_SET_TX)
		return ieee80211_set_tx(sdata, mac_addr, key_idx);

401
	/* reject WEP and TKIP keys if WEP failed to initialize */
402 403 404
	switch (params->cipher) {
	case WLAN_CIPHER_SUITE_WEP40:
	case WLAN_CIPHER_SUITE_TKIP:
405
	case WLAN_CIPHER_SUITE_WEP104:
406
		if (WARN_ON_ONCE(fips_enabled))
407
			return -EINVAL;
408
		break;
409
	case WLAN_CIPHER_SUITE_CCMP:
J
Jouni Malinen 已提交
410
	case WLAN_CIPHER_SUITE_CCMP_256:
411
	case WLAN_CIPHER_SUITE_AES_CMAC:
412
	case WLAN_CIPHER_SUITE_BIP_CMAC_256:
413 414
	case WLAN_CIPHER_SUITE_BIP_GMAC_128:
	case WLAN_CIPHER_SUITE_BIP_GMAC_256:
415
	case WLAN_CIPHER_SUITE_GCMP:
416
	case WLAN_CIPHER_SUITE_GCMP_256:
417
		break;
418
	default:
419
		cs = ieee80211_cs_get(local, params->cipher, sdata->vif.type);
420
		break;
421 422
	}

423
	key = ieee80211_key_alloc(params->cipher, key_idx, params->key_len,
424 425
				  params->key, params->seq_len, params->seq,
				  cs);
426 427
	if (IS_ERR(key))
		return PTR_ERR(key);
428

429 430 431
	if (pairwise)
		key->conf.flags |= IEEE80211_KEY_FLAG_PAIRWISE;

432 433 434
	if (params->mode == NL80211_KEY_NO_TX)
		key->conf.flags |= IEEE80211_KEY_FLAG_NO_AUTO_TX;

435
	mutex_lock(&local->sta_mtx);
436

437
	if (mac_addr) {
438
		sta = sta_info_get_bss(sdata, mac_addr);
J
Johannes Berg 已提交
439 440 441 442 443
		/*
		 * The ASSOC test makes sure the driver is ready to
		 * receive the key. When wpa_supplicant has roamed
		 * using FT, it attempts to set the key before
		 * association has completed, this rejects that attempt
S
Stephen Hemminger 已提交
444
		 * so it will set the key again after association.
J
Johannes Berg 已提交
445 446 447 448 449
		 *
		 * TODO: accept the key if we have a station entry and
		 *       add it to the device after the station.
		 */
		if (!sta || !test_sta_flag(sta, WLAN_STA_ASSOC)) {
450
			ieee80211_key_free_unused(key);
451 452
			err = -ENOENT;
			goto out_unlock;
453
		}
454 455
	}

456 457 458 459 460 461 462 463
	switch (sdata->vif.type) {
	case NL80211_IFTYPE_STATION:
		if (sdata->u.mgd.mfp != IEEE80211_MFP_DISABLED)
			key->conf.flags |= IEEE80211_KEY_FLAG_RX_MGMT;
		break;
	case NL80211_IFTYPE_AP:
	case NL80211_IFTYPE_AP_VLAN:
		/* Keys without a station are used for TX only */
464
		if (sta && test_sta_flag(sta, WLAN_STA_MFP))
465 466 467 468 469 470 471 472 473 474 475 476 477 478
			key->conf.flags |= IEEE80211_KEY_FLAG_RX_MGMT;
		break;
	case NL80211_IFTYPE_ADHOC:
		/* no MFP (yet) */
		break;
	case NL80211_IFTYPE_MESH_POINT:
#ifdef CONFIG_MAC80211_MESH
		if (sdata->u.mesh.security != IEEE80211_MESH_SEC_NONE)
			key->conf.flags |= IEEE80211_KEY_FLAG_RX_MGMT;
		break;
#endif
	case NL80211_IFTYPE_WDS:
	case NL80211_IFTYPE_MONITOR:
	case NL80211_IFTYPE_P2P_DEVICE:
479
	case NL80211_IFTYPE_NAN:
480 481 482 483
	case NL80211_IFTYPE_UNSPECIFIED:
	case NUM_NL80211_IFTYPES:
	case NL80211_IFTYPE_P2P_CLIENT:
	case NL80211_IFTYPE_P2P_GO:
484
	case NL80211_IFTYPE_OCB:
485 486 487 488 489
		/* shouldn't happen */
		WARN_ON_ONCE(1);
		break;
	}

490 491 492
	if (sta)
		sta->cipher_scheme = cs;

493
	err = ieee80211_key_link(key, sdata, sta);
494

495
 out_unlock:
496
	mutex_unlock(&local->sta_mtx);
497 498

	return err;
499 500 501
}

static int ieee80211_del_key(struct wiphy *wiphy, struct net_device *dev,
502
			     u8 key_idx, bool pairwise, const u8 *mac_addr)
503
{
504 505
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
	struct ieee80211_local *local = sdata->local;
506
	struct sta_info *sta;
507
	struct ieee80211_key *key = NULL;
508 509
	int ret;

510 511
	mutex_lock(&local->sta_mtx);
	mutex_lock(&local->key_mtx);
512

513
	if (mac_addr) {
514 515
		ret = -ENOENT;

516
		sta = sta_info_get_bss(sdata, mac_addr);
517
		if (!sta)
518
			goto out_unlock;
519

520
		if (pairwise)
521
			key = key_mtx_dereference(local, sta->ptk[key_idx]);
522
		else
J
Johannes Berg 已提交
523
			key = key_mtx_dereference(local, sta->gtk[key_idx]);
524
	} else
J
Johannes Berg 已提交
525
		key = key_mtx_dereference(local, sdata->keys[key_idx]);
526

527
	if (!key) {
528 529 530
		ret = -ENOENT;
		goto out_unlock;
	}
531

532
	ieee80211_key_free(key, sdata->vif.type == NL80211_IFTYPE_STATION);
533

534 535
	ret = 0;
 out_unlock:
536 537
	mutex_unlock(&local->key_mtx);
	mutex_unlock(&local->sta_mtx);
538 539

	return ret;
540 541
}

542
static int ieee80211_get_key(struct wiphy *wiphy, struct net_device *dev,
543 544
			     u8 key_idx, bool pairwise, const u8 *mac_addr,
			     void *cookie,
545 546 547
			     void (*callback)(void *cookie,
					      struct key_params *params))
{
548
	struct ieee80211_sub_if_data *sdata;
549 550 551
	struct sta_info *sta = NULL;
	u8 seq[6] = {0};
	struct key_params params;
552
	struct ieee80211_key *key = NULL;
J
Johannes Berg 已提交
553
	u64 pn64;
554 555 556
	u32 iv32;
	u16 iv16;
	int err = -ENOENT;
557
	struct ieee80211_key_seq kseq = {};
558

559 560
	sdata = IEEE80211_DEV_TO_SUB_IF(dev);

561 562
	rcu_read_lock();

563
	if (mac_addr) {
564
		sta = sta_info_get_bss(sdata, mac_addr);
565 566 567
		if (!sta)
			goto out;

568
		if (pairwise && key_idx < NUM_DEFAULT_KEYS)
569
			key = rcu_dereference(sta->ptk[key_idx]);
570
		else if (!pairwise &&
571 572
			 key_idx < NUM_DEFAULT_KEYS + NUM_DEFAULT_MGMT_KEYS +
			 NUM_DEFAULT_BEACON_KEYS)
J
Johannes Berg 已提交
573
			key = rcu_dereference(sta->gtk[key_idx]);
574
	} else
J
Johannes Berg 已提交
575
		key = rcu_dereference(sdata->keys[key_idx]);
576 577 578 579 580 581

	if (!key)
		goto out;

	memset(&params, 0, sizeof(params));

582
	params.cipher = key->conf.cipher;
583

584 585
	switch (key->conf.cipher) {
	case WLAN_CIPHER_SUITE_TKIP:
586 587 588
		pn64 = atomic64_read(&key->conf.tx_pn);
		iv32 = TKIP_PN_TO_IV32(pn64);
		iv16 = TKIP_PN_TO_IV16(pn64);
589

590 591 592 593 594 595
		if (key->flags & KEY_FLAG_UPLOADED_TO_HARDWARE &&
		    !(key->conf.flags & IEEE80211_KEY_FLAG_GENERATE_IV)) {
			drv_get_key_seq(sdata->local, key, &kseq);
			iv32 = kseq.tkip.iv32;
			iv16 = kseq.tkip.iv16;
		}
596 597 598 599 600 601 602 603 604 605

		seq[0] = iv16 & 0xff;
		seq[1] = (iv16 >> 8) & 0xff;
		seq[2] = iv32 & 0xff;
		seq[3] = (iv32 >> 8) & 0xff;
		seq[4] = (iv32 >> 16) & 0xff;
		seq[5] = (iv32 >> 24) & 0xff;
		params.seq = seq;
		params.seq_len = 6;
		break;
606
	case WLAN_CIPHER_SUITE_CCMP:
J
Jouni Malinen 已提交
607
	case WLAN_CIPHER_SUITE_CCMP_256:
608
	case WLAN_CIPHER_SUITE_AES_CMAC:
609
	case WLAN_CIPHER_SUITE_BIP_CMAC_256:
610 611
		BUILD_BUG_ON(offsetof(typeof(kseq), ccmp) !=
			     offsetof(typeof(kseq), aes_cmac));
612
		fallthrough;
613 614
	case WLAN_CIPHER_SUITE_BIP_GMAC_128:
	case WLAN_CIPHER_SUITE_BIP_GMAC_256:
615 616
		BUILD_BUG_ON(offsetof(typeof(kseq), ccmp) !=
			     offsetof(typeof(kseq), aes_gmac));
617
		fallthrough;
618 619
	case WLAN_CIPHER_SUITE_GCMP:
	case WLAN_CIPHER_SUITE_GCMP_256:
620 621 622
		BUILD_BUG_ON(offsetof(typeof(kseq), ccmp) !=
			     offsetof(typeof(kseq), gcmp));

623 624 625
		if (key->flags & KEY_FLAG_UPLOADED_TO_HARDWARE &&
		    !(key->conf.flags & IEEE80211_KEY_FLAG_GENERATE_IV)) {
			drv_get_key_seq(sdata->local, key, &kseq);
626
			memcpy(seq, kseq.ccmp.pn, 6);
627
		} else {
628
			pn64 = atomic64_read(&key->conf.tx_pn);
629 630 631 632 633 634 635
			seq[0] = pn64;
			seq[1] = pn64 >> 8;
			seq[2] = pn64 >> 16;
			seq[3] = pn64 >> 24;
			seq[4] = pn64 >> 32;
			seq[5] = pn64 >> 40;
		}
636 637 638
		params.seq = seq;
		params.seq_len = 6;
		break;
639 640 641 642 643 644 645 646 647
	default:
		if (!(key->flags & KEY_FLAG_UPLOADED_TO_HARDWARE))
			break;
		if (WARN_ON(key->conf.flags & IEEE80211_KEY_FLAG_GENERATE_IV))
			break;
		drv_get_key_seq(sdata->local, key, &kseq);
		params.seq = kseq.hw.seq;
		params.seq_len = kseq.hw.seq_len;
		break;
648 649 650 651 652 653 654 655 656
	}

	params.key = key->conf.key;
	params.key_len = key->conf.keylen;

	callback(cookie, &params);
	err = 0;

 out:
657
	rcu_read_unlock();
658 659 660
	return err;
}

661 662
static int ieee80211_config_default_key(struct wiphy *wiphy,
					struct net_device *dev,
663 664
					u8 key_idx, bool uni,
					bool multi)
665
{
J
Johannes Berg 已提交
666
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
667

668
	ieee80211_set_default_key(sdata, key_idx, uni, multi);
669 670 671 672

	return 0;
}

673 674 675 676
static int ieee80211_config_default_mgmt_key(struct wiphy *wiphy,
					     struct net_device *dev,
					     u8 key_idx)
{
677
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
678 679 680 681 682 683

	ieee80211_set_default_mgmt_key(sdata, key_idx);

	return 0;
}

684 685 686 687 688 689 690 691 692 693 694
static int ieee80211_config_default_beacon_key(struct wiphy *wiphy,
					       struct net_device *dev,
					       u8 key_idx)
{
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);

	ieee80211_set_default_beacon_key(sdata, key_idx);

	return 0;
}

695 696 697 698 699
void sta_set_rate_info_tx(struct sta_info *sta,
			  const struct ieee80211_tx_rate *rate,
			  struct rate_info *rinfo)
{
	rinfo->flags = 0;
700
	if (rate->flags & IEEE80211_TX_RC_MCS) {
701
		rinfo->flags |= RATE_INFO_FLAGS_MCS;
702 703 704 705 706 707 708
		rinfo->mcs = rate->idx;
	} else if (rate->flags & IEEE80211_TX_RC_VHT_MCS) {
		rinfo->flags |= RATE_INFO_FLAGS_VHT_MCS;
		rinfo->mcs = ieee80211_rate_get_vht_mcs(rate);
		rinfo->nss = ieee80211_rate_get_vht_nss(rate);
	} else {
		struct ieee80211_supported_band *sband;
709 710 711
		int shift = ieee80211_vif_get_shift(&sta->sdata->vif);
		u16 brate;

712
		sband = ieee80211_get_sband(sta->sdata);
713 714
		WARN_ON_ONCE(sband && !sband->bitrates);
		if (sband && sband->bitrates) {
715 716 717
			brate = sband->bitrates[rate->idx].bitrate;
			rinfo->legacy = DIV_ROUND_UP(brate, 1 << shift);
		}
718
	}
719
	if (rate->flags & IEEE80211_TX_RC_40_MHZ_WIDTH)
720 721 722 723 724 725 726
		rinfo->bw = RATE_INFO_BW_40;
	else if (rate->flags & IEEE80211_TX_RC_80_MHZ_WIDTH)
		rinfo->bw = RATE_INFO_BW_80;
	else if (rate->flags & IEEE80211_TX_RC_160_MHZ_WIDTH)
		rinfo->bw = RATE_INFO_BW_160;
	else
		rinfo->bw = RATE_INFO_BW_20;
727 728 729 730
	if (rate->flags & IEEE80211_TX_RC_SHORT_GI)
		rinfo->flags |= RATE_INFO_FLAGS_SHORT_GI;
}

731
static int ieee80211_dump_station(struct wiphy *wiphy, struct net_device *dev,
732
				  int idx, u8 *mac, struct station_info *sinfo)
733
{
734
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
735
	struct ieee80211_local *local = sdata->local;
736
	struct sta_info *sta;
737 738
	int ret = -ENOENT;

739
	mutex_lock(&local->sta_mtx);
740

741
	sta = sta_info_get_by_idx(sdata, idx);
742 743
	if (sta) {
		ret = 0;
744
		memcpy(mac, sta->sta.addr, ETH_ALEN);
745
		sta_set_sinfo(sta, sinfo, true);
746
	}
747

748
	mutex_unlock(&local->sta_mtx);
749

750
	return ret;
751 752
}

753 754 755 756 757 758 759 760
static int ieee80211_dump_survey(struct wiphy *wiphy, struct net_device *dev,
				 int idx, struct survey_info *survey)
{
	struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);

	return drv_get_survey(local, idx, survey);
}

761
static int ieee80211_get_station(struct wiphy *wiphy, struct net_device *dev,
762
				 const u8 *mac, struct station_info *sinfo)
763
{
764
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
765
	struct ieee80211_local *local = sdata->local;
766
	struct sta_info *sta;
767
	int ret = -ENOENT;
768

769
	mutex_lock(&local->sta_mtx);
770

771
	sta = sta_info_get_bss(sdata, mac);
772 773
	if (sta) {
		ret = 0;
774
		sta_set_sinfo(sta, sinfo, true);
775 776
	}

777
	mutex_unlock(&local->sta_mtx);
778 779

	return ret;
780 781
}

J
Johannes Berg 已提交
782
static int ieee80211_set_monitor_channel(struct wiphy *wiphy,
783
					 struct cfg80211_chan_def *chandef)
784 785
{
	struct ieee80211_local *local = wiphy_priv(wiphy);
J
Johannes Berg 已提交
786 787
	struct ieee80211_sub_if_data *sdata;
	int ret = 0;
788

789
	if (cfg80211_chandef_identical(&local->monitor_chandef, chandef))
J
Johannes Berg 已提交
790
		return 0;
791

792
	mutex_lock(&local->mtx);
J
Johannes Berg 已提交
793
	if (local->use_chanctx) {
794
		sdata = rtnl_dereference(local->monitor_sdata);
J
Johannes Berg 已提交
795 796
		if (sdata) {
			ieee80211_vif_release_channel(sdata);
797
			ret = ieee80211_vif_use_channel(sdata, chandef,
J
Johannes Berg 已提交
798 799 800
					IEEE80211_CHANCTX_EXCLUSIVE);
		}
	} else if (local->open_count == local->monitors) {
801
		local->_oper_chandef = *chandef;
J
Johannes Berg 已提交
802 803
		ieee80211_hw_config(local, 0);
	}
804

805 806
	if (ret == 0)
		local->monitor_chandef = *chandef;
807
	mutex_unlock(&local->mtx);
808

J
Johannes Berg 已提交
809
	return ret;
810 811
}

812
static int ieee80211_set_probe_resp(struct ieee80211_sub_if_data *sdata,
813 814
				    const u8 *resp, size_t resp_len,
				    const struct ieee80211_csa_settings *csa)
815
{
816
	struct probe_resp *new, *old;
817 818

	if (!resp || !resp_len)
819
		return 1;
820

821
	old = sdata_dereference(sdata->u.ap.probe_resp, sdata);
822

823
	new = kzalloc(sizeof(struct probe_resp) + resp_len, GFP_KERNEL);
824 825 826
	if (!new)
		return -ENOMEM;

827 828
	new->len = resp_len;
	memcpy(new->data, resp, resp_len);
829

830
	if (csa)
831
		memcpy(new->cntdwn_counter_offsets, csa->counter_offsets_presp,
832
		       csa->n_counter_offsets_presp *
833
		       sizeof(new->cntdwn_counter_offsets[0]));
834

835
	rcu_assign_pointer(sdata->u.ap.probe_resp, new);
836 837
	if (old)
		kfree_rcu(old, rcu_head);
838 839 840 841

	return 0;
}

842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868
static int ieee80211_set_fils_discovery(struct ieee80211_sub_if_data *sdata,
					struct cfg80211_fils_discovery *params)
{
	struct fils_discovery_data *new, *old = NULL;
	struct ieee80211_fils_discovery *fd;

	if (!params->tmpl || !params->tmpl_len)
		return -EINVAL;

	fd = &sdata->vif.bss_conf.fils_discovery;
	fd->min_interval = params->min_interval;
	fd->max_interval = params->max_interval;

	old = sdata_dereference(sdata->u.ap.fils_discovery, sdata);
	new = kzalloc(sizeof(*new) + params->tmpl_len, GFP_KERNEL);
	if (!new)
		return -ENOMEM;
	new->len = params->tmpl_len;
	memcpy(new->data, params->tmpl, params->tmpl_len);
	rcu_assign_pointer(sdata->u.ap.fils_discovery, new);

	if (old)
		kfree_rcu(old, rcu_head);

	return 0;
}

869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894
static int
ieee80211_set_unsol_bcast_probe_resp(struct ieee80211_sub_if_data *sdata,
				     struct cfg80211_unsol_bcast_probe_resp *params)
{
	struct unsol_bcast_probe_resp_data *new, *old = NULL;

	if (!params->tmpl || !params->tmpl_len)
		return -EINVAL;

	old = sdata_dereference(sdata->u.ap.unsol_bcast_probe_resp, sdata);
	new = kzalloc(sizeof(*new) + params->tmpl_len, GFP_KERNEL);
	if (!new)
		return -ENOMEM;
	new->len = params->tmpl_len;
	memcpy(new->data, params->tmpl, params->tmpl_len);
	rcu_assign_pointer(sdata->u.ap.unsol_bcast_probe_resp, new);

	if (old)
		kfree_rcu(old, rcu_head);

	sdata->vif.bss_conf.unsol_bcast_probe_resp_interval =
							params->interval;

	return 0;
}

895 896 897 898 899 900 901 902 903 904
static int ieee80211_set_ftm_responder_params(
				struct ieee80211_sub_if_data *sdata,
				const u8 *lci, size_t lci_len,
				const u8 *civicloc, size_t civicloc_len)
{
	struct ieee80211_ftm_responder_params *new, *old;
	struct ieee80211_bss_conf *bss_conf;
	u8 *pos;
	int len;

905 906
	if (!lci_len && !civicloc_len)
		return 0;
907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936

	bss_conf = &sdata->vif.bss_conf;
	old = bss_conf->ftmr_params;
	len = lci_len + civicloc_len;

	new = kzalloc(sizeof(*new) + len, GFP_KERNEL);
	if (!new)
		return -ENOMEM;

	pos = (u8 *)(new + 1);
	if (lci_len) {
		new->lci_len = lci_len;
		new->lci = pos;
		memcpy(pos, lci, lci_len);
		pos += lci_len;
	}

	if (civicloc_len) {
		new->civicloc_len = civicloc_len;
		new->civicloc = pos;
		memcpy(pos, civicloc, civicloc_len);
		pos += civicloc_len;
	}

	bss_conf->ftmr_params = new;
	kfree(old);

	return 0;
}

937
static int ieee80211_assign_beacon(struct ieee80211_sub_if_data *sdata,
938 939
				   struct cfg80211_beacon_data *params,
				   const struct ieee80211_csa_settings *csa)
940 941 942
{
	struct beacon_data *new, *old;
	int new_head_len, new_tail_len;
943 944
	int size, err;
	u32 changed = BSS_CHANGED_BEACON;
945

946 947
	old = sdata_dereference(sdata->u.ap.beacon, sdata);

948 949 950

	/* Need to have a beacon head if we don't have one yet */
	if (!params->head && !old)
951
		return -EINVAL;
952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982

	/* new or old head? */
	if (params->head)
		new_head_len = params->head_len;
	else
		new_head_len = old->head_len;

	/* new or old tail? */
	if (params->tail || !old)
		/* params->tail_len will be zero for !params->tail */
		new_tail_len = params->tail_len;
	else
		new_tail_len = old->tail_len;

	size = sizeof(*new) + new_head_len + new_tail_len;

	new = kzalloc(size, GFP_KERNEL);
	if (!new)
		return -ENOMEM;

	/* start filling the new info now */

	/*
	 * pointers go into the block we allocated,
	 * memory is | beacon_data | head | tail |
	 */
	new->head = ((u8 *) new) + sizeof(*new);
	new->tail = new->head + new_head_len;
	new->head_len = new_head_len;
	new->tail_len = new_tail_len;

983
	if (csa) {
984 985
		new->cntdwn_current_counter = csa->count;
		memcpy(new->cntdwn_counter_offsets, csa->counter_offsets_beacon,
986
		       csa->n_counter_offsets_beacon *
987
		       sizeof(new->cntdwn_counter_offsets[0]));
988 989
	}

990 991 992 993 994 995 996 997 998 999 1000 1001 1002
	/* copy in head */
	if (params->head)
		memcpy(new->head, params->head, new_head_len);
	else
		memcpy(new->head, old->head, new_head_len);

	/* copy in optional tail */
	if (params->tail)
		memcpy(new->tail, params->tail, new_tail_len);
	else
		if (old)
			memcpy(new->tail, old->tail, new_tail_len);

1003
	err = ieee80211_set_probe_resp(sdata, params->probe_resp,
1004
				       params->probe_resp_len, csa);
1005 1006
	if (err < 0) {
		kfree(new);
1007
		return err;
1008
	}
1009
	if (err == 0)
1010 1011
		changed |= BSS_CHANGED_AP_PROBE_RESP;

1012 1013 1014 1015 1016 1017 1018 1019
	if (params->ftm_responder != -1) {
		sdata->vif.bss_conf.ftm_responder = params->ftm_responder;
		err = ieee80211_set_ftm_responder_params(sdata,
							 params->lci,
							 params->lci_len,
							 params->civicloc,
							 params->civicloc_len);

1020 1021
		if (err < 0) {
			kfree(new);
1022
			return err;
1023
		}
1024 1025 1026 1027

		changed |= BSS_CHANGED_FTM_RESPONDER;
	}

1028 1029 1030 1031
	rcu_assign_pointer(sdata->u.ap.beacon, new);

	if (old)
		kfree_rcu(old, rcu_head);
1032

1033
	return changed;
1034 1035
}

1036 1037
static int ieee80211_start_ap(struct wiphy *wiphy, struct net_device *dev,
			      struct cfg80211_ap_settings *params)
1038
{
1039
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1040
	struct ieee80211_local *local = sdata->local;
1041
	struct beacon_data *old;
1042
	struct ieee80211_sub_if_data *vlan;
1043 1044 1045
	u32 changed = BSS_CHANGED_BEACON_INT |
		      BSS_CHANGED_BEACON_ENABLED |
		      BSS_CHANGED_BEACON |
1046
		      BSS_CHANGED_SSID |
1047
		      BSS_CHANGED_P2P_PS |
1048
		      BSS_CHANGED_TXPOWER |
1049
		      BSS_CHANGED_TWT;
1050
	int i, err;
1051
	int prev_beacon_int;
1052

1053
	old = sdata_dereference(sdata->u.ap.beacon, sdata);
1054 1055 1056
	if (old)
		return -EALREADY;

1057 1058 1059 1060
	if (params->smps_mode != NL80211_SMPS_OFF)
		return -ENOTSUPP;

	sdata->smps_mode = IEEE80211_SMPS_OFF;
1061

1062 1063
	sdata->needed_rx_chains = sdata->local->rx_chains;

1064
	prev_beacon_int = sdata->vif.bss_conf.beacon_int;
1065 1066
	sdata->vif.bss_conf.beacon_int = params->beacon_interval;

1067
	if (params->he_cap && params->he_oper) {
1068
		sdata->vif.bss_conf.he_support = true;
1069 1070 1071 1072 1073 1074
		sdata->vif.bss_conf.htc_trig_based_pkt_ext =
			le32_get_bits(params->he_oper->he_oper_params,
			      IEEE80211_HE_OPERATION_DFLT_PE_DURATION_MASK);
		sdata->vif.bss_conf.frame_time_rts_th =
			le32_get_bits(params->he_oper->he_oper_params,
			      IEEE80211_HE_OPERATION_RTS_THRESHOLD_MASK);
1075 1076
		changed |= BSS_CHANGED_HE_OBSS_PD;

1077
		if (params->he_bss_color.enabled)
1078
			changed |= BSS_CHANGED_HE_BSS_COLOR;
1079
	}
1080

1081
	mutex_lock(&local->mtx);
1082
	err = ieee80211_vif_use_channel(sdata, &params->chandef,
J
Johannes Berg 已提交
1083
					IEEE80211_CHANCTX_SHARED);
1084 1085
	if (!err)
		ieee80211_vif_copy_chanctx_to_vlans(sdata, false);
1086
	mutex_unlock(&local->mtx);
1087 1088
	if (err) {
		sdata->vif.bss_conf.beacon_int = prev_beacon_int;
1089
		return err;
1090
	}
1091

1092 1093 1094 1095 1096 1097
	/*
	 * Apply control port protocol, this allows us to
	 * not encrypt dynamic WEP control frames.
	 */
	sdata->control_port_protocol = params->crypto.control_port_ethertype;
	sdata->control_port_no_encrypt = params->crypto.control_port_no_encrypt;
1098 1099
	sdata->control_port_over_nl80211 =
				params->crypto.control_port_over_nl80211;
1100 1101
	sdata->control_port_no_preauth =
				params->crypto.control_port_no_preauth;
1102 1103 1104 1105
	sdata->encrypt_headroom = ieee80211_cs_headroom(sdata->local,
							&params->crypto,
							sdata->vif.type);

1106 1107 1108 1109 1110
	list_for_each_entry(vlan, &sdata->u.ap.vlans, u.vlan.list) {
		vlan->control_port_protocol =
			params->crypto.control_port_ethertype;
		vlan->control_port_no_encrypt =
			params->crypto.control_port_no_encrypt;
1111 1112
		vlan->control_port_over_nl80211 =
			params->crypto.control_port_over_nl80211;
1113 1114
		vlan->control_port_no_preauth =
			params->crypto.control_port_no_preauth;
1115 1116 1117 1118
		vlan->encrypt_headroom =
			ieee80211_cs_headroom(sdata->local,
					      &params->crypto,
					      vlan->vif.type);
1119 1120
	}

1121
	sdata->vif.bss_conf.dtim_period = params->dtim_period;
1122
	sdata->vif.bss_conf.enable_beacon = true;
1123
	sdata->vif.bss_conf.allow_p2p_go_ps = sdata->vif.p2p;
1124
	sdata->vif.bss_conf.twt_responder = params->twt_responder;
1125
	sdata->vif.bss_conf.he_obss_pd = params->he_obss_pd;
1126
	sdata->vif.bss_conf.he_bss_color = params->he_bss_color;
1127 1128
	sdata->vif.bss_conf.s1g = params->chandef.chan->band ==
				  NL80211_BAND_S1GHZ;
1129 1130 1131 1132 1133 1134 1135 1136

	sdata->vif.bss_conf.ssid_len = params->ssid_len;
	if (params->ssid_len)
		memcpy(sdata->vif.bss_conf.ssid, params->ssid,
		       params->ssid_len);
	sdata->vif.bss_conf.hidden_ssid =
		(params->hidden_ssid != NL80211_HIDDEN_SSID_NOT_IN_USE);

J
Janusz Dziedzic 已提交
1137 1138 1139 1140 1141 1142 1143
	memset(&sdata->vif.bss_conf.p2p_noa_attr, 0,
	       sizeof(sdata->vif.bss_conf.p2p_noa_attr));
	sdata->vif.bss_conf.p2p_noa_attr.oppps_ctwindow =
		params->p2p_ctwindow & IEEE80211_P2P_OPPPS_CTWINDOW_MASK;
	if (params->p2p_opp_ps)
		sdata->vif.bss_conf.p2p_noa_attr.oppps_ctwindow |=
					IEEE80211_P2P_OPPPS_ENABLE_BIT;
1144

1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155
	sdata->beacon_rate_set = false;
	if (wiphy_ext_feature_isset(local->hw.wiphy,
				    NL80211_EXT_FEATURE_BEACON_RATE_LEGACY)) {
		for (i = 0; i < NUM_NL80211_BANDS; i++) {
			sdata->beacon_rateidx_mask[i] =
				params->beacon_rate.control[i].legacy;
			if (sdata->beacon_rateidx_mask[i])
				sdata->beacon_rate_set = true;
		}
	}

1156 1157 1158
	if (ieee80211_hw_check(&local->hw, HAS_RATE_CONTROL))
		sdata->vif.bss_conf.beacon_tx_rate = params->beacon_rate;

1159
	err = ieee80211_assign_beacon(sdata, &params->beacon, NULL);
1160 1161
	if (err < 0)
		goto error;
1162 1163
	changed |= err;

1164 1165 1166 1167 1168 1169 1170 1171
	if (params->fils_discovery.max_interval) {
		err = ieee80211_set_fils_discovery(sdata,
						   &params->fils_discovery);
		if (err < 0)
			goto error;
		changed |= BSS_CHANGED_FILS_DISCOVERY;
	}

1172 1173 1174 1175 1176 1177 1178 1179
	if (params->unsol_bcast_probe_resp.interval) {
		err = ieee80211_set_unsol_bcast_probe_resp(sdata,
							   &params->unsol_bcast_probe_resp);
		if (err < 0)
			goto error;
		changed |= BSS_CHANGED_UNSOL_BCAST_PROBE_RESP;
	}

1180 1181
	err = drv_start_ap(sdata->local, sdata);
	if (err) {
1182 1183
		old = sdata_dereference(sdata->u.ap.beacon, sdata);

1184 1185 1186
		if (old)
			kfree_rcu(old, rcu_head);
		RCU_INIT_POINTER(sdata->u.ap.beacon, NULL);
1187
		goto error;
1188 1189
	}

1190
	ieee80211_recalc_dtim(local, sdata);
1191 1192
	ieee80211_bss_info_change_notify(sdata, changed);

1193 1194 1195 1196
	netif_carrier_on(dev);
	list_for_each_entry(vlan, &sdata->u.ap.vlans, u.vlan.list)
		netif_carrier_on(vlan->dev);

1197
	return 0;
1198 1199 1200 1201

error:
	ieee80211_vif_release_channel(sdata);
	return err;
1202 1203
}

1204 1205
static int ieee80211_change_beacon(struct wiphy *wiphy, struct net_device *dev,
				   struct cfg80211_beacon_data *params)
1206
{
1207
	struct ieee80211_sub_if_data *sdata;
1208
	struct beacon_data *old;
1209
	int err;
1210

1211
	sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1212
	sdata_assert_lock(sdata);
1213

1214 1215 1216 1217 1218 1219
	/* don't allow changing the beacon while CSA is in place - offset
	 * of channel switch counter may change
	 */
	if (sdata->vif.csa_active)
		return -EBUSY;

1220
	old = sdata_dereference(sdata->u.ap.beacon, sdata);
1221 1222 1223
	if (!old)
		return -ENOENT;

1224
	err = ieee80211_assign_beacon(sdata, params, NULL);
1225 1226 1227 1228
	if (err < 0)
		return err;
	ieee80211_bss_info_change_notify(sdata, err);
	return 0;
1229 1230
}

1231
static int ieee80211_stop_ap(struct wiphy *wiphy, struct net_device *dev)
1232
{
1233 1234 1235 1236 1237
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
	struct ieee80211_sub_if_data *vlan;
	struct ieee80211_local *local = sdata->local;
	struct beacon_data *old_beacon;
	struct probe_resp *old_probe_resp;
1238
	struct fils_discovery_data *old_fils_discovery;
1239
	struct unsol_bcast_probe_resp_data *old_unsol_bcast_probe_resp;
1240
	struct cfg80211_chan_def chandef;
1241

1242 1243
	sdata_assert_lock(sdata);

1244
	old_beacon = sdata_dereference(sdata->u.ap.beacon, sdata);
1245
	if (!old_beacon)
1246
		return -ENOENT;
1247
	old_probe_resp = sdata_dereference(sdata->u.ap.probe_resp, sdata);
1248 1249
	old_fils_discovery = sdata_dereference(sdata->u.ap.fils_discovery,
					       sdata);
1250 1251 1252
	old_unsol_bcast_probe_resp =
		sdata_dereference(sdata->u.ap.unsol_bcast_probe_resp,
				  sdata);
1253

1254
	/* abort any running channel switch */
1255
	mutex_lock(&local->mtx);
1256
	sdata->vif.csa_active = false;
1257 1258 1259 1260 1261 1262
	if (sdata->csa_block_tx) {
		ieee80211_wake_vif_queues(local, sdata,
					  IEEE80211_QUEUE_STOP_REASON_CSA);
		sdata->csa_block_tx = false;
	}

1263 1264
	mutex_unlock(&local->mtx);

1265 1266 1267
	kfree(sdata->u.ap.next_beacon);
	sdata->u.ap.next_beacon = NULL;

1268
	/* turn off carrier for this interface and dependent VLANs */
1269 1270 1271 1272
	list_for_each_entry(vlan, &sdata->u.ap.vlans, u.vlan.list)
		netif_carrier_off(vlan->dev);
	netif_carrier_off(dev);

1273
	/* remove beacon and probe response */
1274
	RCU_INIT_POINTER(sdata->u.ap.beacon, NULL);
1275
	RCU_INIT_POINTER(sdata->u.ap.probe_resp, NULL);
1276
	RCU_INIT_POINTER(sdata->u.ap.fils_discovery, NULL);
1277
	RCU_INIT_POINTER(sdata->u.ap.unsol_bcast_probe_resp, NULL);
1278 1279 1280
	kfree_rcu(old_beacon, rcu_head);
	if (old_probe_resp)
		kfree_rcu(old_probe_resp, rcu_head);
1281 1282
	if (old_fils_discovery)
		kfree_rcu(old_fils_discovery, rcu_head);
1283 1284
	if (old_unsol_bcast_probe_resp)
		kfree_rcu(old_unsol_bcast_probe_resp, rcu_head);
1285

1286 1287 1288
	kfree(sdata->vif.bss_conf.ftmr_params);
	sdata->vif.bss_conf.ftmr_params = NULL;

1289
	__sta_info_flush(sdata, true);
1290
	ieee80211_free_keys(sdata, true);
1291

1292
	sdata->vif.bss_conf.enable_beacon = false;
1293
	sdata->beacon_rate_set = false;
1294
	sdata->vif.bss_conf.ssid_len = 0;
1295
	clear_bit(SDATA_STATE_OFFCHANNEL_BEACON_STOPPED, &sdata->state);
1296
	ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_BEACON_ENABLED);
1297

1298
	if (sdata->wdev.cac_started) {
1299
		chandef = sdata->vif.bss_conf.chandef;
1300
		cancel_delayed_work_sync(&sdata->dfs_cac_timer_work);
1301 1302
		cfg80211_cac_event(sdata->dev, &chandef,
				   NL80211_RADAR_CAC_ABORTED,
1303 1304 1305
				   GFP_KERNEL);
	}

1306 1307
	drv_stop_ap(sdata->local, sdata);

1308 1309
	/* free all potentially still buffered bcast frames */
	local->total_ps_buffered -= skb_queue_len(&sdata->u.ap.ps.bc_buf);
1310
	ieee80211_purge_tx_queue(&local->hw, &sdata->u.ap.ps.bc_buf);
1311

1312
	mutex_lock(&local->mtx);
1313
	ieee80211_vif_copy_chanctx_to_vlans(sdata, true);
J
Johannes Berg 已提交
1314
	ieee80211_vif_release_channel(sdata);
1315
	mutex_unlock(&local->mtx);
J
Johannes Berg 已提交
1316

1317
	return 0;
1318 1319
}

1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336
static int sta_apply_auth_flags(struct ieee80211_local *local,
				struct sta_info *sta,
				u32 mask, u32 set)
{
	int ret;

	if (mask & BIT(NL80211_STA_FLAG_AUTHENTICATED) &&
	    set & BIT(NL80211_STA_FLAG_AUTHENTICATED) &&
	    !test_sta_flag(sta, WLAN_STA_AUTH)) {
		ret = sta_info_move_state(sta, IEEE80211_STA_AUTH);
		if (ret)
			return ret;
	}

	if (mask & BIT(NL80211_STA_FLAG_ASSOCIATED) &&
	    set & BIT(NL80211_STA_FLAG_ASSOCIATED) &&
	    !test_sta_flag(sta, WLAN_STA_ASSOC)) {
1337 1338 1339 1340 1341
		/*
		 * When peer becomes associated, init rate control as
		 * well. Some drivers require rate control initialized
		 * before drv_sta_state() is called.
		 */
1342
		if (!test_sta_flag(sta, WLAN_STA_RATE_CONTROL))
1343 1344
			rate_control_rate_init(sta);

1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379
		ret = sta_info_move_state(sta, IEEE80211_STA_ASSOC);
		if (ret)
			return ret;
	}

	if (mask & BIT(NL80211_STA_FLAG_AUTHORIZED)) {
		if (set & BIT(NL80211_STA_FLAG_AUTHORIZED))
			ret = sta_info_move_state(sta, IEEE80211_STA_AUTHORIZED);
		else if (test_sta_flag(sta, WLAN_STA_AUTHORIZED))
			ret = sta_info_move_state(sta, IEEE80211_STA_ASSOC);
		else
			ret = 0;
		if (ret)
			return ret;
	}

	if (mask & BIT(NL80211_STA_FLAG_ASSOCIATED) &&
	    !(set & BIT(NL80211_STA_FLAG_ASSOCIATED)) &&
	    test_sta_flag(sta, WLAN_STA_ASSOC)) {
		ret = sta_info_move_state(sta, IEEE80211_STA_AUTH);
		if (ret)
			return ret;
	}

	if (mask & BIT(NL80211_STA_FLAG_AUTHENTICATED) &&
	    !(set & BIT(NL80211_STA_FLAG_AUTHENTICATED)) &&
	    test_sta_flag(sta, WLAN_STA_AUTH)) {
		ret = sta_info_move_state(sta, IEEE80211_STA_NONE);
		if (ret)
			return ret;
	}

	return 0;
}

1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393
static void sta_apply_mesh_params(struct ieee80211_local *local,
				  struct sta_info *sta,
				  struct station_parameters *params)
{
#ifdef CONFIG_MAC80211_MESH
	struct ieee80211_sub_if_data *sdata = sta->sdata;
	u32 changed = 0;

	if (params->sta_modify_mask & STATION_PARAM_APPLY_PLINK_STATE) {
		switch (params->plink_state) {
		case NL80211_PLINK_ESTAB:
			if (sta->mesh->plink_state != NL80211_PLINK_ESTAB)
				changed = mesh_plink_inc_estab_count(sdata);
			sta->mesh->plink_state = params->plink_state;
1394
			sta->mesh->aid = params->peer_aid;
1395 1396 1397 1398

			ieee80211_mps_sta_status_update(sta);
			changed |= ieee80211_mps_set_sta_local_pm(sta,
				      sdata->u.mesh.mshcfg.power_mode);
1399 1400 1401 1402 1403

			ewma_mesh_tx_rate_avg_init(&sta->mesh->tx_rate_avg);
			/* init at low value */
			ewma_mesh_tx_rate_avg_add(&sta->mesh->tx_rate_avg, 10);

1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444
			break;
		case NL80211_PLINK_LISTEN:
		case NL80211_PLINK_BLOCKED:
		case NL80211_PLINK_OPN_SNT:
		case NL80211_PLINK_OPN_RCVD:
		case NL80211_PLINK_CNF_RCVD:
		case NL80211_PLINK_HOLDING:
			if (sta->mesh->plink_state == NL80211_PLINK_ESTAB)
				changed = mesh_plink_dec_estab_count(sdata);
			sta->mesh->plink_state = params->plink_state;

			ieee80211_mps_sta_status_update(sta);
			changed |= ieee80211_mps_set_sta_local_pm(sta,
					NL80211_MESH_POWER_UNKNOWN);
			break;
		default:
			/*  nothing  */
			break;
		}
	}

	switch (params->plink_action) {
	case NL80211_PLINK_ACTION_NO_ACTION:
		/* nothing */
		break;
	case NL80211_PLINK_ACTION_OPEN:
		changed |= mesh_plink_open(sta);
		break;
	case NL80211_PLINK_ACTION_BLOCK:
		changed |= mesh_plink_block(sta);
		break;
	}

	if (params->local_pm)
		changed |= ieee80211_mps_set_sta_local_pm(sta,
							  params->local_pm);

	ieee80211_mbss_info_change_notify(sdata, changed);
#endif
}

1445 1446 1447
static int sta_apply_parameters(struct ieee80211_local *local,
				struct sta_info *sta,
				struct station_parameters *params)
1448
{
1449
	int ret = 0;
1450
	struct ieee80211_supported_band *sband;
1451
	struct ieee80211_sub_if_data *sdata = sta->sdata;
1452
	u32 mask, set;
1453

1454 1455 1456
	sband = ieee80211_get_sband(sdata);
	if (!sband)
		return -EINVAL;
J
Johannes Berg 已提交
1457

1458 1459
	mask = params->sta_flags_mask;
	set = params->sta_flags_set;
J
Johannes Berg 已提交
1460

1461 1462 1463 1464 1465 1466 1467 1468 1469
	if (ieee80211_vif_is_mesh(&sdata->vif)) {
		/*
		 * In mesh mode, ASSOCIATED isn't part of the nl80211
		 * API but must follow AUTHENTICATED for driver state.
		 */
		if (mask & BIT(NL80211_STA_FLAG_AUTHENTICATED))
			mask |= BIT(NL80211_STA_FLAG_ASSOCIATED);
		if (set & BIT(NL80211_STA_FLAG_AUTHENTICATED))
			set |= BIT(NL80211_STA_FLAG_ASSOCIATED);
1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481
	} else if (test_sta_flag(sta, WLAN_STA_TDLS_PEER)) {
		/*
		 * TDLS -- everything follows authorized, but
		 * only becoming authorized is possible, not
		 * going back
		 */
		if (set & BIT(NL80211_STA_FLAG_AUTHORIZED)) {
			set |= BIT(NL80211_STA_FLAG_AUTHENTICATED) |
			       BIT(NL80211_STA_FLAG_ASSOCIATED);
			mask |= BIT(NL80211_STA_FLAG_AUTHENTICATED) |
				BIT(NL80211_STA_FLAG_ASSOCIATED);
		}
1482
	}
1483

1484 1485 1486 1487
	if (mask & BIT(NL80211_STA_FLAG_WME) &&
	    local->hw.queues >= IEEE80211_NUM_ACS)
		sta->sta.wme = set & BIT(NL80211_STA_FLAG_WME);

1488 1489 1490 1491 1492
	/* auth flags will be set later for TDLS,
	 * and for unassociated stations that move to assocaited */
	if (!test_sta_flag(sta, WLAN_STA_TDLS_PEER) &&
	    !((mask & BIT(NL80211_STA_FLAG_ASSOCIATED)) &&
	      (set & BIT(NL80211_STA_FLAG_ASSOCIATED)))) {
1493 1494 1495 1496
		ret = sta_apply_auth_flags(local, sta, mask, set);
		if (ret)
			return ret;
	}
1497

1498 1499
	if (mask & BIT(NL80211_STA_FLAG_SHORT_PREAMBLE)) {
		if (set & BIT(NL80211_STA_FLAG_SHORT_PREAMBLE))
J
Johannes Berg 已提交
1500 1501 1502
			set_sta_flag(sta, WLAN_STA_SHORT_PREAMBLE);
		else
			clear_sta_flag(sta, WLAN_STA_SHORT_PREAMBLE);
1503
	}
1504

1505
	if (mask & BIT(NL80211_STA_FLAG_MFP)) {
1506
		sta->sta.mfp = !!(set & BIT(NL80211_STA_FLAG_MFP));
1507
		if (set & BIT(NL80211_STA_FLAG_MFP))
J
Johannes Berg 已提交
1508 1509 1510
			set_sta_flag(sta, WLAN_STA_MFP);
		else
			clear_sta_flag(sta, WLAN_STA_MFP);
1511
	}
1512

1513 1514
	if (mask & BIT(NL80211_STA_FLAG_TDLS_PEER)) {
		if (set & BIT(NL80211_STA_FLAG_TDLS_PEER))
J
Johannes Berg 已提交
1515 1516 1517
			set_sta_flag(sta, WLAN_STA_TDLS_PEER);
		else
			clear_sta_flag(sta, WLAN_STA_TDLS_PEER);
1518
	}
1519

1520 1521 1522 1523 1524 1525 1526
	/* mark TDLS channel switch support, if the AP allows it */
	if (test_sta_flag(sta, WLAN_STA_TDLS_PEER) &&
	    !sdata->u.mgd.tdls_chan_switch_prohibited &&
	    params->ext_capab_len >= 4 &&
	    params->ext_capab[3] & WLAN_EXT_CAPA4_TDLS_CHAN_SWITCH)
		set_sta_flag(sta, WLAN_STA_TDLS_CHAN_SWITCH);

1527
	if (test_sta_flag(sta, WLAN_STA_TDLS_PEER) &&
1528
	    !sdata->u.mgd.tdls_wider_bw_prohibited &&
1529 1530 1531 1532 1533
	    ieee80211_hw_check(&local->hw, TDLS_WIDER_BW) &&
	    params->ext_capab_len >= 8 &&
	    params->ext_capab[7] & WLAN_EXT_CAPA8_TDLS_WIDE_BW_ENABLED)
		set_sta_flag(sta, WLAN_STA_TDLS_WIDER_BW);

1534 1535 1536 1537
	if (params->sta_modify_mask & STATION_PARAM_APPLY_UAPSD) {
		sta->sta.uapsd_queues = params->uapsd_queues;
		sta->sta.max_sp = params->max_sp;
	}
1538

1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566
	/* The sender might not have sent the last bit, consider it to be 0 */
	if (params->ext_capab_len >= 8) {
		u8 val = (params->ext_capab[7] &
			  WLAN_EXT_CAPA8_MAX_MSDU_IN_AMSDU_LSB) >> 7;

		/* we did get all the bits, take the MSB as well */
		if (params->ext_capab_len >= 9) {
			u8 val_msb = params->ext_capab[8] &
				WLAN_EXT_CAPA9_MAX_MSDU_IN_AMSDU_MSB;
			val_msb <<= 1;
			val |= val_msb;
		}

		switch (val) {
		case 1:
			sta->sta.max_amsdu_subframes = 32;
			break;
		case 2:
			sta->sta.max_amsdu_subframes = 16;
			break;
		case 3:
			sta->sta.max_amsdu_subframes = 8;
			break;
		default:
			sta->sta.max_amsdu_subframes = 0;
		}
	}

1567 1568 1569 1570 1571 1572 1573
	/*
	 * cfg80211 validates this (1-2007) and allows setting the AID
	 * only when creating a new station entry
	 */
	if (params->aid)
		sta->sta.aid = params->aid;

J
Johannes Berg 已提交
1574
	/*
1575 1576 1577 1578 1579
	 * Some of the following updates would be racy if called on an
	 * existing station, via ieee80211_change_station(). However,
	 * all such changes are rejected by cfg80211 except for updates
	 * changing the supported rates on an existing but not yet used
	 * TDLS peer.
J
Johannes Berg 已提交
1580 1581
	 */

1582 1583 1584
	if (params->listen_interval >= 0)
		sta->listen_interval = params->listen_interval;

1585 1586 1587 1588 1589 1590 1591 1592 1593
	if (params->sta_modify_mask & STATION_PARAM_APPLY_STA_TXPOWER) {
		sta->sta.txpwr.type = params->txpwr.type;
		if (params->txpwr.type == NL80211_TX_POWER_LIMITED)
			sta->sta.txpwr.power = params->txpwr.power;
		ret = drv_sta_set_txpwr(local, sdata, sta);
		if (ret)
			return ret;
	}

1594
	if (params->supported_rates && params->supported_rates_len) {
1595 1596 1597
		ieee80211_parse_bitrates(&sdata->vif.bss_conf.chandef,
					 sband, params->supported_rates,
					 params->supported_rates_len,
1598
					 &sta->sta.supp_rates[sband->band]);
1599
	}
1600

J
Johannes Berg 已提交
1601
	if (params->ht_capa)
B
Ben Greear 已提交
1602
		ieee80211_ht_cap_ie_to_sta_ht_cap(sdata, sband,
1603
						  params->ht_capa, sta);
1604

1605
	/* VHT can override some HT caps such as the A-MSDU max length */
M
Mahesh Palivela 已提交
1606 1607
	if (params->vht_capa)
		ieee80211_vht_cap_ie_to_sta_vht_cap(sdata, sband,
1608
						    params->vht_capa, sta);
M
Mahesh Palivela 已提交
1609

L
Luca Coelho 已提交
1610 1611 1612
	if (params->he_capa)
		ieee80211_he_cap_ie_to_sta_he_cap(sdata, sband,
						  (void *)params->he_capa,
1613 1614 1615
						  params->he_capa_len,
						  (void *)params->he_6ghz_capa,
						  sta);
L
Luca Coelho 已提交
1616

1617 1618 1619 1620
	if (params->opmode_notif_used) {
		/* returned value is only needed for rc update, but the
		 * rc isn't initialized here yet, so ignore it
		 */
1621 1622
		__ieee80211_vht_handle_opmode(sdata, sta, params->opmode_notif,
					      sband->band);
1623 1624
	}

1625 1626 1627
	if (params->support_p2p_ps >= 0)
		sta->sta.support_p2p_ps = params->support_p2p_ps;

1628 1629
	if (ieee80211_vif_is_mesh(&sdata->vif))
		sta_apply_mesh_params(local, sta, params);
1630

1631 1632 1633
	if (params->airtime_weight)
		sta->airtime_weight = params->airtime_weight;

1634
	/* set the STA state after all sta info from usermode has been set */
1635 1636
	if (test_sta_flag(sta, WLAN_STA_TDLS_PEER) ||
	    set & BIT(NL80211_STA_FLAG_ASSOCIATED)) {
1637 1638 1639 1640 1641
		ret = sta_apply_auth_flags(local, sta, mask, set);
		if (ret)
			return ret;
	}

1642
	return 0;
1643 1644 1645
}

static int ieee80211_add_station(struct wiphy *wiphy, struct net_device *dev,
1646 1647
				 const u8 *mac,
				 struct station_parameters *params)
1648
{
1649
	struct ieee80211_local *local = wiphy_priv(wiphy);
1650 1651
	struct sta_info *sta;
	struct ieee80211_sub_if_data *sdata;
J
Johannes Berg 已提交
1652
	int err;
1653 1654 1655 1656

	if (params->vlan) {
		sdata = IEEE80211_DEV_TO_SUB_IF(params->vlan);

1657 1658
		if (sdata->vif.type != NL80211_IFTYPE_AP_VLAN &&
		    sdata->vif.type != NL80211_IFTYPE_AP)
1659 1660 1661 1662
			return -EINVAL;
	} else
		sdata = IEEE80211_DEV_TO_SUB_IF(dev);

1663
	if (ether_addr_equal(mac, sdata->vif.addr))
1664 1665
		return -EINVAL;

1666
	if (!is_valid_ether_addr(mac))
1667 1668
		return -EINVAL;

J
Johannes Berg 已提交
1669 1670 1671 1672 1673
	if (params->sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER) &&
	    sdata->vif.type == NL80211_IFTYPE_STATION &&
	    !sdata->u.mgd.associated)
		return -EINVAL;

1674
	sta = sta_info_alloc(sdata, mac, GFP_KERNEL);
J
Johannes Berg 已提交
1675 1676
	if (!sta)
		return -ENOMEM;
1677

1678 1679
	if (params->sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER))
		sta->sta.tdls = true;
1680

1681 1682 1683 1684 1685
	err = sta_apply_parameters(local, sta, params);
	if (err) {
		sta_info_free(local, sta);
		return err;
	}
1686

1687
	/*
1688 1689 1690
	 * for TDLS and for unassociated station, rate control should be
	 * initialized only when rates are known and station is marked
	 * authorized/associated
1691
	 */
1692 1693
	if (!test_sta_flag(sta, WLAN_STA_TDLS_PEER) &&
	    test_sta_flag(sta, WLAN_STA_ASSOC))
1694
		rate_control_rate_init(sta);
1695

1696
	err = sta_info_insert_rcu(sta);
J
Johannes Berg 已提交
1697 1698 1699 1700 1701 1702 1703
	if (err) {
		rcu_read_unlock();
		return err;
	}

	rcu_read_unlock();

1704 1705 1706 1707
	return 0;
}

static int ieee80211_del_station(struct wiphy *wiphy, struct net_device *dev,
1708
				 struct station_del_parameters *params)
1709
{
1710
	struct ieee80211_sub_if_data *sdata;
1711

1712 1713
	sdata = IEEE80211_DEV_TO_SUB_IF(dev);

1714 1715
	if (params->mac)
		return sta_info_destroy_addr_bss(sdata, params->mac);
1716

1717
	sta_info_flush(sdata);
1718 1719 1720 1721
	return 0;
}

static int ieee80211_change_station(struct wiphy *wiphy,
1722
				    struct net_device *dev, const u8 *mac,
1723 1724
				    struct station_parameters *params)
{
1725
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1726
	struct ieee80211_local *local = wiphy_priv(wiphy);
1727 1728
	struct sta_info *sta;
	struct ieee80211_sub_if_data *vlansdata;
1729
	enum cfg80211_station_type statype;
1730
	int err;
1731

1732
	mutex_lock(&local->sta_mtx);
J
Johannes Berg 已提交
1733

1734
	sta = sta_info_get_bss(sdata, mac);
J
Johannes Berg 已提交
1735
	if (!sta) {
1736 1737
		err = -ENOENT;
		goto out_err;
J
Johannes Berg 已提交
1738
	}
1739

1740 1741
	switch (sdata->vif.type) {
	case NL80211_IFTYPE_MESH_POINT:
1742
		if (sdata->u.mesh.user_mpm)
1743
			statype = CFG80211_STA_MESH_PEER_USER;
1744
		else
1745
			statype = CFG80211_STA_MESH_PEER_KERNEL;
1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761
		break;
	case NL80211_IFTYPE_ADHOC:
		statype = CFG80211_STA_IBSS;
		break;
	case NL80211_IFTYPE_STATION:
		if (!test_sta_flag(sta, WLAN_STA_TDLS_PEER)) {
			statype = CFG80211_STA_AP_STA;
			break;
		}
		if (test_sta_flag(sta, WLAN_STA_AUTHORIZED))
			statype = CFG80211_STA_TDLS_PEER_ACTIVE;
		else
			statype = CFG80211_STA_TDLS_PEER_SETUP;
		break;
	case NL80211_IFTYPE_AP:
	case NL80211_IFTYPE_AP_VLAN:
1762 1763 1764 1765
		if (test_sta_flag(sta, WLAN_STA_ASSOC))
			statype = CFG80211_STA_AP_CLIENT;
		else
			statype = CFG80211_STA_AP_CLIENT_UNASSOC;
1766 1767 1768 1769
		break;
	default:
		err = -EOPNOTSUPP;
		goto out_err;
1770 1771
	}

1772 1773 1774 1775
	err = cfg80211_check_station_change(wiphy, params, statype);
	if (err)
		goto out_err;

1776
	if (params->vlan && params->vlan != sta->sdata->dev) {
1777 1778
		vlansdata = IEEE80211_DEV_TO_SUB_IF(params->vlan);

1779
		if (params->vlan->ieee80211_ptr->use_4addr) {
J
Johannes Berg 已提交
1780
			if (vlansdata->u.vlan.sta) {
1781 1782
				err = -EBUSY;
				goto out_err;
J
Johannes Berg 已提交
1783
			}
1784

1785
			rcu_assign_pointer(vlansdata->u.vlan.sta, sta);
J
Johannes Berg 已提交
1786
			__ieee80211_check_fast_rx_iface(vlansdata);
1787
			drv_sta_set_4addr(local, sta->sdata, &sta->sta, true);
1788 1789 1790
		}

		if (sta->sdata->vif.type == NL80211_IFTYPE_AP_VLAN &&
1791
		    sta->sdata->u.vlan.sta)
M
Monam Agarwal 已提交
1792
			RCU_INIT_POINTER(sta->sdata->u.vlan.sta, NULL);
1793 1794 1795

		if (test_sta_flag(sta, WLAN_STA_AUTHORIZED))
			ieee80211_vif_dec_num_mcast(sta->sdata);
1796

1797
		sta->sdata = vlansdata;
1798
		ieee80211_check_fast_xmit(sta);
1799

1800
		if (test_sta_flag(sta, WLAN_STA_AUTHORIZED)) {
1801
			ieee80211_vif_inc_num_mcast(sta->sdata);
1802 1803 1804
			cfg80211_send_layer2_update(sta->sdata->dev,
						    sta->sta.addr);
		}
1805 1806
	}

1807
	err = sta_apply_parameters(local, sta, params);
1808 1809
	if (err)
		goto out_err;
1810

1811
	mutex_unlock(&local->sta_mtx);
J
Johannes Berg 已提交
1812

1813
	if (sdata->vif.type == NL80211_IFTYPE_STATION &&
E
Eliad Peller 已提交
1814
	    params->sta_flags_mask & BIT(NL80211_STA_FLAG_AUTHORIZED)) {
J
Johannes Berg 已提交
1815
		ieee80211_recalc_ps(local);
E
Eliad Peller 已提交
1816 1817
		ieee80211_recalc_ps_vif(sdata);
	}
1818

1819
	return 0;
1820 1821 1822
out_err:
	mutex_unlock(&local->sta_mtx);
	return err;
1823 1824
}

1825 1826
#ifdef CONFIG_MAC80211_MESH
static int ieee80211_add_mpath(struct wiphy *wiphy, struct net_device *dev,
1827
			       const u8 *dst, const u8 *next_hop)
1828
{
1829
	struct ieee80211_sub_if_data *sdata;
1830 1831 1832
	struct mesh_path *mpath;
	struct sta_info *sta;

1833 1834
	sdata = IEEE80211_DEV_TO_SUB_IF(dev);

1835
	rcu_read_lock();
1836
	sta = sta_info_get(sdata, next_hop);
1837 1838
	if (!sta) {
		rcu_read_unlock();
1839
		return -ENOENT;
1840
	}
1841

1842 1843
	mpath = mesh_path_add(sdata, dst);
	if (IS_ERR(mpath)) {
1844
		rcu_read_unlock();
1845
		return PTR_ERR(mpath);
1846
	}
1847 1848

	mesh_path_fix_nexthop(mpath, sta);
1849

1850 1851 1852 1853 1854
	rcu_read_unlock();
	return 0;
}

static int ieee80211_del_mpath(struct wiphy *wiphy, struct net_device *dev,
1855
			       const u8 *dst)
1856
{
1857 1858
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);

1859
	if (dst)
J
Johannes Berg 已提交
1860
		return mesh_path_del(sdata, dst);
1861

1862
	mesh_path_flush_by_iface(sdata);
1863 1864 1865
	return 0;
}

1866 1867
static int ieee80211_change_mpath(struct wiphy *wiphy, struct net_device *dev,
				  const u8 *dst, const u8 *next_hop)
1868
{
1869
	struct ieee80211_sub_if_data *sdata;
1870 1871 1872
	struct mesh_path *mpath;
	struct sta_info *sta;

1873 1874
	sdata = IEEE80211_DEV_TO_SUB_IF(dev);

1875 1876
	rcu_read_lock();

1877
	sta = sta_info_get(sdata, next_hop);
1878 1879
	if (!sta) {
		rcu_read_unlock();
1880
		return -ENOENT;
1881
	}
1882

J
Johannes Berg 已提交
1883
	mpath = mesh_path_lookup(sdata, dst);
1884 1885 1886 1887 1888 1889
	if (!mpath) {
		rcu_read_unlock();
		return -ENOENT;
	}

	mesh_path_fix_nexthop(mpath, sta);
1890

1891 1892 1893 1894 1895 1896 1897
	rcu_read_unlock();
	return 0;
}

static void mpath_set_pinfo(struct mesh_path *mpath, u8 *next_hop,
			    struct mpath_info *pinfo)
{
J
Johannes Berg 已提交
1898 1899 1900 1901
	struct sta_info *next_hop_sta = rcu_dereference(mpath->next_hop);

	if (next_hop_sta)
		memcpy(next_hop, next_hop_sta->sta.addr, ETH_ALEN);
1902
	else
1903
		eth_zero_addr(next_hop);
1904

1905 1906
	memset(pinfo, 0, sizeof(*pinfo));

1907
	pinfo->generation = mpath->sdata->u.mesh.mesh_paths_generation;
1908

1909
	pinfo->filled = MPATH_INFO_FRAME_QLEN |
1910
			MPATH_INFO_SN |
1911 1912 1913 1914
			MPATH_INFO_METRIC |
			MPATH_INFO_EXPTIME |
			MPATH_INFO_DISCOVERY_TIMEOUT |
			MPATH_INFO_DISCOVERY_RETRIES |
1915
			MPATH_INFO_FLAGS |
1916 1917
			MPATH_INFO_HOP_COUNT |
			MPATH_INFO_PATH_CHANGE;
1918 1919

	pinfo->frame_qlen = mpath->frame_queue.qlen;
1920
	pinfo->sn = mpath->sn;
1921 1922 1923 1924 1925 1926 1927 1928 1929 1930
	pinfo->metric = mpath->metric;
	if (time_before(jiffies, mpath->exp_time))
		pinfo->exptime = jiffies_to_msecs(mpath->exp_time - jiffies);
	pinfo->discovery_timeout =
			jiffies_to_msecs(mpath->discovery_timeout);
	pinfo->discovery_retries = mpath->discovery_retries;
	if (mpath->flags & MESH_PATH_ACTIVE)
		pinfo->flags |= NL80211_MPATH_FLAG_ACTIVE;
	if (mpath->flags & MESH_PATH_RESOLVING)
		pinfo->flags |= NL80211_MPATH_FLAG_RESOLVING;
1931 1932
	if (mpath->flags & MESH_PATH_SN_VALID)
		pinfo->flags |= NL80211_MPATH_FLAG_SN_VALID;
1933 1934
	if (mpath->flags & MESH_PATH_FIXED)
		pinfo->flags |= NL80211_MPATH_FLAG_FIXED;
1935 1936
	if (mpath->flags & MESH_PATH_RESOLVED)
		pinfo->flags |= NL80211_MPATH_FLAG_RESOLVED;
1937
	pinfo->hop_count = mpath->hop_count;
1938
	pinfo->path_change_count = mpath->path_change_count;
1939 1940 1941 1942 1943 1944
}

static int ieee80211_get_mpath(struct wiphy *wiphy, struct net_device *dev,
			       u8 *dst, u8 *next_hop, struct mpath_info *pinfo)

{
1945
	struct ieee80211_sub_if_data *sdata;
1946 1947
	struct mesh_path *mpath;

1948 1949
	sdata = IEEE80211_DEV_TO_SUB_IF(dev);

1950
	rcu_read_lock();
J
Johannes Berg 已提交
1951
	mpath = mesh_path_lookup(sdata, dst);
1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962
	if (!mpath) {
		rcu_read_unlock();
		return -ENOENT;
	}
	memcpy(dst, mpath->dst, ETH_ALEN);
	mpath_set_pinfo(mpath, next_hop, pinfo);
	rcu_read_unlock();
	return 0;
}

static int ieee80211_dump_mpath(struct wiphy *wiphy, struct net_device *dev,
1963 1964
				int idx, u8 *dst, u8 *next_hop,
				struct mpath_info *pinfo)
1965
{
1966
	struct ieee80211_sub_if_data *sdata;
1967 1968
	struct mesh_path *mpath;

1969 1970
	sdata = IEEE80211_DEV_TO_SUB_IF(dev);

1971
	rcu_read_lock();
J
Johannes Berg 已提交
1972
	mpath = mesh_path_lookup_by_idx(sdata, idx);
1973 1974 1975 1976 1977 1978 1979 1980 1981
	if (!mpath) {
		rcu_read_unlock();
		return -ENOENT;
	}
	memcpy(dst, mpath->dst, ETH_ALEN);
	mpath_set_pinfo(mpath, next_hop, pinfo);
	rcu_read_unlock();
	return 0;
}
1982

1983 1984 1985 1986 1987 1988
static void mpp_set_pinfo(struct mesh_path *mpath, u8 *mpp,
			  struct mpath_info *pinfo)
{
	memset(pinfo, 0, sizeof(*pinfo));
	memcpy(mpp, mpath->mpp, ETH_ALEN);

1989
	pinfo->generation = mpath->sdata->u.mesh.mpp_paths_generation;
1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033
}

static int ieee80211_get_mpp(struct wiphy *wiphy, struct net_device *dev,
			     u8 *dst, u8 *mpp, struct mpath_info *pinfo)

{
	struct ieee80211_sub_if_data *sdata;
	struct mesh_path *mpath;

	sdata = IEEE80211_DEV_TO_SUB_IF(dev);

	rcu_read_lock();
	mpath = mpp_path_lookup(sdata, dst);
	if (!mpath) {
		rcu_read_unlock();
		return -ENOENT;
	}
	memcpy(dst, mpath->dst, ETH_ALEN);
	mpp_set_pinfo(mpath, mpp, pinfo);
	rcu_read_unlock();
	return 0;
}

static int ieee80211_dump_mpp(struct wiphy *wiphy, struct net_device *dev,
			      int idx, u8 *dst, u8 *mpp,
			      struct mpath_info *pinfo)
{
	struct ieee80211_sub_if_data *sdata;
	struct mesh_path *mpath;

	sdata = IEEE80211_DEV_TO_SUB_IF(dev);

	rcu_read_lock();
	mpath = mpp_path_lookup_by_idx(sdata, idx);
	if (!mpath) {
		rcu_read_unlock();
		return -ENOENT;
	}
	memcpy(dst, mpath->dst, ETH_ALEN);
	mpp_set_pinfo(mpath, mpp, pinfo);
	rcu_read_unlock();
	return 0;
}

2034
static int ieee80211_get_mesh_config(struct wiphy *wiphy,
2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049
				struct net_device *dev,
				struct mesh_config *conf)
{
	struct ieee80211_sub_if_data *sdata;
	sdata = IEEE80211_DEV_TO_SUB_IF(dev);

	memcpy(conf, &(sdata->u.mesh.mshcfg), sizeof(struct mesh_config));
	return 0;
}

static inline bool _chg_mesh_attr(enum nl80211_meshconf_params parm, u32 mask)
{
	return (mask >> (parm-1)) & 0x1;
}

2050 2051 2052 2053 2054
static int copy_mesh_setup(struct ieee80211_if_mesh *ifmsh,
		const struct mesh_setup *setup)
{
	u8 *new_ie;
	const u8 *old_ie;
2055 2056
	struct ieee80211_sub_if_data *sdata = container_of(ifmsh,
					struct ieee80211_sub_if_data, u.mesh);
2057
	int i;
2058

2059
	/* allocate information elements */
2060
	new_ie = NULL;
2061
	old_ie = ifmsh->ie;
2062

2063 2064
	if (setup->ie_len) {
		new_ie = kmemdup(setup->ie, setup->ie_len,
2065 2066 2067 2068
				GFP_KERNEL);
		if (!new_ie)
			return -ENOMEM;
	}
2069 2070 2071
	ifmsh->ie_len = setup->ie_len;
	ifmsh->ie = new_ie;
	kfree(old_ie);
2072 2073 2074 2075

	/* now copy the rest of the setup parameters */
	ifmsh->mesh_id_len = setup->mesh_id_len;
	memcpy(ifmsh->mesh_id, setup->mesh_id, ifmsh->mesh_id_len);
2076
	ifmsh->mesh_sp_id = setup->sync_method;
2077 2078
	ifmsh->mesh_pp_id = setup->path_sel_proto;
	ifmsh->mesh_pm_id = setup->path_metric;
2079
	ifmsh->user_mpm = setup->user_mpm;
2080
	ifmsh->mesh_auth_id = setup->auth_id;
2081
	ifmsh->security = IEEE80211_MESH_SEC_NONE;
2082
	ifmsh->userspace_handles_dfs = setup->userspace_handles_dfs;
2083 2084 2085 2086
	if (setup->is_authenticated)
		ifmsh->security |= IEEE80211_MESH_SEC_AUTHED;
	if (setup->is_secure)
		ifmsh->security |= IEEE80211_MESH_SEC_SECURED;
2087

2088 2089 2090
	/* mcast rate setting in Mesh Node */
	memcpy(sdata->vif.bss_conf.mcast_rate, setup->mcast_rate,
						sizeof(setup->mcast_rate));
2091
	sdata->vif.bss_conf.basic_rates = setup->basic_rates;
2092

2093 2094 2095
	sdata->vif.bss_conf.beacon_int = setup->beacon_interval;
	sdata->vif.bss_conf.dtim_period = setup->dtim_period;

2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106
	sdata->beacon_rate_set = false;
	if (wiphy_ext_feature_isset(sdata->local->hw.wiphy,
				    NL80211_EXT_FEATURE_BEACON_RATE_LEGACY)) {
		for (i = 0; i < NUM_NL80211_BANDS; i++) {
			sdata->beacon_rateidx_mask[i] =
				setup->beacon_rate.control[i].legacy;
			if (sdata->beacon_rateidx_mask[i])
				sdata->beacon_rate_set = true;
		}
	}

2107 2108 2109
	return 0;
}

2110
static int ieee80211_update_mesh_config(struct wiphy *wiphy,
2111 2112
					struct net_device *dev, u32 mask,
					const struct mesh_config *nconf)
2113 2114 2115
{
	struct mesh_config *conf;
	struct ieee80211_sub_if_data *sdata;
2116 2117
	struct ieee80211_if_mesh *ifmsh;

2118
	sdata = IEEE80211_DEV_TO_SUB_IF(dev);
2119
	ifmsh = &sdata->u.mesh;
2120 2121 2122 2123 2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134

	/* Set the config options which we are interested in setting */
	conf = &(sdata->u.mesh.mshcfg);
	if (_chg_mesh_attr(NL80211_MESHCONF_RETRY_TIMEOUT, mask))
		conf->dot11MeshRetryTimeout = nconf->dot11MeshRetryTimeout;
	if (_chg_mesh_attr(NL80211_MESHCONF_CONFIRM_TIMEOUT, mask))
		conf->dot11MeshConfirmTimeout = nconf->dot11MeshConfirmTimeout;
	if (_chg_mesh_attr(NL80211_MESHCONF_HOLDING_TIMEOUT, mask))
		conf->dot11MeshHoldingTimeout = nconf->dot11MeshHoldingTimeout;
	if (_chg_mesh_attr(NL80211_MESHCONF_MAX_PEER_LINKS, mask))
		conf->dot11MeshMaxPeerLinks = nconf->dot11MeshMaxPeerLinks;
	if (_chg_mesh_attr(NL80211_MESHCONF_MAX_RETRIES, mask))
		conf->dot11MeshMaxRetries = nconf->dot11MeshMaxRetries;
	if (_chg_mesh_attr(NL80211_MESHCONF_TTL, mask))
		conf->dot11MeshTTL = nconf->dot11MeshTTL;
2135
	if (_chg_mesh_attr(NL80211_MESHCONF_ELEMENT_TTL, mask))
2136
		conf->element_ttl = nconf->element_ttl;
2137 2138 2139
	if (_chg_mesh_attr(NL80211_MESHCONF_AUTO_OPEN_PLINKS, mask)) {
		if (ifmsh->user_mpm)
			return -EBUSY;
2140
		conf->auto_open_plinks = nconf->auto_open_plinks;
2141
	}
2142 2143 2144
	if (_chg_mesh_attr(NL80211_MESHCONF_SYNC_OFFSET_MAX_NEIGHBOR, mask))
		conf->dot11MeshNbrOffsetMaxNeighbor =
			nconf->dot11MeshNbrOffsetMaxNeighbor;
2145 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156 2157
	if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES, mask))
		conf->dot11MeshHWMPmaxPREQretries =
			nconf->dot11MeshHWMPmaxPREQretries;
	if (_chg_mesh_attr(NL80211_MESHCONF_PATH_REFRESH_TIME, mask))
		conf->path_refresh_time = nconf->path_refresh_time;
	if (_chg_mesh_attr(NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT, mask))
		conf->min_discovery_timeout = nconf->min_discovery_timeout;
	if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT, mask))
		conf->dot11MeshHWMPactivePathTimeout =
			nconf->dot11MeshHWMPactivePathTimeout;
	if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL, mask))
		conf->dot11MeshHWMPpreqMinInterval =
			nconf->dot11MeshHWMPpreqMinInterval;
2158 2159 2160
	if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_PERR_MIN_INTERVAL, mask))
		conf->dot11MeshHWMPperrMinInterval =
			nconf->dot11MeshHWMPperrMinInterval;
2161 2162 2163 2164
	if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME,
			   mask))
		conf->dot11MeshHWMPnetDiameterTraversalTime =
			nconf->dot11MeshHWMPnetDiameterTraversalTime;
2165 2166 2167 2168
	if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_ROOTMODE, mask)) {
		conf->dot11MeshHWMPRootMode = nconf->dot11MeshHWMPRootMode;
		ieee80211_mesh_root_setup(ifmsh);
	}
2169
	if (_chg_mesh_attr(NL80211_MESHCONF_GATE_ANNOUNCEMENTS, mask)) {
T
Thomas Pedersen 已提交
2170 2171 2172 2173
		/* our current gate announcement implementation rides on root
		 * announcements, so require this ifmsh to also be a root node
		 * */
		if (nconf->dot11MeshGateAnnouncementProtocol &&
2174 2175
		    !(conf->dot11MeshHWMPRootMode > IEEE80211_ROOTMODE_ROOT)) {
			conf->dot11MeshHWMPRootMode = IEEE80211_PROACTIVE_RANN;
T
Thomas Pedersen 已提交
2176 2177
			ieee80211_mesh_root_setup(ifmsh);
		}
2178 2179 2180
		conf->dot11MeshGateAnnouncementProtocol =
			nconf->dot11MeshGateAnnouncementProtocol;
	}
2181
	if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_RANN_INTERVAL, mask))
2182 2183
		conf->dot11MeshHWMPRannInterval =
			nconf->dot11MeshHWMPRannInterval;
2184 2185
	if (_chg_mesh_attr(NL80211_MESHCONF_FORWARDING, mask))
		conf->dot11MeshForwarding = nconf->dot11MeshForwarding;
2186 2187 2188 2189
	if (_chg_mesh_attr(NL80211_MESHCONF_RSSI_THRESHOLD, mask)) {
		/* our RSSI threshold implementation is supported only for
		 * devices that report signal in dBm.
		 */
2190
		if (!ieee80211_hw_check(&sdata->local->hw, SIGNAL_DBM))
2191 2192 2193
			return -ENOTSUPP;
		conf->rssi_threshold = nconf->rssi_threshold;
	}
2194 2195 2196 2197 2198
	if (_chg_mesh_attr(NL80211_MESHCONF_HT_OPMODE, mask)) {
		conf->ht_opmode = nconf->ht_opmode;
		sdata->vif.bss_conf.ht_operation_mode = nconf->ht_opmode;
		ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_HT);
	}
2199 2200 2201 2202 2203 2204
	if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_PATH_TO_ROOT_TIMEOUT, mask))
		conf->dot11MeshHWMPactivePathToRootTimeout =
			nconf->dot11MeshHWMPactivePathToRootTimeout;
	if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_ROOT_INTERVAL, mask))
		conf->dot11MeshHWMProotInterval =
			nconf->dot11MeshHWMProotInterval;
2205 2206 2207
	if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_CONFIRMATION_INTERVAL, mask))
		conf->dot11MeshHWMPconfirmationInterval =
			nconf->dot11MeshHWMPconfirmationInterval;
M
Marco Porsch 已提交
2208 2209 2210 2211
	if (_chg_mesh_attr(NL80211_MESHCONF_POWER_MODE, mask)) {
		conf->power_mode = nconf->power_mode;
		ieee80211_mps_local_status_update(sdata);
	}
T
Thomas Pedersen 已提交
2212
	if (_chg_mesh_attr(NL80211_MESHCONF_AWAKE_WINDOW, mask))
M
Marco Porsch 已提交
2213 2214
		conf->dot11MeshAwakeWindowDuration =
			nconf->dot11MeshAwakeWindowDuration;
2215 2216
	if (_chg_mesh_attr(NL80211_MESHCONF_PLINK_TIMEOUT, mask))
		conf->plink_timeout = nconf->plink_timeout;
2217 2218 2219
	if (_chg_mesh_attr(NL80211_MESHCONF_CONNECTED_TO_GATE, mask))
		conf->dot11MeshConnectedToMeshGate =
			nconf->dot11MeshConnectedToMeshGate;
2220 2221
	if (_chg_mesh_attr(NL80211_MESHCONF_NOLEARN, mask))
		conf->dot11MeshNolearn = nconf->dot11MeshNolearn;
2222 2223 2224
	if (_chg_mesh_attr(NL80211_MESHCONF_CONNECTED_TO_AS, mask))
		conf->dot11MeshConnectedToAuthServer =
			nconf->dot11MeshConnectedToAuthServer;
T
Thomas Pedersen 已提交
2225
	ieee80211_mbss_info_change_notify(sdata, BSS_CHANGED_BEACON);
2226 2227 2228
	return 0;
}

2229 2230 2231 2232 2233 2234
static int ieee80211_join_mesh(struct wiphy *wiphy, struct net_device *dev,
			       const struct mesh_config *conf,
			       const struct mesh_setup *setup)
{
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
	struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;
2235
	int err;
2236

2237 2238 2239 2240
	memcpy(&ifmsh->mshcfg, conf, sizeof(struct mesh_config));
	err = copy_mesh_setup(ifmsh, setup);
	if (err)
		return err;
2241

2242 2243
	sdata->control_port_over_nl80211 = setup->control_port_over_nl80211;

2244 2245 2246 2247
	/* can mesh use other SMPS modes? */
	sdata->smps_mode = IEEE80211_SMPS_OFF;
	sdata->needed_rx_chains = sdata->local->rx_chains;

2248
	mutex_lock(&sdata->local->mtx);
2249
	err = ieee80211_vif_use_channel(sdata, &setup->chandef,
J
Johannes Berg 已提交
2250
					IEEE80211_CHANCTX_SHARED);
2251
	mutex_unlock(&sdata->local->mtx);
2252 2253 2254
	if (err)
		return err;

T
Thomas Pedersen 已提交
2255
	return ieee80211_start_mesh(sdata);
2256 2257 2258 2259 2260 2261 2262
}

static int ieee80211_leave_mesh(struct wiphy *wiphy, struct net_device *dev)
{
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);

	ieee80211_stop_mesh(sdata);
2263
	mutex_lock(&sdata->local->mtx);
J
Johannes Berg 已提交
2264
	ieee80211_vif_release_channel(sdata);
2265
	kfree(sdata->u.mesh.ie);
2266
	mutex_unlock(&sdata->local->mtx);
2267 2268 2269

	return 0;
}
2270 2271
#endif

2272 2273 2274 2275
static int ieee80211_change_bss(struct wiphy *wiphy,
				struct net_device *dev,
				struct bss_parameters *params)
{
J
Johannes Berg 已提交
2276
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
2277
	struct ieee80211_supported_band *sband;
2278 2279
	u32 changed = 0;

2280
	if (!sdata_dereference(sdata->u.ap.beacon, sdata))
J
Johannes Berg 已提交
2281 2282
		return -ENOENT;

2283 2284 2285
	sband = ieee80211_get_sband(sdata);
	if (!sband)
		return -EINVAL;
2286 2287

	if (params->use_cts_prot >= 0) {
J
Johannes Berg 已提交
2288
		sdata->vif.bss_conf.use_cts_prot = params->use_cts_prot;
2289 2290 2291
		changed |= BSS_CHANGED_ERP_CTS_PROT;
	}
	if (params->use_short_preamble >= 0) {
J
Johannes Berg 已提交
2292
		sdata->vif.bss_conf.use_short_preamble =
2293 2294 2295
			params->use_short_preamble;
		changed |= BSS_CHANGED_ERP_PREAMBLE;
	}
2296 2297

	if (!sdata->vif.bss_conf.use_short_slot &&
2298 2299
	    (sband->band == NL80211_BAND_5GHZ ||
	     sband->band == NL80211_BAND_6GHZ)) {
2300 2301 2302 2303
		sdata->vif.bss_conf.use_short_slot = true;
		changed |= BSS_CHANGED_ERP_SLOT;
	}

2304
	if (params->use_short_slot_time >= 0) {
J
Johannes Berg 已提交
2305
		sdata->vif.bss_conf.use_short_slot =
2306 2307 2308 2309
			params->use_short_slot_time;
		changed |= BSS_CHANGED_ERP_SLOT;
	}

2310
	if (params->basic_rates) {
2311
		ieee80211_parse_bitrates(&sdata->vif.bss_conf.chandef,
2312
					 wiphy->bands[sband->band],
2313 2314 2315
					 params->basic_rates,
					 params->basic_rates_len,
					 &sdata->vif.bss_conf.basic_rates);
2316
		changed |= BSS_CHANGED_BASIC_RATES;
2317
		ieee80211_check_rate_mask(sdata);
2318 2319
	}

2320 2321 2322 2323 2324
	if (params->ap_isolate >= 0) {
		if (params->ap_isolate)
			sdata->flags |= IEEE80211_SDATA_DONT_BRIDGE_PACKETS;
		else
			sdata->flags &= ~IEEE80211_SDATA_DONT_BRIDGE_PACKETS;
J
Johannes Berg 已提交
2325
		ieee80211_check_fast_rx_iface(sdata);
2326 2327
	}

2328 2329 2330 2331 2332 2333
	if (params->ht_opmode >= 0) {
		sdata->vif.bss_conf.ht_operation_mode =
			(u16) params->ht_opmode;
		changed |= BSS_CHANGED_HT;
	}

2334
	if (params->p2p_ctwindow >= 0) {
J
Janusz Dziedzic 已提交
2335 2336 2337 2338
		sdata->vif.bss_conf.p2p_noa_attr.oppps_ctwindow &=
					~IEEE80211_P2P_OPPPS_CTWINDOW_MASK;
		sdata->vif.bss_conf.p2p_noa_attr.oppps_ctwindow |=
			params->p2p_ctwindow & IEEE80211_P2P_OPPPS_CTWINDOW_MASK;
2339 2340 2341
		changed |= BSS_CHANGED_P2P_PS;
	}

J
Janusz Dziedzic 已提交
2342 2343 2344 2345 2346 2347 2348
	if (params->p2p_opp_ps > 0) {
		sdata->vif.bss_conf.p2p_noa_attr.oppps_ctwindow |=
					IEEE80211_P2P_OPPPS_ENABLE_BIT;
		changed |= BSS_CHANGED_P2P_PS;
	} else if (params->p2p_opp_ps == 0) {
		sdata->vif.bss_conf.p2p_noa_attr.oppps_ctwindow &=
					~IEEE80211_P2P_OPPPS_ENABLE_BIT;
2349 2350 2351
		changed |= BSS_CHANGED_P2P_PS;
	}

2352 2353 2354 2355 2356
	ieee80211_bss_info_change_notify(sdata, changed);

	return 0;
}

2357
static int ieee80211_set_txq_params(struct wiphy *wiphy,
2358
				    struct net_device *dev,
2359 2360 2361
				    struct ieee80211_txq_params *params)
{
	struct ieee80211_local *local = wiphy_priv(wiphy);
2362
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
2363 2364 2365 2366 2367
	struct ieee80211_tx_queue_params p;

	if (!local->ops->conf_tx)
		return -EOPNOTSUPP;

2368 2369 2370
	if (local->hw.queues < IEEE80211_NUM_ACS)
		return -EOPNOTSUPP;

2371 2372 2373 2374 2375
	memset(&p, 0, sizeof(p));
	p.aifs = params->aifs;
	p.cw_max = params->cwmax;
	p.cw_min = params->cwmin;
	p.txop = params->txop;
K
Kalle Valo 已提交
2376 2377 2378 2379 2380 2381 2382

	/*
	 * Setting tx queue params disables u-apsd because it's only
	 * called in master mode.
	 */
	p.uapsd = false;

2383 2384
	ieee80211_regulatory_limit_wmm_params(sdata, &p, params->ac);

2385 2386
	sdata->tx_conf[params->ac] = p;
	if (drv_conf_tx(local, sdata, params->ac, &p)) {
J
Joe Perches 已提交
2387
		wiphy_debug(local->hw.wiphy,
2388 2389
			    "failed to set TX queue parameters for AC %d\n",
			    params->ac);
2390 2391 2392
		return -EINVAL;
	}

2393 2394
	ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_QOS);

2395 2396 2397
	return 0;
}

2398
#ifdef CONFIG_PM
J
Johannes Berg 已提交
2399 2400
static int ieee80211_suspend(struct wiphy *wiphy,
			     struct cfg80211_wowlan *wowlan)
2401
{
2402
	return __ieee80211_suspend(wiphy_priv(wiphy), wowlan);
2403 2404 2405 2406 2407 2408 2409 2410 2411 2412 2413
}

static int ieee80211_resume(struct wiphy *wiphy)
{
	return __ieee80211_resume(wiphy_priv(wiphy));
}
#else
#define ieee80211_suspend NULL
#define ieee80211_resume NULL
#endif

2414 2415 2416
static int ieee80211_scan(struct wiphy *wiphy,
			  struct cfg80211_scan_request *req)
{
J
Johannes Berg 已提交
2417 2418 2419
	struct ieee80211_sub_if_data *sdata;

	sdata = IEEE80211_WDEV_TO_SUB_IF(req->wdev);
2420

2421 2422 2423 2424 2425
	switch (ieee80211_vif_type_p2p(&sdata->vif)) {
	case NL80211_IFTYPE_STATION:
	case NL80211_IFTYPE_ADHOC:
	case NL80211_IFTYPE_MESH_POINT:
	case NL80211_IFTYPE_P2P_CLIENT:
2426
	case NL80211_IFTYPE_P2P_DEVICE:
2427 2428 2429 2430
		break;
	case NL80211_IFTYPE_P2P_GO:
		if (sdata->local->ops->hw_scan)
			break;
2431 2432 2433 2434 2435
		/*
		 * FIXME: implement NoA while scanning in software,
		 * for now fall through to allow scanning only when
		 * beaconing hasn't been configured yet
		 */
2436
		fallthrough;
2437
	case NL80211_IFTYPE_AP:
2438 2439 2440 2441 2442 2443 2444 2445 2446 2447
		/*
		 * If the scan has been forced (and the driver supports
		 * forcing), don't care about being beaconing already.
		 * This will create problems to the attached stations (e.g. all
		 * the  frames sent while scanning on other channel will be
		 * lost)
		 */
		if (sdata->u.ap.beacon &&
		    (!(wiphy->features & NL80211_FEATURE_AP_SCAN) ||
		     !(req->flags & NL80211_SCAN_FLAG_AP)))
2448 2449
			return -EOPNOTSUPP;
		break;
2450
	case NL80211_IFTYPE_NAN:
2451 2452 2453
	default:
		return -EOPNOTSUPP;
	}
2454 2455 2456 2457

	return ieee80211_request_scan(sdata, req);
}

2458 2459 2460 2461 2462
static void ieee80211_abort_scan(struct wiphy *wiphy, struct wireless_dev *wdev)
{
	ieee80211_scan_cancel(wiphy_priv(wiphy));
}

2463 2464 2465 2466 2467 2468 2469 2470 2471 2472 2473 2474 2475 2476
static int
ieee80211_sched_scan_start(struct wiphy *wiphy,
			   struct net_device *dev,
			   struct cfg80211_sched_scan_request *req)
{
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);

	if (!sdata->local->ops->sched_scan_start)
		return -EOPNOTSUPP;

	return ieee80211_request_sched_scan_start(sdata, req);
}

static int
2477 2478
ieee80211_sched_scan_stop(struct wiphy *wiphy, struct net_device *dev,
			  u64 reqid)
2479
{
2480
	struct ieee80211_local *local = wiphy_priv(wiphy);
2481

2482
	if (!local->ops->sched_scan_stop)
2483 2484
		return -EOPNOTSUPP;

2485
	return ieee80211_request_sched_scan_stop(local);
2486 2487
}

2488 2489 2490
static int ieee80211_auth(struct wiphy *wiphy, struct net_device *dev,
			  struct cfg80211_auth_request *req)
{
2491
	return ieee80211_mgd_auth(IEEE80211_DEV_TO_SUB_IF(dev), req);
2492 2493 2494 2495 2496
}

static int ieee80211_assoc(struct wiphy *wiphy, struct net_device *dev,
			   struct cfg80211_assoc_request *req)
{
2497
	return ieee80211_mgd_assoc(IEEE80211_DEV_TO_SUB_IF(dev), req);
2498 2499 2500
}

static int ieee80211_deauth(struct wiphy *wiphy, struct net_device *dev,
2501
			    struct cfg80211_deauth_request *req)
2502
{
2503
	return ieee80211_mgd_deauth(IEEE80211_DEV_TO_SUB_IF(dev), req);
2504 2505 2506
}

static int ieee80211_disassoc(struct wiphy *wiphy, struct net_device *dev,
2507
			      struct cfg80211_disassoc_request *req)
2508
{
2509
	return ieee80211_mgd_disassoc(IEEE80211_DEV_TO_SUB_IF(dev), req);
2510 2511
}

2512 2513 2514
static int ieee80211_join_ibss(struct wiphy *wiphy, struct net_device *dev,
			       struct cfg80211_ibss_params *params)
{
J
Johannes Berg 已提交
2515
	return ieee80211_ibss_join(IEEE80211_DEV_TO_SUB_IF(dev), params);
2516 2517 2518 2519
}

static int ieee80211_leave_ibss(struct wiphy *wiphy, struct net_device *dev)
{
J
Johannes Berg 已提交
2520
	return ieee80211_ibss_leave(IEEE80211_DEV_TO_SUB_IF(dev));
2521 2522
}

2523 2524 2525 2526 2527 2528 2529 2530 2531 2532 2533
static int ieee80211_join_ocb(struct wiphy *wiphy, struct net_device *dev,
			      struct ocb_setup *setup)
{
	return ieee80211_ocb_join(IEEE80211_DEV_TO_SUB_IF(dev), setup);
}

static int ieee80211_leave_ocb(struct wiphy *wiphy, struct net_device *dev)
{
	return ieee80211_ocb_leave(IEEE80211_DEV_TO_SUB_IF(dev));
}

2534
static int ieee80211_set_mcast_rate(struct wiphy *wiphy, struct net_device *dev,
2535
				    int rate[NUM_NL80211_BANDS])
2536 2537 2538
{
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);

2539
	memcpy(sdata->vif.bss_conf.mcast_rate, rate,
2540
	       sizeof(int) * NUM_NL80211_BANDS);
2541

2542 2543
	ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_MCAST_RATE);

2544 2545 2546
	return 0;
}

2547 2548 2549
static int ieee80211_set_wiphy_params(struct wiphy *wiphy, u32 changed)
{
	struct ieee80211_local *local = wiphy_priv(wiphy);
2550
	int err;
2551

2552
	if (changed & WIPHY_PARAM_FRAG_THRESHOLD) {
J
Johannes Berg 已提交
2553 2554
		ieee80211_check_fast_xmit_all(local);

2555 2556
		err = drv_set_frag_threshold(local, wiphy->frag_threshold);

J
Johannes Berg 已提交
2557 2558
		if (err) {
			ieee80211_check_fast_xmit_all(local);
2559
			return err;
J
Johannes Berg 已提交
2560
		}
2561 2562
	}

2563 2564 2565 2566 2567 2568 2569
	if ((changed & WIPHY_PARAM_COVERAGE_CLASS) ||
	    (changed & WIPHY_PARAM_DYN_ACK)) {
		s16 coverage_class;

		coverage_class = changed & WIPHY_PARAM_COVERAGE_CLASS ?
					wiphy->coverage_class : -1;
		err = drv_set_coverage_class(local, coverage_class);
2570 2571 2572 2573 2574

		if (err)
			return err;
	}

2575
	if (changed & WIPHY_PARAM_RTS_THRESHOLD) {
2576
		err = drv_set_rts_threshold(local, wiphy->rts_threshold);
2577

2578 2579
		if (err)
			return err;
2580 2581
	}

2582 2583 2584
	if (changed & WIPHY_PARAM_RETRY_SHORT) {
		if (wiphy->retry_short > IEEE80211_MAX_TX_RETRY)
			return -EINVAL;
2585
		local->hw.conf.short_frame_max_tx_count = wiphy->retry_short;
2586 2587 2588 2589
	}
	if (changed & WIPHY_PARAM_RETRY_LONG) {
		if (wiphy->retry_long > IEEE80211_MAX_TX_RETRY)
			return -EINVAL;
2590
		local->hw.conf.long_frame_max_tx_count = wiphy->retry_long;
2591
	}
2592 2593 2594 2595
	if (changed &
	    (WIPHY_PARAM_RETRY_SHORT | WIPHY_PARAM_RETRY_LONG))
		ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_RETRY_LIMITS);

2596 2597 2598 2599 2600
	if (changed & (WIPHY_PARAM_TXQ_LIMIT |
		       WIPHY_PARAM_TXQ_MEMORY_LIMIT |
		       WIPHY_PARAM_TXQ_QUANTUM))
		ieee80211_txq_set_params(local);

2601 2602 2603
	return 0;
}

2604
static int ieee80211_set_tx_power(struct wiphy *wiphy,
2605
				  struct wireless_dev *wdev,
2606
				  enum nl80211_tx_power_setting type, int mbm)
2607 2608
{
	struct ieee80211_local *local = wiphy_priv(wiphy);
2609
	struct ieee80211_sub_if_data *sdata;
2610 2611
	enum nl80211_tx_power_setting txp_type = type;
	bool update_txp_type = false;
2612
	bool has_monitor = false;
2613

2614 2615 2616
	if (wdev) {
		sdata = IEEE80211_WDEV_TO_SUB_IF(wdev);

2617 2618 2619 2620 2621 2622
		if (sdata->vif.type == NL80211_IFTYPE_MONITOR) {
			sdata = rtnl_dereference(local->monitor_sdata);
			if (!sdata)
				return -EOPNOTSUPP;
		}

2623 2624 2625
		switch (type) {
		case NL80211_TX_POWER_AUTOMATIC:
			sdata->user_power_level = IEEE80211_UNSET_POWER_LEVEL;
2626
			txp_type = NL80211_TX_POWER_LIMITED;
2627 2628 2629 2630 2631 2632 2633 2634 2635
			break;
		case NL80211_TX_POWER_LIMITED:
		case NL80211_TX_POWER_FIXED:
			if (mbm < 0 || (mbm % 100))
				return -EOPNOTSUPP;
			sdata->user_power_level = MBM_TO_DBM(mbm);
			break;
		}

2636 2637 2638 2639 2640 2641
		if (txp_type != sdata->vif.bss_conf.txpower_type) {
			update_txp_type = true;
			sdata->vif.bss_conf.txpower_type = txp_type;
		}

		ieee80211_recalc_txpower(sdata, update_txp_type);
2642 2643 2644

		return 0;
	}
J
Johannes Berg 已提交
2645

2646
	switch (type) {
2647
	case NL80211_TX_POWER_AUTOMATIC:
2648
		local->user_power_level = IEEE80211_UNSET_POWER_LEVEL;
2649
		txp_type = NL80211_TX_POWER_LIMITED;
2650
		break;
2651 2652 2653 2654 2655
	case NL80211_TX_POWER_LIMITED:
	case NL80211_TX_POWER_FIXED:
		if (mbm < 0 || (mbm % 100))
			return -EOPNOTSUPP;
		local->user_power_level = MBM_TO_DBM(mbm);
2656 2657 2658
		break;
	}

2659
	mutex_lock(&local->iflist_mtx);
2660
	list_for_each_entry(sdata, &local->interfaces, list) {
2661 2662 2663 2664
		if (sdata->vif.type == NL80211_IFTYPE_MONITOR) {
			has_monitor = true;
			continue;
		}
2665
		sdata->user_power_level = local->user_power_level;
2666 2667 2668 2669
		if (txp_type != sdata->vif.bss_conf.txpower_type)
			update_txp_type = true;
		sdata->vif.bss_conf.txpower_type = txp_type;
	}
2670 2671 2672
	list_for_each_entry(sdata, &local->interfaces, list) {
		if (sdata->vif.type == NL80211_IFTYPE_MONITOR)
			continue;
2673
		ieee80211_recalc_txpower(sdata, update_txp_type);
2674
	}
2675
	mutex_unlock(&local->iflist_mtx);
2676

2677 2678 2679 2680 2681 2682 2683 2684 2685 2686 2687 2688
	if (has_monitor) {
		sdata = rtnl_dereference(local->monitor_sdata);
		if (sdata) {
			sdata->user_power_level = local->user_power_level;
			if (txp_type != sdata->vif.bss_conf.txpower_type)
				update_txp_type = true;
			sdata->vif.bss_conf.txpower_type = txp_type;

			ieee80211_recalc_txpower(sdata, update_txp_type);
		}
	}

2689 2690 2691
	return 0;
}

2692 2693 2694
static int ieee80211_get_tx_power(struct wiphy *wiphy,
				  struct wireless_dev *wdev,
				  int *dbm)
2695 2696
{
	struct ieee80211_local *local = wiphy_priv(wiphy);
2697
	struct ieee80211_sub_if_data *sdata = IEEE80211_WDEV_TO_SUB_IF(wdev);
2698

2699 2700 2701
	if (local->ops->get_txpower)
		return drv_get_txpower(local, sdata, dbm);

2702 2703 2704 2705
	if (!local->use_chanctx)
		*dbm = local->hw.conf.power_level;
	else
		*dbm = sdata->vif.bss_conf.txpower;
2706 2707 2708 2709

	return 0;
}

J
Johannes Berg 已提交
2710 2711 2712 2713 2714 2715 2716
static void ieee80211_rfkill_poll(struct wiphy *wiphy)
{
	struct ieee80211_local *local = wiphy_priv(wiphy);

	drv_rfkill_poll(local);
}

2717
#ifdef CONFIG_NL80211_TESTMODE
2718 2719 2720
static int ieee80211_testmode_cmd(struct wiphy *wiphy,
				  struct wireless_dev *wdev,
				  void *data, int len)
2721 2722
{
	struct ieee80211_local *local = wiphy_priv(wiphy);
2723
	struct ieee80211_vif *vif = NULL;
2724 2725 2726 2727

	if (!local->ops->testmode_cmd)
		return -EOPNOTSUPP;

2728 2729 2730 2731 2732 2733 2734 2735 2736
	if (wdev) {
		struct ieee80211_sub_if_data *sdata;

		sdata = IEEE80211_WDEV_TO_SUB_IF(wdev);
		if (sdata->flags & IEEE80211_SDATA_IN_DRIVER)
			vif = &sdata->vif;
	}

	return local->ops->testmode_cmd(&local->hw, vif, data, len);
2737
}
W
Wey-Yi Guy 已提交
2738 2739 2740 2741 2742 2743 2744 2745 2746 2747 2748 2749 2750

static int ieee80211_testmode_dump(struct wiphy *wiphy,
				   struct sk_buff *skb,
				   struct netlink_callback *cb,
				   void *data, int len)
{
	struct ieee80211_local *local = wiphy_priv(wiphy);

	if (!local->ops->testmode_dump)
		return -EOPNOTSUPP;

	return local->ops->testmode_dump(&local->hw, skb, cb, data, len);
}
2751 2752
#endif

2753 2754
int __ieee80211_request_smps_mgd(struct ieee80211_sub_if_data *sdata,
				 enum ieee80211_smps_mode smps_mode)
2755 2756 2757 2758
{
	const u8 *ap;
	enum ieee80211_smps_mode old_req;
	int err;
2759 2760
	struct sta_info *sta;
	bool tdls_peer_found = false;
2761

2762
	lockdep_assert_held(&sdata->wdev.mtx);
2763

2764 2765 2766
	if (WARN_ON_ONCE(sdata->vif.type != NL80211_IFTYPE_STATION))
		return -EINVAL;

2767 2768 2769 2770 2771 2772 2773 2774 2775
	old_req = sdata->u.mgd.req_smps;
	sdata->u.mgd.req_smps = smps_mode;

	if (old_req == smps_mode &&
	    smps_mode != IEEE80211_SMPS_AUTOMATIC)
		return 0;

	/*
	 * If not associated, or current association is not an HT
2776 2777
	 * association, there's no need to do anything, just store
	 * the new value until we associate.
2778 2779
	 */
	if (!sdata->u.mgd.associated ||
2780
	    sdata->vif.bss_conf.chandef.width == NL80211_CHAN_WIDTH_20_NOHT)
2781 2782
		return 0;

2783
	ap = sdata->u.mgd.associated->bssid;
2784

2785 2786 2787 2788 2789 2790 2791 2792 2793 2794 2795
	rcu_read_lock();
	list_for_each_entry_rcu(sta, &sdata->local->sta_list, list) {
		if (!sta->sta.tdls || sta->sdata != sdata || !sta->uploaded ||
		    !test_sta_flag(sta, WLAN_STA_AUTHORIZED))
			continue;

		tdls_peer_found = true;
		break;
	}
	rcu_read_unlock();

2796
	if (smps_mode == IEEE80211_SMPS_AUTOMATIC) {
2797
		if (tdls_peer_found || !sdata->u.mgd.powersave)
2798
			smps_mode = IEEE80211_SMPS_OFF;
2799 2800
		else
			smps_mode = IEEE80211_SMPS_DYNAMIC;
2801 2802 2803 2804 2805 2806 2807
	}

	/* send SM PS frame to AP */
	err = ieee80211_send_smps_action(sdata, smps_mode,
					 ap, ap);
	if (err)
		sdata->u.mgd.req_smps = old_req;
2808 2809
	else if (smps_mode != IEEE80211_SMPS_OFF && tdls_peer_found)
		ieee80211_teardown_tdls_peers(sdata);
2810 2811 2812 2813

	return err;
}

J
Johannes Berg 已提交
2814 2815 2816 2817 2818 2819
static int ieee80211_set_power_mgmt(struct wiphy *wiphy, struct net_device *dev,
				    bool enabled, int timeout)
{
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
	struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);

2820
	if (sdata->vif.type != NL80211_IFTYPE_STATION)
2821 2822
		return -EOPNOTSUPP;

2823
	if (!ieee80211_hw_check(&local->hw, SUPPORTS_PS))
J
Johannes Berg 已提交
2824 2825 2826
		return -EOPNOTSUPP;

	if (enabled == sdata->u.mgd.powersave &&
2827
	    timeout == local->dynamic_ps_forced_timeout)
J
Johannes Berg 已提交
2828 2829 2830
		return 0;

	sdata->u.mgd.powersave = enabled;
2831
	local->dynamic_ps_forced_timeout = timeout;
J
Johannes Berg 已提交
2832

2833
	/* no change, but if automatic follow powersave */
2834
	sdata_lock(sdata);
2835
	__ieee80211_request_smps_mgd(sdata, sdata->u.mgd.req_smps);
2836
	sdata_unlock(sdata);
2837

2838
	if (ieee80211_hw_check(&local->hw, SUPPORTS_DYNAMIC_PS))
J
Johannes Berg 已提交
2839 2840
		ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_PS);

J
Johannes Berg 已提交
2841
	ieee80211_recalc_ps(local);
E
Eliad Peller 已提交
2842
	ieee80211_recalc_ps_vif(sdata);
2843
	ieee80211_check_fast_rx_iface(sdata);
J
Johannes Berg 已提交
2844 2845 2846 2847

	return 0;
}

2848 2849 2850 2851 2852 2853 2854 2855 2856 2857 2858 2859
static int ieee80211_set_cqm_rssi_config(struct wiphy *wiphy,
					 struct net_device *dev,
					 s32 rssi_thold, u32 rssi_hyst)
{
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
	struct ieee80211_vif *vif = &sdata->vif;
	struct ieee80211_bss_conf *bss_conf = &vif->bss_conf;

	if (rssi_thold == bss_conf->cqm_rssi_thold &&
	    rssi_hyst == bss_conf->cqm_rssi_hyst)
		return 0;

2860 2861 2862 2863
	if (sdata->vif.driver_flags & IEEE80211_VIF_BEACON_FILTER &&
	    !(sdata->vif.driver_flags & IEEE80211_VIF_SUPPORTS_CQM_RSSI))
		return -EOPNOTSUPP;

2864 2865
	bss_conf->cqm_rssi_thold = rssi_thold;
	bss_conf->cqm_rssi_hyst = rssi_hyst;
2866 2867 2868 2869 2870 2871 2872 2873 2874 2875 2876 2877 2878 2879 2880 2881 2882 2883 2884 2885 2886 2887 2888 2889 2890 2891 2892
	bss_conf->cqm_rssi_low = 0;
	bss_conf->cqm_rssi_high = 0;
	sdata->u.mgd.last_cqm_event_signal = 0;

	/* tell the driver upon association, unless already associated */
	if (sdata->u.mgd.associated &&
	    sdata->vif.driver_flags & IEEE80211_VIF_SUPPORTS_CQM_RSSI)
		ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_CQM);

	return 0;
}

static int ieee80211_set_cqm_rssi_range_config(struct wiphy *wiphy,
					       struct net_device *dev,
					       s32 rssi_low, s32 rssi_high)
{
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
	struct ieee80211_vif *vif = &sdata->vif;
	struct ieee80211_bss_conf *bss_conf = &vif->bss_conf;

	if (sdata->vif.driver_flags & IEEE80211_VIF_BEACON_FILTER)
		return -EOPNOTSUPP;

	bss_conf->cqm_rssi_low = rssi_low;
	bss_conf->cqm_rssi_high = rssi_high;
	bss_conf->cqm_rssi_thold = 0;
	bss_conf->cqm_rssi_hyst = 0;
2893
	sdata->u.mgd.last_cqm_event_signal = 0;
2894 2895

	/* tell the driver upon association, unless already associated */
2896 2897
	if (sdata->u.mgd.associated &&
	    sdata->vif.driver_flags & IEEE80211_VIF_SUPPORTS_CQM_RSSI)
2898 2899 2900 2901 2902
		ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_CQM);

	return 0;
}

J
Johannes Berg 已提交
2903 2904 2905 2906 2907 2908 2909
static int ieee80211_set_bitrate_mask(struct wiphy *wiphy,
				      struct net_device *dev,
				      const u8 *addr,
				      const struct cfg80211_bitrate_mask *mask)
{
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
	struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
2910
	int i, ret;
2911

2912 2913 2914
	if (!ieee80211_sdata_running(sdata))
		return -ENETDOWN;

2915 2916 2917 2918 2919 2920 2921 2922 2923 2924 2925 2926 2927 2928 2929
	/*
	 * If active validate the setting and reject it if it doesn't leave
	 * at least one basic rate usable, since we really have to be able
	 * to send something, and if we're an AP we have to be able to do
	 * so at a basic rate so that all clients can receive it.
	 */
	if (rcu_access_pointer(sdata->vif.chanctx_conf) &&
	    sdata->vif.bss_conf.chandef.chan) {
		u32 basic_rates = sdata->vif.bss_conf.basic_rates;
		enum nl80211_band band = sdata->vif.bss_conf.chandef.chan->band;

		if (!(mask->control[band].legacy & basic_rates))
			return -EINVAL;
	}

2930 2931 2932 2933 2934 2935
	if (ieee80211_hw_check(&local->hw, HAS_RATE_CONTROL)) {
		ret = drv_set_bitrate_mask(local, sdata, mask);
		if (ret)
			return ret;
	}

2936
	for (i = 0; i < NUM_NL80211_BANDS; i++) {
2937 2938 2939
		struct ieee80211_supported_band *sband = wiphy->bands[i];
		int j;

2940
		sdata->rc_rateidx_mask[i] = mask->control[i].legacy;
2941 2942
		memcpy(sdata->rc_rateidx_mcs_mask[i], mask->control[i].ht_mcs,
		       sizeof(mask->control[i].ht_mcs));
2943 2944 2945
		memcpy(sdata->rc_rateidx_vht_mcs_mask[i],
		       mask->control[i].vht_mcs,
		       sizeof(mask->control[i].vht_mcs));
2946 2947

		sdata->rc_has_mcs_mask[i] = false;
2948
		sdata->rc_has_vht_mcs_mask[i] = false;
2949 2950 2951
		if (!sband)
			continue;

2952
		for (j = 0; j < IEEE80211_HT_MCS_MASK_LEN; j++) {
J
Johannes Berg 已提交
2953
			if (sdata->rc_rateidx_mcs_mask[i][j] != 0xff) {
2954
				sdata->rc_has_mcs_mask[i] = true;
2955 2956 2957
				break;
			}
		}
2958

2959
		for (j = 0; j < NL80211_VHT_NSS_MAX; j++) {
J
Johannes Berg 已提交
2960
			if (sdata->rc_rateidx_vht_mcs_mask[i][j] != 0xffff) {
2961
				sdata->rc_has_vht_mcs_mask[i] = true;
2962
				break;
2963
			}
2964
		}
2965
	}
J
Johannes Berg 已提交
2966

2967
	return 0;
J
Johannes Berg 已提交
2968 2969
}

2970 2971
static int ieee80211_start_radar_detection(struct wiphy *wiphy,
					   struct net_device *dev,
2972 2973
					   struct cfg80211_chan_def *chandef,
					   u32 cac_time_ms)
2974 2975 2976 2977 2978
{
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
	struct ieee80211_local *local = sdata->local;
	int err;

2979 2980 2981 2982 2983
	mutex_lock(&local->mtx);
	if (!list_empty(&local->roc_list) || local->scanning) {
		err = -EBUSY;
		goto out_unlock;
	}
2984 2985 2986 2987 2988 2989 2990 2991

	/* whatever, but channel contexts should not complain about that one */
	sdata->smps_mode = IEEE80211_SMPS_OFF;
	sdata->needed_rx_chains = local->rx_chains;

	err = ieee80211_vif_use_channel(sdata, chandef,
					IEEE80211_CHANCTX_SHARED);
	if (err)
2992
		goto out_unlock;
2993 2994

	ieee80211_queue_delayed_work(&sdata->local->hw,
2995 2996
				     &sdata->dfs_cac_timer_work,
				     msecs_to_jiffies(cac_time_ms));
2997

2998 2999 3000
 out_unlock:
	mutex_unlock(&local->mtx);
	return err;
3001 3002
}

3003 3004 3005 3006 3007 3008 3009 3010 3011 3012 3013 3014 3015 3016 3017 3018 3019 3020 3021 3022 3023 3024
static void ieee80211_end_cac(struct wiphy *wiphy,
			      struct net_device *dev)
{
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
	struct ieee80211_local *local = sdata->local;

	mutex_lock(&local->mtx);
	list_for_each_entry(sdata, &local->interfaces, list) {
		/* it might be waiting for the local->mtx, but then
		 * by the time it gets it, sdata->wdev.cac_started
		 * will no longer be true
		 */
		cancel_delayed_work(&sdata->dfs_cac_timer_work);

		if (sdata->wdev.cac_started) {
			ieee80211_vif_release_channel(sdata);
			sdata->wdev.cac_started = false;
		}
	}
	mutex_unlock(&local->mtx);
}

3025 3026 3027 3028 3029 3030 3031 3032 3033
static struct cfg80211_beacon_data *
cfg80211_beacon_dup(struct cfg80211_beacon_data *beacon)
{
	struct cfg80211_beacon_data *new_beacon;
	u8 *pos;
	int len;

	len = beacon->head_len + beacon->tail_len + beacon->beacon_ies_len +
	      beacon->proberesp_ies_len + beacon->assocresp_ies_len +
3034
	      beacon->probe_resp_len + beacon->lci_len + beacon->civicloc_len;
3035 3036 3037 3038 3039 3040 3041 3042 3043 3044 3045 3046 3047 3048 3049 3050 3051 3052 3053 3054 3055 3056 3057 3058 3059 3060 3061 3062 3063 3064 3065 3066 3067 3068 3069 3070 3071 3072

	new_beacon = kzalloc(sizeof(*new_beacon) + len, GFP_KERNEL);
	if (!new_beacon)
		return NULL;

	pos = (u8 *)(new_beacon + 1);
	if (beacon->head_len) {
		new_beacon->head_len = beacon->head_len;
		new_beacon->head = pos;
		memcpy(pos, beacon->head, beacon->head_len);
		pos += beacon->head_len;
	}
	if (beacon->tail_len) {
		new_beacon->tail_len = beacon->tail_len;
		new_beacon->tail = pos;
		memcpy(pos, beacon->tail, beacon->tail_len);
		pos += beacon->tail_len;
	}
	if (beacon->beacon_ies_len) {
		new_beacon->beacon_ies_len = beacon->beacon_ies_len;
		new_beacon->beacon_ies = pos;
		memcpy(pos, beacon->beacon_ies, beacon->beacon_ies_len);
		pos += beacon->beacon_ies_len;
	}
	if (beacon->proberesp_ies_len) {
		new_beacon->proberesp_ies_len = beacon->proberesp_ies_len;
		new_beacon->proberesp_ies = pos;
		memcpy(pos, beacon->proberesp_ies, beacon->proberesp_ies_len);
		pos += beacon->proberesp_ies_len;
	}
	if (beacon->assocresp_ies_len) {
		new_beacon->assocresp_ies_len = beacon->assocresp_ies_len;
		new_beacon->assocresp_ies = pos;
		memcpy(pos, beacon->assocresp_ies, beacon->assocresp_ies_len);
		pos += beacon->assocresp_ies_len;
	}
	if (beacon->probe_resp_len) {
		new_beacon->probe_resp_len = beacon->probe_resp_len;
3073
		new_beacon->probe_resp = pos;
3074 3075 3076
		memcpy(pos, beacon->probe_resp, beacon->probe_resp_len);
		pos += beacon->probe_resp_len;
	}
3077 3078 3079

	/* might copy -1, meaning no changes requested */
	new_beacon->ftm_responder = beacon->ftm_responder;
3080 3081 3082 3083 3084 3085 3086 3087 3088 3089 3090 3091
	if (beacon->lci) {
		new_beacon->lci_len = beacon->lci_len;
		new_beacon->lci = pos;
		memcpy(pos, beacon->lci, beacon->lci_len);
		pos += beacon->lci_len;
	}
	if (beacon->civicloc) {
		new_beacon->civicloc_len = beacon->civicloc_len;
		new_beacon->civicloc = pos;
		memcpy(pos, beacon->civicloc, beacon->civicloc_len);
		pos += beacon->civicloc_len;
	}
3092 3093 3094 3095

	return new_beacon;
}

3096
void ieee80211_csa_finish(struct ieee80211_vif *vif)
3097
{
3098
	struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
3099

3100 3101 3102 3103
	ieee80211_queue_work(&sdata->local->hw,
			     &sdata->csa_finalize_work);
}
EXPORT_SYMBOL(ieee80211_csa_finish);
3104

3105 3106
static int ieee80211_set_after_csa_beacon(struct ieee80211_sub_if_data *sdata,
					  u32 *changed)
3107
{
3108
	int err;
3109

3110 3111
	switch (sdata->vif.type) {
	case NL80211_IFTYPE_AP:
3112 3113
		err = ieee80211_assign_beacon(sdata, sdata->u.ap.next_beacon,
					      NULL);
3114 3115 3116
		kfree(sdata->u.ap.next_beacon);
		sdata->u.ap.next_beacon = NULL;

3117
		if (err < 0)
3118 3119
			return err;
		*changed |= err;
3120 3121
		break;
	case NL80211_IFTYPE_ADHOC:
3122 3123
		err = ieee80211_ibss_finish_csa(sdata);
		if (err < 0)
3124 3125
			return err;
		*changed |= err;
3126
		break;
3127 3128 3129 3130
#ifdef CONFIG_MAC80211_MESH
	case NL80211_IFTYPE_MESH_POINT:
		err = ieee80211_mesh_finish_csa(sdata);
		if (err < 0)
3131 3132
			return err;
		*changed |= err;
3133 3134
		break;
#endif
3135 3136
	default:
		WARN_ON(1);
3137 3138 3139 3140 3141 3142
		return -EINVAL;
	}

	return 0;
}

3143
static int __ieee80211_csa_finalize(struct ieee80211_sub_if_data *sdata)
3144 3145 3146 3147 3148 3149 3150
{
	struct ieee80211_local *local = sdata->local;
	u32 changed = 0;
	int err;

	sdata_assert_lock(sdata);
	lockdep_assert_held(&local->mtx);
3151
	lockdep_assert_held(&local->chanctx_mtx);
3152

3153 3154 3155 3156 3157 3158
	/*
	 * using reservation isn't immediate as it may be deferred until later
	 * with multi-vif. once reservation is complete it will re-schedule the
	 * work with no reserved_chanctx so verify chandef to check if it
	 * completed successfully
	 */
3159

3160 3161 3162 3163 3164 3165 3166 3167 3168
	if (sdata->reserved_chanctx) {
		/*
		 * with multi-vif csa driver may call ieee80211_csa_finish()
		 * many times while waiting for other interfaces to use their
		 * reservations
		 */
		if (sdata->reserved_ready)
			return 0;

3169
		return ieee80211_vif_use_reserved_context(sdata);
3170
	}
3171

3172 3173 3174 3175
	if (!cfg80211_chandef_identical(&sdata->vif.bss_conf.chandef,
					&sdata->csa_chandef))
		return -EINVAL;

3176 3177 3178 3179
	sdata->vif.csa_active = false;

	err = ieee80211_set_after_csa_beacon(sdata, &changed);
	if (err)
3180
		return err;
3181

3182
	ieee80211_bss_info_change_notify(sdata, changed);
3183

3184 3185 3186 3187 3188
	if (sdata->csa_block_tx) {
		ieee80211_wake_vif_queues(local, sdata,
					  IEEE80211_QUEUE_STOP_REASON_CSA);
		sdata->csa_block_tx = false;
	}
3189

3190 3191 3192 3193 3194 3195
	err = drv_post_channel_switch(sdata);
	if (err)
		return err;

	cfg80211_ch_switch_notify(sdata->dev, &sdata->csa_chandef);

3196 3197 3198 3199 3200 3201 3202 3203 3204 3205
	return 0;
}

static void ieee80211_csa_finalize(struct ieee80211_sub_if_data *sdata)
{
	if (__ieee80211_csa_finalize(sdata)) {
		sdata_info(sdata, "failed to finalize CSA, disconnecting\n");
		cfg80211_stop_iface(sdata->local->hw.wiphy, &sdata->wdev,
				    GFP_KERNEL);
	}
3206 3207 3208 3209 3210 3211 3212
}

void ieee80211_csa_finalize_work(struct work_struct *work)
{
	struct ieee80211_sub_if_data *sdata =
		container_of(work, struct ieee80211_sub_if_data,
			     csa_finalize_work);
3213
	struct ieee80211_local *local = sdata->local;
3214 3215

	sdata_lock(sdata);
3216
	mutex_lock(&local->mtx);
3217
	mutex_lock(&local->chanctx_mtx);
3218

3219 3220 3221 3222 3223 3224 3225 3226
	/* AP might have been stopped while waiting for the lock. */
	if (!sdata->vif.csa_active)
		goto unlock;

	if (!ieee80211_sdata_running(sdata))
		goto unlock;

	ieee80211_csa_finalize(sdata);
3227 3228

unlock:
3229
	mutex_unlock(&local->chanctx_mtx);
3230
	mutex_unlock(&local->mtx);
3231
	sdata_unlock(sdata);
3232 3233
}

3234 3235 3236
static int ieee80211_set_csa_beacon(struct ieee80211_sub_if_data *sdata,
				    struct cfg80211_csa_settings *params,
				    u32 *changed)
3237
{
3238
	struct ieee80211_csa_settings csa = {};
3239
	int err;
3240 3241 3242

	switch (sdata->vif.type) {
	case NL80211_IFTYPE_AP:
3243 3244 3245 3246 3247
		sdata->u.ap.next_beacon =
			cfg80211_beacon_dup(&params->beacon_after);
		if (!sdata->u.ap.next_beacon)
			return -ENOMEM;

3248 3249 3250 3251 3252 3253 3254 3255 3256 3257 3258 3259 3260 3261 3262 3263 3264 3265 3266
		/*
		 * With a count of 0, we don't have to wait for any
		 * TBTT before switching, so complete the CSA
		 * immediately.  In theory, with a count == 1 we
		 * should delay the switch until just before the next
		 * TBTT, but that would complicate things so we switch
		 * immediately too.  If we would delay the switch
		 * until the next TBTT, we would have to set the probe
		 * response here.
		 *
		 * TODO: A channel switch with count <= 1 without
		 * sending a CSA action frame is kind of useless,
		 * because the clients won't know we're changing
		 * channels.  The action frame must be implemented
		 * either here or in the userspace.
		 */
		if (params->count <= 1)
			break;

3267
		if ((params->n_counter_offsets_beacon >
3268
		     IEEE80211_MAX_CNTDWN_COUNTERS_NUM) ||
3269
		    (params->n_counter_offsets_presp >
3270
		     IEEE80211_MAX_CNTDWN_COUNTERS_NUM))
3271
			return -EINVAL;
3272

3273 3274 3275 3276 3277
		csa.counter_offsets_beacon = params->counter_offsets_beacon;
		csa.counter_offsets_presp = params->counter_offsets_presp;
		csa.n_counter_offsets_beacon = params->n_counter_offsets_beacon;
		csa.n_counter_offsets_presp = params->n_counter_offsets_presp;
		csa.count = params->count;
3278

3279
		err = ieee80211_assign_beacon(sdata, &params->beacon_csa, &csa);
3280 3281 3282 3283
		if (err < 0) {
			kfree(sdata->u.ap.next_beacon);
			return err;
		}
3284
		*changed |= err;
3285

3286 3287 3288 3289 3290 3291 3292 3293 3294 3295 3296 3297 3298
		break;
	case NL80211_IFTYPE_ADHOC:
		if (!sdata->vif.bss_conf.ibss_joined)
			return -EINVAL;

		if (params->chandef.width != sdata->u.ibss.chandef.width)
			return -EINVAL;

		switch (params->chandef.width) {
		case NL80211_CHAN_WIDTH_40:
			if (cfg80211_get_chandef_type(&params->chandef) !=
			    cfg80211_get_chandef_type(&sdata->u.ibss.chandef))
				return -EINVAL;
3299
			break;
3300 3301 3302 3303 3304 3305 3306 3307 3308 3309 3310 3311 3312 3313
		case NL80211_CHAN_WIDTH_5:
		case NL80211_CHAN_WIDTH_10:
		case NL80211_CHAN_WIDTH_20_NOHT:
		case NL80211_CHAN_WIDTH_20:
			break;
		default:
			return -EINVAL;
		}

		/* changes into another band are not supported */
		if (sdata->u.ibss.chandef.chan->band !=
		    params->chandef.chan->band)
			return -EINVAL;

3314 3315 3316 3317 3318
		/* see comments in the NL80211_IFTYPE_AP block */
		if (params->count > 1) {
			err = ieee80211_ibss_csa_beacon(sdata, params);
			if (err < 0)
				return err;
3319
			*changed |= err;
3320 3321 3322 3323
		}

		ieee80211_send_action_csa(sdata, params);

3324
		break;
3325
#ifdef CONFIG_MAC80211_MESH
3326 3327
	case NL80211_IFTYPE_MESH_POINT: {
		struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;
3328 3329 3330 3331 3332 3333 3334 3335 3336

		if (params->chandef.width != sdata->vif.bss_conf.chandef.width)
			return -EINVAL;

		/* changes into another band are not supported */
		if (sdata->vif.bss_conf.chandef.chan->band !=
		    params->chandef.chan->band)
			return -EINVAL;

3337
		if (ifmsh->csa_role == IEEE80211_MESH_CSA_ROLE_NONE) {
3338
			ifmsh->csa_role = IEEE80211_MESH_CSA_ROLE_INIT;
3339 3340 3341 3342 3343
			if (!ifmsh->pre_value)
				ifmsh->pre_value = 1;
			else
				ifmsh->pre_value++;
		}
3344

3345 3346 3347 3348 3349 3350 3351
		/* see comments in the NL80211_IFTYPE_AP block */
		if (params->count > 1) {
			err = ieee80211_mesh_csa_beacon(sdata, params);
			if (err < 0) {
				ifmsh->csa_role = IEEE80211_MESH_CSA_ROLE_NONE;
				return err;
			}
3352
			*changed |= err;
3353
		}
3354 3355 3356 3357

		if (ifmsh->csa_role == IEEE80211_MESH_CSA_ROLE_INIT)
			ieee80211_send_action_csa(sdata, params);

3358
		break;
3359
		}
3360
#endif
3361 3362 3363 3364
	default:
		return -EOPNOTSUPP;
	}

3365 3366 3367
	return 0;
}

3368 3369 3370
static int
__ieee80211_channel_switch(struct wiphy *wiphy, struct net_device *dev,
			   struct cfg80211_csa_settings *params)
3371 3372 3373
{
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
	struct ieee80211_local *local = sdata->local;
3374
	struct ieee80211_channel_switch ch_switch;
3375
	struct ieee80211_chanctx_conf *conf;
3376
	struct ieee80211_chanctx *chanctx;
3377 3378
	u32 changed = 0;
	int err;
3379 3380

	sdata_assert_lock(sdata);
3381
	lockdep_assert_held(&local->mtx);
3382 3383 3384 3385 3386 3387 3388 3389 3390 3391 3392

	if (!list_empty(&local->roc_list) || local->scanning)
		return -EBUSY;

	if (sdata->wdev.cac_started)
		return -EBUSY;

	if (cfg80211_chandef_identical(&params->chandef,
				       &sdata->vif.bss_conf.chandef))
		return -EINVAL;

3393 3394 3395 3396
	/* don't allow another channel switch if one is already active. */
	if (sdata->vif.csa_active)
		return -EBUSY;

3397 3398 3399 3400
	mutex_lock(&local->chanctx_mtx);
	conf = rcu_dereference_protected(sdata->vif.chanctx_conf,
					 lockdep_is_held(&local->chanctx_mtx));
	if (!conf) {
3401 3402
		err = -EBUSY;
		goto out;
3403 3404
	}

3405 3406 3407 3408 3409 3410
	if (params->chandef.chan->freq_offset) {
		/* this may work, but is untested */
		err = -EOPNOTSUPP;
		goto out;
	}

3411
	chanctx = container_of(conf, struct ieee80211_chanctx, conf);
3412

3413 3414 3415 3416 3417 3418
	ch_switch.timestamp = 0;
	ch_switch.device_timestamp = 0;
	ch_switch.block_tx = params->block_tx;
	ch_switch.chandef = params->chandef;
	ch_switch.count = params->count;

3419 3420 3421 3422
	err = drv_pre_channel_switch(sdata, &ch_switch);
	if (err)
		goto out;

3423 3424 3425 3426 3427
	err = ieee80211_vif_reserve_chanctx(sdata, &params->chandef,
					    chanctx->mode,
					    params->radar_required);
	if (err)
		goto out;
3428

3429 3430 3431 3432 3433 3434
	/* if reservation is invalid then this will fail */
	err = ieee80211_check_combinations(sdata, NULL, chanctx->mode, 0);
	if (err) {
		ieee80211_vif_unreserve_chanctx(sdata);
		goto out;
	}
3435 3436

	err = ieee80211_set_csa_beacon(sdata, params, &changed);
3437 3438 3439 3440
	if (err) {
		ieee80211_vif_unreserve_chanctx(sdata);
		goto out;
	}
3441

3442
	sdata->csa_chandef = params->chandef;
3443
	sdata->csa_block_tx = params->block_tx;
3444 3445
	sdata->vif.csa_active = true;

3446
	if (sdata->csa_block_tx)
3447 3448
		ieee80211_stop_vif_queues(local, sdata,
					  IEEE80211_QUEUE_STOP_REASON_CSA);
3449

3450
	cfg80211_ch_switch_started_notify(sdata->dev, &sdata->csa_chandef,
3451
					  params->count, params->block_tx);
3452

3453 3454 3455 3456 3457 3458 3459
	if (changed) {
		ieee80211_bss_info_change_notify(sdata, changed);
		drv_channel_switch_beacon(sdata, &params->chandef);
	} else {
		/* if the beacon didn't change, we can finalize immediately */
		ieee80211_csa_finalize(sdata);
	}
3460

3461 3462 3463
out:
	mutex_unlock(&local->chanctx_mtx);
	return err;
3464 3465
}

3466 3467 3468 3469 3470 3471 3472 3473 3474 3475 3476 3477 3478 3479
int ieee80211_channel_switch(struct wiphy *wiphy, struct net_device *dev,
			     struct cfg80211_csa_settings *params)
{
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
	struct ieee80211_local *local = sdata->local;
	int err;

	mutex_lock(&local->mtx);
	err = __ieee80211_channel_switch(wiphy, dev, params);
	mutex_unlock(&local->mtx);

	return err;
}

3480 3481 3482 3483 3484 3485 3486 3487 3488 3489 3490 3491 3492
u64 ieee80211_mgmt_tx_cookie(struct ieee80211_local *local)
{
	lockdep_assert_held(&local->mtx);

	local->roc_cookie_counter++;

	/* wow, you wrapped 64 bits ... more likely a bug */
	if (WARN_ON(local->roc_cookie_counter == 0))
		local->roc_cookie_counter++;

	return local->roc_cookie_counter;
}

3493 3494
int ieee80211_attach_ack_skb(struct ieee80211_local *local, struct sk_buff *skb,
			     u64 *cookie, gfp_t gfp)
3495 3496 3497 3498 3499 3500 3501
{
	unsigned long spin_flags;
	struct sk_buff *ack_skb;
	int id;

	ack_skb = skb_copy(skb, gfp);
	if (!ack_skb)
3502
		return -ENOMEM;
3503 3504 3505

	spin_lock_irqsave(&local->ack_status_lock, spin_flags);
	id = idr_alloc(&local->ack_status_frames, ack_skb,
3506
		       1, 0x2000, GFP_ATOMIC);
3507 3508 3509 3510
	spin_unlock_irqrestore(&local->ack_status_lock, spin_flags);

	if (id < 0) {
		kfree_skb(ack_skb);
3511
		return -ENOMEM;
3512 3513 3514 3515 3516 3517 3518
	}

	IEEE80211_SKB_CB(skb)->ack_frame_id = id;

	*cookie = ieee80211_mgmt_tx_cookie(local);
	IEEE80211_SKB_CB(ack_skb)->ack.cookie = *cookie;

3519
	return 0;
3520 3521
}

3522 3523
static void
ieee80211_update_mgmt_frame_registrations(struct wiphy *wiphy,
3524
					  struct wireless_dev *wdev,
3525
					  struct mgmt_frame_regs *upd)
3526 3527
{
	struct ieee80211_local *local = wiphy_priv(wiphy);
3528
	struct ieee80211_sub_if_data *sdata = IEEE80211_WDEV_TO_SUB_IF(wdev);
3529
	u32 preq_mask = BIT(IEEE80211_STYPE_PROBE_REQ >> 4);
3530
	u32 action_mask = BIT(IEEE80211_STYPE_ACTION >> 4);
3531
	bool global_change, intf_change;
3532

3533
	global_change =
3534 3535 3536
		(local->probe_req_reg != !!(upd->global_stypes & preq_mask)) ||
		(local->rx_mcast_action_reg !=
		 !!(upd->global_mcast_stypes & action_mask));
3537
	local->probe_req_reg = upd->global_stypes & preq_mask;
3538
	local->rx_mcast_action_reg = upd->global_mcast_stypes & action_mask;
3539

3540 3541 3542 3543
	intf_change = (sdata->vif.probe_req_reg !=
		       !!(upd->interface_stypes & preq_mask)) ||
		(sdata->vif.rx_mcast_action_reg !=
		 !!(upd->interface_mcast_stypes & action_mask));
3544
	sdata->vif.probe_req_reg = upd->interface_stypes & preq_mask;
3545 3546
	sdata->vif.rx_mcast_action_reg =
		upd->interface_mcast_stypes & action_mask;
3547

3548 3549
	if (!local->open_count)
		return;
3550

3551 3552 3553 3554 3555
	if (intf_change && ieee80211_sdata_running(sdata))
		drv_config_iface_filter(local, sdata,
					sdata->vif.probe_req_reg ?
						FIF_PROBE_REQ : 0,
					FIF_PROBE_REQ);
3556

3557
	if (global_change)
3558
		ieee80211_configure_filter(local);
3559 3560
}

3561 3562 3563 3564 3565 3566 3567 3568 3569 3570 3571 3572 3573 3574 3575 3576 3577
static int ieee80211_set_antenna(struct wiphy *wiphy, u32 tx_ant, u32 rx_ant)
{
	struct ieee80211_local *local = wiphy_priv(wiphy);

	if (local->started)
		return -EOPNOTSUPP;

	return drv_set_antenna(local, tx_ant, rx_ant);
}

static int ieee80211_get_antenna(struct wiphy *wiphy, u32 *tx_ant, u32 *rx_ant)
{
	struct ieee80211_local *local = wiphy_priv(wiphy);

	return drv_get_antenna(local, tx_ant, rx_ant);
}

3578 3579 3580 3581 3582 3583 3584 3585 3586 3587 3588 3589 3590 3591 3592
static int ieee80211_set_rekey_data(struct wiphy *wiphy,
				    struct net_device *dev,
				    struct cfg80211_gtk_rekey_data *data)
{
	struct ieee80211_local *local = wiphy_priv(wiphy);
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);

	if (!local->ops->set_rekey_data)
		return -EOPNOTSUPP;

	drv_set_rekey_data(local, sdata, data);

	return 0;
}

J
Johannes Berg 已提交
3593 3594 3595 3596 3597 3598
static int ieee80211_probe_client(struct wiphy *wiphy, struct net_device *dev,
				  const u8 *peer, u64 *cookie)
{
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
	struct ieee80211_local *local = sdata->local;
	struct ieee80211_qos_hdr *nullfunc;
3599
	struct sk_buff *skb;
J
Johannes Berg 已提交
3600 3601 3602 3603 3604
	int size = sizeof(*nullfunc);
	__le16 fc;
	bool qos;
	struct ieee80211_tx_info *info;
	struct sta_info *sta;
J
Johannes Berg 已提交
3605
	struct ieee80211_chanctx_conf *chanctx_conf;
3606
	enum nl80211_band band;
3607 3608 3609 3610
	int ret;

	/* the lock is needed to assign the cookie later */
	mutex_lock(&local->mtx);
J
Johannes Berg 已提交
3611 3612

	rcu_read_lock();
J
Johannes Berg 已提交
3613 3614
	chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf);
	if (WARN_ON(!chanctx_conf)) {
3615 3616
		ret = -EINVAL;
		goto unlock;
J
Johannes Berg 已提交
3617
	}
3618
	band = chanctx_conf->def.chan->band;
3619
	sta = sta_info_get_bss(sdata, peer);
3620
	if (sta) {
3621
		qos = sta->sta.wme;
3622
	} else {
3623 3624
		ret = -ENOLINK;
		goto unlock;
3625
	}
J
Johannes Berg 已提交
3626 3627 3628 3629 3630 3631 3632 3633 3634 3635 3636 3637 3638

	if (qos) {
		fc = cpu_to_le16(IEEE80211_FTYPE_DATA |
				 IEEE80211_STYPE_QOS_NULLFUNC |
				 IEEE80211_FCTL_FROMDS);
	} else {
		size -= 2;
		fc = cpu_to_le16(IEEE80211_FTYPE_DATA |
				 IEEE80211_STYPE_NULLFUNC |
				 IEEE80211_FCTL_FROMDS);
	}

	skb = dev_alloc_skb(local->hw.extra_tx_headroom + size);
J
Johannes Berg 已提交
3639
	if (!skb) {
3640 3641
		ret = -ENOMEM;
		goto unlock;
J
Johannes Berg 已提交
3642
	}
J
Johannes Berg 已提交
3643 3644 3645 3646 3647

	skb->dev = dev;

	skb_reserve(skb, local->hw.extra_tx_headroom);

3648
	nullfunc = skb_put(skb, size);
J
Johannes Berg 已提交
3649 3650 3651 3652 3653 3654 3655 3656 3657 3658 3659
	nullfunc->frame_control = fc;
	nullfunc->duration_id = 0;
	memcpy(nullfunc->addr1, sta->sta.addr, ETH_ALEN);
	memcpy(nullfunc->addr2, sdata->vif.addr, ETH_ALEN);
	memcpy(nullfunc->addr3, sdata->vif.addr, ETH_ALEN);
	nullfunc->seq_ctrl = 0;

	info = IEEE80211_SKB_CB(skb);

	info->flags |= IEEE80211_TX_CTL_REQ_TX_STATUS |
		       IEEE80211_TX_INTFL_NL80211_FRAME_TX;
3660
	info->band = band;
J
Johannes Berg 已提交
3661 3662 3663 3664 3665 3666

	skb_set_queue_mapping(skb, IEEE80211_AC_VO);
	skb->priority = 7;
	if (qos)
		nullfunc->qos_ctrl = cpu_to_le16(7);

3667 3668
	ret = ieee80211_attach_ack_skb(local, skb, cookie, GFP_ATOMIC);
	if (ret) {
3669 3670 3671 3672
		kfree_skb(skb);
		goto unlock;
	}

J
Johannes Berg 已提交
3673
	local_bh_disable();
3674
	ieee80211_xmit(sdata, sta, skb);
J
Johannes Berg 已提交
3675
	local_bh_enable();
3676 3677 3678

	ret = 0;
unlock:
J
Johannes Berg 已提交
3679
	rcu_read_unlock();
3680
	mutex_unlock(&local->mtx);
J
Johannes Berg 已提交
3681

3682
	return ret;
J
Johannes Berg 已提交
3683 3684
}

3685 3686 3687
static int ieee80211_cfg_get_channel(struct wiphy *wiphy,
				     struct wireless_dev *wdev,
				     struct cfg80211_chan_def *chandef)
3688
{
J
Johannes Berg 已提交
3689
	struct ieee80211_sub_if_data *sdata = IEEE80211_WDEV_TO_SUB_IF(wdev);
3690
	struct ieee80211_local *local = wiphy_priv(wiphy);
J
Johannes Berg 已提交
3691
	struct ieee80211_chanctx_conf *chanctx_conf;
3692
	int ret = -ENODATA;
J
Johannes Berg 已提交
3693 3694

	rcu_read_lock();
3695 3696
	chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf);
	if (chanctx_conf) {
3697
		*chandef = sdata->vif.bss_conf.chandef;
3698 3699 3700 3701 3702 3703 3704
		ret = 0;
	} else if (local->open_count > 0 &&
		   local->open_count == local->monitors &&
		   sdata->vif.type == NL80211_IFTYPE_MONITOR) {
		if (local->use_chanctx)
			*chandef = local->monitor_chandef;
		else
3705
			*chandef = local->_oper_chandef;
3706
		ret = 0;
J
Johannes Berg 已提交
3707 3708
	}
	rcu_read_unlock();
3709

3710
	return ret;
3711 3712
}

3713 3714 3715 3716 3717 3718 3719
#ifdef CONFIG_PM
static void ieee80211_set_wakeup(struct wiphy *wiphy, bool enabled)
{
	drv_set_wakeup(wiphy_priv(wiphy), enabled);
}
#endif

3720 3721 3722 3723 3724 3725 3726 3727 3728 3729 3730 3731 3732 3733 3734 3735 3736
static int ieee80211_set_qos_map(struct wiphy *wiphy,
				 struct net_device *dev,
				 struct cfg80211_qos_map *qos_map)
{
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
	struct mac80211_qos_map *new_qos_map, *old_qos_map;

	if (qos_map) {
		new_qos_map = kzalloc(sizeof(*new_qos_map), GFP_KERNEL);
		if (!new_qos_map)
			return -ENOMEM;
		memcpy(&new_qos_map->qos_map, qos_map, sizeof(*qos_map));
	} else {
		/* A NULL qos_map was passed to disable QoS mapping */
		new_qos_map = NULL;
	}

3737
	old_qos_map = sdata_dereference(sdata->qos_map, sdata);
3738 3739 3740 3741 3742 3743 3744
	rcu_assign_pointer(sdata->qos_map, new_qos_map);
	if (old_qos_map)
		kfree_rcu(old_qos_map, rcu_head);

	return 0;
}

3745 3746 3747 3748 3749 3750 3751 3752 3753 3754 3755 3756 3757 3758 3759
static int ieee80211_set_ap_chanwidth(struct wiphy *wiphy,
				      struct net_device *dev,
				      struct cfg80211_chan_def *chandef)
{
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
	int ret;
	u32 changed = 0;

	ret = ieee80211_vif_change_bandwidth(sdata, chandef, &changed);
	if (ret == 0)
		ieee80211_bss_info_change_notify(sdata, changed);

	return ret;
}

3760 3761 3762 3763 3764 3765 3766 3767 3768 3769 3770 3771 3772 3773 3774 3775 3776 3777 3778 3779 3780 3781 3782 3783 3784 3785 3786 3787 3788 3789 3790 3791 3792 3793 3794 3795 3796 3797 3798 3799 3800 3801 3802 3803 3804 3805 3806 3807 3808 3809 3810 3811
static int ieee80211_add_tx_ts(struct wiphy *wiphy, struct net_device *dev,
			       u8 tsid, const u8 *peer, u8 up,
			       u16 admitted_time)
{
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
	struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
	int ac = ieee802_1d_to_ac[up];

	if (sdata->vif.type != NL80211_IFTYPE_STATION)
		return -EOPNOTSUPP;

	if (!(sdata->wmm_acm & BIT(up)))
		return -EINVAL;

	if (ifmgd->tx_tspec[ac].admitted_time)
		return -EBUSY;

	if (admitted_time) {
		ifmgd->tx_tspec[ac].admitted_time = 32 * admitted_time;
		ifmgd->tx_tspec[ac].tsid = tsid;
		ifmgd->tx_tspec[ac].up = up;
	}

	return 0;
}

static int ieee80211_del_tx_ts(struct wiphy *wiphy, struct net_device *dev,
			       u8 tsid, const u8 *peer)
{
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
	struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
	struct ieee80211_local *local = wiphy_priv(wiphy);
	int ac;

	for (ac = 0; ac < IEEE80211_NUM_ACS; ac++) {
		struct ieee80211_sta_tx_tspec *tx_tspec = &ifmgd->tx_tspec[ac];

		/* skip unused entries */
		if (!tx_tspec->admitted_time)
			continue;

		if (tx_tspec->tsid != tsid)
			continue;

		/* due to this new packets will be reassigned to non-ACM ACs */
		tx_tspec->up = -1;

		/* Make sure that all packets have been sent to avoid to
		 * restore the QoS params on packets that are still on the
		 * queues.
		 */
		synchronize_net();
3812
		ieee80211_flush_queues(local, sdata, false);
3813 3814 3815 3816 3817 3818 3819 3820 3821 3822 3823 3824 3825 3826 3827 3828 3829

		/* restore the normal QoS parameters
		 * (unconditionally to avoid races)
		 */
		tx_tspec->action = TX_TSPEC_ACTION_STOP_DOWNGRADE;
		tx_tspec->downgraded = false;
		ieee80211_sta_handle_tspec_ac_params(sdata);

		/* finally clear all the data */
		memset(tx_tspec, 0, sizeof(*tx_tspec));

		return 0;
	}

	return -ENOENT;
}

3830 3831 3832 3833 3834 3835 3836 3837 3838 3839 3840 3841 3842 3843 3844 3845 3846 3847 3848 3849 3850 3851 3852 3853 3854 3855 3856 3857 3858 3859 3860 3861
void ieee80211_nan_func_terminated(struct ieee80211_vif *vif,
				   u8 inst_id,
				   enum nl80211_nan_func_term_reason reason,
				   gfp_t gfp)
{
	struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
	struct cfg80211_nan_func *func;
	u64 cookie;

	if (WARN_ON(vif->type != NL80211_IFTYPE_NAN))
		return;

	spin_lock_bh(&sdata->u.nan.func_lock);

	func = idr_find(&sdata->u.nan.function_inst_ids, inst_id);
	if (WARN_ON(!func)) {
		spin_unlock_bh(&sdata->u.nan.func_lock);
		return;
	}

	cookie = func->cookie;
	idr_remove(&sdata->u.nan.function_inst_ids, inst_id);

	spin_unlock_bh(&sdata->u.nan.func_lock);

	cfg80211_free_nan_func(func);

	cfg80211_nan_func_terminated(ieee80211_vif_to_wdev(vif), inst_id,
				     reason, cookie, gfp);
}
EXPORT_SYMBOL(ieee80211_nan_func_terminated);

3862 3863 3864 3865 3866 3867 3868 3869 3870 3871 3872 3873 3874 3875 3876 3877 3878 3879 3880 3881 3882 3883 3884 3885 3886
void ieee80211_nan_func_match(struct ieee80211_vif *vif,
			      struct cfg80211_nan_match_params *match,
			      gfp_t gfp)
{
	struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
	struct cfg80211_nan_func *func;

	if (WARN_ON(vif->type != NL80211_IFTYPE_NAN))
		return;

	spin_lock_bh(&sdata->u.nan.func_lock);

	func = idr_find(&sdata->u.nan.function_inst_ids,  match->inst_id);
	if (WARN_ON(!func)) {
		spin_unlock_bh(&sdata->u.nan.func_lock);
		return;
	}
	match->cookie = func->cookie;

	spin_unlock_bh(&sdata->u.nan.func_lock);

	cfg80211_nan_match(ieee80211_vif_to_wdev(vif), match, gfp);
}
EXPORT_SYMBOL(ieee80211_nan_func_match);

3887 3888 3889 3890 3891 3892 3893 3894 3895 3896 3897
static int ieee80211_set_multicast_to_unicast(struct wiphy *wiphy,
					      struct net_device *dev,
					      const bool enabled)
{
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);

	sdata->u.ap.multicast_to_unicast = enabled;

	return 0;
}

3898 3899 3900 3901 3902 3903 3904 3905 3906 3907 3908 3909 3910 3911 3912 3913 3914 3915 3916 3917 3918 3919 3920 3921 3922 3923 3924 3925 3926 3927 3928 3929 3930 3931 3932 3933 3934 3935 3936 3937 3938 3939 3940 3941 3942 3943 3944 3945 3946 3947 3948 3949 3950 3951 3952 3953 3954 3955 3956 3957 3958 3959 3960 3961 3962 3963 3964 3965 3966 3967 3968 3969 3970 3971 3972 3973 3974 3975 3976 3977 3978 3979 3980 3981 3982 3983 3984 3985 3986 3987 3988 3989 3990
void ieee80211_fill_txq_stats(struct cfg80211_txq_stats *txqstats,
			      struct txq_info *txqi)
{
	if (!(txqstats->filled & BIT(NL80211_TXQ_STATS_BACKLOG_BYTES))) {
		txqstats->filled |= BIT(NL80211_TXQ_STATS_BACKLOG_BYTES);
		txqstats->backlog_bytes = txqi->tin.backlog_bytes;
	}

	if (!(txqstats->filled & BIT(NL80211_TXQ_STATS_BACKLOG_PACKETS))) {
		txqstats->filled |= BIT(NL80211_TXQ_STATS_BACKLOG_PACKETS);
		txqstats->backlog_packets = txqi->tin.backlog_packets;
	}

	if (!(txqstats->filled & BIT(NL80211_TXQ_STATS_FLOWS))) {
		txqstats->filled |= BIT(NL80211_TXQ_STATS_FLOWS);
		txqstats->flows = txqi->tin.flows;
	}

	if (!(txqstats->filled & BIT(NL80211_TXQ_STATS_DROPS))) {
		txqstats->filled |= BIT(NL80211_TXQ_STATS_DROPS);
		txqstats->drops = txqi->cstats.drop_count;
	}

	if (!(txqstats->filled & BIT(NL80211_TXQ_STATS_ECN_MARKS))) {
		txqstats->filled |= BIT(NL80211_TXQ_STATS_ECN_MARKS);
		txqstats->ecn_marks = txqi->cstats.ecn_mark;
	}

	if (!(txqstats->filled & BIT(NL80211_TXQ_STATS_OVERLIMIT))) {
		txqstats->filled |= BIT(NL80211_TXQ_STATS_OVERLIMIT);
		txqstats->overlimit = txqi->tin.overlimit;
	}

	if (!(txqstats->filled & BIT(NL80211_TXQ_STATS_COLLISIONS))) {
		txqstats->filled |= BIT(NL80211_TXQ_STATS_COLLISIONS);
		txqstats->collisions = txqi->tin.collisions;
	}

	if (!(txqstats->filled & BIT(NL80211_TXQ_STATS_TX_BYTES))) {
		txqstats->filled |= BIT(NL80211_TXQ_STATS_TX_BYTES);
		txqstats->tx_bytes = txqi->tin.tx_bytes;
	}

	if (!(txqstats->filled & BIT(NL80211_TXQ_STATS_TX_PACKETS))) {
		txqstats->filled |= BIT(NL80211_TXQ_STATS_TX_PACKETS);
		txqstats->tx_packets = txqi->tin.tx_packets;
	}
}

static int ieee80211_get_txq_stats(struct wiphy *wiphy,
				   struct wireless_dev *wdev,
				   struct cfg80211_txq_stats *txqstats)
{
	struct ieee80211_local *local = wiphy_priv(wiphy);
	struct ieee80211_sub_if_data *sdata;
	int ret = 0;

	if (!local->ops->wake_tx_queue)
		return 1;

	spin_lock_bh(&local->fq.lock);
	rcu_read_lock();

	if (wdev) {
		sdata = IEEE80211_WDEV_TO_SUB_IF(wdev);
		if (!sdata->vif.txq) {
			ret = 1;
			goto out;
		}
		ieee80211_fill_txq_stats(txqstats, to_txq_info(sdata->vif.txq));
	} else {
		/* phy stats */
		txqstats->filled |= BIT(NL80211_TXQ_STATS_BACKLOG_PACKETS) |
				    BIT(NL80211_TXQ_STATS_BACKLOG_BYTES) |
				    BIT(NL80211_TXQ_STATS_OVERLIMIT) |
				    BIT(NL80211_TXQ_STATS_OVERMEMORY) |
				    BIT(NL80211_TXQ_STATS_COLLISIONS) |
				    BIT(NL80211_TXQ_STATS_MAX_FLOWS);
		txqstats->backlog_packets = local->fq.backlog;
		txqstats->backlog_bytes = local->fq.memory_usage;
		txqstats->overlimit = local->fq.overlimit;
		txqstats->overmemory = local->fq.overmemory;
		txqstats->collisions = local->fq.collisions;
		txqstats->max_flows = local->fq.flows_cnt;
	}

out:
	rcu_read_unlock();
	spin_unlock_bh(&local->fq.lock);

	return ret;
}

3991 3992 3993 3994 3995 3996 3997 3998 3999 4000 4001
static int
ieee80211_get_ftm_responder_stats(struct wiphy *wiphy,
				  struct net_device *dev,
				  struct cfg80211_ftm_responder_stats *ftm_stats)
{
	struct ieee80211_local *local = wiphy_priv(wiphy);
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);

	return drv_get_ftm_responder_stats(local, sdata, ftm_stats);
}

4002 4003 4004 4005 4006 4007 4008 4009 4010 4011 4012 4013 4014 4015 4016 4017 4018 4019 4020 4021
static int
ieee80211_start_pmsr(struct wiphy *wiphy, struct wireless_dev *dev,
		     struct cfg80211_pmsr_request *request)
{
	struct ieee80211_local *local = wiphy_priv(wiphy);
	struct ieee80211_sub_if_data *sdata = IEEE80211_WDEV_TO_SUB_IF(dev);

	return drv_start_pmsr(local, sdata, request);
}

static void
ieee80211_abort_pmsr(struct wiphy *wiphy, struct wireless_dev *dev,
		     struct cfg80211_pmsr_request *request)
{
	struct ieee80211_local *local = wiphy_priv(wiphy);
	struct ieee80211_sub_if_data *sdata = IEEE80211_WDEV_TO_SUB_IF(dev);

	return drv_abort_pmsr(local, sdata, request);
}

4022 4023 4024 4025 4026 4027 4028 4029 4030 4031 4032 4033 4034 4035 4036 4037 4038 4039 4040 4041 4042 4043 4044 4045 4046 4047 4048 4049 4050
static int ieee80211_set_tid_config(struct wiphy *wiphy,
				    struct net_device *dev,
				    struct cfg80211_tid_config *tid_conf)
{
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
	struct sta_info *sta;
	int ret;

	if (!sdata->local->ops->set_tid_config)
		return -EOPNOTSUPP;

	if (!tid_conf->peer)
		return drv_set_tid_config(sdata->local, sdata, NULL, tid_conf);

	mutex_lock(&sdata->local->sta_mtx);
	sta = sta_info_get_bss(sdata, tid_conf->peer);
	if (!sta) {
		mutex_unlock(&sdata->local->sta_mtx);
		return -ENOENT;
	}

	ret = drv_set_tid_config(sdata->local, sdata, &sta->sta, tid_conf);
	mutex_unlock(&sdata->local->sta_mtx);

	return ret;
}

static int ieee80211_reset_tid_config(struct wiphy *wiphy,
				      struct net_device *dev,
4051
				      const u8 *peer, u8 tids)
4052 4053 4054 4055 4056 4057 4058 4059 4060
{
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
	struct sta_info *sta;
	int ret;

	if (!sdata->local->ops->reset_tid_config)
		return -EOPNOTSUPP;

	if (!peer)
4061
		return drv_reset_tid_config(sdata->local, sdata, NULL, tids);
4062 4063 4064 4065 4066 4067 4068 4069

	mutex_lock(&sdata->local->sta_mtx);
	sta = sta_info_get_bss(sdata, peer);
	if (!sta) {
		mutex_unlock(&sdata->local->sta_mtx);
		return -ENOENT;
	}

4070
	ret = drv_reset_tid_config(sdata->local, sdata, &sta->sta, tids);
4071 4072 4073 4074 4075
	mutex_unlock(&sdata->local->sta_mtx);

	return ret;
}

C
Carl Huang 已提交
4076 4077 4078 4079 4080 4081 4082 4083 4084 4085 4086
static int ieee80211_set_sar_specs(struct wiphy *wiphy,
				   struct cfg80211_sar_specs *sar)
{
	struct ieee80211_local *local = wiphy_priv(wiphy);

	if (!local->ops->set_sar_specs)
		return -EOPNOTSUPP;

	return local->ops->set_sar_specs(&local->hw, sar);
}

4087
const struct cfg80211_ops mac80211_config_ops = {
4088 4089
	.add_virtual_intf = ieee80211_add_iface,
	.del_virtual_intf = ieee80211_del_iface,
4090
	.change_virtual_intf = ieee80211_change_iface,
4091 4092
	.start_p2p_device = ieee80211_start_p2p_device,
	.stop_p2p_device = ieee80211_stop_p2p_device,
4093 4094
	.add_key = ieee80211_add_key,
	.del_key = ieee80211_del_key,
4095
	.get_key = ieee80211_get_key,
4096
	.set_default_key = ieee80211_config_default_key,
4097
	.set_default_mgmt_key = ieee80211_config_default_mgmt_key,
4098
	.set_default_beacon_key = ieee80211_config_default_beacon_key,
4099 4100 4101
	.start_ap = ieee80211_start_ap,
	.change_beacon = ieee80211_change_beacon,
	.stop_ap = ieee80211_stop_ap,
4102 4103 4104
	.add_station = ieee80211_add_station,
	.del_station = ieee80211_del_station,
	.change_station = ieee80211_change_station,
4105
	.get_station = ieee80211_get_station,
4106
	.dump_station = ieee80211_dump_station,
4107
	.dump_survey = ieee80211_dump_survey,
4108 4109 4110 4111 4112 4113
#ifdef CONFIG_MAC80211_MESH
	.add_mpath = ieee80211_add_mpath,
	.del_mpath = ieee80211_del_mpath,
	.change_mpath = ieee80211_change_mpath,
	.get_mpath = ieee80211_get_mpath,
	.dump_mpath = ieee80211_dump_mpath,
4114 4115
	.get_mpp = ieee80211_get_mpp,
	.dump_mpp = ieee80211_dump_mpp,
4116 4117
	.update_mesh_config = ieee80211_update_mesh_config,
	.get_mesh_config = ieee80211_get_mesh_config,
4118 4119
	.join_mesh = ieee80211_join_mesh,
	.leave_mesh = ieee80211_leave_mesh,
4120
#endif
4121 4122
	.join_ocb = ieee80211_join_ocb,
	.leave_ocb = ieee80211_leave_ocb,
4123
	.change_bss = ieee80211_change_bss,
4124
	.set_txq_params = ieee80211_set_txq_params,
4125
	.set_monitor_channel = ieee80211_set_monitor_channel,
4126 4127
	.suspend = ieee80211_suspend,
	.resume = ieee80211_resume,
4128
	.scan = ieee80211_scan,
4129
	.abort_scan = ieee80211_abort_scan,
4130 4131
	.sched_scan_start = ieee80211_sched_scan_start,
	.sched_scan_stop = ieee80211_sched_scan_stop,
4132 4133 4134 4135
	.auth = ieee80211_auth,
	.assoc = ieee80211_assoc,
	.deauth = ieee80211_deauth,
	.disassoc = ieee80211_disassoc,
4136 4137
	.join_ibss = ieee80211_join_ibss,
	.leave_ibss = ieee80211_leave_ibss,
4138
	.set_mcast_rate = ieee80211_set_mcast_rate,
4139
	.set_wiphy_params = ieee80211_set_wiphy_params,
4140 4141
	.set_tx_power = ieee80211_set_tx_power,
	.get_tx_power = ieee80211_get_tx_power,
J
Johannes Berg 已提交
4142
	.rfkill_poll = ieee80211_rfkill_poll,
4143
	CFG80211_TESTMODE_CMD(ieee80211_testmode_cmd)
W
Wey-Yi Guy 已提交
4144
	CFG80211_TESTMODE_DUMP(ieee80211_testmode_dump)
J
Johannes Berg 已提交
4145
	.set_power_mgmt = ieee80211_set_power_mgmt,
J
Johannes Berg 已提交
4146
	.set_bitrate_mask = ieee80211_set_bitrate_mask,
4147 4148
	.remain_on_channel = ieee80211_remain_on_channel,
	.cancel_remain_on_channel = ieee80211_cancel_remain_on_channel,
4149
	.mgmt_tx = ieee80211_mgmt_tx,
4150
	.mgmt_tx_cancel_wait = ieee80211_mgmt_tx_cancel_wait,
4151
	.set_cqm_rssi_config = ieee80211_set_cqm_rssi_config,
4152
	.set_cqm_rssi_range_config = ieee80211_set_cqm_rssi_range_config,
4153 4154
	.update_mgmt_frame_registrations =
		ieee80211_update_mgmt_frame_registrations,
4155 4156
	.set_antenna = ieee80211_set_antenna,
	.get_antenna = ieee80211_get_antenna,
4157
	.set_rekey_data = ieee80211_set_rekey_data,
4158 4159
	.tdls_oper = ieee80211_tdls_oper,
	.tdls_mgmt = ieee80211_tdls_mgmt,
4160 4161
	.tdls_channel_switch = ieee80211_tdls_channel_switch,
	.tdls_cancel_channel_switch = ieee80211_tdls_cancel_channel_switch,
J
Johannes Berg 已提交
4162
	.probe_client = ieee80211_probe_client,
4163
	.set_noack_map = ieee80211_set_noack_map,
4164 4165 4166
#ifdef CONFIG_PM
	.set_wakeup = ieee80211_set_wakeup,
#endif
4167
	.get_channel = ieee80211_cfg_get_channel,
4168
	.start_radar_detection = ieee80211_start_radar_detection,
4169
	.end_cac = ieee80211_end_cac,
4170
	.channel_switch = ieee80211_channel_switch,
4171
	.set_qos_map = ieee80211_set_qos_map,
4172
	.set_ap_chanwidth = ieee80211_set_ap_chanwidth,
4173 4174
	.add_tx_ts = ieee80211_add_tx_ts,
	.del_tx_ts = ieee80211_del_tx_ts,
4175 4176
	.start_nan = ieee80211_start_nan,
	.stop_nan = ieee80211_stop_nan,
4177
	.nan_change_conf = ieee80211_nan_change_conf,
4178 4179
	.add_nan_func = ieee80211_add_nan_func,
	.del_nan_func = ieee80211_del_nan_func,
4180
	.set_multicast_to_unicast = ieee80211_set_multicast_to_unicast,
4181
	.tx_control_port = ieee80211_tx_control_port,
4182
	.get_txq_stats = ieee80211_get_txq_stats,
4183
	.get_ftm_responder_stats = ieee80211_get_ftm_responder_stats,
4184 4185
	.start_pmsr = ieee80211_start_pmsr,
	.abort_pmsr = ieee80211_abort_pmsr,
4186
	.probe_mesh_link = ieee80211_probe_mesh_link,
4187 4188
	.set_tid_config = ieee80211_set_tid_config,
	.reset_tid_config = ieee80211_reset_tid_config,
C
Carl Huang 已提交
4189
	.set_sar_specs = ieee80211_set_sar_specs,
4190
};