cfg.c 106.2 KB
Newer Older
1 2 3
/*
 * mac80211 configuration hooks for cfg80211
 *
4
 * Copyright 2006-2010	Johannes Berg <johannes@sipsolutions.net>
5 6 7 8
 *
 * This file is GPLv2 as found in COPYING.
 */

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

23 24
static struct wireless_dev *ieee80211_add_iface(struct wiphy *wiphy,
						const char *name,
25 26 27
						enum nl80211_iftype type,
						u32 *flags,
						struct vif_params *params)
28 29
{
	struct ieee80211_local *local = wiphy_priv(wiphy);
30
	struct wireless_dev *wdev;
31 32
	struct ieee80211_sub_if_data *sdata;
	int err;
33

34
	err = ieee80211_if_add(local, name, &wdev, type, params);
35 36
	if (err)
		return ERR_PTR(err);
37

38
	if (type == NL80211_IFTYPE_MONITOR && flags) {
39
		sdata = IEEE80211_WDEV_TO_SUB_IF(wdev);
40 41 42
		sdata->u.mntr_flags = *flags;
	}

43
	return wdev;
44 45
}

46
static int ieee80211_del_iface(struct wiphy *wiphy, struct wireless_dev *wdev)
47
{
48
	ieee80211_if_remove(IEEE80211_WDEV_TO_SUB_IF(wdev));
49

50
	return 0;
51 52
}

53 54
static int ieee80211_change_iface(struct wiphy *wiphy,
				  struct net_device *dev,
55 56
				  enum nl80211_iftype type, u32 *flags,
				  struct vif_params *params)
57
{
58
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
59
	int ret;
60

61
	ret = ieee80211_if_change_type(sdata, type);
62 63
	if (ret)
		return ret;
64

65 66
	if (type == NL80211_IFTYPE_AP_VLAN &&
	    params && params->use_4addr == 0)
67
		RCU_INIT_POINTER(sdata->u.vlan.sta, NULL);
68 69 70 71
	else if (type == NL80211_IFTYPE_STATION &&
		 params && params->use_4addr >= 0)
		sdata->u.mgd.use_4addr = params->use_4addr;

72 73 74 75
	if (sdata->vif.type == NL80211_IFTYPE_MONITOR && flags) {
		struct ieee80211_local *local = sdata->local;

		if (ieee80211_sdata_running(sdata)) {
76 77 78
			u32 mask = MONITOR_FLAG_COOK_FRAMES |
				   MONITOR_FLAG_ACTIVE;

79
			/*
80 81 82
			 * Prohibit MONITOR_FLAG_COOK_FRAMES and
			 * MONITOR_FLAG_ACTIVE to be changed while the
			 * interface is up.
83 84 85 86 87
			 * Else we would need to add a lot of cruft
			 * to update everything:
			 *	cooked_mntrs, monitor and all fif_* counters
			 *	reconfigure hardware
			 */
88
			if ((*flags & mask) != (sdata->u.mntr_flags & mask))
89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104
				return -EBUSY;

			ieee80211_adjust_monitor_flags(sdata, -1);
			sdata->u.mntr_flags = *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 = *flags;
		}
	}
105

106 107 108
	return 0;
}

109 110 111 112 113 114 115 116 117 118 119 120
static int ieee80211_start_p2p_device(struct wiphy *wiphy,
				      struct wireless_dev *wdev)
{
	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));
}

121 122 123 124 125 126 127 128 129 130
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;
	return 0;
}

131
static int ieee80211_add_key(struct wiphy *wiphy, struct net_device *dev,
132
			     u8 key_idx, bool pairwise, const u8 *mac_addr,
133 134
			     struct key_params *params)
{
135
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
136
	struct ieee80211_local *local = sdata->local;
137
	struct sta_info *sta = NULL;
138
	const struct ieee80211_cipher_scheme *cs = NULL;
139
	struct ieee80211_key *key;
140
	int err;
141

142
	if (!ieee80211_sdata_running(sdata))
J
Johannes Berg 已提交
143 144
		return -ENETDOWN;

145
	/* reject WEP and TKIP keys if WEP failed to initialize */
146 147 148
	switch (params->cipher) {
	case WLAN_CIPHER_SUITE_WEP40:
	case WLAN_CIPHER_SUITE_TKIP:
149
	case WLAN_CIPHER_SUITE_WEP104:
150
		if (IS_ERR(local->wep_tx_tfm))
151
			return -EINVAL;
152
		break;
153 154 155 156
	case WLAN_CIPHER_SUITE_CCMP:
	case WLAN_CIPHER_SUITE_AES_CMAC:
	case WLAN_CIPHER_SUITE_GCMP:
		break;
157
	default:
158
		cs = ieee80211_cs_get(local, params->cipher, sdata->vif.type);
159
		break;
160 161
	}

162
	key = ieee80211_key_alloc(params->cipher, key_idx, params->key_len,
163 164
				  params->key, params->seq_len, params->seq,
				  cs);
165 166
	if (IS_ERR(key))
		return PTR_ERR(key);
167

168 169 170
	if (pairwise)
		key->conf.flags |= IEEE80211_KEY_FLAG_PAIRWISE;

171
	mutex_lock(&local->sta_mtx);
172

173
	if (mac_addr) {
174 175 176 177
		if (ieee80211_vif_is_mesh(&sdata->vif))
			sta = sta_info_get(sdata, mac_addr);
		else
			sta = sta_info_get_bss(sdata, mac_addr);
J
Johannes Berg 已提交
178 179 180 181 182 183 184 185 186 187 188
		/*
		 * 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
		 * so it will set the key again after assocation.
		 *
		 * 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)) {
189
			ieee80211_key_free_unused(key);
190 191
			err = -ENOENT;
			goto out_unlock;
192
		}
193 194
	}

195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226
	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 */
		if (key->sta && test_sta_flag(key->sta, WLAN_STA_MFP))
			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:
	case NL80211_IFTYPE_UNSPECIFIED:
	case NUM_NL80211_IFTYPES:
	case NL80211_IFTYPE_P2P_CLIENT:
	case NL80211_IFTYPE_P2P_GO:
		/* shouldn't happen */
		WARN_ON_ONCE(1);
		break;
	}

227 228 229
	if (sta)
		sta->cipher_scheme = cs;

230
	err = ieee80211_key_link(key, sdata, sta);
231

232
 out_unlock:
233
	mutex_unlock(&local->sta_mtx);
234 235

	return err;
236 237 238
}

static int ieee80211_del_key(struct wiphy *wiphy, struct net_device *dev,
239
			     u8 key_idx, bool pairwise, const u8 *mac_addr)
240
{
241 242
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
	struct ieee80211_local *local = sdata->local;
243
	struct sta_info *sta;
244
	struct ieee80211_key *key = NULL;
245 246
	int ret;

247 248
	mutex_lock(&local->sta_mtx);
	mutex_lock(&local->key_mtx);
249

250
	if (mac_addr) {
251 252
		ret = -ENOENT;

253
		sta = sta_info_get_bss(sdata, mac_addr);
254
		if (!sta)
255
			goto out_unlock;
256

257
		if (pairwise)
258
			key = key_mtx_dereference(local, sta->ptk[key_idx]);
259
		else
J
Johannes Berg 已提交
260
			key = key_mtx_dereference(local, sta->gtk[key_idx]);
261
	} else
J
Johannes Berg 已提交
262
		key = key_mtx_dereference(local, sdata->keys[key_idx]);
263

264
	if (!key) {
265 266 267
		ret = -ENOENT;
		goto out_unlock;
	}
268

269
	ieee80211_key_free(key, true);
270

271 272
	ret = 0;
 out_unlock:
273 274
	mutex_unlock(&local->key_mtx);
	mutex_unlock(&local->sta_mtx);
275 276

	return ret;
277 278
}

279
static int ieee80211_get_key(struct wiphy *wiphy, struct net_device *dev,
280 281
			     u8 key_idx, bool pairwise, const u8 *mac_addr,
			     void *cookie,
282 283 284
			     void (*callback)(void *cookie,
					      struct key_params *params))
{
285
	struct ieee80211_sub_if_data *sdata;
286 287 288
	struct sta_info *sta = NULL;
	u8 seq[6] = {0};
	struct key_params params;
289
	struct ieee80211_key *key = NULL;
J
Johannes Berg 已提交
290
	u64 pn64;
291 292 293 294
	u32 iv32;
	u16 iv16;
	int err = -ENOENT;

295 296
	sdata = IEEE80211_DEV_TO_SUB_IF(dev);

297 298
	rcu_read_lock();

299
	if (mac_addr) {
300
		sta = sta_info_get_bss(sdata, mac_addr);
301 302 303
		if (!sta)
			goto out;

304
		if (pairwise && key_idx < NUM_DEFAULT_KEYS)
305
			key = rcu_dereference(sta->ptk[key_idx]);
306 307
		else if (!pairwise &&
			 key_idx < NUM_DEFAULT_KEYS + NUM_DEFAULT_MGMT_KEYS)
J
Johannes Berg 已提交
308
			key = rcu_dereference(sta->gtk[key_idx]);
309
	} else
J
Johannes Berg 已提交
310
		key = rcu_dereference(sdata->keys[key_idx]);
311 312 313 314 315 316

	if (!key)
		goto out;

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

317
	params.cipher = key->conf.cipher;
318

319 320
	switch (key->conf.cipher) {
	case WLAN_CIPHER_SUITE_TKIP:
321 322
		iv32 = key->u.tkip.tx.iv32;
		iv16 = key->u.tkip.tx.iv16;
323

324 325 326 327
		if (key->flags & KEY_FLAG_UPLOADED_TO_HARDWARE)
			drv_get_tkip_seq(sdata->local,
					 key->conf.hw_key_idx,
					 &iv32, &iv16);
328 329 330 331 332 333 334 335 336 337

		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;
338
	case WLAN_CIPHER_SUITE_CCMP:
J
Johannes Berg 已提交
339 340 341 342 343 344 345
		pn64 = atomic64_read(&key->u.ccmp.tx_pn);
		seq[0] = pn64;
		seq[1] = pn64 >> 8;
		seq[2] = pn64 >> 16;
		seq[3] = pn64 >> 24;
		seq[4] = pn64 >> 32;
		seq[5] = pn64 >> 40;
346 347 348
		params.seq = seq;
		params.seq_len = 6;
		break;
349
	case WLAN_CIPHER_SUITE_AES_CMAC:
J
Johannes Berg 已提交
350 351 352 353 354 355 356
		pn64 = atomic64_read(&key->u.aes_cmac.tx_pn);
		seq[0] = pn64;
		seq[1] = pn64 >> 8;
		seq[2] = pn64 >> 16;
		seq[3] = pn64 >> 24;
		seq[4] = pn64 >> 32;
		seq[5] = pn64 >> 40;
357 358 359
		params.seq = seq;
		params.seq_len = 6;
		break;
360 361 362 363 364 365 366 367 368
	}

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

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

 out:
369
	rcu_read_unlock();
370 371 372
	return err;
}

373 374
static int ieee80211_config_default_key(struct wiphy *wiphy,
					struct net_device *dev,
375 376
					u8 key_idx, bool uni,
					bool multi)
377
{
J
Johannes Berg 已提交
378
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
379

380
	ieee80211_set_default_key(sdata, key_idx, uni, multi);
381 382 383 384

	return 0;
}

385 386 387 388
static int ieee80211_config_default_mgmt_key(struct wiphy *wiphy,
					     struct net_device *dev,
					     u8 key_idx)
{
389
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
390 391 392 393 394 395

	ieee80211_set_default_mgmt_key(sdata, key_idx);

	return 0;
}

396 397 398 399 400
void sta_set_rate_info_tx(struct sta_info *sta,
			  const struct ieee80211_tx_rate *rate,
			  struct rate_info *rinfo)
{
	rinfo->flags = 0;
401
	if (rate->flags & IEEE80211_TX_RC_MCS) {
402
		rinfo->flags |= RATE_INFO_FLAGS_MCS;
403 404 405 406 407 408 409
		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;
410 411 412
		int shift = ieee80211_vif_get_shift(&sta->sdata->vif);
		u16 brate;

413 414
		sband = sta->local->hw.wiphy->bands[
				ieee80211_get_sdata_band(sta->sdata)];
415 416
		brate = sband->bitrates[rate->idx].bitrate;
		rinfo->legacy = DIV_ROUND_UP(brate, 1 << shift);
417
	}
418 419
	if (rate->flags & IEEE80211_TX_RC_40_MHZ_WIDTH)
		rinfo->flags |= RATE_INFO_FLAGS_40_MHZ_WIDTH;
420 421 422 423
	if (rate->flags & IEEE80211_TX_RC_80_MHZ_WIDTH)
		rinfo->flags |= RATE_INFO_FLAGS_80_MHZ_WIDTH;
	if (rate->flags & IEEE80211_TX_RC_160_MHZ_WIDTH)
		rinfo->flags |= RATE_INFO_FLAGS_160_MHZ_WIDTH;
424 425 426 427
	if (rate->flags & IEEE80211_TX_RC_SHORT_GI)
		rinfo->flags |= RATE_INFO_FLAGS_SHORT_GI;
}

428 429 430 431 432 433 434 435 436 437 438 439 440
void sta_set_rate_info_rx(struct sta_info *sta, struct rate_info *rinfo)
{
	rinfo->flags = 0;

	if (sta->last_rx_rate_flag & RX_FLAG_HT) {
		rinfo->flags |= RATE_INFO_FLAGS_MCS;
		rinfo->mcs = sta->last_rx_rate_idx;
	} else if (sta->last_rx_rate_flag & RX_FLAG_VHT) {
		rinfo->flags |= RATE_INFO_FLAGS_VHT_MCS;
		rinfo->nss = sta->last_rx_rate_vht_nss;
		rinfo->mcs = sta->last_rx_rate_idx;
	} else {
		struct ieee80211_supported_band *sband;
441 442
		int shift = ieee80211_vif_get_shift(&sta->sdata->vif);
		u16 brate;
443 444 445

		sband = sta->local->hw.wiphy->bands[
				ieee80211_get_sdata_band(sta->sdata)];
446 447
		brate = sband->bitrates[sta->last_rx_rate_idx].bitrate;
		rinfo->legacy = DIV_ROUND_UP(brate, 1 << shift);
448 449 450 451 452 453 454 455 456 457 458 459 460 461
	}

	if (sta->last_rx_rate_flag & RX_FLAG_40MHZ)
		rinfo->flags |= RATE_INFO_FLAGS_40_MHZ_WIDTH;
	if (sta->last_rx_rate_flag & RX_FLAG_SHORT_GI)
		rinfo->flags |= RATE_INFO_FLAGS_SHORT_GI;
	if (sta->last_rx_rate_flag & RX_FLAG_80MHZ)
		rinfo->flags |= RATE_INFO_FLAGS_80_MHZ_WIDTH;
	if (sta->last_rx_rate_flag & RX_FLAG_80P80MHZ)
		rinfo->flags |= RATE_INFO_FLAGS_80P80_MHZ_WIDTH;
	if (sta->last_rx_rate_flag & RX_FLAG_160MHZ)
		rinfo->flags |= RATE_INFO_FLAGS_160_MHZ_WIDTH;
}

462 463
static void sta_set_sinfo(struct sta_info *sta, struct station_info *sinfo)
{
464
	struct ieee80211_sub_if_data *sdata = sta->sdata;
465
	struct ieee80211_local *local = sdata->local;
466
	struct timespec uptime;
467
	u64 packets = 0;
468
	int i, ac;
469

470 471
	sinfo->generation = sdata->local->sta_generation;

472
	sinfo->filled = STATION_INFO_INACTIVE_TIME |
473 474
			STATION_INFO_RX_BYTES64 |
			STATION_INFO_TX_BYTES64 |
475 476
			STATION_INFO_RX_PACKETS |
			STATION_INFO_TX_PACKETS |
477 478
			STATION_INFO_TX_RETRIES |
			STATION_INFO_TX_FAILED |
479
			STATION_INFO_TX_BITRATE |
480
			STATION_INFO_RX_BITRATE |
481
			STATION_INFO_RX_DROP_MISC |
482
			STATION_INFO_BSS_PARAM |
483
			STATION_INFO_CONNECTED_TIME |
484 485
			STATION_INFO_STA_FLAGS |
			STATION_INFO_BEACON_LOSS_COUNT;
486 487 488

	do_posix_clock_monotonic_gettime(&uptime);
	sinfo->connected_time = uptime.tv_sec - sta->last_connected;
489 490

	sinfo->inactive_time = jiffies_to_msecs(jiffies - sta->last_rx);
491 492 493 494 495 496
	sinfo->tx_bytes = 0;
	for (ac = 0; ac < IEEE80211_NUM_ACS; ac++) {
		sinfo->tx_bytes += sta->tx_bytes[ac];
		packets += sta->tx_packets[ac];
	}
	sinfo->tx_packets = packets;
497
	sinfo->rx_bytes = sta->rx_bytes;
498
	sinfo->rx_packets = sta->rx_packets;
499 500
	sinfo->tx_retries = sta->tx_retry_count;
	sinfo->tx_failed = sta->tx_retry_failed;
501
	sinfo->rx_dropped_misc = sta->rx_dropped;
502
	sinfo->beacon_loss_count = sta->beacon_loss_count;
503

504 505
	if ((sta->local->hw.flags & IEEE80211_HW_SIGNAL_DBM) ||
	    (sta->local->hw.flags & IEEE80211_HW_SIGNAL_UNSPEC)) {
506
		sinfo->filled |= STATION_INFO_SIGNAL | STATION_INFO_SIGNAL_AVG;
507 508 509
		if (!local->ops->get_rssi ||
		    drv_get_rssi(local, sdata, &sta->sta, &sinfo->signal))
			sinfo->signal = (s8)sta->last_signal;
510
		sinfo->signal_avg = (s8) -ewma_read(&sta->avg_signal);
511
	}
512 513 514 515 516 517 518 519 520 521 522
	if (sta->chains) {
		sinfo->filled |= STATION_INFO_CHAIN_SIGNAL |
				 STATION_INFO_CHAIN_SIGNAL_AVG;

		sinfo->chains = sta->chains;
		for (i = 0; i < ARRAY_SIZE(sinfo->chain_signal); i++) {
			sinfo->chain_signal[i] = sta->chain_signal_last[i];
			sinfo->chain_signal_avg[i] =
				(s8) -ewma_read(&sta->chain_signal_avg[i]);
		}
	}
523

524
	sta_set_rate_info_tx(sta, &sta->last_tx_rate, &sinfo->txrate);
525
	sta_set_rate_info_rx(sta, &sinfo->rxrate);
526

J
Johannes Berg 已提交
527
	if (ieee80211_vif_is_mesh(&sdata->vif)) {
528 529 530
#ifdef CONFIG_MAC80211_MESH
		sinfo->filled |= STATION_INFO_LLID |
				 STATION_INFO_PLID |
M
Marco Porsch 已提交
531 532 533 534
				 STATION_INFO_PLINK_STATE |
				 STATION_INFO_LOCAL_PM |
				 STATION_INFO_PEER_PM |
				 STATION_INFO_NONPEER_PM;
535

536 537
		sinfo->llid = sta->llid;
		sinfo->plid = sta->plid;
538
		sinfo->plink_state = sta->plink_state;
539 540 541 542
		if (test_sta_flag(sta, WLAN_STA_TOFFSET_KNOWN)) {
			sinfo->filled |= STATION_INFO_T_OFFSET;
			sinfo->t_offset = sta->t_offset;
		}
M
Marco Porsch 已提交
543 544 545
		sinfo->local_pm = sta->local_pm;
		sinfo->peer_pm = sta->peer_pm;
		sinfo->nonpeer_pm = sta->nonpeer_pm;
546
#endif
J
Johannes Berg 已提交
547
	}
548 549 550 551 552 553 554 555 556 557

	sinfo->bss_param.flags = 0;
	if (sdata->vif.bss_conf.use_cts_prot)
		sinfo->bss_param.flags |= BSS_PARAM_FLAGS_CTS_PROT;
	if (sdata->vif.bss_conf.use_short_preamble)
		sinfo->bss_param.flags |= BSS_PARAM_FLAGS_SHORT_PREAMBLE;
	if (sdata->vif.bss_conf.use_short_slot)
		sinfo->bss_param.flags |= BSS_PARAM_FLAGS_SHORT_SLOT_TIME;
	sinfo->bss_param.dtim_period = sdata->local->hw.conf.ps_dtim_period;
	sinfo->bss_param.beacon_interval = sdata->vif.bss_conf.beacon_int;
558 559 560 561 562 563

	sinfo->sta_flags.set = 0;
	sinfo->sta_flags.mask = BIT(NL80211_STA_FLAG_AUTHORIZED) |
				BIT(NL80211_STA_FLAG_SHORT_PREAMBLE) |
				BIT(NL80211_STA_FLAG_WME) |
				BIT(NL80211_STA_FLAG_MFP) |
564
				BIT(NL80211_STA_FLAG_AUTHENTICATED) |
565
				BIT(NL80211_STA_FLAG_ASSOCIATED) |
566
				BIT(NL80211_STA_FLAG_TDLS_PEER);
567 568 569 570 571 572 573 574 575 576
	if (test_sta_flag(sta, WLAN_STA_AUTHORIZED))
		sinfo->sta_flags.set |= BIT(NL80211_STA_FLAG_AUTHORIZED);
	if (test_sta_flag(sta, WLAN_STA_SHORT_PREAMBLE))
		sinfo->sta_flags.set |= BIT(NL80211_STA_FLAG_SHORT_PREAMBLE);
	if (test_sta_flag(sta, WLAN_STA_WME))
		sinfo->sta_flags.set |= BIT(NL80211_STA_FLAG_WME);
	if (test_sta_flag(sta, WLAN_STA_MFP))
		sinfo->sta_flags.set |= BIT(NL80211_STA_FLAG_MFP);
	if (test_sta_flag(sta, WLAN_STA_AUTH))
		sinfo->sta_flags.set |= BIT(NL80211_STA_FLAG_AUTHENTICATED);
577 578
	if (test_sta_flag(sta, WLAN_STA_ASSOC))
		sinfo->sta_flags.set |= BIT(NL80211_STA_FLAG_ASSOCIATED);
579 580
	if (test_sta_flag(sta, WLAN_STA_TDLS_PEER))
		sinfo->sta_flags.set |= BIT(NL80211_STA_FLAG_TDLS_PEER);
581 582
}

583 584 585 586 587
static const char ieee80211_gstrings_sta_stats[][ETH_GSTRING_LEN] = {
	"rx_packets", "rx_bytes", "wep_weak_iv_count",
	"rx_duplicates", "rx_fragments", "rx_dropped",
	"tx_packets", "tx_bytes", "tx_fragments",
	"tx_filtered", "tx_retry_failed", "tx_retries",
588 589 590
	"beacon_loss", "sta_state", "txrate", "rxrate", "signal",
	"channel", "noise", "ch_time", "ch_time_busy",
	"ch_time_ext_busy", "ch_time_rx", "ch_time_tx"
591 592 593 594 595 596 597
};
#define STA_STATS_LEN	ARRAY_SIZE(ieee80211_gstrings_sta_stats)

static int ieee80211_get_et_sset_count(struct wiphy *wiphy,
				       struct net_device *dev,
				       int sset)
{
598 599 600
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
	int rv = 0;

601
	if (sset == ETH_SS_STATS)
602 603 604
		rv += STA_STATS_LEN;

	rv += drv_get_et_sset_count(sdata, sset);
605

606 607 608
	if (rv == 0)
		return -EOPNOTSUPP;
	return rv;
609 610 611 612 613 614 615 616
}

static void ieee80211_get_et_stats(struct wiphy *wiphy,
				   struct net_device *dev,
				   struct ethtool_stats *stats,
				   u64 *data)
{
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
J
Johannes Berg 已提交
617 618
	struct ieee80211_chanctx_conf *chanctx_conf;
	struct ieee80211_channel *channel;
619 620
	struct sta_info *sta;
	struct ieee80211_local *local = sdata->local;
621 622 623 624
	struct station_info sinfo;
	struct survey_info survey;
	int i, q;
#define STA_STATS_SURVEY_LEN 7
625 626 627 628 629 630 631 632 633 634 635 636

	memset(data, 0, sizeof(u64) * STA_STATS_LEN);

#define ADD_STA_STATS(sta)				\
	do {						\
		data[i++] += sta->rx_packets;		\
		data[i++] += sta->rx_bytes;		\
		data[i++] += sta->wep_weak_iv_count;	\
		data[i++] += sta->num_duplicates;	\
		data[i++] += sta->rx_fragments;		\
		data[i++] += sta->rx_dropped;		\
							\
637 638
		data[i++] += sinfo.tx_packets;		\
		data[i++] += sinfo.tx_bytes;		\
639 640 641 642 643 644 645 646 647 648 649 650 651
		data[i++] += sta->tx_fragments;		\
		data[i++] += sta->tx_filtered_count;	\
		data[i++] += sta->tx_retry_failed;	\
		data[i++] += sta->tx_retry_count;	\
		data[i++] += sta->beacon_loss_count;	\
	} while (0)

	/* For Managed stations, find the single station based on BSSID
	 * and use that.  For interface types, iterate through all available
	 * stations and add stats for any station that is assigned to this
	 * network device.
	 */

652
	mutex_lock(&local->sta_mtx);
653 654 655

	if (sdata->vif.type == NL80211_IFTYPE_STATION) {
		sta = sta_info_get_bss(sdata, sdata->u.mgd.bssid);
656 657 658 659

		if (!(sta && !WARN_ON(sta->sdata->dev != dev)))
			goto do_survey;

660 661 662
		sinfo.filled = 0;
		sta_set_sinfo(sta, &sinfo);

663 664 665 666 667 668
		i = 0;
		ADD_STA_STATS(sta);

		data[i++] = sta->sta_state;


669
		if (sinfo.filled & STATION_INFO_TX_BITRATE)
670 671 672
			data[i] = 100000 *
				cfg80211_calculate_bitrate(&sinfo.txrate);
		i++;
673
		if (sinfo.filled & STATION_INFO_RX_BITRATE)
674 675 676 677
			data[i] = 100000 *
				cfg80211_calculate_bitrate(&sinfo.rxrate);
		i++;

678
		if (sinfo.filled & STATION_INFO_SIGNAL_AVG)
679 680
			data[i] = (u8)sinfo.signal_avg;
		i++;
681
	} else {
682
		list_for_each_entry(sta, &local->sta_list, list) {
683 684 685 686
			/* Make sure this station belongs to the proper dev */
			if (sta->sdata->dev != dev)
				continue;

687 688
			sinfo.filled = 0;
			sta_set_sinfo(sta, &sinfo);
689 690 691 692 693
			i = 0;
			ADD_STA_STATS(sta);
		}
	}

694 695 696
do_survey:
	i = STA_STATS_LEN - STA_STATS_SURVEY_LEN;
	/* Get survey stats for current channel */
J
Johannes Berg 已提交
697
	survey.filled = 0;
698

J
Johannes Berg 已提交
699 700 701
	rcu_read_lock();
	chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf);
	if (chanctx_conf)
702
		channel = chanctx_conf->def.chan;
J
Johannes Berg 已提交
703 704 705 706 707 708 709 710 711 712 713 714 715 716
	else
		channel = NULL;
	rcu_read_unlock();

	if (channel) {
		q = 0;
		do {
			survey.filled = 0;
			if (drv_get_survey(local, q, &survey) != 0) {
				survey.filled = 0;
				break;
			}
			q++;
		} while (channel != survey.channel);
717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747
	}

	if (survey.filled)
		data[i++] = survey.channel->center_freq;
	else
		data[i++] = 0;
	if (survey.filled & SURVEY_INFO_NOISE_DBM)
		data[i++] = (u8)survey.noise;
	else
		data[i++] = -1LL;
	if (survey.filled & SURVEY_INFO_CHANNEL_TIME)
		data[i++] = survey.channel_time;
	else
		data[i++] = -1LL;
	if (survey.filled & SURVEY_INFO_CHANNEL_TIME_BUSY)
		data[i++] = survey.channel_time_busy;
	else
		data[i++] = -1LL;
	if (survey.filled & SURVEY_INFO_CHANNEL_TIME_EXT_BUSY)
		data[i++] = survey.channel_time_ext_busy;
	else
		data[i++] = -1LL;
	if (survey.filled & SURVEY_INFO_CHANNEL_TIME_RX)
		data[i++] = survey.channel_time_rx;
	else
		data[i++] = -1LL;
	if (survey.filled & SURVEY_INFO_CHANNEL_TIME_TX)
		data[i++] = survey.channel_time_tx;
	else
		data[i++] = -1LL;

748
	mutex_unlock(&local->sta_mtx);
749

750 751 752
	if (WARN_ON(i != STA_STATS_LEN))
		return;

753
	drv_get_et_stats(sdata, stats, &(data[STA_STATS_LEN]));
754 755 756 757 758 759
}

static void ieee80211_get_et_strings(struct wiphy *wiphy,
				     struct net_device *dev,
				     u32 sset, u8 *data)
{
760 761 762
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
	int sz_sta_stats = 0;

763
	if (sset == ETH_SS_STATS) {
764
		sz_sta_stats = sizeof(ieee80211_gstrings_sta_stats);
765
		memcpy(data, ieee80211_gstrings_sta_stats, sz_sta_stats);
766
	}
767
	drv_get_et_strings(sdata, sset, &(data[sz_sta_stats]));
768
}
769 770 771 772

static int ieee80211_dump_station(struct wiphy *wiphy, struct net_device *dev,
				 int idx, u8 *mac, struct station_info *sinfo)
{
773
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
774
	struct ieee80211_local *local = sdata->local;
775
	struct sta_info *sta;
776 777
	int ret = -ENOENT;

778
	mutex_lock(&local->sta_mtx);
779

780
	sta = sta_info_get_by_idx(sdata, idx);
781 782
	if (sta) {
		ret = 0;
783
		memcpy(mac, sta->sta.addr, ETH_ALEN);
784 785
		sta_set_sinfo(sta, sinfo);
	}
786

787
	mutex_unlock(&local->sta_mtx);
788

789
	return ret;
790 791
}

792 793 794 795 796 797 798 799
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);
}

800
static int ieee80211_get_station(struct wiphy *wiphy, struct net_device *dev,
801
				 u8 *mac, struct station_info *sinfo)
802
{
803
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
804
	struct ieee80211_local *local = sdata->local;
805
	struct sta_info *sta;
806
	int ret = -ENOENT;
807

808
	mutex_lock(&local->sta_mtx);
809

810
	sta = sta_info_get_bss(sdata, mac);
811 812 813 814 815
	if (sta) {
		ret = 0;
		sta_set_sinfo(sta, sinfo);
	}

816
	mutex_unlock(&local->sta_mtx);
817 818

	return ret;
819 820
}

J
Johannes Berg 已提交
821
static int ieee80211_set_monitor_channel(struct wiphy *wiphy,
822
					 struct cfg80211_chan_def *chandef)
823 824
{
	struct ieee80211_local *local = wiphy_priv(wiphy);
J
Johannes Berg 已提交
825 826
	struct ieee80211_sub_if_data *sdata;
	int ret = 0;
827

828
	if (cfg80211_chandef_identical(&local->monitor_chandef, chandef))
J
Johannes Berg 已提交
829
		return 0;
830

831
	mutex_lock(&local->mtx);
J
Johannes Berg 已提交
832 833 834 835 836 837 838
	mutex_lock(&local->iflist_mtx);
	if (local->use_chanctx) {
		sdata = rcu_dereference_protected(
				local->monitor_sdata,
				lockdep_is_held(&local->iflist_mtx));
		if (sdata) {
			ieee80211_vif_release_channel(sdata);
839
			ret = ieee80211_vif_use_channel(sdata, chandef,
J
Johannes Berg 已提交
840 841 842
					IEEE80211_CHANCTX_EXCLUSIVE);
		}
	} else if (local->open_count == local->monitors) {
843
		local->_oper_chandef = *chandef;
J
Johannes Berg 已提交
844 845
		ieee80211_hw_config(local, 0);
	}
846

847 848
	if (ret == 0)
		local->monitor_chandef = *chandef;
J
Johannes Berg 已提交
849
	mutex_unlock(&local->iflist_mtx);
850
	mutex_unlock(&local->mtx);
851

J
Johannes Berg 已提交
852
	return ret;
853 854
}

855
static int ieee80211_set_probe_resp(struct ieee80211_sub_if_data *sdata,
856
				    const u8 *resp, size_t resp_len)
857
{
858
	struct probe_resp *new, *old;
859 860

	if (!resp || !resp_len)
861
		return 1;
862

863
	old = sdata_dereference(sdata->u.ap.probe_resp, sdata);
864

865
	new = kzalloc(sizeof(struct probe_resp) + resp_len, GFP_KERNEL);
866 867 868
	if (!new)
		return -ENOMEM;

869 870
	new->len = resp_len;
	memcpy(new->data, resp, resp_len);
871 872

	rcu_assign_pointer(sdata->u.ap.probe_resp, new);
873 874
	if (old)
		kfree_rcu(old, rcu_head);
875 876 877 878

	return 0;
}

879 880
static int ieee80211_assign_beacon(struct ieee80211_sub_if_data *sdata,
				   struct cfg80211_beacon_data *params)
881 882 883
{
	struct beacon_data *new, *old;
	int new_head_len, new_tail_len;
884 885
	int size, err;
	u32 changed = BSS_CHANGED_BEACON;
886

887 888
	old = sdata_dereference(sdata->u.ap.beacon, sdata);

889 890 891

	/* Need to have a beacon head if we don't have one yet */
	if (!params->head && !old)
892
		return -EINVAL;
893 894 895 896 897 898 899 900 901 902 903 904 905 906 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

	/* 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;

	/* 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);

937 938
	err = ieee80211_set_probe_resp(sdata, params->probe_resp,
				       params->probe_resp_len);
939 940 941
	if (err < 0)
		return err;
	if (err == 0)
942 943
		changed |= BSS_CHANGED_AP_PROBE_RESP;

944 945 946 947
	rcu_assign_pointer(sdata->u.ap.beacon, new);

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

949
	return changed;
950 951
}

952 953
static int ieee80211_start_ap(struct wiphy *wiphy, struct net_device *dev,
			      struct cfg80211_ap_settings *params)
954
{
955
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
956
	struct ieee80211_local *local = sdata->local;
957
	struct beacon_data *old;
958
	struct ieee80211_sub_if_data *vlan;
959 960 961
	u32 changed = BSS_CHANGED_BEACON_INT |
		      BSS_CHANGED_BEACON_ENABLED |
		      BSS_CHANGED_BEACON |
962 963
		      BSS_CHANGED_SSID |
		      BSS_CHANGED_P2P_PS;
964
	int err;
965

966
	old = sdata_dereference(sdata->u.ap.beacon, sdata);
967 968 969
	if (old)
		return -EALREADY;

970 971 972
	/* TODO: make hostapd tell us what it wants */
	sdata->smps_mode = IEEE80211_SMPS_OFF;
	sdata->needed_rx_chains = sdata->local->rx_chains;
973
	sdata->radar_required = params->radar_required;
974

975
	mutex_lock(&local->mtx);
976
	err = ieee80211_vif_use_channel(sdata, &params->chandef,
J
Johannes Berg 已提交
977
					IEEE80211_CHANCTX_SHARED);
978
	mutex_unlock(&local->mtx);
979 980
	if (err)
		return err;
981
	ieee80211_vif_copy_chanctx_to_vlans(sdata, false);
982

983 984 985 986 987 988
	/*
	 * 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;
989 990 991 992
	sdata->encrypt_headroom = ieee80211_cs_headroom(sdata->local,
							&params->crypto,
							sdata->vif.type);

993 994 995 996 997
	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;
998 999 1000 1001
		vlan->encrypt_headroom =
			ieee80211_cs_headroom(sdata->local,
					      &params->crypto,
					      vlan->vif.type);
1002 1003
	}

1004 1005
	sdata->vif.bss_conf.beacon_int = params->beacon_interval;
	sdata->vif.bss_conf.dtim_period = params->dtim_period;
1006
	sdata->vif.bss_conf.enable_beacon = true;
1007 1008 1009 1010 1011 1012 1013 1014

	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 已提交
1015 1016 1017 1018 1019 1020 1021
	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;
1022

1023 1024 1025 1026 1027
	err = ieee80211_assign_beacon(sdata, &params->beacon);
	if (err < 0)
		return err;
	changed |= err;

1028 1029
	err = drv_start_ap(sdata->local, sdata);
	if (err) {
1030 1031
		old = sdata_dereference(sdata->u.ap.beacon, sdata);

1032 1033 1034 1035 1036 1037
		if (old)
			kfree_rcu(old, rcu_head);
		RCU_INIT_POINTER(sdata->u.ap.beacon, NULL);
		return err;
	}

1038
	ieee80211_recalc_dtim(local, sdata);
1039 1040
	ieee80211_bss_info_change_notify(sdata, changed);

1041 1042 1043 1044
	netif_carrier_on(dev);
	list_for_each_entry(vlan, &sdata->u.ap.vlans, u.vlan.list)
		netif_carrier_on(vlan->dev);

1045
	return 0;
1046 1047
}

1048 1049
static int ieee80211_change_beacon(struct wiphy *wiphy, struct net_device *dev,
				   struct cfg80211_beacon_data *params)
1050
{
1051
	struct ieee80211_sub_if_data *sdata;
1052
	struct beacon_data *old;
1053
	int err;
1054

1055 1056
	sdata = IEEE80211_DEV_TO_SUB_IF(dev);

1057 1058 1059 1060 1061 1062
	/* 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;

1063
	old = sdata_dereference(sdata->u.ap.beacon, sdata);
1064 1065 1066
	if (!old)
		return -ENOENT;

1067 1068 1069 1070 1071
	err = ieee80211_assign_beacon(sdata, params);
	if (err < 0)
		return err;
	ieee80211_bss_info_change_notify(sdata, err);
	return 0;
1072 1073
}

1074
static int ieee80211_stop_ap(struct wiphy *wiphy, struct net_device *dev)
1075
{
1076 1077 1078 1079 1080
	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;
1081
	struct cfg80211_chan_def chandef;
1082

1083
	old_beacon = sdata_dereference(sdata->u.ap.beacon, sdata);
1084
	if (!old_beacon)
1085
		return -ENOENT;
1086
	old_probe_resp = sdata_dereference(sdata->u.ap.probe_resp, sdata);
1087

1088 1089
	/* abort any running channel switch */
	sdata->vif.csa_active = false;
1090 1091 1092
	kfree(sdata->u.ap.next_beacon);
	sdata->u.ap.next_beacon = NULL;

1093
	cancel_work_sync(&sdata->u.ap.request_smps_work);
1094

1095
	/* turn off carrier for this interface and dependent VLANs */
1096 1097 1098 1099
	list_for_each_entry(vlan, &sdata->u.ap.vlans, u.vlan.list)
		netif_carrier_off(vlan->dev);
	netif_carrier_off(dev);

1100
	/* remove beacon and probe response */
1101
	RCU_INIT_POINTER(sdata->u.ap.beacon, NULL);
1102 1103 1104 1105
	RCU_INIT_POINTER(sdata->u.ap.probe_resp, NULL);
	kfree_rcu(old_beacon, rcu_head);
	if (old_probe_resp)
		kfree_rcu(old_probe_resp, rcu_head);
1106

1107
	__sta_info_flush(sdata, true);
1108
	ieee80211_free_keys(sdata, true);
1109

1110
	sdata->vif.bss_conf.enable_beacon = false;
1111
	sdata->vif.bss_conf.ssid_len = 0;
1112
	clear_bit(SDATA_STATE_OFFCHANNEL_BEACON_STOPPED, &sdata->state);
1113
	ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_BEACON_ENABLED);
1114

1115
	if (sdata->wdev.cac_started) {
1116
		chandef = sdata->vif.bss_conf.chandef;
1117
		cancel_delayed_work_sync(&sdata->dfs_cac_timer_work);
1118 1119
		cfg80211_cac_event(sdata->dev, &chandef,
				   NL80211_RADAR_CAC_ABORTED,
1120 1121 1122
				   GFP_KERNEL);
	}

1123 1124
	drv_stop_ap(sdata->local, sdata);

1125 1126 1127 1128
	/* free all potentially still buffered bcast frames */
	local->total_ps_buffered -= skb_queue_len(&sdata->u.ap.ps.bc_buf);
	skb_queue_purge(&sdata->u.ap.ps.bc_buf);

1129
	ieee80211_vif_copy_chanctx_to_vlans(sdata, true);
1130
	mutex_lock(&local->mtx);
J
Johannes Berg 已提交
1131
	ieee80211_vif_release_channel(sdata);
1132
	mutex_unlock(&local->mtx);
J
Johannes Berg 已提交
1133

1134
	return 0;
1135 1136
}

1137 1138 1139 1140 1141 1142 1143 1144 1145
/* Layer 2 Update frame (802.2 Type 1 LLC XID Update response) */
struct iapp_layer2_update {
	u8 da[ETH_ALEN];	/* broadcast */
	u8 sa[ETH_ALEN];	/* STA addr */
	__be16 len;		/* 6 */
	u8 dsap;		/* 0 */
	u8 ssap;		/* 0 */
	u8 control;
	u8 xid_info[3];
E
Eric Dumazet 已提交
1146
} __packed;
1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163

static void ieee80211_send_layer2_update(struct sta_info *sta)
{
	struct iapp_layer2_update *msg;
	struct sk_buff *skb;

	/* Send Level 2 Update Frame to update forwarding tables in layer 2
	 * bridge devices */

	skb = dev_alloc_skb(sizeof(*msg));
	if (!skb)
		return;
	msg = (struct iapp_layer2_update *)skb_put(skb, sizeof(*msg));

	/* 802.2 Type 1 Logical Link Control (LLC) Exchange Identifier (XID)
	 * Update response frame; IEEE Std 802.2-1998, 5.4.1.2.1 */

J
Johannes Berg 已提交
1164
	eth_broadcast_addr(msg->da);
1165
	memcpy(msg->sa, sta->sta.addr, ETH_ALEN);
1166 1167 1168 1169 1170 1171 1172 1173 1174
	msg->len = htons(6);
	msg->dsap = 0;
	msg->ssap = 0x01;	/* NULL LSAP, CR Bit: Response */
	msg->control = 0xaf;	/* XID response lsb.1111F101.
				 * F=0 (no poll command; unsolicited frame) */
	msg->xid_info[0] = 0x81;	/* XID format identifier */
	msg->xid_info[1] = 1;	/* LLC types/classes: Type 1 LLC */
	msg->xid_info[2] = 0;	/* XID sender's receive window size (RW) */

1175 1176
	skb->dev = sta->sdata->dev;
	skb->protocol = eth_type_trans(skb, sta->sdata->dev);
1177
	memset(skb->cb, 0, sizeof(skb->cb));
1178
	netif_rx_ni(skb);
1179 1180
}

1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232
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)) {
		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;
}

1233 1234 1235
static int sta_apply_parameters(struct ieee80211_local *local,
				struct sta_info *sta,
				struct station_parameters *params)
1236
{
1237
	int ret = 0;
1238
	struct ieee80211_supported_band *sband;
1239
	struct ieee80211_sub_if_data *sdata = sta->sdata;
J
Johannes Berg 已提交
1240
	enum ieee80211_band band = ieee80211_get_sdata_band(sdata);
1241
	u32 mask, set;
1242

J
Johannes Berg 已提交
1243
	sband = local->hw.wiphy->bands[band];
J
Johannes Berg 已提交
1244

1245 1246
	mask = params->sta_flags_mask;
	set = params->sta_flags_set;
J
Johannes Berg 已提交
1247

1248 1249 1250 1251 1252 1253 1254 1255 1256
	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);
1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268
	} 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);
		}
1269
	}
1270

1271 1272 1273
	ret = sta_apply_auth_flags(local, sta, mask, set);
	if (ret)
		return ret;
1274

1275 1276
	if (mask & BIT(NL80211_STA_FLAG_SHORT_PREAMBLE)) {
		if (set & BIT(NL80211_STA_FLAG_SHORT_PREAMBLE))
J
Johannes Berg 已提交
1277 1278 1279
			set_sta_flag(sta, WLAN_STA_SHORT_PREAMBLE);
		else
			clear_sta_flag(sta, WLAN_STA_SHORT_PREAMBLE);
1280
	}
1281

1282
	if (mask & BIT(NL80211_STA_FLAG_WME)) {
1283
		if (set & BIT(NL80211_STA_FLAG_WME)) {
J
Johannes Berg 已提交
1284
			set_sta_flag(sta, WLAN_STA_WME);
1285
			sta->sta.wme = true;
J
Johannes Berg 已提交
1286 1287 1288
		} else {
			clear_sta_flag(sta, WLAN_STA_WME);
			sta->sta.wme = false;
1289
		}
1290
	}
1291

1292 1293
	if (mask & BIT(NL80211_STA_FLAG_MFP)) {
		if (set & BIT(NL80211_STA_FLAG_MFP))
J
Johannes Berg 已提交
1294 1295 1296
			set_sta_flag(sta, WLAN_STA_MFP);
		else
			clear_sta_flag(sta, WLAN_STA_MFP);
1297
	}
1298

1299 1300
	if (mask & BIT(NL80211_STA_FLAG_TDLS_PEER)) {
		if (set & BIT(NL80211_STA_FLAG_TDLS_PEER))
J
Johannes Berg 已提交
1301 1302 1303
			set_sta_flag(sta, WLAN_STA_TDLS_PEER);
		else
			clear_sta_flag(sta, WLAN_STA_TDLS_PEER);
1304
	}
1305

1306 1307 1308 1309
	if (params->sta_modify_mask & STATION_PARAM_APPLY_UAPSD) {
		sta->sta.uapsd_queues = params->uapsd_queues;
		sta->sta.max_sp = params->max_sp;
	}
1310

1311 1312 1313 1314 1315 1316 1317
	/*
	 * 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 已提交
1318
	/*
1319 1320 1321 1322 1323
	 * 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 已提交
1324 1325
	 */

1326 1327 1328 1329
	if (params->listen_interval >= 0)
		sta->listen_interval = params->listen_interval;

	if (params->supported_rates) {
1330 1331 1332 1333
		ieee80211_parse_bitrates(&sdata->vif.bss_conf.chandef,
					 sband, params->supported_rates,
					 params->supported_rates_len,
					 &sta->sta.supp_rates[band]);
1334
	}
1335

J
Johannes Berg 已提交
1336
	if (params->ht_capa)
B
Ben Greear 已提交
1337
		ieee80211_ht_cap_ie_to_sta_ht_cap(sdata, sband,
1338
						  params->ht_capa, sta);
1339

M
Mahesh Palivela 已提交
1340 1341
	if (params->vht_capa)
		ieee80211_vht_cap_ie_to_sta_vht_cap(sdata, sband,
1342
						    params->vht_capa, sta);
M
Mahesh Palivela 已提交
1343

1344
	if (ieee80211_vif_is_mesh(&sdata->vif)) {
1345
#ifdef CONFIG_MAC80211_MESH
1346
		u32 changed = 0;
1347 1348

		if (params->sta_modify_mask & STATION_PARAM_APPLY_PLINK_STATE) {
1349
			switch (params->plink_state) {
1350
			case NL80211_PLINK_ESTAB:
1351 1352 1353 1354
				if (sta->plink_state != NL80211_PLINK_ESTAB)
					changed = mesh_plink_inc_estab_count(
							sdata);
				sta->plink_state = params->plink_state;
M
Marco Porsch 已提交
1355 1356

				ieee80211_mps_sta_status_update(sta);
1357 1358
				changed |= ieee80211_mps_set_sta_local_pm(sta,
					      sdata->u.mesh.mshcfg.power_mode);
1359 1360
				break;
			case NL80211_PLINK_LISTEN:
1361
			case NL80211_PLINK_BLOCKED:
1362 1363 1364 1365 1366 1367 1368
			case NL80211_PLINK_OPN_SNT:
			case NL80211_PLINK_OPN_RCVD:
			case NL80211_PLINK_CNF_RCVD:
			case NL80211_PLINK_HOLDING:
				if (sta->plink_state == NL80211_PLINK_ESTAB)
					changed = mesh_plink_dec_estab_count(
							sdata);
1369
				sta->plink_state = params->plink_state;
M
Marco Porsch 已提交
1370 1371

				ieee80211_mps_sta_status_update(sta);
1372 1373
				changed |= ieee80211_mps_set_sta_local_pm(sta,
						NL80211_MESH_POWER_UNKNOWN);
1374 1375 1376 1377 1378
				break;
			default:
				/*  nothing  */
				break;
			}
1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390
		}

		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;
1391
		}
M
Marco Porsch 已提交
1392 1393

		if (params->local_pm)
1394 1395 1396
			changed |=
			      ieee80211_mps_set_sta_local_pm(sta,
							     params->local_pm);
1397
		ieee80211_mbss_info_change_notify(sdata, changed);
1398
#endif
J
Johannes Berg 已提交
1399
	}
1400 1401

	return 0;
1402 1403 1404 1405 1406
}

static int ieee80211_add_station(struct wiphy *wiphy, struct net_device *dev,
				 u8 *mac, struct station_parameters *params)
{
1407
	struct ieee80211_local *local = wiphy_priv(wiphy);
1408 1409
	struct sta_info *sta;
	struct ieee80211_sub_if_data *sdata;
J
Johannes Berg 已提交
1410
	int err;
1411
	int layer2_update;
1412 1413 1414 1415

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

1416 1417
		if (sdata->vif.type != NL80211_IFTYPE_AP_VLAN &&
		    sdata->vif.type != NL80211_IFTYPE_AP)
1418 1419 1420 1421
			return -EINVAL;
	} else
		sdata = IEEE80211_DEV_TO_SUB_IF(dev);

1422
	if (ether_addr_equal(mac, sdata->vif.addr))
1423 1424 1425 1426 1427 1428
		return -EINVAL;

	if (is_multicast_ether_addr(mac))
		return -EINVAL;

	sta = sta_info_alloc(sdata, mac, GFP_KERNEL);
J
Johannes Berg 已提交
1429 1430
	if (!sta)
		return -ENOMEM;
1431

1432 1433 1434 1435
	/*
	 * defaults -- if userspace wants something else we'll
	 * change it accordingly in sta_apply_parameters()
	 */
1436 1437 1438 1439
	if (!(params->sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER))) {
		sta_info_pre_move_state(sta, IEEE80211_STA_AUTH);
		sta_info_pre_move_state(sta, IEEE80211_STA_ASSOC);
	}
1440

1441 1442 1443 1444 1445
	err = sta_apply_parameters(local, sta, params);
	if (err) {
		sta_info_free(local, sta);
		return err;
	}
1446

1447
	/*
1448 1449
	 * for TDLS, rate control should be initialized only when
	 * rates are known and station is marked authorized
1450 1451 1452
	 */
	if (!test_sta_flag(sta, WLAN_STA_TDLS_PEER))
		rate_control_rate_init(sta);
1453

1454 1455 1456
	layer2_update = sdata->vif.type == NL80211_IFTYPE_AP_VLAN ||
		sdata->vif.type == NL80211_IFTYPE_AP;

1457
	err = sta_info_insert_rcu(sta);
J
Johannes Berg 已提交
1458 1459 1460 1461 1462
	if (err) {
		rcu_read_unlock();
		return err;
	}

1463
	if (layer2_update)
J
Johannes Berg 已提交
1464 1465 1466 1467
		ieee80211_send_layer2_update(sta);

	rcu_read_unlock();

1468 1469 1470 1471 1472 1473
	return 0;
}

static int ieee80211_del_station(struct wiphy *wiphy, struct net_device *dev,
				 u8 *mac)
{
1474
	struct ieee80211_sub_if_data *sdata;
1475

1476 1477
	sdata = IEEE80211_DEV_TO_SUB_IF(dev);

1478 1479
	if (mac)
		return sta_info_destroy_addr_bss(sdata, mac);
1480

1481
	sta_info_flush(sdata);
1482 1483 1484 1485
	return 0;
}

static int ieee80211_change_station(struct wiphy *wiphy,
1486
				    struct net_device *dev, u8 *mac,
1487 1488
				    struct station_parameters *params)
{
1489
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1490
	struct ieee80211_local *local = wiphy_priv(wiphy);
1491 1492
	struct sta_info *sta;
	struct ieee80211_sub_if_data *vlansdata;
1493
	enum cfg80211_station_type statype;
1494
	int err;
1495

1496
	mutex_lock(&local->sta_mtx);
J
Johannes Berg 已提交
1497

1498
	sta = sta_info_get_bss(sdata, mac);
J
Johannes Berg 已提交
1499
	if (!sta) {
1500 1501
		err = -ENOENT;
		goto out_err;
J
Johannes Berg 已提交
1502
	}
1503

1504 1505
	switch (sdata->vif.type) {
	case NL80211_IFTYPE_MESH_POINT:
1506
		if (sdata->u.mesh.user_mpm)
1507
			statype = CFG80211_STA_MESH_PEER_USER;
1508
		else
1509
			statype = CFG80211_STA_MESH_PEER_KERNEL;
1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530
		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:
		statype = CFG80211_STA_AP_CLIENT;
		break;
	default:
		err = -EOPNOTSUPP;
		goto out_err;
1531 1532
	}

1533 1534 1535 1536
	err = cfg80211_check_station_change(wiphy, params, statype);
	if (err)
		goto out_err;

1537
	if (params->vlan && params->vlan != sta->sdata->dev) {
1538 1539 1540
		bool prev_4addr = false;
		bool new_4addr = false;

1541 1542
		vlansdata = IEEE80211_DEV_TO_SUB_IF(params->vlan);

1543
		if (params->vlan->ieee80211_ptr->use_4addr) {
J
Johannes Berg 已提交
1544
			if (vlansdata->u.vlan.sta) {
1545 1546
				err = -EBUSY;
				goto out_err;
J
Johannes Berg 已提交
1547
			}
1548

1549
			rcu_assign_pointer(vlansdata->u.vlan.sta, sta);
1550 1551 1552 1553 1554 1555 1556
			new_4addr = true;
		}

		if (sta->sdata->vif.type == NL80211_IFTYPE_AP_VLAN &&
		    sta->sdata->u.vlan.sta) {
			rcu_assign_pointer(sta->sdata->u.vlan.sta, NULL);
			prev_4addr = true;
1557 1558
		}

1559
		sta->sdata = vlansdata;
1560 1561 1562 1563 1564 1565 1566 1567 1568

		if (sta->sta_state == IEEE80211_STA_AUTHORIZED &&
		    prev_4addr != new_4addr) {
			if (new_4addr)
				atomic_dec(&sta->sdata->bss->num_mcast_sta);
			else
				atomic_inc(&sta->sdata->bss->num_mcast_sta);
		}

1569 1570 1571
		ieee80211_send_layer2_update(sta);
	}

1572
	err = sta_apply_parameters(local, sta, params);
1573 1574
	if (err)
		goto out_err;
1575

1576 1577 1578
	/* When peer becomes authorized, init rate control as well */
	if (test_sta_flag(sta, WLAN_STA_TDLS_PEER) &&
	    test_sta_flag(sta, WLAN_STA_AUTHORIZED))
1579 1580
		rate_control_rate_init(sta);

1581
	mutex_unlock(&local->sta_mtx);
J
Johannes Berg 已提交
1582

1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596
	if ((sdata->vif.type == NL80211_IFTYPE_AP ||
	     sdata->vif.type == NL80211_IFTYPE_AP_VLAN) &&
	    sta->known_smps_mode != sta->sdata->bss->req_smps &&
	    test_sta_flag(sta, WLAN_STA_AUTHORIZED) &&
	    sta_info_tx_streams(sta) != 1) {
		ht_dbg(sta->sdata,
		       "%pM just authorized and MIMO capable - update SMPS\n",
		       sta->sta.addr);
		ieee80211_send_smps_action(sta->sdata,
			sta->sdata->bss->req_smps,
			sta->sta.addr,
			sta->sdata->vif.bss_conf.bssid);
	}

1597
	if (sdata->vif.type == NL80211_IFTYPE_STATION &&
E
Eliad Peller 已提交
1598
	    params->sta_flags_mask & BIT(NL80211_STA_FLAG_AUTHORIZED)) {
1599
		ieee80211_recalc_ps(local, -1);
E
Eliad Peller 已提交
1600 1601
		ieee80211_recalc_ps_vif(sdata);
	}
1602

1603
	return 0;
1604 1605 1606
out_err:
	mutex_unlock(&local->sta_mtx);
	return err;
1607 1608
}

1609 1610 1611 1612
#ifdef CONFIG_MAC80211_MESH
static int ieee80211_add_mpath(struct wiphy *wiphy, struct net_device *dev,
				 u8 *dst, u8 *next_hop)
{
1613
	struct ieee80211_sub_if_data *sdata;
1614 1615 1616
	struct mesh_path *mpath;
	struct sta_info *sta;

1617 1618
	sdata = IEEE80211_DEV_TO_SUB_IF(dev);

1619
	rcu_read_lock();
1620
	sta = sta_info_get(sdata, next_hop);
1621 1622
	if (!sta) {
		rcu_read_unlock();
1623
		return -ENOENT;
1624
	}
1625

1626 1627
	mpath = mesh_path_add(sdata, dst);
	if (IS_ERR(mpath)) {
1628
		rcu_read_unlock();
1629
		return PTR_ERR(mpath);
1630
	}
1631 1632

	mesh_path_fix_nexthop(mpath, sta);
1633

1634 1635 1636 1637 1638
	rcu_read_unlock();
	return 0;
}

static int ieee80211_del_mpath(struct wiphy *wiphy, struct net_device *dev,
J
Johannes Berg 已提交
1639
			       u8 *dst)
1640
{
1641 1642
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);

1643
	if (dst)
J
Johannes Berg 已提交
1644
		return mesh_path_del(sdata, dst);
1645

1646
	mesh_path_flush_by_iface(sdata);
1647 1648 1649 1650 1651 1652 1653
	return 0;
}

static int ieee80211_change_mpath(struct wiphy *wiphy,
				    struct net_device *dev,
				    u8 *dst, u8 *next_hop)
{
1654
	struct ieee80211_sub_if_data *sdata;
1655 1656 1657
	struct mesh_path *mpath;
	struct sta_info *sta;

1658 1659
	sdata = IEEE80211_DEV_TO_SUB_IF(dev);

1660 1661
	rcu_read_lock();

1662
	sta = sta_info_get(sdata, next_hop);
1663 1664
	if (!sta) {
		rcu_read_unlock();
1665
		return -ENOENT;
1666
	}
1667

J
Johannes Berg 已提交
1668
	mpath = mesh_path_lookup(sdata, dst);
1669 1670 1671 1672 1673 1674
	if (!mpath) {
		rcu_read_unlock();
		return -ENOENT;
	}

	mesh_path_fix_nexthop(mpath, sta);
1675

1676 1677 1678 1679 1680 1681 1682
	rcu_read_unlock();
	return 0;
}

static void mpath_set_pinfo(struct mesh_path *mpath, u8 *next_hop,
			    struct mpath_info *pinfo)
{
J
Johannes Berg 已提交
1683 1684 1685 1686
	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);
1687 1688 1689
	else
		memset(next_hop, 0, ETH_ALEN);

1690 1691
	memset(pinfo, 0, sizeof(*pinfo));

1692 1693
	pinfo->generation = mesh_paths_generation;

1694
	pinfo->filled = MPATH_INFO_FRAME_QLEN |
1695
			MPATH_INFO_SN |
1696 1697 1698 1699 1700 1701 1702
			MPATH_INFO_METRIC |
			MPATH_INFO_EXPTIME |
			MPATH_INFO_DISCOVERY_TIMEOUT |
			MPATH_INFO_DISCOVERY_RETRIES |
			MPATH_INFO_FLAGS;

	pinfo->frame_qlen = mpath->frame_queue.qlen;
1703
	pinfo->sn = mpath->sn;
1704 1705 1706 1707 1708 1709 1710 1711 1712 1713
	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;
1714 1715
	if (mpath->flags & MESH_PATH_SN_VALID)
		pinfo->flags |= NL80211_MPATH_FLAG_SN_VALID;
1716 1717
	if (mpath->flags & MESH_PATH_FIXED)
		pinfo->flags |= NL80211_MPATH_FLAG_FIXED;
1718 1719
	if (mpath->flags & MESH_PATH_RESOLVED)
		pinfo->flags |= NL80211_MPATH_FLAG_RESOLVED;
1720 1721 1722 1723 1724 1725
}

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

{
1726
	struct ieee80211_sub_if_data *sdata;
1727 1728
	struct mesh_path *mpath;

1729 1730
	sdata = IEEE80211_DEV_TO_SUB_IF(dev);

1731
	rcu_read_lock();
J
Johannes Berg 已提交
1732
	mpath = mesh_path_lookup(sdata, dst);
1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746
	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,
				 int idx, u8 *dst, u8 *next_hop,
				 struct mpath_info *pinfo)
{
1747
	struct ieee80211_sub_if_data *sdata;
1748 1749
	struct mesh_path *mpath;

1750 1751
	sdata = IEEE80211_DEV_TO_SUB_IF(dev);

1752
	rcu_read_lock();
J
Johannes Berg 已提交
1753
	mpath = mesh_path_lookup_by_idx(sdata, idx);
1754 1755 1756 1757 1758 1759 1760 1761 1762
	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;
}
1763

1764
static int ieee80211_get_mesh_config(struct wiphy *wiphy,
1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779
				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;
}

1780 1781 1782 1783 1784
static int copy_mesh_setup(struct ieee80211_if_mesh *ifmsh,
		const struct mesh_setup *setup)
{
	u8 *new_ie;
	const u8 *old_ie;
1785 1786
	struct ieee80211_sub_if_data *sdata = container_of(ifmsh,
					struct ieee80211_sub_if_data, u.mesh);
1787

1788
	/* allocate information elements */
1789
	new_ie = NULL;
1790
	old_ie = ifmsh->ie;
1791

1792 1793
	if (setup->ie_len) {
		new_ie = kmemdup(setup->ie, setup->ie_len,
1794 1795 1796 1797
				GFP_KERNEL);
		if (!new_ie)
			return -ENOMEM;
	}
1798 1799 1800
	ifmsh->ie_len = setup->ie_len;
	ifmsh->ie = new_ie;
	kfree(old_ie);
1801 1802 1803 1804

	/* 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);
1805
	ifmsh->mesh_sp_id = setup->sync_method;
1806 1807
	ifmsh->mesh_pp_id = setup->path_sel_proto;
	ifmsh->mesh_pm_id = setup->path_metric;
1808
	ifmsh->user_mpm = setup->user_mpm;
1809
	ifmsh->mesh_auth_id = setup->auth_id;
1810 1811 1812 1813 1814
	ifmsh->security = IEEE80211_MESH_SEC_NONE;
	if (setup->is_authenticated)
		ifmsh->security |= IEEE80211_MESH_SEC_AUTHED;
	if (setup->is_secure)
		ifmsh->security |= IEEE80211_MESH_SEC_SECURED;
1815

1816 1817 1818
	/* mcast rate setting in Mesh Node */
	memcpy(sdata->vif.bss_conf.mcast_rate, setup->mcast_rate,
						sizeof(setup->mcast_rate));
1819
	sdata->vif.bss_conf.basic_rates = setup->basic_rates;
1820

1821 1822 1823
	sdata->vif.bss_conf.beacon_int = setup->beacon_interval;
	sdata->vif.bss_conf.dtim_period = setup->dtim_period;

1824 1825 1826
	return 0;
}

1827
static int ieee80211_update_mesh_config(struct wiphy *wiphy,
1828 1829
					struct net_device *dev, u32 mask,
					const struct mesh_config *nconf)
1830 1831 1832
{
	struct mesh_config *conf;
	struct ieee80211_sub_if_data *sdata;
1833 1834
	struct ieee80211_if_mesh *ifmsh;

1835
	sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1836
	ifmsh = &sdata->u.mesh;
1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851

	/* 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;
1852
	if (_chg_mesh_attr(NL80211_MESHCONF_ELEMENT_TTL, mask))
1853
		conf->element_ttl = nconf->element_ttl;
1854 1855 1856
	if (_chg_mesh_attr(NL80211_MESHCONF_AUTO_OPEN_PLINKS, mask)) {
		if (ifmsh->user_mpm)
			return -EBUSY;
1857
		conf->auto_open_plinks = nconf->auto_open_plinks;
1858
	}
1859 1860 1861
	if (_chg_mesh_attr(NL80211_MESHCONF_SYNC_OFFSET_MAX_NEIGHBOR, mask))
		conf->dot11MeshNbrOffsetMaxNeighbor =
			nconf->dot11MeshNbrOffsetMaxNeighbor;
1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874
	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;
1875 1876 1877
	if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_PERR_MIN_INTERVAL, mask))
		conf->dot11MeshHWMPperrMinInterval =
			nconf->dot11MeshHWMPperrMinInterval;
1878 1879 1880 1881
	if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME,
			   mask))
		conf->dot11MeshHWMPnetDiameterTraversalTime =
			nconf->dot11MeshHWMPnetDiameterTraversalTime;
1882 1883 1884 1885
	if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_ROOTMODE, mask)) {
		conf->dot11MeshHWMPRootMode = nconf->dot11MeshHWMPRootMode;
		ieee80211_mesh_root_setup(ifmsh);
	}
1886
	if (_chg_mesh_attr(NL80211_MESHCONF_GATE_ANNOUNCEMENTS, mask)) {
T
Thomas Pedersen 已提交
1887 1888 1889 1890
		/* our current gate announcement implementation rides on root
		 * announcements, so require this ifmsh to also be a root node
		 * */
		if (nconf->dot11MeshGateAnnouncementProtocol &&
1891 1892
		    !(conf->dot11MeshHWMPRootMode > IEEE80211_ROOTMODE_ROOT)) {
			conf->dot11MeshHWMPRootMode = IEEE80211_PROACTIVE_RANN;
T
Thomas Pedersen 已提交
1893 1894
			ieee80211_mesh_root_setup(ifmsh);
		}
1895 1896 1897
		conf->dot11MeshGateAnnouncementProtocol =
			nconf->dot11MeshGateAnnouncementProtocol;
	}
1898
	if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_RANN_INTERVAL, mask))
1899 1900
		conf->dot11MeshHWMPRannInterval =
			nconf->dot11MeshHWMPRannInterval;
1901 1902
	if (_chg_mesh_attr(NL80211_MESHCONF_FORWARDING, mask))
		conf->dot11MeshForwarding = nconf->dot11MeshForwarding;
1903 1904 1905 1906 1907 1908 1909 1910
	if (_chg_mesh_attr(NL80211_MESHCONF_RSSI_THRESHOLD, mask)) {
		/* our RSSI threshold implementation is supported only for
		 * devices that report signal in dBm.
		 */
		if (!(sdata->local->hw.flags & IEEE80211_HW_SIGNAL_DBM))
			return -ENOTSUPP;
		conf->rssi_threshold = nconf->rssi_threshold;
	}
1911 1912 1913 1914 1915
	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);
	}
1916 1917 1918 1919 1920 1921
	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;
1922 1923 1924
	if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_CONFIRMATION_INTERVAL, mask))
		conf->dot11MeshHWMPconfirmationInterval =
			nconf->dot11MeshHWMPconfirmationInterval;
M
Marco Porsch 已提交
1925 1926 1927 1928
	if (_chg_mesh_attr(NL80211_MESHCONF_POWER_MODE, mask)) {
		conf->power_mode = nconf->power_mode;
		ieee80211_mps_local_status_update(sdata);
	}
T
Thomas Pedersen 已提交
1929
	if (_chg_mesh_attr(NL80211_MESHCONF_AWAKE_WINDOW, mask))
M
Marco Porsch 已提交
1930 1931
		conf->dot11MeshAwakeWindowDuration =
			nconf->dot11MeshAwakeWindowDuration;
1932 1933
	if (_chg_mesh_attr(NL80211_MESHCONF_PLINK_TIMEOUT, mask))
		conf->plink_timeout = nconf->plink_timeout;
T
Thomas Pedersen 已提交
1934
	ieee80211_mbss_info_change_notify(sdata, BSS_CHANGED_BEACON);
1935 1936 1937
	return 0;
}

1938 1939 1940 1941 1942 1943
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;
1944
	int err;
1945

1946 1947 1948 1949
	memcpy(&ifmsh->mshcfg, conf, sizeof(struct mesh_config));
	err = copy_mesh_setup(ifmsh, setup);
	if (err)
		return err;
1950

1951 1952 1953 1954
	/* can mesh use other SMPS modes? */
	sdata->smps_mode = IEEE80211_SMPS_OFF;
	sdata->needed_rx_chains = sdata->local->rx_chains;

1955
	mutex_lock(&sdata->local->mtx);
1956
	err = ieee80211_vif_use_channel(sdata, &setup->chandef,
J
Johannes Berg 已提交
1957
					IEEE80211_CHANCTX_SHARED);
1958
	mutex_unlock(&sdata->local->mtx);
1959 1960 1961
	if (err)
		return err;

T
Thomas Pedersen 已提交
1962
	return ieee80211_start_mesh(sdata);
1963 1964 1965 1966 1967 1968 1969
}

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);
1970
	mutex_lock(&sdata->local->mtx);
J
Johannes Berg 已提交
1971
	ieee80211_vif_release_channel(sdata);
1972
	mutex_unlock(&sdata->local->mtx);
1973 1974 1975

	return 0;
}
1976 1977
#endif

1978 1979 1980 1981
static int ieee80211_change_bss(struct wiphy *wiphy,
				struct net_device *dev,
				struct bss_parameters *params)
{
J
Johannes Berg 已提交
1982 1983
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
	enum ieee80211_band band;
1984 1985
	u32 changed = 0;

1986
	if (!sdata_dereference(sdata->u.ap.beacon, sdata))
J
Johannes Berg 已提交
1987 1988 1989
		return -ENOENT;

	band = ieee80211_get_sdata_band(sdata);
1990 1991

	if (params->use_cts_prot >= 0) {
J
Johannes Berg 已提交
1992
		sdata->vif.bss_conf.use_cts_prot = params->use_cts_prot;
1993 1994 1995
		changed |= BSS_CHANGED_ERP_CTS_PROT;
	}
	if (params->use_short_preamble >= 0) {
J
Johannes Berg 已提交
1996
		sdata->vif.bss_conf.use_short_preamble =
1997 1998 1999
			params->use_short_preamble;
		changed |= BSS_CHANGED_ERP_PREAMBLE;
	}
2000 2001

	if (!sdata->vif.bss_conf.use_short_slot &&
J
Johannes Berg 已提交
2002
	    band == IEEE80211_BAND_5GHZ) {
2003 2004 2005 2006
		sdata->vif.bss_conf.use_short_slot = true;
		changed |= BSS_CHANGED_ERP_SLOT;
	}

2007
	if (params->use_short_slot_time >= 0) {
J
Johannes Berg 已提交
2008
		sdata->vif.bss_conf.use_short_slot =
2009 2010 2011 2012
			params->use_short_slot_time;
		changed |= BSS_CHANGED_ERP_SLOT;
	}

2013
	if (params->basic_rates) {
2014 2015 2016 2017 2018
		ieee80211_parse_bitrates(&sdata->vif.bss_conf.chandef,
					 wiphy->bands[band],
					 params->basic_rates,
					 params->basic_rates_len,
					 &sdata->vif.bss_conf.basic_rates);
2019 2020 2021
		changed |= BSS_CHANGED_BASIC_RATES;
	}

2022 2023 2024 2025 2026 2027 2028
	if (params->ap_isolate >= 0) {
		if (params->ap_isolate)
			sdata->flags |= IEEE80211_SDATA_DONT_BRIDGE_PACKETS;
		else
			sdata->flags &= ~IEEE80211_SDATA_DONT_BRIDGE_PACKETS;
	}

2029 2030 2031 2032 2033 2034
	if (params->ht_opmode >= 0) {
		sdata->vif.bss_conf.ht_operation_mode =
			(u16) params->ht_opmode;
		changed |= BSS_CHANGED_HT;
	}

2035
	if (params->p2p_ctwindow >= 0) {
J
Janusz Dziedzic 已提交
2036 2037 2038 2039
		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;
2040 2041 2042
		changed |= BSS_CHANGED_P2P_PS;
	}

J
Janusz Dziedzic 已提交
2043 2044 2045 2046 2047 2048 2049
	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;
2050 2051 2052
		changed |= BSS_CHANGED_P2P_PS;
	}

2053 2054 2055 2056 2057
	ieee80211_bss_info_change_notify(sdata, changed);

	return 0;
}

2058
static int ieee80211_set_txq_params(struct wiphy *wiphy,
2059
				    struct net_device *dev,
2060 2061 2062
				    struct ieee80211_txq_params *params)
{
	struct ieee80211_local *local = wiphy_priv(wiphy);
2063
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
2064 2065 2066 2067 2068
	struct ieee80211_tx_queue_params p;

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

2069 2070 2071
	if (local->hw.queues < IEEE80211_NUM_ACS)
		return -EOPNOTSUPP;

2072 2073 2074 2075 2076
	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 已提交
2077 2078 2079 2080 2081 2082 2083

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

2084 2085
	sdata->tx_conf[params->ac] = p;
	if (drv_conf_tx(local, sdata, params->ac, &p)) {
J
Joe Perches 已提交
2086
		wiphy_debug(local->hw.wiphy,
2087 2088
			    "failed to set TX queue parameters for AC %d\n",
			    params->ac);
2089 2090 2091
		return -EINVAL;
	}

2092 2093
	ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_QOS);

2094 2095 2096
	return 0;
}

2097
#ifdef CONFIG_PM
J
Johannes Berg 已提交
2098 2099
static int ieee80211_suspend(struct wiphy *wiphy,
			     struct cfg80211_wowlan *wowlan)
2100
{
2101
	return __ieee80211_suspend(wiphy_priv(wiphy), wowlan);
2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112
}

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

2113 2114 2115
static int ieee80211_scan(struct wiphy *wiphy,
			  struct cfg80211_scan_request *req)
{
J
Johannes Berg 已提交
2116 2117 2118
	struct ieee80211_sub_if_data *sdata;

	sdata = IEEE80211_WDEV_TO_SUB_IF(req->wdev);
2119

2120 2121 2122 2123 2124
	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:
2125
	case NL80211_IFTYPE_P2P_DEVICE:
2126 2127 2128 2129
		break;
	case NL80211_IFTYPE_P2P_GO:
		if (sdata->local->ops->hw_scan)
			break;
2130 2131 2132 2133 2134
		/*
		 * FIXME: implement NoA while scanning in software,
		 * for now fall through to allow scanning only when
		 * beaconing hasn't been configured yet
		 */
2135
	case NL80211_IFTYPE_AP:
2136 2137 2138 2139 2140 2141 2142 2143 2144 2145
		/*
		 * 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)))
2146 2147 2148 2149 2150
			return -EOPNOTSUPP;
		break;
	default:
		return -EOPNOTSUPP;
	}
2151 2152 2153 2154

	return ieee80211_request_scan(sdata, req);
}

2155 2156 2157 2158 2159 2160 2161 2162 2163 2164 2165 2166 2167 2168
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
2169
ieee80211_sched_scan_stop(struct wiphy *wiphy, struct net_device *dev)
2170 2171 2172 2173 2174 2175
{
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);

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

2176
	return ieee80211_request_sched_scan_stop(sdata);
2177 2178
}

2179 2180 2181
static int ieee80211_auth(struct wiphy *wiphy, struct net_device *dev,
			  struct cfg80211_auth_request *req)
{
2182
	return ieee80211_mgd_auth(IEEE80211_DEV_TO_SUB_IF(dev), req);
2183 2184 2185 2186 2187
}

static int ieee80211_assoc(struct wiphy *wiphy, struct net_device *dev,
			   struct cfg80211_assoc_request *req)
{
2188
	return ieee80211_mgd_assoc(IEEE80211_DEV_TO_SUB_IF(dev), req);
2189 2190 2191
}

static int ieee80211_deauth(struct wiphy *wiphy, struct net_device *dev,
2192
			    struct cfg80211_deauth_request *req)
2193
{
2194
	return ieee80211_mgd_deauth(IEEE80211_DEV_TO_SUB_IF(dev), req);
2195 2196 2197
}

static int ieee80211_disassoc(struct wiphy *wiphy, struct net_device *dev,
2198
			      struct cfg80211_disassoc_request *req)
2199
{
2200
	return ieee80211_mgd_disassoc(IEEE80211_DEV_TO_SUB_IF(dev), req);
2201 2202
}

2203 2204 2205
static int ieee80211_join_ibss(struct wiphy *wiphy, struct net_device *dev,
			       struct cfg80211_ibss_params *params)
{
J
Johannes Berg 已提交
2206
	return ieee80211_ibss_join(IEEE80211_DEV_TO_SUB_IF(dev), params);
2207 2208 2209 2210
}

static int ieee80211_leave_ibss(struct wiphy *wiphy, struct net_device *dev)
{
J
Johannes Berg 已提交
2211
	return ieee80211_ibss_leave(IEEE80211_DEV_TO_SUB_IF(dev));
2212 2213
}

2214 2215 2216 2217 2218
static int ieee80211_set_mcast_rate(struct wiphy *wiphy, struct net_device *dev,
				    int rate[IEEE80211_NUM_BANDS])
{
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);

2219 2220
	memcpy(sdata->vif.bss_conf.mcast_rate, rate,
	       sizeof(int) * IEEE80211_NUM_BANDS);
2221 2222 2223 2224

	return 0;
}

2225 2226 2227
static int ieee80211_set_wiphy_params(struct wiphy *wiphy, u32 changed)
{
	struct ieee80211_local *local = wiphy_priv(wiphy);
2228
	int err;
2229

2230 2231 2232 2233 2234 2235 2236
	if (changed & WIPHY_PARAM_FRAG_THRESHOLD) {
		err = drv_set_frag_threshold(local, wiphy->frag_threshold);

		if (err)
			return err;
	}

2237 2238 2239 2240 2241 2242 2243
	if (changed & WIPHY_PARAM_COVERAGE_CLASS) {
		err = drv_set_coverage_class(local, wiphy->coverage_class);

		if (err)
			return err;
	}

2244
	if (changed & WIPHY_PARAM_RTS_THRESHOLD) {
2245
		err = drv_set_rts_threshold(local, wiphy->rts_threshold);
2246

2247 2248
		if (err)
			return err;
2249 2250
	}

2251 2252 2253
	if (changed & WIPHY_PARAM_RETRY_SHORT) {
		if (wiphy->retry_short > IEEE80211_MAX_TX_RETRY)
			return -EINVAL;
2254
		local->hw.conf.short_frame_max_tx_count = wiphy->retry_short;
2255 2256 2257 2258
	}
	if (changed & WIPHY_PARAM_RETRY_LONG) {
		if (wiphy->retry_long > IEEE80211_MAX_TX_RETRY)
			return -EINVAL;
2259
		local->hw.conf.long_frame_max_tx_count = wiphy->retry_long;
2260
	}
2261 2262 2263 2264 2265 2266 2267
	if (changed &
	    (WIPHY_PARAM_RETRY_SHORT | WIPHY_PARAM_RETRY_LONG))
		ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_RETRY_LIMITS);

	return 0;
}

2268
static int ieee80211_set_tx_power(struct wiphy *wiphy,
2269
				  struct wireless_dev *wdev,
2270
				  enum nl80211_tx_power_setting type, int mbm)
2271 2272
{
	struct ieee80211_local *local = wiphy_priv(wiphy);
2273
	struct ieee80211_sub_if_data *sdata;
2274

2275 2276 2277 2278 2279 2280 2281 2282 2283 2284 2285 2286 2287 2288 2289 2290 2291 2292 2293
	if (wdev) {
		sdata = IEEE80211_WDEV_TO_SUB_IF(wdev);

		switch (type) {
		case NL80211_TX_POWER_AUTOMATIC:
			sdata->user_power_level = IEEE80211_UNSET_POWER_LEVEL;
			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;
		}

		ieee80211_recalc_txpower(sdata);

		return 0;
	}
J
Johannes Berg 已提交
2294

2295
	switch (type) {
2296
	case NL80211_TX_POWER_AUTOMATIC:
2297
		local->user_power_level = IEEE80211_UNSET_POWER_LEVEL;
2298
		break;
2299 2300 2301 2302 2303
	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);
2304 2305 2306
		break;
	}

2307 2308 2309 2310 2311 2312
	mutex_lock(&local->iflist_mtx);
	list_for_each_entry(sdata, &local->interfaces, list)
		sdata->user_power_level = local->user_power_level;
	list_for_each_entry(sdata, &local->interfaces, list)
		ieee80211_recalc_txpower(sdata);
	mutex_unlock(&local->iflist_mtx);
2313 2314 2315 2316

	return 0;
}

2317 2318 2319
static int ieee80211_get_tx_power(struct wiphy *wiphy,
				  struct wireless_dev *wdev,
				  int *dbm)
2320 2321
{
	struct ieee80211_local *local = wiphy_priv(wiphy);
2322
	struct ieee80211_sub_if_data *sdata = IEEE80211_WDEV_TO_SUB_IF(wdev);
2323

2324 2325 2326 2327
	if (!local->use_chanctx)
		*dbm = local->hw.conf.power_level;
	else
		*dbm = sdata->vif.bss_conf.txpower;
2328 2329 2330 2331

	return 0;
}

J
Johannes Berg 已提交
2332
static int ieee80211_set_wds_peer(struct wiphy *wiphy, struct net_device *dev,
J
Johannes Berg 已提交
2333
				  const u8 *addr)
J
Johannes Berg 已提交
2334 2335 2336 2337 2338 2339 2340 2341
{
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);

	memcpy(&sdata->u.wds.remote_addr, addr, ETH_ALEN);

	return 0;
}

J
Johannes Berg 已提交
2342 2343 2344 2345 2346 2347 2348
static void ieee80211_rfkill_poll(struct wiphy *wiphy)
{
	struct ieee80211_local *local = wiphy_priv(wiphy);

	drv_rfkill_poll(local);
}

2349
#ifdef CONFIG_NL80211_TESTMODE
2350 2351 2352
static int ieee80211_testmode_cmd(struct wiphy *wiphy,
				  struct wireless_dev *wdev,
				  void *data, int len)
2353 2354
{
	struct ieee80211_local *local = wiphy_priv(wiphy);
2355
	struct ieee80211_vif *vif = NULL;
2356 2357 2358 2359

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

2360 2361 2362 2363 2364 2365 2366 2367 2368
	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);
2369
}
W
Wey-Yi Guy 已提交
2370 2371 2372 2373 2374 2375 2376 2377 2378 2379 2380 2381 2382

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);
}
2383 2384
#endif

2385 2386 2387 2388 2389 2390 2391 2392 2393 2394 2395 2396 2397 2398 2399 2400 2401 2402 2403 2404 2405 2406 2407 2408 2409 2410 2411 2412 2413 2414 2415 2416 2417 2418 2419 2420 2421 2422 2423 2424 2425 2426 2427 2428 2429 2430 2431 2432 2433 2434 2435 2436 2437 2438 2439 2440 2441 2442 2443 2444 2445 2446 2447 2448 2449 2450 2451 2452 2453 2454 2455 2456 2457 2458 2459 2460 2461 2462 2463 2464 2465 2466 2467 2468 2469 2470
int __ieee80211_request_smps_ap(struct ieee80211_sub_if_data *sdata,
				enum ieee80211_smps_mode smps_mode)
{
	struct sta_info *sta;
	enum ieee80211_smps_mode old_req;
	int i;

	if (WARN_ON_ONCE(sdata->vif.type != NL80211_IFTYPE_AP))
		return -EINVAL;

	if (sdata->vif.bss_conf.chandef.width == NL80211_CHAN_WIDTH_20_NOHT)
		return 0;

	old_req = sdata->u.ap.req_smps;
	sdata->u.ap.req_smps = smps_mode;

	/* AUTOMATIC doesn't mean much for AP - don't allow it */
	if (old_req == smps_mode ||
	    smps_mode == IEEE80211_SMPS_AUTOMATIC)
		return 0;

	 /* If no associated stations, there's no need to do anything */
	if (!atomic_read(&sdata->u.ap.num_mcast_sta)) {
		sdata->smps_mode = smps_mode;
		ieee80211_queue_work(&sdata->local->hw, &sdata->recalc_smps);
		return 0;
	}

	ht_dbg(sdata,
	       "SMSP %d requested in AP mode, sending Action frame to %d stations\n",
	       smps_mode, atomic_read(&sdata->u.ap.num_mcast_sta));

	mutex_lock(&sdata->local->sta_mtx);
	for (i = 0; i < STA_HASH_SIZE; i++) {
		for (sta = rcu_dereference_protected(sdata->local->sta_hash[i],
				lockdep_is_held(&sdata->local->sta_mtx));
		     sta;
		     sta = rcu_dereference_protected(sta->hnext,
				lockdep_is_held(&sdata->local->sta_mtx))) {
			/*
			 * Only stations associated to our AP and
			 * associated VLANs
			 */
			if (sta->sdata->bss != &sdata->u.ap)
				continue;

			/* This station doesn't support MIMO - skip it */
			if (sta_info_tx_streams(sta) == 1)
				continue;

			/*
			 * Don't wake up a STA just to send the action frame
			 * unless we are getting more restrictive.
			 */
			if (test_sta_flag(sta, WLAN_STA_PS_STA) &&
			    !ieee80211_smps_is_restrictive(sta->known_smps_mode,
							   smps_mode)) {
				ht_dbg(sdata,
				       "Won't send SMPS to sleeping STA %pM\n",
				       sta->sta.addr);
				continue;
			}

			/*
			 * If the STA is not authorized, wait until it gets
			 * authorized and the action frame will be sent then.
			 */
			if (!test_sta_flag(sta, WLAN_STA_AUTHORIZED))
				continue;

			ht_dbg(sdata, "Sending SMPS to %pM\n", sta->sta.addr);
			ieee80211_send_smps_action(sdata, smps_mode,
						   sta->sta.addr,
						   sdata->vif.bss_conf.bssid);
		}
	}
	mutex_unlock(&sdata->local->sta_mtx);

	sdata->smps_mode = smps_mode;
	ieee80211_queue_work(&sdata->local->hw, &sdata->recalc_smps);

	return 0;
}

int __ieee80211_request_smps_mgd(struct ieee80211_sub_if_data *sdata,
				 enum ieee80211_smps_mode smps_mode)
2471 2472 2473 2474 2475
{
	const u8 *ap;
	enum ieee80211_smps_mode old_req;
	int err;

2476
	lockdep_assert_held(&sdata->wdev.mtx);
2477

2478 2479 2480
	if (WARN_ON_ONCE(sdata->vif.type != NL80211_IFTYPE_STATION))
		return -EINVAL;

2481 2482 2483 2484 2485 2486 2487 2488 2489
	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
2490 2491
	 * association, there's no need to do anything, just store
	 * the new value until we associate.
2492 2493
	 */
	if (!sdata->u.mgd.associated ||
2494
	    sdata->vif.bss_conf.chandef.width == NL80211_CHAN_WIDTH_20_NOHT)
2495 2496
		return 0;

2497
	ap = sdata->u.mgd.associated->bssid;
2498 2499 2500 2501 2502 2503 2504 2505 2506 2507 2508 2509 2510 2511 2512 2513 2514

	if (smps_mode == IEEE80211_SMPS_AUTOMATIC) {
		if (sdata->u.mgd.powersave)
			smps_mode = IEEE80211_SMPS_DYNAMIC;
		else
			smps_mode = IEEE80211_SMPS_OFF;
	}

	/* 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;

	return err;
}

J
Johannes Berg 已提交
2515 2516 2517 2518 2519 2520
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);

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

J
Johannes Berg 已提交
2524 2525 2526 2527
	if (!(local->hw.flags & IEEE80211_HW_SUPPORTS_PS))
		return -EOPNOTSUPP;

	if (enabled == sdata->u.mgd.powersave &&
2528
	    timeout == local->dynamic_ps_forced_timeout)
J
Johannes Berg 已提交
2529 2530 2531
		return 0;

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

2534
	/* no change, but if automatic follow powersave */
2535
	sdata_lock(sdata);
2536
	__ieee80211_request_smps_mgd(sdata, sdata->u.mgd.req_smps);
2537
	sdata_unlock(sdata);
2538

J
Johannes Berg 已提交
2539 2540 2541 2542
	if (local->hw.flags & IEEE80211_HW_SUPPORTS_DYNAMIC_PS)
		ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_PS);

	ieee80211_recalc_ps(local, -1);
E
Eliad Peller 已提交
2543
	ieee80211_recalc_ps_vif(sdata);
J
Johannes Berg 已提交
2544 2545 2546 2547

	return 0;
}

2548 2549 2550 2551 2552 2553 2554 2555 2556 2557 2558 2559 2560 2561 2562 2563
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;

	bss_conf->cqm_rssi_thold = rssi_thold;
	bss_conf->cqm_rssi_hyst = rssi_hyst;

	/* tell the driver upon association, unless already associated */
2564 2565
	if (sdata->u.mgd.associated &&
	    sdata->vif.driver_flags & IEEE80211_VIF_SUPPORTS_CQM_RSSI)
2566 2567 2568 2569 2570
		ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_CQM);

	return 0;
}

J
Johannes Berg 已提交
2571 2572 2573 2574 2575 2576 2577
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);
2578
	int i, ret;
2579

2580 2581 2582
	if (!ieee80211_sdata_running(sdata))
		return -ENETDOWN;

2583 2584 2585 2586 2587
	if (local->hw.flags & IEEE80211_HW_HAS_RATE_CONTROL) {
		ret = drv_set_bitrate_mask(local, sdata, mask);
		if (ret)
			return ret;
	}
J
Johannes Berg 已提交
2588

2589
	for (i = 0; i < IEEE80211_NUM_BANDS; i++) {
2590 2591 2592
		struct ieee80211_supported_band *sband = wiphy->bands[i];
		int j;

2593
		sdata->rc_rateidx_mask[i] = mask->control[i].legacy;
2594 2595
		memcpy(sdata->rc_rateidx_mcs_mask[i], mask->control[i].ht_mcs,
		       sizeof(mask->control[i].ht_mcs));
2596 2597 2598 2599 2600 2601 2602 2603 2604 2605

		sdata->rc_has_mcs_mask[i] = false;
		if (!sband)
			continue;

		for (j = 0; j < IEEE80211_HT_MCS_MASK_LEN; j++)
			if (~sdata->rc_rateidx_mcs_mask[i][j]) {
				sdata->rc_has_mcs_mask[i] = true;
				break;
			}
2606
	}
J
Johannes Berg 已提交
2607

2608
	return 0;
J
Johannes Berg 已提交
2609 2610
}

2611 2612 2613 2614
static int ieee80211_start_roc_work(struct ieee80211_local *local,
				    struct ieee80211_sub_if_data *sdata,
				    struct ieee80211_channel *channel,
				    unsigned int duration, u64 *cookie,
2615 2616
				    struct sk_buff *txskb,
				    enum ieee80211_roc_type type)
2617 2618 2619
{
	struct ieee80211_roc_work *roc, *tmp;
	bool queued = false;
2620 2621 2622 2623
	int ret;

	lockdep_assert_held(&local->mtx);

2624 2625 2626
	if (local->use_chanctx && !local->ops->remain_on_channel)
		return -EOPNOTSUPP;

2627 2628 2629 2630
	roc = kzalloc(sizeof(*roc), GFP_KERNEL);
	if (!roc)
		return -ENOMEM;

2631 2632 2633 2634 2635 2636 2637 2638 2639 2640 2641 2642
	/*
	 * If the duration is zero, then the driver
	 * wouldn't actually do anything. Set it to
	 * 10 for now.
	 *
	 * TODO: cancel the off-channel operation
	 *       when we get the SKB's TX status and
	 *       the wait time was zero before.
	 */
	if (!duration)
		duration = 10;

2643 2644 2645 2646
	roc->chan = channel;
	roc->duration = duration;
	roc->req_duration = duration;
	roc->frame = txskb;
2647
	roc->type = type;
2648 2649 2650 2651 2652 2653
	roc->mgmt_tx_cookie = (unsigned long)txskb;
	roc->sdata = sdata;
	INIT_DELAYED_WORK(&roc->work, ieee80211_sw_roc_work);
	INIT_LIST_HEAD(&roc->dependents);

	/* if there's one pending or we're scanning, queue this one */
2654 2655
	if (!list_empty(&local->roc_list) ||
	    local->scanning || local->radar_detect_enabled)
2656 2657 2658 2659 2660 2661 2662 2663 2664 2665
		goto out_check_combine;

	/* if not HW assist, just queue & schedule work */
	if (!local->ops->remain_on_channel) {
		ieee80211_queue_delayed_work(&local->hw, &roc->work, 0);
		goto out_queue;
	}

	/* otherwise actually kick it off here (for error handling) */

2666
	ret = drv_remain_on_channel(local, sdata, channel, duration, type);
2667
	if (ret) {
2668 2669
		kfree(roc);
		return ret;
2670 2671
	}

2672 2673 2674 2675 2676
	roc->started = true;
	goto out_queue;

 out_check_combine:
	list_for_each_entry(tmp, &local->roc_list, list) {
2677
		if (tmp->chan != channel || tmp->sdata != sdata)
2678 2679 2680 2681 2682 2683 2684
			continue;

		/*
		 * Extend this ROC if possible:
		 *
		 * If it hasn't started yet, just increase the duration
		 * and add the new one to the list of dependents.
2685 2686
		 * If the type of the new ROC has higher priority, modify the
		 * type of the previous one to match that of the new one.
2687 2688 2689 2690
		 */
		if (!tmp->started) {
			list_add_tail(&roc->list, &tmp->dependents);
			tmp->duration = max(tmp->duration, roc->duration);
2691
			tmp->type = max(tmp->type, roc->type);
2692 2693 2694 2695 2696 2697 2698 2699 2700 2701 2702
			queued = true;
			break;
		}

		/* If it has already started, it's more difficult ... */
		if (local->ops->remain_on_channel) {
			unsigned long j = jiffies;

			/*
			 * In the offloaded ROC case, if it hasn't begun, add
			 * this new one to the dependent list to be handled
2703
			 * when the master one begins. If it has begun,
2704 2705
			 * check that there's still a minimum time left and
			 * if so, start this one, transmitting the frame, but
2706
			 * add it to the list directly after this one with
2707 2708 2709 2710 2711 2712
			 * a reduced time so we'll ask the driver to execute
			 * it right after finishing the previous one, in the
			 * hope that it'll also be executed right afterwards,
			 * effectively extending the old one.
			 * If there's no minimum time left, just add it to the
			 * normal list.
2713 2714
			 * TODO: the ROC type is ignored here, assuming that it
			 * is better to immediately use the current ROC.
2715 2716 2717 2718 2719 2720 2721 2722 2723 2724 2725 2726 2727 2728 2729 2730 2731 2732 2733 2734 2735 2736 2737 2738 2739 2740 2741 2742 2743 2744 2745 2746 2747 2748 2749 2750 2751 2752 2753 2754 2755 2756 2757 2758 2759 2760 2761 2762 2763 2764 2765 2766 2767 2768 2769 2770 2771 2772 2773 2774 2775
			 */
			if (!tmp->hw_begun) {
				list_add_tail(&roc->list, &tmp->dependents);
				queued = true;
				break;
			}

			if (time_before(j + IEEE80211_ROC_MIN_LEFT,
					tmp->hw_start_time +
					msecs_to_jiffies(tmp->duration))) {
				int new_dur;

				ieee80211_handle_roc_started(roc);

				new_dur = roc->duration -
					  jiffies_to_msecs(tmp->hw_start_time +
							   msecs_to_jiffies(
								tmp->duration) -
							   j);

				if (new_dur > 0) {
					/* add right after tmp */
					list_add(&roc->list, &tmp->list);
				} else {
					list_add_tail(&roc->list,
						      &tmp->dependents);
				}
				queued = true;
			}
		} else if (del_timer_sync(&tmp->work.timer)) {
			unsigned long new_end;

			/*
			 * In the software ROC case, cancel the timer, if
			 * that fails then the finish work is already
			 * queued/pending and thus we queue the new ROC
			 * normally, if that succeeds then we can extend
			 * the timer duration and TX the frame (if any.)
			 */

			list_add_tail(&roc->list, &tmp->dependents);
			queued = true;

			new_end = jiffies + msecs_to_jiffies(roc->duration);

			/* ok, it was started & we canceled timer */
			if (time_after(new_end, tmp->work.timer.expires))
				mod_timer(&tmp->work.timer, new_end);
			else
				add_timer(&tmp->work.timer);

			ieee80211_handle_roc_started(roc);
		}
		break;
	}

 out_queue:
	if (!queued)
		list_add_tail(&roc->list, &local->roc_list);

	/*
2776
	 * cookie is either the roc cookie (for normal roc)
2777 2778
	 * or the SKB (for mgmt TX)
	 */
2779 2780 2781 2782 2783 2784 2785 2786 2787 2788 2789
	if (!txskb) {
		/* local->mtx protects this */
		local->roc_cookie_counter++;
		roc->cookie = local->roc_cookie_counter;
		/* wow, you wrapped 64 bits ... more likely a bug */
		if (WARN_ON(roc->cookie == 0)) {
			roc->cookie = 1;
			local->roc_cookie_counter++;
		}
		*cookie = roc->cookie;
	} else {
2790
		*cookie = (unsigned long)txskb;
2791
	}
2792 2793

	return 0;
2794 2795
}

2796
static int ieee80211_remain_on_channel(struct wiphy *wiphy,
2797
				       struct wireless_dev *wdev,
2798 2799 2800 2801
				       struct ieee80211_channel *chan,
				       unsigned int duration,
				       u64 *cookie)
{
2802
	struct ieee80211_sub_if_data *sdata = IEEE80211_WDEV_TO_SUB_IF(wdev);
2803
	struct ieee80211_local *local = sdata->local;
2804
	int ret;
2805

2806
	mutex_lock(&local->mtx);
2807
	ret = ieee80211_start_roc_work(local, sdata, chan,
2808 2809
				       duration, cookie, NULL,
				       IEEE80211_ROC_TYPE_NORMAL);
2810
	mutex_unlock(&local->mtx);
2811

2812
	return ret;
2813 2814
}

2815 2816
static int ieee80211_cancel_roc(struct ieee80211_local *local,
				u64 cookie, bool mgmt_tx)
2817
{
2818
	struct ieee80211_roc_work *roc, *tmp, *found = NULL;
2819 2820
	int ret;

2821 2822
	mutex_lock(&local->mtx);
	list_for_each_entry_safe(roc, tmp, &local->roc_list, list) {
2823 2824 2825
		struct ieee80211_roc_work *dep, *tmp2;

		list_for_each_entry_safe(dep, tmp2, &roc->dependents, list) {
2826
			if (!mgmt_tx && dep->cookie != cookie)
2827 2828 2829 2830 2831 2832 2833
				continue;
			else if (mgmt_tx && dep->mgmt_tx_cookie != cookie)
				continue;
			/* found dependent item -- just remove it */
			list_del(&dep->list);
			mutex_unlock(&local->mtx);

2834
			ieee80211_roc_notify_destroy(dep, true);
2835 2836 2837
			return 0;
		}

2838
		if (!mgmt_tx && roc->cookie != cookie)
2839 2840 2841
			continue;
		else if (mgmt_tx && roc->mgmt_tx_cookie != cookie)
			continue;
2842

2843 2844 2845
		found = roc;
		break;
	}
2846

2847 2848 2849 2850
	if (!found) {
		mutex_unlock(&local->mtx);
		return -ENOENT;
	}
2851

2852 2853 2854 2855 2856 2857 2858
	/*
	 * We found the item to cancel, so do that. Note that it
	 * may have dependents, which we also cancel (and send
	 * the expired signal for.) Not doing so would be quite
	 * tricky here, but we may need to fix it later.
	 */

2859 2860 2861 2862 2863 2864 2865 2866
	if (local->ops->remain_on_channel) {
		if (found->started) {
			ret = drv_cancel_remain_on_channel(local);
			if (WARN_ON_ONCE(ret)) {
				mutex_unlock(&local->mtx);
				return ret;
			}
		}
2867

2868
		list_del(&found->list);
2869

2870 2871
		if (found->started)
			ieee80211_start_next_roc(local);
2872
		mutex_unlock(&local->mtx);
2873

2874
		ieee80211_roc_notify_destroy(found, true);
2875 2876 2877 2878
	} else {
		/* work may be pending so use it all the time */
		found->abort = true;
		ieee80211_queue_delayed_work(&local->hw, &found->work, 0);
2879 2880 2881

		mutex_unlock(&local->mtx);

2882 2883
		/* work will clean up etc */
		flush_delayed_work(&found->work);
2884 2885
		WARN_ON(!found->to_be_freed);
		kfree(found);
2886
	}
2887

2888
	return 0;
2889 2890
}

2891
static int ieee80211_cancel_remain_on_channel(struct wiphy *wiphy,
2892
					      struct wireless_dev *wdev,
2893
					      u64 cookie)
2894
{
2895
	struct ieee80211_sub_if_data *sdata = IEEE80211_WDEV_TO_SUB_IF(wdev);
2896
	struct ieee80211_local *local = sdata->local;
2897

2898
	return ieee80211_cancel_roc(local, cookie, false);
2899 2900
}

2901 2902 2903 2904 2905 2906 2907 2908 2909
static int ieee80211_start_radar_detection(struct wiphy *wiphy,
					   struct net_device *dev,
					   struct cfg80211_chan_def *chandef)
{
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
	struct ieee80211_local *local = sdata->local;
	unsigned long timeout;
	int err;

2910 2911 2912 2913 2914
	mutex_lock(&local->mtx);
	if (!list_empty(&local->roc_list) || local->scanning) {
		err = -EBUSY;
		goto out_unlock;
	}
2915 2916 2917 2918 2919 2920 2921 2922 2923

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

	err = ieee80211_vif_use_channel(sdata, chandef,
					IEEE80211_CHANCTX_SHARED);
	if (err)
2924
		goto out_unlock;
2925 2926 2927 2928 2929

	timeout = msecs_to_jiffies(IEEE80211_DFS_MIN_CAC_TIME_MS);
	ieee80211_queue_delayed_work(&sdata->local->hw,
				     &sdata->dfs_cac_timer_work, timeout);

2930 2931 2932
 out_unlock:
	mutex_unlock(&local->mtx);
	return err;
2933 2934
}

2935 2936 2937 2938 2939 2940 2941 2942 2943 2944 2945 2946 2947 2948 2949 2950 2951 2952 2953 2954 2955 2956 2957 2958 2959 2960 2961 2962 2963 2964 2965 2966 2967 2968 2969 2970 2971 2972 2973 2974 2975 2976 2977 2978 2979 2980 2981 2982 2983 2984 2985 2986 2987 2988 2989 2990
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 +
	      beacon->probe_resp_len;

	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;
		beacon->probe_resp = pos;
		memcpy(pos, beacon->probe_resp, beacon->probe_resp_len);
		pos += beacon->probe_resp_len;
	}

	return new_beacon;
}

2991
void ieee80211_csa_finish(struct ieee80211_vif *vif)
2992
{
2993
	struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
2994

2995 2996 2997 2998
	ieee80211_queue_work(&sdata->local->hw,
			     &sdata->csa_finalize_work);
}
EXPORT_SYMBOL(ieee80211_csa_finish);
2999

3000 3001 3002 3003
static void ieee80211_csa_finalize(struct ieee80211_sub_if_data *sdata)
{
	struct ieee80211_local *local = sdata->local;
	int err, changed = 0;
3004 3005

	sdata->radar_required = sdata->csa_radar_required;
3006
	mutex_lock(&local->mtx);
3007
	err = ieee80211_vif_change_channel(sdata, &changed);
3008
	mutex_unlock(&local->mtx);
3009
	if (WARN_ON(err < 0))
3010
		return;
3011

3012
	if (!local->use_chanctx) {
3013
		local->_oper_chandef = sdata->csa_chandef;
3014 3015 3016
		ieee80211_hw_config(local, 0);
	}

3017
	sdata->vif.csa_active = false;
3018 3019 3020
	switch (sdata->vif.type) {
	case NL80211_IFTYPE_AP:
		err = ieee80211_assign_beacon(sdata, sdata->u.ap.next_beacon);
3021 3022 3023
		kfree(sdata->u.ap.next_beacon);
		sdata->u.ap.next_beacon = NULL;

3024
		if (err < 0)
3025
			return;
3026 3027 3028
		changed |= err;
		break;
	case NL80211_IFTYPE_ADHOC:
3029 3030 3031 3032
		err = ieee80211_ibss_finish_csa(sdata);
		if (err < 0)
			return;
		changed |= err;
3033
		break;
3034 3035 3036 3037
#ifdef CONFIG_MAC80211_MESH
	case NL80211_IFTYPE_MESH_POINT:
		err = ieee80211_mesh_finish_csa(sdata);
		if (err < 0)
3038
			return;
3039
		changed |= err;
3040 3041
		break;
#endif
3042 3043
	default:
		WARN_ON(1);
3044
		return;
3045
	}
3046

3047 3048
	ieee80211_bss_info_change_notify(sdata, changed);

3049 3050 3051 3052
	ieee80211_wake_queues_by_reason(&sdata->local->hw,
					IEEE80211_MAX_QUEUE_MAP,
					IEEE80211_QUEUE_STOP_REASON_CSA);

3053
	cfg80211_ch_switch_notify(sdata->dev, &sdata->csa_chandef);
3054 3055 3056 3057 3058 3059 3060 3061 3062 3063 3064 3065 3066 3067 3068 3069 3070
}

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);

	sdata_lock(sdata);
	/* 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);
3071 3072 3073

unlock:
	sdata_unlock(sdata);
3074 3075
}

3076 3077
int ieee80211_channel_switch(struct wiphy *wiphy, struct net_device *dev,
			     struct cfg80211_csa_settings *params)
3078 3079 3080 3081 3082
{
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
	struct ieee80211_local *local = sdata->local;
	struct ieee80211_chanctx_conf *chanctx_conf;
	struct ieee80211_chanctx *chanctx;
3083
	struct ieee80211_if_mesh __maybe_unused *ifmsh;
3084
	int err, num_chanctx, changed = 0;
3085

3086 3087
	lockdep_assert_held(&sdata->wdev.mtx);

3088 3089 3090 3091 3092 3093 3094 3095 3096 3097 3098 3099 3100 3101 3102 3103 3104 3105 3106 3107 3108 3109 3110 3111 3112 3113 3114 3115 3116 3117 3118 3119 3120 3121 3122 3123 3124
	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;

	rcu_read_lock();
	chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf);
	if (!chanctx_conf) {
		rcu_read_unlock();
		return -EBUSY;
	}

	/* don't handle for multi-VIF cases */
	chanctx = container_of(chanctx_conf, struct ieee80211_chanctx, conf);
	if (chanctx->refcount > 1) {
		rcu_read_unlock();
		return -EBUSY;
	}
	num_chanctx = 0;
	list_for_each_entry_rcu(chanctx, &local->chanctx_list, list)
		num_chanctx++;
	rcu_read_unlock();

	if (num_chanctx > 1)
		return -EBUSY;

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

	switch (sdata->vif.type) {
	case NL80211_IFTYPE_AP:
3125 3126 3127 3128 3129
		sdata->u.ap.next_beacon =
			cfg80211_beacon_dup(&params->beacon_after);
		if (!sdata->u.ap.next_beacon)
			return -ENOMEM;

3130 3131 3132 3133 3134 3135 3136 3137 3138 3139 3140 3141 3142 3143 3144 3145 3146 3147 3148 3149 3150 3151
		/*
		 * 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;

		sdata->csa_counter_offset_beacon =
			params->counter_offset_beacon;
		sdata->csa_counter_offset_presp = params->counter_offset_presp;
3152 3153 3154 3155 3156
		err = ieee80211_assign_beacon(sdata, &params->beacon_csa);
		if (err < 0) {
			kfree(sdata->u.ap.next_beacon);
			return err;
		}
3157 3158
		changed |= err;

3159 3160 3161 3162 3163 3164 3165 3166 3167 3168 3169 3170 3171 3172 3173 3174 3175 3176 3177 3178 3179 3180 3181 3182 3183 3184 3185
		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;
		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;

3186 3187 3188 3189 3190 3191 3192 3193 3194 3195
		/* see comments in the NL80211_IFTYPE_AP block */
		if (params->count > 1) {
			err = ieee80211_ibss_csa_beacon(sdata, params);
			if (err < 0)
				return err;
			changed |= err;
		}

		ieee80211_send_action_csa(sdata, params);

3196
		break;
3197 3198 3199 3200 3201 3202 3203 3204 3205 3206 3207 3208
#ifdef CONFIG_MAC80211_MESH
	case NL80211_IFTYPE_MESH_POINT:
		ifmsh = &sdata->u.mesh;

		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;

3209
		if (ifmsh->csa_role == IEEE80211_MESH_CSA_ROLE_NONE) {
3210
			ifmsh->csa_role = IEEE80211_MESH_CSA_ROLE_INIT;
3211 3212 3213 3214 3215
			if (!ifmsh->pre_value)
				ifmsh->pre_value = 1;
			else
				ifmsh->pre_value++;
		}
3216

3217 3218 3219 3220 3221 3222 3223 3224
		/* 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;
			}
			changed |= err;
3225
		}
3226 3227 3228 3229

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

3230 3231
		break;
#endif
3232 3233 3234 3235 3236 3237 3238 3239 3240 3241 3242
	default:
		return -EOPNOTSUPP;
	}

	sdata->csa_radar_required = params->radar_required;

	if (params->block_tx)
		ieee80211_stop_queues_by_reason(&local->hw,
				IEEE80211_MAX_QUEUE_MAP,
				IEEE80211_QUEUE_STOP_REASON_CSA);

3243
	sdata->csa_chandef = params->chandef;
3244 3245
	sdata->vif.csa_active = true;

3246 3247 3248 3249 3250 3251 3252
	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);
	}
3253 3254 3255 3256

	return 0;
}

3257
static int ieee80211_mgmt_tx(struct wiphy *wiphy, struct wireless_dev *wdev,
3258 3259
			     struct cfg80211_mgmt_tx_params *params,
			     u64 *cookie)
3260
{
3261
	struct ieee80211_sub_if_data *sdata = IEEE80211_WDEV_TO_SUB_IF(wdev);
3262 3263 3264
	struct ieee80211_local *local = sdata->local;
	struct sk_buff *skb;
	struct sta_info *sta;
3265
	const struct ieee80211_mgmt *mgmt = (void *)params->buf;
3266
	bool need_offchan = false;
3267
	u32 flags;
3268
	int ret;
3269

3270
	if (params->dont_wait_for_ack)
3271 3272 3273 3274 3275
		flags = IEEE80211_TX_CTL_NO_ACK;
	else
		flags = IEEE80211_TX_INTFL_NL80211_FRAME_TX |
			IEEE80211_TX_CTL_REQ_TX_STATUS;

3276
	if (params->no_cck)
3277 3278
		flags |= IEEE80211_TX_CTL_NO_CCK_RATE;

3279 3280
	switch (sdata->vif.type) {
	case NL80211_IFTYPE_ADHOC:
3281 3282 3283 3284 3285 3286 3287 3288 3289 3290
		if (!sdata->vif.bss_conf.ibss_joined)
			need_offchan = true;
		/* fall through */
#ifdef CONFIG_MAC80211_MESH
	case NL80211_IFTYPE_MESH_POINT:
		if (ieee80211_vif_is_mesh(&sdata->vif) &&
		    !sdata->u.mesh.mesh_id_len)
			need_offchan = true;
		/* fall through */
#endif
3291 3292 3293
	case NL80211_IFTYPE_AP:
	case NL80211_IFTYPE_AP_VLAN:
	case NL80211_IFTYPE_P2P_GO:
3294 3295 3296 3297
		if (sdata->vif.type != NL80211_IFTYPE_ADHOC &&
		    !ieee80211_vif_is_mesh(&sdata->vif) &&
		    !rcu_access_pointer(sdata->bss->beacon))
			need_offchan = true;
3298
		if (!ieee80211_is_action(mgmt->frame_control) ||
3299
		    mgmt->u.action.category == WLAN_CATEGORY_PUBLIC ||
3300 3301
		    mgmt->u.action.category == WLAN_CATEGORY_SELF_PROTECTED ||
		    mgmt->u.action.category == WLAN_CATEGORY_SPECTRUM_MGMT)
3302 3303 3304 3305 3306 3307 3308 3309
			break;
		rcu_read_lock();
		sta = sta_info_get(sdata, mgmt->da);
		rcu_read_unlock();
		if (!sta)
			return -ENOLINK;
		break;
	case NL80211_IFTYPE_STATION:
3310
	case NL80211_IFTYPE_P2P_CLIENT:
3311 3312
		if (!sdata->u.mgd.associated)
			need_offchan = true;
3313
		break;
3314 3315 3316
	case NL80211_IFTYPE_P2P_DEVICE:
		need_offchan = true;
		break;
3317 3318 3319 3320
	default:
		return -EOPNOTSUPP;
	}

3321 3322 3323
	/* configurations requiring offchan cannot work if no channel has been
	 * specified
	 */
3324
	if (need_offchan && !params->chan)
3325 3326
		return -EINVAL;

3327 3328 3329 3330
	mutex_lock(&local->mtx);

	/* Check if the operating channel is the requested channel */
	if (!need_offchan) {
J
Johannes Berg 已提交
3331 3332 3333 3334 3335
		struct ieee80211_chanctx_conf *chanctx_conf;

		rcu_read_lock();
		chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf);

3336
		if (chanctx_conf) {
3337 3338 3339 3340
			need_offchan = params->chan &&
				       (params->chan !=
					chanctx_conf->def.chan);
		} else if (!params->chan) {
3341 3342 3343 3344
			ret = -EINVAL;
			rcu_read_unlock();
			goto out_unlock;
		} else {
3345
			need_offchan = true;
3346
		}
J
Johannes Berg 已提交
3347
		rcu_read_unlock();
3348 3349
	}

3350
	if (need_offchan && !params->offchan) {
3351 3352 3353 3354
		ret = -EBUSY;
		goto out_unlock;
	}

3355
	skb = dev_alloc_skb(local->hw.extra_tx_headroom + params->len);
3356 3357 3358 3359
	if (!skb) {
		ret = -ENOMEM;
		goto out_unlock;
	}
3360 3361
	skb_reserve(skb, local->hw.extra_tx_headroom);

3362
	memcpy(skb_put(skb, params->len), params->buf, params->len);
3363 3364 3365 3366 3367

	IEEE80211_SKB_CB(skb)->flags = flags;

	skb->dev = sdata->dev;

3368
	if (!need_offchan) {
3369
		*cookie = (unsigned long) skb;
3370
		ieee80211_tx_skb(sdata, skb);
3371 3372
		ret = 0;
		goto out_unlock;
3373 3374
	}

3375 3376
	IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_CTL_TX_OFFCHAN |
					IEEE80211_TX_INTFL_OFFCHAN_TX_OK;
3377 3378 3379
	if (local->hw.flags & IEEE80211_HW_QUEUE_CONTROL)
		IEEE80211_SKB_CB(skb)->hw_queue =
			local->hw.offchannel_tx_hw_queue;
3380

3381
	/* This will handle all kinds of coalescing and immediate TX */
3382 3383
	ret = ieee80211_start_roc_work(local, sdata, params->chan,
				       params->wait, cookie, skb,
3384
				       IEEE80211_ROC_TYPE_MGMT_TX);
3385 3386 3387 3388 3389
	if (ret)
		kfree_skb(skb);
 out_unlock:
	mutex_unlock(&local->mtx);
	return ret;
3390 3391
}

3392
static int ieee80211_mgmt_tx_cancel_wait(struct wiphy *wiphy,
3393
					 struct wireless_dev *wdev,
3394 3395
					 u64 cookie)
{
3396
	struct ieee80211_local *local = wiphy_priv(wiphy);
3397

3398
	return ieee80211_cancel_roc(local, cookie, true);
3399 3400
}

3401
static void ieee80211_mgmt_frame_register(struct wiphy *wiphy,
3402
					  struct wireless_dev *wdev,
3403 3404 3405 3406
					  u16 frame_type, bool reg)
{
	struct ieee80211_local *local = wiphy_priv(wiphy);

3407 3408 3409 3410 3411 3412
	switch (frame_type) {
	case IEEE80211_FTYPE_MGMT | IEEE80211_STYPE_PROBE_REQ:
		if (reg)
			local->probe_req_reg++;
		else
			local->probe_req_reg--;
3413

3414 3415 3416
		if (!local->open_count)
			break;

3417 3418 3419 3420 3421
		ieee80211_queue_work(&local->hw, &local->reconfig_filter);
		break;
	default:
		break;
	}
3422 3423
}

3424 3425 3426 3427 3428 3429 3430 3431 3432 3433 3434 3435 3436 3437 3438 3439 3440
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);
}

3441 3442 3443 3444 3445 3446 3447 3448 3449 3450 3451 3452 3453 3454 3455
static int ieee80211_set_ringparam(struct wiphy *wiphy, u32 tx, u32 rx)
{
	struct ieee80211_local *local = wiphy_priv(wiphy);

	return drv_set_ringparam(local, tx, rx);
}

static void ieee80211_get_ringparam(struct wiphy *wiphy,
				    u32 *tx, u32 *tx_max, u32 *rx, u32 *rx_max)
{
	struct ieee80211_local *local = wiphy_priv(wiphy);

	drv_get_ringparam(local, tx, tx_max, rx, rx_max);
}

3456 3457 3458 3459 3460 3461 3462 3463 3464 3465 3466 3467 3468 3469 3470
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;
}

3471 3472 3473 3474 3475 3476 3477 3478 3479 3480 3481 3482 3483 3484 3485 3486 3487 3488 3489
static void ieee80211_tdls_add_ext_capab(struct sk_buff *skb)
{
	u8 *pos = (void *)skb_put(skb, 7);

	*pos++ = WLAN_EID_EXT_CAPABILITY;
	*pos++ = 5; /* len */
	*pos++ = 0x0;
	*pos++ = 0x0;
	*pos++ = 0x0;
	*pos++ = 0x0;
	*pos++ = WLAN_EXT_CAPA5_TDLS_ENABLED;
}

static u16 ieee80211_get_tdls_sta_capab(struct ieee80211_sub_if_data *sdata)
{
	struct ieee80211_local *local = sdata->local;
	u16 capab;

	capab = 0;
J
Johannes Berg 已提交
3490
	if (ieee80211_get_sdata_band(sdata) != IEEE80211_BAND_2GHZ)
3491 3492 3493 3494 3495 3496 3497 3498 3499 3500 3501 3502 3503 3504 3505 3506 3507 3508 3509 3510 3511 3512 3513 3514 3515 3516 3517 3518 3519 3520 3521
		return capab;

	if (!(local->hw.flags & IEEE80211_HW_2GHZ_SHORT_SLOT_INCAPABLE))
		capab |= WLAN_CAPABILITY_SHORT_SLOT_TIME;
	if (!(local->hw.flags & IEEE80211_HW_2GHZ_SHORT_PREAMBLE_INCAPABLE))
		capab |= WLAN_CAPABILITY_SHORT_PREAMBLE;

	return capab;
}

static void ieee80211_tdls_add_link_ie(struct sk_buff *skb, u8 *src_addr,
				       u8 *peer, u8 *bssid)
{
	struct ieee80211_tdls_lnkie *lnkid;

	lnkid = (void *)skb_put(skb, sizeof(struct ieee80211_tdls_lnkie));

	lnkid->ie_type = WLAN_EID_LINK_ID;
	lnkid->ie_len = sizeof(struct ieee80211_tdls_lnkie) - 2;

	memcpy(lnkid->bssid, bssid, ETH_ALEN);
	memcpy(lnkid->init_sta, src_addr, ETH_ALEN);
	memcpy(lnkid->resp_sta, peer, ETH_ALEN);
}

static int
ieee80211_prep_tdls_encap_data(struct wiphy *wiphy, struct net_device *dev,
			       u8 *peer, u8 action_code, u8 dialog_token,
			       u16 status_code, struct sk_buff *skb)
{
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
J
Johannes Berg 已提交
3522
	enum ieee80211_band band = ieee80211_get_sdata_band(sdata);
3523 3524 3525 3526 3527 3528 3529 3530 3531 3532 3533 3534 3535 3536 3537 3538 3539 3540 3541
	struct ieee80211_tdls_data *tf;

	tf = (void *)skb_put(skb, offsetof(struct ieee80211_tdls_data, u));

	memcpy(tf->da, peer, ETH_ALEN);
	memcpy(tf->sa, sdata->vif.addr, ETH_ALEN);
	tf->ether_type = cpu_to_be16(ETH_P_TDLS);
	tf->payload_type = WLAN_TDLS_SNAP_RFTYPE;

	switch (action_code) {
	case WLAN_TDLS_SETUP_REQUEST:
		tf->category = WLAN_CATEGORY_TDLS;
		tf->action_code = WLAN_TDLS_SETUP_REQUEST;

		skb_put(skb, sizeof(tf->u.setup_req));
		tf->u.setup_req.dialog_token = dialog_token;
		tf->u.setup_req.capability =
			cpu_to_le16(ieee80211_get_tdls_sta_capab(sdata));

J
Johannes Berg 已提交
3542 3543
		ieee80211_add_srates_ie(sdata, skb, false, band);
		ieee80211_add_ext_srates_ie(sdata, skb, false, band);
3544 3545 3546 3547 3548 3549 3550 3551 3552 3553 3554 3555
		ieee80211_tdls_add_ext_capab(skb);
		break;
	case WLAN_TDLS_SETUP_RESPONSE:
		tf->category = WLAN_CATEGORY_TDLS;
		tf->action_code = WLAN_TDLS_SETUP_RESPONSE;

		skb_put(skb, sizeof(tf->u.setup_resp));
		tf->u.setup_resp.status_code = cpu_to_le16(status_code);
		tf->u.setup_resp.dialog_token = dialog_token;
		tf->u.setup_resp.capability =
			cpu_to_le16(ieee80211_get_tdls_sta_capab(sdata));

J
Johannes Berg 已提交
3556 3557
		ieee80211_add_srates_ie(sdata, skb, false, band);
		ieee80211_add_ext_srates_ie(sdata, skb, false, band);
3558 3559 3560 3561 3562 3563 3564 3565 3566 3567 3568 3569 3570 3571 3572 3573 3574 3575 3576 3577 3578 3579 3580 3581 3582 3583 3584 3585 3586 3587 3588 3589 3590 3591 3592 3593 3594
		ieee80211_tdls_add_ext_capab(skb);
		break;
	case WLAN_TDLS_SETUP_CONFIRM:
		tf->category = WLAN_CATEGORY_TDLS;
		tf->action_code = WLAN_TDLS_SETUP_CONFIRM;

		skb_put(skb, sizeof(tf->u.setup_cfm));
		tf->u.setup_cfm.status_code = cpu_to_le16(status_code);
		tf->u.setup_cfm.dialog_token = dialog_token;
		break;
	case WLAN_TDLS_TEARDOWN:
		tf->category = WLAN_CATEGORY_TDLS;
		tf->action_code = WLAN_TDLS_TEARDOWN;

		skb_put(skb, sizeof(tf->u.teardown));
		tf->u.teardown.reason_code = cpu_to_le16(status_code);
		break;
	case WLAN_TDLS_DISCOVERY_REQUEST:
		tf->category = WLAN_CATEGORY_TDLS;
		tf->action_code = WLAN_TDLS_DISCOVERY_REQUEST;

		skb_put(skb, sizeof(tf->u.discover_req));
		tf->u.discover_req.dialog_token = dialog_token;
		break;
	default:
		return -EINVAL;
	}

	return 0;
}

static int
ieee80211_prep_tdls_direct(struct wiphy *wiphy, struct net_device *dev,
			   u8 *peer, u8 action_code, u8 dialog_token,
			   u16 status_code, struct sk_buff *skb)
{
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
J
Johannes Berg 已提交
3595
	enum ieee80211_band band = ieee80211_get_sdata_band(sdata);
3596 3597 3598 3599 3600 3601 3602 3603 3604 3605 3606 3607 3608 3609 3610 3611 3612 3613 3614 3615 3616 3617
	struct ieee80211_mgmt *mgmt;

	mgmt = (void *)skb_put(skb, 24);
	memset(mgmt, 0, 24);
	memcpy(mgmt->da, peer, ETH_ALEN);
	memcpy(mgmt->sa, sdata->vif.addr, ETH_ALEN);
	memcpy(mgmt->bssid, sdata->u.mgd.bssid, ETH_ALEN);

	mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
					  IEEE80211_STYPE_ACTION);

	switch (action_code) {
	case WLAN_PUB_ACTION_TDLS_DISCOVER_RES:
		skb_put(skb, 1 + sizeof(mgmt->u.action.u.tdls_discover_resp));
		mgmt->u.action.category = WLAN_CATEGORY_PUBLIC;
		mgmt->u.action.u.tdls_discover_resp.action_code =
			WLAN_PUB_ACTION_TDLS_DISCOVER_RES;
		mgmt->u.action.u.tdls_discover_resp.dialog_token =
			dialog_token;
		mgmt->u.action.u.tdls_discover_resp.capability =
			cpu_to_le16(ieee80211_get_tdls_sta_capab(sdata));

J
Johannes Berg 已提交
3618 3619
		ieee80211_add_srates_ie(sdata, skb, false, band);
		ieee80211_add_ext_srates_ie(sdata, skb, false, band);
3620 3621 3622 3623 3624 3625 3626 3627 3628 3629 3630 3631 3632 3633 3634 3635 3636 3637 3638 3639 3640 3641 3642 3643 3644 3645 3646 3647
		ieee80211_tdls_add_ext_capab(skb);
		break;
	default:
		return -EINVAL;
	}

	return 0;
}

static int ieee80211_tdls_mgmt(struct wiphy *wiphy, struct net_device *dev,
			       u8 *peer, u8 action_code, u8 dialog_token,
			       u16 status_code, const u8 *extra_ies,
			       size_t extra_ies_len)
{
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
	struct ieee80211_local *local = sdata->local;
	struct sk_buff *skb = NULL;
	bool send_direct;
	int ret;

	if (!(wiphy->flags & WIPHY_FLAG_SUPPORTS_TDLS))
		return -ENOTSUPP;

	/* make sure we are in managed mode, and associated */
	if (sdata->vif.type != NL80211_IFTYPE_STATION ||
	    !sdata->u.mgd.associated)
		return -EINVAL;

J
Johannes Berg 已提交
3648 3649
	tdls_dbg(sdata, "TDLS mgmt action %d peer %pM\n",
		 action_code, peer);
3650 3651 3652 3653 3654 3655 3656 3657 3658 3659 3660 3661 3662 3663 3664 3665 3666 3667 3668 3669 3670 3671 3672 3673 3674 3675 3676 3677 3678 3679 3680 3681 3682 3683 3684 3685 3686 3687 3688 3689 3690 3691 3692 3693 3694 3695 3696 3697 3698 3699 3700 3701 3702 3703 3704 3705 3706 3707 3708 3709 3710 3711 3712 3713 3714 3715 3716 3717 3718 3719 3720 3721 3722 3723 3724 3725 3726 3727 3728 3729 3730 3731 3732 3733 3734 3735 3736 3737 3738 3739 3740 3741 3742 3743 3744 3745 3746 3747

	skb = dev_alloc_skb(local->hw.extra_tx_headroom +
			    max(sizeof(struct ieee80211_mgmt),
				sizeof(struct ieee80211_tdls_data)) +
			    50 + /* supported rates */
			    7 + /* ext capab */
			    extra_ies_len +
			    sizeof(struct ieee80211_tdls_lnkie));
	if (!skb)
		return -ENOMEM;

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

	switch (action_code) {
	case WLAN_TDLS_SETUP_REQUEST:
	case WLAN_TDLS_SETUP_RESPONSE:
	case WLAN_TDLS_SETUP_CONFIRM:
	case WLAN_TDLS_TEARDOWN:
	case WLAN_TDLS_DISCOVERY_REQUEST:
		ret = ieee80211_prep_tdls_encap_data(wiphy, dev, peer,
						     action_code, dialog_token,
						     status_code, skb);
		send_direct = false;
		break;
	case WLAN_PUB_ACTION_TDLS_DISCOVER_RES:
		ret = ieee80211_prep_tdls_direct(wiphy, dev, peer, action_code,
						 dialog_token, status_code,
						 skb);
		send_direct = true;
		break;
	default:
		ret = -ENOTSUPP;
		break;
	}

	if (ret < 0)
		goto fail;

	if (extra_ies_len)
		memcpy(skb_put(skb, extra_ies_len), extra_ies, extra_ies_len);

	/* the TDLS link IE is always added last */
	switch (action_code) {
	case WLAN_TDLS_SETUP_REQUEST:
	case WLAN_TDLS_SETUP_CONFIRM:
	case WLAN_TDLS_TEARDOWN:
	case WLAN_TDLS_DISCOVERY_REQUEST:
		/* we are the initiator */
		ieee80211_tdls_add_link_ie(skb, sdata->vif.addr, peer,
					   sdata->u.mgd.bssid);
		break;
	case WLAN_TDLS_SETUP_RESPONSE:
	case WLAN_PUB_ACTION_TDLS_DISCOVER_RES:
		/* we are the responder */
		ieee80211_tdls_add_link_ie(skb, peer, sdata->vif.addr,
					   sdata->u.mgd.bssid);
		break;
	default:
		ret = -ENOTSUPP;
		goto fail;
	}

	if (send_direct) {
		ieee80211_tx_skb(sdata, skb);
		return 0;
	}

	/*
	 * According to 802.11z: Setup req/resp are sent in AC_BK, otherwise
	 * we should default to AC_VI.
	 */
	switch (action_code) {
	case WLAN_TDLS_SETUP_REQUEST:
	case WLAN_TDLS_SETUP_RESPONSE:
		skb_set_queue_mapping(skb, IEEE80211_AC_BK);
		skb->priority = 2;
		break;
	default:
		skb_set_queue_mapping(skb, IEEE80211_AC_VI);
		skb->priority = 5;
		break;
	}

	/* disable bottom halves when entering the Tx path */
	local_bh_disable();
	ret = ieee80211_subif_start_xmit(skb, dev);
	local_bh_enable();

	return ret;

fail:
	dev_kfree_skb(skb);
	return ret;
}

static int ieee80211_tdls_oper(struct wiphy *wiphy, struct net_device *dev,
			       u8 *peer, enum nl80211_tdls_operation oper)
{
3748
	struct sta_info *sta;
3749 3750 3751 3752 3753 3754 3755 3756
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);

	if (!(wiphy->flags & WIPHY_FLAG_SUPPORTS_TDLS))
		return -ENOTSUPP;

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

J
Johannes Berg 已提交
3757
	tdls_dbg(sdata, "TDLS oper %d peer %pM\n", oper, peer);
3758 3759 3760

	switch (oper) {
	case NL80211_TDLS_ENABLE_LINK:
3761 3762 3763 3764 3765 3766 3767
		rcu_read_lock();
		sta = sta_info_get(sdata, peer);
		if (!sta) {
			rcu_read_unlock();
			return -ENOLINK;
		}

J
Johannes Berg 已提交
3768
		set_sta_flag(sta, WLAN_STA_TDLS_PEER_AUTH);
3769
		rcu_read_unlock();
3770 3771 3772 3773 3774 3775 3776 3777 3778 3779 3780 3781 3782 3783 3784
		break;
	case NL80211_TDLS_DISABLE_LINK:
		return sta_info_destroy_addr(sdata, peer);
	case NL80211_TDLS_TEARDOWN:
	case NL80211_TDLS_SETUP:
	case NL80211_TDLS_DISCOVERY_REQ:
		/* We don't support in-driver setup/teardown/discovery */
		return -ENOTSUPP;
	default:
		return -ENOTSUPP;
	}

	return 0;
}

J
Johannes Berg 已提交
3785 3786 3787 3788 3789 3790 3791 3792 3793 3794 3795 3796
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;
	struct sk_buff *skb;
	int size = sizeof(*nullfunc);
	__le16 fc;
	bool qos;
	struct ieee80211_tx_info *info;
	struct sta_info *sta;
J
Johannes Berg 已提交
3797 3798
	struct ieee80211_chanctx_conf *chanctx_conf;
	enum ieee80211_band band;
J
Johannes Berg 已提交
3799 3800

	rcu_read_lock();
J
Johannes Berg 已提交
3801 3802 3803 3804 3805
	chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf);
	if (WARN_ON(!chanctx_conf)) {
		rcu_read_unlock();
		return -EINVAL;
	}
3806
	band = chanctx_conf->def.chan->band;
3807
	sta = sta_info_get_bss(sdata, peer);
3808
	if (sta) {
J
Johannes Berg 已提交
3809
		qos = test_sta_flag(sta, WLAN_STA_WME);
3810 3811
	} else {
		rcu_read_unlock();
J
Johannes Berg 已提交
3812
		return -ENOLINK;
3813
	}
J
Johannes Berg 已提交
3814 3815 3816 3817 3818 3819 3820 3821 3822 3823 3824 3825 3826

	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 已提交
3827 3828
	if (!skb) {
		rcu_read_unlock();
J
Johannes Berg 已提交
3829
		return -ENOMEM;
J
Johannes Berg 已提交
3830
	}
J
Johannes Berg 已提交
3831 3832 3833 3834 3835 3836 3837 3838 3839 3840 3841 3842 3843 3844 3845 3846 3847 3848 3849 3850 3851 3852 3853 3854

	skb->dev = dev;

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

	nullfunc = (void *) skb_put(skb, size);
	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;

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

	local_bh_disable();
J
Johannes Berg 已提交
3855
	ieee80211_xmit(sdata, skb, band);
J
Johannes Berg 已提交
3856
	local_bh_enable();
J
Johannes Berg 已提交
3857
	rcu_read_unlock();
J
Johannes Berg 已提交
3858 3859 3860 3861 3862

	*cookie = (unsigned long) skb;
	return 0;
}

3863 3864 3865
static int ieee80211_cfg_get_channel(struct wiphy *wiphy,
				     struct wireless_dev *wdev,
				     struct cfg80211_chan_def *chandef)
3866
{
J
Johannes Berg 已提交
3867
	struct ieee80211_sub_if_data *sdata = IEEE80211_WDEV_TO_SUB_IF(wdev);
3868
	struct ieee80211_local *local = wiphy_priv(wiphy);
J
Johannes Berg 已提交
3869
	struct ieee80211_chanctx_conf *chanctx_conf;
3870
	int ret = -ENODATA;
J
Johannes Berg 已提交
3871 3872

	rcu_read_lock();
3873 3874 3875 3876 3877 3878 3879 3880 3881 3882
	chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf);
	if (chanctx_conf) {
		*chandef = chanctx_conf->def;
		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
3883
			*chandef = local->_oper_chandef;
3884
		ret = 0;
J
Johannes Berg 已提交
3885 3886
	}
	rcu_read_unlock();
3887

3888
	return ret;
3889 3890
}

3891 3892 3893 3894 3895 3896 3897
#ifdef CONFIG_PM
static void ieee80211_set_wakeup(struct wiphy *wiphy, bool enabled)
{
	drv_set_wakeup(wiphy_priv(wiphy), enabled);
}
#endif

3898 3899 3900 3901 3902 3903 3904 3905 3906 3907 3908 3909 3910 3911 3912 3913 3914
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;
	}

3915
	old_qos_map = sdata_dereference(sdata->qos_map, sdata);
3916 3917 3918 3919 3920 3921 3922
	rcu_assign_pointer(sdata->qos_map, new_qos_map);
	if (old_qos_map)
		kfree_rcu(old_qos_map, rcu_head);

	return 0;
}

3923
const struct cfg80211_ops mac80211_config_ops = {
3924 3925
	.add_virtual_intf = ieee80211_add_iface,
	.del_virtual_intf = ieee80211_del_iface,
3926
	.change_virtual_intf = ieee80211_change_iface,
3927 3928
	.start_p2p_device = ieee80211_start_p2p_device,
	.stop_p2p_device = ieee80211_stop_p2p_device,
3929 3930
	.add_key = ieee80211_add_key,
	.del_key = ieee80211_del_key,
3931
	.get_key = ieee80211_get_key,
3932
	.set_default_key = ieee80211_config_default_key,
3933
	.set_default_mgmt_key = ieee80211_config_default_mgmt_key,
3934 3935 3936
	.start_ap = ieee80211_start_ap,
	.change_beacon = ieee80211_change_beacon,
	.stop_ap = ieee80211_stop_ap,
3937 3938 3939
	.add_station = ieee80211_add_station,
	.del_station = ieee80211_del_station,
	.change_station = ieee80211_change_station,
3940
	.get_station = ieee80211_get_station,
3941
	.dump_station = ieee80211_dump_station,
3942
	.dump_survey = ieee80211_dump_survey,
3943 3944 3945 3946 3947 3948
#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,
3949 3950
	.update_mesh_config = ieee80211_update_mesh_config,
	.get_mesh_config = ieee80211_get_mesh_config,
3951 3952
	.join_mesh = ieee80211_join_mesh,
	.leave_mesh = ieee80211_leave_mesh,
3953
#endif
3954
	.change_bss = ieee80211_change_bss,
3955
	.set_txq_params = ieee80211_set_txq_params,
3956
	.set_monitor_channel = ieee80211_set_monitor_channel,
3957 3958
	.suspend = ieee80211_suspend,
	.resume = ieee80211_resume,
3959
	.scan = ieee80211_scan,
3960 3961
	.sched_scan_start = ieee80211_sched_scan_start,
	.sched_scan_stop = ieee80211_sched_scan_stop,
3962 3963 3964 3965
	.auth = ieee80211_auth,
	.assoc = ieee80211_assoc,
	.deauth = ieee80211_deauth,
	.disassoc = ieee80211_disassoc,
3966 3967
	.join_ibss = ieee80211_join_ibss,
	.leave_ibss = ieee80211_leave_ibss,
3968
	.set_mcast_rate = ieee80211_set_mcast_rate,
3969
	.set_wiphy_params = ieee80211_set_wiphy_params,
3970 3971
	.set_tx_power = ieee80211_set_tx_power,
	.get_tx_power = ieee80211_get_tx_power,
J
Johannes Berg 已提交
3972
	.set_wds_peer = ieee80211_set_wds_peer,
J
Johannes Berg 已提交
3973
	.rfkill_poll = ieee80211_rfkill_poll,
3974
	CFG80211_TESTMODE_CMD(ieee80211_testmode_cmd)
W
Wey-Yi Guy 已提交
3975
	CFG80211_TESTMODE_DUMP(ieee80211_testmode_dump)
J
Johannes Berg 已提交
3976
	.set_power_mgmt = ieee80211_set_power_mgmt,
J
Johannes Berg 已提交
3977
	.set_bitrate_mask = ieee80211_set_bitrate_mask,
3978 3979
	.remain_on_channel = ieee80211_remain_on_channel,
	.cancel_remain_on_channel = ieee80211_cancel_remain_on_channel,
3980
	.mgmt_tx = ieee80211_mgmt_tx,
3981
	.mgmt_tx_cancel_wait = ieee80211_mgmt_tx_cancel_wait,
3982
	.set_cqm_rssi_config = ieee80211_set_cqm_rssi_config,
3983
	.mgmt_frame_register = ieee80211_mgmt_frame_register,
3984 3985
	.set_antenna = ieee80211_set_antenna,
	.get_antenna = ieee80211_get_antenna,
3986 3987
	.set_ringparam = ieee80211_set_ringparam,
	.get_ringparam = ieee80211_get_ringparam,
3988
	.set_rekey_data = ieee80211_set_rekey_data,
3989 3990
	.tdls_oper = ieee80211_tdls_oper,
	.tdls_mgmt = ieee80211_tdls_mgmt,
J
Johannes Berg 已提交
3991
	.probe_client = ieee80211_probe_client,
3992
	.set_noack_map = ieee80211_set_noack_map,
3993 3994 3995
#ifdef CONFIG_PM
	.set_wakeup = ieee80211_set_wakeup,
#endif
3996 3997 3998
	.get_et_sset_count = ieee80211_get_et_sset_count,
	.get_et_stats = ieee80211_get_et_stats,
	.get_et_strings = ieee80211_get_et_strings,
3999
	.get_channel = ieee80211_cfg_get_channel,
4000
	.start_radar_detection = ieee80211_start_radar_detection,
4001
	.channel_switch = ieee80211_channel_switch,
4002
	.set_qos_map = ieee80211_set_qos_map,
4003
};