cfg.c 107.1 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
static int ieee80211_start_p2p_device(struct wiphy *wiphy,
				      struct wireless_dev *wdev)
{
112 113 114 115 116 117 118 119 120
	struct ieee80211_sub_if_data *sdata = IEEE80211_WDEV_TO_SUB_IF(wdev);
	int ret;

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

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

130 131 132 133 134 135 136 137 138 139
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;
}

140
static int ieee80211_add_key(struct wiphy *wiphy, struct net_device *dev,
141
			     u8 key_idx, bool pairwise, const u8 *mac_addr,
142 143
			     struct key_params *params)
{
144
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
145
	struct ieee80211_local *local = sdata->local;
146
	struct sta_info *sta = NULL;
147
	const struct ieee80211_cipher_scheme *cs = NULL;
148
	struct ieee80211_key *key;
149
	int err;
150

151
	if (!ieee80211_sdata_running(sdata))
J
Johannes Berg 已提交
152 153
		return -ENETDOWN;

154
	/* reject WEP and TKIP keys if WEP failed to initialize */
155 156 157
	switch (params->cipher) {
	case WLAN_CIPHER_SUITE_WEP40:
	case WLAN_CIPHER_SUITE_TKIP:
158
	case WLAN_CIPHER_SUITE_WEP104:
159
		if (IS_ERR(local->wep_tx_tfm))
160
			return -EINVAL;
161
		break;
162 163 164 165
	case WLAN_CIPHER_SUITE_CCMP:
	case WLAN_CIPHER_SUITE_AES_CMAC:
	case WLAN_CIPHER_SUITE_GCMP:
		break;
166
	default:
167
		cs = ieee80211_cs_get(local, params->cipher, sdata->vif.type);
168
		break;
169 170
	}

171
	key = ieee80211_key_alloc(params->cipher, key_idx, params->key_len,
172 173
				  params->key, params->seq_len, params->seq,
				  cs);
174 175
	if (IS_ERR(key))
		return PTR_ERR(key);
176

177 178 179
	if (pairwise)
		key->conf.flags |= IEEE80211_KEY_FLAG_PAIRWISE;

180
	mutex_lock(&local->sta_mtx);
181

182
	if (mac_addr) {
183 184 185 186
		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 已提交
187 188 189 190 191 192 193 194 195 196 197
		/*
		 * 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)) {
198
			ieee80211_key_free_unused(key);
199 200
			err = -ENOENT;
			goto out_unlock;
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 227 228 229 230 231 232 233 234 235
	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;
	}

236 237 238
	if (sta)
		sta->cipher_scheme = cs;

239
	err = ieee80211_key_link(key, sdata, sta);
240

241
 out_unlock:
242
	mutex_unlock(&local->sta_mtx);
243 244

	return err;
245 246 247
}

static int ieee80211_del_key(struct wiphy *wiphy, struct net_device *dev,
248
			     u8 key_idx, bool pairwise, const u8 *mac_addr)
249
{
250 251
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
	struct ieee80211_local *local = sdata->local;
252
	struct sta_info *sta;
253
	struct ieee80211_key *key = NULL;
254 255
	int ret;

256 257
	mutex_lock(&local->sta_mtx);
	mutex_lock(&local->key_mtx);
258

259
	if (mac_addr) {
260 261
		ret = -ENOENT;

262
		sta = sta_info_get_bss(sdata, mac_addr);
263
		if (!sta)
264
			goto out_unlock;
265

266
		if (pairwise)
267
			key = key_mtx_dereference(local, sta->ptk[key_idx]);
268
		else
J
Johannes Berg 已提交
269
			key = key_mtx_dereference(local, sta->gtk[key_idx]);
270
	} else
J
Johannes Berg 已提交
271
		key = key_mtx_dereference(local, sdata->keys[key_idx]);
272

273
	if (!key) {
274 275 276
		ret = -ENOENT;
		goto out_unlock;
	}
277

278
	ieee80211_key_free(key, true);
279

280 281
	ret = 0;
 out_unlock:
282 283
	mutex_unlock(&local->key_mtx);
	mutex_unlock(&local->sta_mtx);
284 285

	return ret;
286 287
}

288
static int ieee80211_get_key(struct wiphy *wiphy, struct net_device *dev,
289 290
			     u8 key_idx, bool pairwise, const u8 *mac_addr,
			     void *cookie,
291 292 293
			     void (*callback)(void *cookie,
					      struct key_params *params))
{
294
	struct ieee80211_sub_if_data *sdata;
295 296 297
	struct sta_info *sta = NULL;
	u8 seq[6] = {0};
	struct key_params params;
298
	struct ieee80211_key *key = NULL;
J
Johannes Berg 已提交
299
	u64 pn64;
300 301 302 303
	u32 iv32;
	u16 iv16;
	int err = -ENOENT;

304 305
	sdata = IEEE80211_DEV_TO_SUB_IF(dev);

306 307
	rcu_read_lock();

308
	if (mac_addr) {
309
		sta = sta_info_get_bss(sdata, mac_addr);
310 311 312
		if (!sta)
			goto out;

313
		if (pairwise && key_idx < NUM_DEFAULT_KEYS)
314
			key = rcu_dereference(sta->ptk[key_idx]);
315 316
		else if (!pairwise &&
			 key_idx < NUM_DEFAULT_KEYS + NUM_DEFAULT_MGMT_KEYS)
J
Johannes Berg 已提交
317
			key = rcu_dereference(sta->gtk[key_idx]);
318
	} else
J
Johannes Berg 已提交
319
		key = rcu_dereference(sdata->keys[key_idx]);
320 321 322 323 324 325

	if (!key)
		goto out;

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

326
	params.cipher = key->conf.cipher;
327

328 329
	switch (key->conf.cipher) {
	case WLAN_CIPHER_SUITE_TKIP:
330 331
		iv32 = key->u.tkip.tx.iv32;
		iv16 = key->u.tkip.tx.iv16;
332

333 334 335 336
		if (key->flags & KEY_FLAG_UPLOADED_TO_HARDWARE)
			drv_get_tkip_seq(sdata->local,
					 key->conf.hw_key_idx,
					 &iv32, &iv16);
337 338 339 340 341 342 343 344 345 346

		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;
347
	case WLAN_CIPHER_SUITE_CCMP:
J
Johannes Berg 已提交
348 349 350 351 352 353 354
		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;
355 356 357
		params.seq = seq;
		params.seq_len = 6;
		break;
358
	case WLAN_CIPHER_SUITE_AES_CMAC:
J
Johannes Berg 已提交
359 360 361 362 363 364 365
		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;
366 367 368
		params.seq = seq;
		params.seq_len = 6;
		break;
369 370 371 372 373 374 375 376 377
	}

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

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

 out:
378
	rcu_read_unlock();
379 380 381
	return err;
}

382 383
static int ieee80211_config_default_key(struct wiphy *wiphy,
					struct net_device *dev,
384 385
					u8 key_idx, bool uni,
					bool multi)
386
{
J
Johannes Berg 已提交
387
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
388

389
	ieee80211_set_default_key(sdata, key_idx, uni, multi);
390 391 392 393

	return 0;
}

394 395 396 397
static int ieee80211_config_default_mgmt_key(struct wiphy *wiphy,
					     struct net_device *dev,
					     u8 key_idx)
{
398
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
399 400 401 402 403 404

	ieee80211_set_default_mgmt_key(sdata, key_idx);

	return 0;
}

405 406 407 408 409
void sta_set_rate_info_tx(struct sta_info *sta,
			  const struct ieee80211_tx_rate *rate,
			  struct rate_info *rinfo)
{
	rinfo->flags = 0;
410
	if (rate->flags & IEEE80211_TX_RC_MCS) {
411
		rinfo->flags |= RATE_INFO_FLAGS_MCS;
412 413 414 415 416 417 418
		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;
419 420 421
		int shift = ieee80211_vif_get_shift(&sta->sdata->vif);
		u16 brate;

422 423
		sband = sta->local->hw.wiphy->bands[
				ieee80211_get_sdata_band(sta->sdata)];
424 425
		brate = sband->bitrates[rate->idx].bitrate;
		rinfo->legacy = DIV_ROUND_UP(brate, 1 << shift);
426
	}
427 428
	if (rate->flags & IEEE80211_TX_RC_40_MHZ_WIDTH)
		rinfo->flags |= RATE_INFO_FLAGS_40_MHZ_WIDTH;
429 430 431 432
	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;
433 434 435 436
	if (rate->flags & IEEE80211_TX_RC_SHORT_GI)
		rinfo->flags |= RATE_INFO_FLAGS_SHORT_GI;
}

437 438 439 440 441 442 443 444 445 446 447 448 449
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;
450 451
		int shift = ieee80211_vif_get_shift(&sta->sdata->vif);
		u16 brate;
452 453 454

		sband = sta->local->hw.wiphy->bands[
				ieee80211_get_sdata_band(sta->sdata)];
455 456
		brate = sband->bitrates[sta->last_rx_rate_idx].bitrate;
		rinfo->legacy = DIV_ROUND_UP(brate, 1 << shift);
457 458 459 460 461 462
	}

	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;
463
	if (sta->last_rx_rate_vht_flag & RX_VHT_FLAG_80MHZ)
464
		rinfo->flags |= RATE_INFO_FLAGS_80_MHZ_WIDTH;
465
	if (sta->last_rx_rate_vht_flag & RX_VHT_FLAG_80P80MHZ)
466
		rinfo->flags |= RATE_INFO_FLAGS_80P80_MHZ_WIDTH;
467
	if (sta->last_rx_rate_vht_flag & RX_VHT_FLAG_160MHZ)
468 469 470
		rinfo->flags |= RATE_INFO_FLAGS_160_MHZ_WIDTH;
}

471 472
static void sta_set_sinfo(struct sta_info *sta, struct station_info *sinfo)
{
473
	struct ieee80211_sub_if_data *sdata = sta->sdata;
474
	struct ieee80211_local *local = sdata->local;
475
	struct timespec uptime;
476
	u64 packets = 0;
477
	int i, ac;
478

479 480
	sinfo->generation = sdata->local->sta_generation;

481
	sinfo->filled = STATION_INFO_INACTIVE_TIME |
482 483
			STATION_INFO_RX_BYTES64 |
			STATION_INFO_TX_BYTES64 |
484 485
			STATION_INFO_RX_PACKETS |
			STATION_INFO_TX_PACKETS |
486 487
			STATION_INFO_TX_RETRIES |
			STATION_INFO_TX_FAILED |
488
			STATION_INFO_TX_BITRATE |
489
			STATION_INFO_RX_BITRATE |
490
			STATION_INFO_RX_DROP_MISC |
491
			STATION_INFO_BSS_PARAM |
492
			STATION_INFO_CONNECTED_TIME |
493 494
			STATION_INFO_STA_FLAGS |
			STATION_INFO_BEACON_LOSS_COUNT;
495 496 497

	do_posix_clock_monotonic_gettime(&uptime);
	sinfo->connected_time = uptime.tv_sec - sta->last_connected;
498 499

	sinfo->inactive_time = jiffies_to_msecs(jiffies - sta->last_rx);
500 501 502 503 504 505
	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;
506
	sinfo->rx_bytes = sta->rx_bytes;
507
	sinfo->rx_packets = sta->rx_packets;
508 509
	sinfo->tx_retries = sta->tx_retry_count;
	sinfo->tx_failed = sta->tx_retry_failed;
510
	sinfo->rx_dropped_misc = sta->rx_dropped;
511
	sinfo->beacon_loss_count = sta->beacon_loss_count;
512

513 514
	if ((sta->local->hw.flags & IEEE80211_HW_SIGNAL_DBM) ||
	    (sta->local->hw.flags & IEEE80211_HW_SIGNAL_UNSPEC)) {
515
		sinfo->filled |= STATION_INFO_SIGNAL | STATION_INFO_SIGNAL_AVG;
516 517 518
		if (!local->ops->get_rssi ||
		    drv_get_rssi(local, sdata, &sta->sta, &sinfo->signal))
			sinfo->signal = (s8)sta->last_signal;
519
		sinfo->signal_avg = (s8) -ewma_read(&sta->avg_signal);
520
	}
521 522 523 524 525 526 527 528 529 530 531
	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]);
		}
	}
532

533
	sta_set_rate_info_tx(sta, &sta->last_tx_rate, &sinfo->txrate);
534
	sta_set_rate_info_rx(sta, &sinfo->rxrate);
535

J
Johannes Berg 已提交
536
	if (ieee80211_vif_is_mesh(&sdata->vif)) {
537 538 539
#ifdef CONFIG_MAC80211_MESH
		sinfo->filled |= STATION_INFO_LLID |
				 STATION_INFO_PLID |
M
Marco Porsch 已提交
540 541 542 543
				 STATION_INFO_PLINK_STATE |
				 STATION_INFO_LOCAL_PM |
				 STATION_INFO_PEER_PM |
				 STATION_INFO_NONPEER_PM;
544

545 546
		sinfo->llid = sta->llid;
		sinfo->plid = sta->plid;
547
		sinfo->plink_state = sta->plink_state;
548 549 550 551
		if (test_sta_flag(sta, WLAN_STA_TOFFSET_KNOWN)) {
			sinfo->filled |= STATION_INFO_T_OFFSET;
			sinfo->t_offset = sta->t_offset;
		}
M
Marco Porsch 已提交
552 553 554
		sinfo->local_pm = sta->local_pm;
		sinfo->peer_pm = sta->peer_pm;
		sinfo->nonpeer_pm = sta->nonpeer_pm;
555
#endif
J
Johannes Berg 已提交
556
	}
557 558 559 560 561 562 563 564 565 566

	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;
567 568 569 570 571 572

	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) |
573
				BIT(NL80211_STA_FLAG_AUTHENTICATED) |
574
				BIT(NL80211_STA_FLAG_ASSOCIATED) |
575
				BIT(NL80211_STA_FLAG_TDLS_PEER);
576 577 578 579 580 581 582 583 584 585
	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);
586 587
	if (test_sta_flag(sta, WLAN_STA_ASSOC))
		sinfo->sta_flags.set |= BIT(NL80211_STA_FLAG_ASSOCIATED);
588 589
	if (test_sta_flag(sta, WLAN_STA_TDLS_PEER))
		sinfo->sta_flags.set |= BIT(NL80211_STA_FLAG_TDLS_PEER);
590 591
}

592 593 594 595 596
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",
597 598 599
	"beacon_loss", "sta_state", "txrate", "rxrate", "signal",
	"channel", "noise", "ch_time", "ch_time_busy",
	"ch_time_ext_busy", "ch_time_rx", "ch_time_tx"
600 601 602 603 604 605 606
};
#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)
{
607 608 609
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
	int rv = 0;

610
	if (sset == ETH_SS_STATS)
611 612 613
		rv += STA_STATS_LEN;

	rv += drv_get_et_sset_count(sdata, sset);
614

615 616 617
	if (rv == 0)
		return -EOPNOTSUPP;
	return rv;
618 619 620 621 622 623 624 625
}

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 已提交
626 627
	struct ieee80211_chanctx_conf *chanctx_conf;
	struct ieee80211_channel *channel;
628 629
	struct sta_info *sta;
	struct ieee80211_local *local = sdata->local;
630 631 632 633
	struct station_info sinfo;
	struct survey_info survey;
	int i, q;
#define STA_STATS_SURVEY_LEN 7
634 635 636 637 638 639 640 641 642 643 644 645

	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;		\
							\
646 647
		data[i++] += sinfo.tx_packets;		\
		data[i++] += sinfo.tx_bytes;		\
648 649 650 651 652 653 654 655 656 657 658 659 660
		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.
	 */

661
	mutex_lock(&local->sta_mtx);
662 663 664

	if (sdata->vif.type == NL80211_IFTYPE_STATION) {
		sta = sta_info_get_bss(sdata, sdata->u.mgd.bssid);
665 666 667 668

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

669 670 671
		sinfo.filled = 0;
		sta_set_sinfo(sta, &sinfo);

672 673 674 675 676 677
		i = 0;
		ADD_STA_STATS(sta);

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


678
		if (sinfo.filled & STATION_INFO_TX_BITRATE)
679 680 681
			data[i] = 100000 *
				cfg80211_calculate_bitrate(&sinfo.txrate);
		i++;
682
		if (sinfo.filled & STATION_INFO_RX_BITRATE)
683 684 685 686
			data[i] = 100000 *
				cfg80211_calculate_bitrate(&sinfo.rxrate);
		i++;

687
		if (sinfo.filled & STATION_INFO_SIGNAL_AVG)
688 689
			data[i] = (u8)sinfo.signal_avg;
		i++;
690
	} else {
691
		list_for_each_entry(sta, &local->sta_list, list) {
692 693 694 695
			/* Make sure this station belongs to the proper dev */
			if (sta->sdata->dev != dev)
				continue;

696 697
			sinfo.filled = 0;
			sta_set_sinfo(sta, &sinfo);
698 699 700 701 702
			i = 0;
			ADD_STA_STATS(sta);
		}
	}

703 704 705
do_survey:
	i = STA_STATS_LEN - STA_STATS_SURVEY_LEN;
	/* Get survey stats for current channel */
J
Johannes Berg 已提交
706
	survey.filled = 0;
707

J
Johannes Berg 已提交
708 709 710
	rcu_read_lock();
	chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf);
	if (chanctx_conf)
711
		channel = chanctx_conf->def.chan;
J
Johannes Berg 已提交
712 713 714 715 716 717 718 719 720 721 722 723 724 725
	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);
726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756
	}

	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;

757
	mutex_unlock(&local->sta_mtx);
758

759 760 761
	if (WARN_ON(i != STA_STATS_LEN))
		return;

762
	drv_get_et_stats(sdata, stats, &(data[STA_STATS_LEN]));
763 764 765 766 767 768
}

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

772
	if (sset == ETH_SS_STATS) {
773
		sz_sta_stats = sizeof(ieee80211_gstrings_sta_stats);
774
		memcpy(data, ieee80211_gstrings_sta_stats, sz_sta_stats);
775
	}
776
	drv_get_et_strings(sdata, sset, &(data[sz_sta_stats]));
777
}
778 779 780 781

static int ieee80211_dump_station(struct wiphy *wiphy, struct net_device *dev,
				 int idx, u8 *mac, struct station_info *sinfo)
{
782
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
783
	struct ieee80211_local *local = sdata->local;
784
	struct sta_info *sta;
785 786
	int ret = -ENOENT;

787
	mutex_lock(&local->sta_mtx);
788

789
	sta = sta_info_get_by_idx(sdata, idx);
790 791
	if (sta) {
		ret = 0;
792
		memcpy(mac, sta->sta.addr, ETH_ALEN);
793 794
		sta_set_sinfo(sta, sinfo);
	}
795

796
	mutex_unlock(&local->sta_mtx);
797

798
	return ret;
799 800
}

801 802 803 804 805 806 807 808
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);
}

809
static int ieee80211_get_station(struct wiphy *wiphy, struct net_device *dev,
810
				 u8 *mac, struct station_info *sinfo)
811
{
812
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
813
	struct ieee80211_local *local = sdata->local;
814
	struct sta_info *sta;
815
	int ret = -ENOENT;
816

817
	mutex_lock(&local->sta_mtx);
818

819
	sta = sta_info_get_bss(sdata, mac);
820 821 822 823 824
	if (sta) {
		ret = 0;
		sta_set_sinfo(sta, sinfo);
	}

825
	mutex_unlock(&local->sta_mtx);
826 827

	return ret;
828 829
}

J
Johannes Berg 已提交
830
static int ieee80211_set_monitor_channel(struct wiphy *wiphy,
831
					 struct cfg80211_chan_def *chandef)
832 833
{
	struct ieee80211_local *local = wiphy_priv(wiphy);
J
Johannes Berg 已提交
834 835
	struct ieee80211_sub_if_data *sdata;
	int ret = 0;
836

837
	if (cfg80211_chandef_identical(&local->monitor_chandef, chandef))
J
Johannes Berg 已提交
838
		return 0;
839

840
	mutex_lock(&local->mtx);
J
Johannes Berg 已提交
841 842 843 844 845 846 847
	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);
848
			ret = ieee80211_vif_use_channel(sdata, chandef,
J
Johannes Berg 已提交
849 850 851
					IEEE80211_CHANCTX_EXCLUSIVE);
		}
	} else if (local->open_count == local->monitors) {
852
		local->_oper_chandef = *chandef;
J
Johannes Berg 已提交
853 854
		ieee80211_hw_config(local, 0);
	}
855

856 857
	if (ret == 0)
		local->monitor_chandef = *chandef;
J
Johannes Berg 已提交
858
	mutex_unlock(&local->iflist_mtx);
859
	mutex_unlock(&local->mtx);
860

J
Johannes Berg 已提交
861
	return ret;
862 863
}

864
static int ieee80211_set_probe_resp(struct ieee80211_sub_if_data *sdata,
865
				    const u8 *resp, size_t resp_len)
866
{
867
	struct probe_resp *new, *old;
868 869

	if (!resp || !resp_len)
870
		return 1;
871

872
	old = sdata_dereference(sdata->u.ap.probe_resp, sdata);
873

874
	new = kzalloc(sizeof(struct probe_resp) + resp_len, GFP_KERNEL);
875 876 877
	if (!new)
		return -ENOMEM;

878 879
	new->len = resp_len;
	memcpy(new->data, resp, resp_len);
880 881

	rcu_assign_pointer(sdata->u.ap.probe_resp, new);
882 883
	if (old)
		kfree_rcu(old, rcu_head);
884 885 886 887

	return 0;
}

888 889
static int ieee80211_assign_beacon(struct ieee80211_sub_if_data *sdata,
				   struct cfg80211_beacon_data *params)
890 891 892
{
	struct beacon_data *new, *old;
	int new_head_len, new_tail_len;
893 894
	int size, err;
	u32 changed = BSS_CHANGED_BEACON;
895

896 897
	old = sdata_dereference(sdata->u.ap.beacon, sdata);

898 899 900

	/* Need to have a beacon head if we don't have one yet */
	if (!params->head && !old)
901
		return -EINVAL;
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 937 938 939 940 941 942 943 944 945

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

946 947
	err = ieee80211_set_probe_resp(sdata, params->probe_resp,
				       params->probe_resp_len);
948 949 950
	if (err < 0)
		return err;
	if (err == 0)
951 952
		changed |= BSS_CHANGED_AP_PROBE_RESP;

953 954 955 956
	rcu_assign_pointer(sdata->u.ap.beacon, new);

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

958
	return changed;
959 960
}

961 962
static int ieee80211_start_ap(struct wiphy *wiphy, struct net_device *dev,
			      struct cfg80211_ap_settings *params)
963
{
964
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
965
	struct ieee80211_local *local = sdata->local;
966
	struct beacon_data *old;
967
	struct ieee80211_sub_if_data *vlan;
968 969 970
	u32 changed = BSS_CHANGED_BEACON_INT |
		      BSS_CHANGED_BEACON_ENABLED |
		      BSS_CHANGED_BEACON |
971 972
		      BSS_CHANGED_SSID |
		      BSS_CHANGED_P2P_PS;
973
	int err;
974

975
	old = sdata_dereference(sdata->u.ap.beacon, sdata);
976 977 978
	if (old)
		return -EALREADY;

979 980 981 982
	/* TODO: make hostapd tell us what it wants */
	sdata->smps_mode = IEEE80211_SMPS_OFF;
	sdata->needed_rx_chains = sdata->local->rx_chains;

983
	mutex_lock(&local->mtx);
984
	err = ieee80211_vif_use_channel(sdata, &params->chandef,
J
Johannes Berg 已提交
985
					IEEE80211_CHANCTX_SHARED);
986 987
	if (!err)
		ieee80211_vif_copy_chanctx_to_vlans(sdata, false);
988
	mutex_unlock(&local->mtx);
989 990 991
	if (err)
		return err;

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

1002 1003 1004 1005 1006
	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;
1007 1008 1009 1010
		vlan->encrypt_headroom =
			ieee80211_cs_headroom(sdata->local,
					      &params->crypto,
					      vlan->vif.type);
1011 1012
	}

1013 1014
	sdata->vif.bss_conf.beacon_int = params->beacon_interval;
	sdata->vif.bss_conf.dtim_period = params->dtim_period;
1015
	sdata->vif.bss_conf.enable_beacon = true;
1016 1017 1018 1019 1020 1021 1022 1023

	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 已提交
1024 1025 1026 1027 1028 1029 1030
	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;
1031

1032
	err = ieee80211_assign_beacon(sdata, &params->beacon);
1033 1034
	if (err < 0) {
		ieee80211_vif_release_channel(sdata);
1035
		return err;
1036
	}
1037 1038
	changed |= err;

1039 1040
	err = drv_start_ap(sdata->local, sdata);
	if (err) {
1041 1042
		old = sdata_dereference(sdata->u.ap.beacon, sdata);

1043 1044 1045
		if (old)
			kfree_rcu(old, rcu_head);
		RCU_INIT_POINTER(sdata->u.ap.beacon, NULL);
1046
		ieee80211_vif_release_channel(sdata);
1047 1048 1049
		return err;
	}

1050
	ieee80211_recalc_dtim(local, sdata);
1051 1052
	ieee80211_bss_info_change_notify(sdata, changed);

1053 1054 1055 1056
	netif_carrier_on(dev);
	list_for_each_entry(vlan, &sdata->u.ap.vlans, u.vlan.list)
		netif_carrier_on(vlan->dev);

1057
	return 0;
1058 1059
}

1060 1061
static int ieee80211_change_beacon(struct wiphy *wiphy, struct net_device *dev,
				   struct cfg80211_beacon_data *params)
1062
{
1063
	struct ieee80211_sub_if_data *sdata;
1064
	struct beacon_data *old;
1065
	int err;
1066

1067
	sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1068
	sdata_assert_lock(sdata);
1069

1070 1071 1072 1073 1074 1075
	/* 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;

1076
	old = sdata_dereference(sdata->u.ap.beacon, sdata);
1077 1078 1079
	if (!old)
		return -ENOENT;

1080 1081 1082 1083 1084
	err = ieee80211_assign_beacon(sdata, params);
	if (err < 0)
		return err;
	ieee80211_bss_info_change_notify(sdata, err);
	return 0;
1085 1086
}

1087
static int ieee80211_stop_ap(struct wiphy *wiphy, struct net_device *dev)
1088
{
1089 1090 1091 1092 1093
	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;
1094
	struct cfg80211_chan_def chandef;
1095

1096 1097
	sdata_assert_lock(sdata);

1098
	old_beacon = sdata_dereference(sdata->u.ap.beacon, sdata);
1099
	if (!old_beacon)
1100
		return -ENOENT;
1101
	old_probe_resp = sdata_dereference(sdata->u.ap.probe_resp, sdata);
1102

1103 1104
	/* abort any running channel switch */
	sdata->vif.csa_active = false;
1105 1106 1107
	kfree(sdata->u.ap.next_beacon);
	sdata->u.ap.next_beacon = NULL;

1108
	/* turn off carrier for this interface and dependent VLANs */
1109 1110 1111 1112
	list_for_each_entry(vlan, &sdata->u.ap.vlans, u.vlan.list)
		netif_carrier_off(vlan->dev);
	netif_carrier_off(dev);

1113
	/* remove beacon and probe response */
1114
	RCU_INIT_POINTER(sdata->u.ap.beacon, NULL);
1115 1116 1117 1118
	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);
1119
	sdata->u.ap.driver_smps_mode = IEEE80211_SMPS_OFF;
1120

1121
	__sta_info_flush(sdata, true);
1122
	ieee80211_free_keys(sdata, true);
1123

1124
	sdata->vif.bss_conf.enable_beacon = false;
1125
	sdata->vif.bss_conf.ssid_len = 0;
1126
	clear_bit(SDATA_STATE_OFFCHANNEL_BEACON_STOPPED, &sdata->state);
1127
	ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_BEACON_ENABLED);
1128

1129
	if (sdata->wdev.cac_started) {
1130
		chandef = sdata->vif.bss_conf.chandef;
1131
		cancel_delayed_work_sync(&sdata->dfs_cac_timer_work);
1132 1133
		cfg80211_cac_event(sdata->dev, &chandef,
				   NL80211_RADAR_CAC_ABORTED,
1134 1135 1136
				   GFP_KERNEL);
	}

1137 1138
	drv_stop_ap(sdata->local, sdata);

1139 1140 1141 1142
	/* 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);

1143
	mutex_lock(&local->mtx);
1144
	ieee80211_vif_copy_chanctx_to_vlans(sdata, true);
J
Johannes Berg 已提交
1145
	ieee80211_vif_release_channel(sdata);
1146
	mutex_unlock(&local->mtx);
J
Johannes Berg 已提交
1147

1148
	return 0;
1149 1150
}

1151 1152 1153 1154 1155 1156 1157 1158 1159
/* 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 已提交
1160
} __packed;
1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177

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 已提交
1178
	eth_broadcast_addr(msg->da);
1179
	memcpy(msg->sa, sta->sta.addr, ETH_ALEN);
1180 1181 1182 1183 1184 1185 1186 1187 1188
	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) */

1189 1190
	skb->dev = sta->sdata->dev;
	skb->protocol = eth_type_trans(skb, sta->sdata->dev);
1191
	memset(skb->cb, 0, sizeof(skb->cb));
1192
	netif_rx_ni(skb);
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 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246
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;
}

1247 1248 1249
static int sta_apply_parameters(struct ieee80211_local *local,
				struct sta_info *sta,
				struct station_parameters *params)
1250
{
1251
	int ret = 0;
1252
	struct ieee80211_supported_band *sband;
1253
	struct ieee80211_sub_if_data *sdata = sta->sdata;
J
Johannes Berg 已提交
1254
	enum ieee80211_band band = ieee80211_get_sdata_band(sdata);
1255
	u32 mask, set;
1256

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

1259 1260
	mask = params->sta_flags_mask;
	set = params->sta_flags_set;
J
Johannes Berg 已提交
1261

1262 1263 1264 1265 1266 1267 1268 1269 1270
	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);
1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282
	} 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);
		}
1283
	}
1284

1285 1286 1287
	ret = sta_apply_auth_flags(local, sta, mask, set);
	if (ret)
		return ret;
1288

1289 1290
	if (mask & BIT(NL80211_STA_FLAG_SHORT_PREAMBLE)) {
		if (set & BIT(NL80211_STA_FLAG_SHORT_PREAMBLE))
J
Johannes Berg 已提交
1291 1292 1293
			set_sta_flag(sta, WLAN_STA_SHORT_PREAMBLE);
		else
			clear_sta_flag(sta, WLAN_STA_SHORT_PREAMBLE);
1294
	}
1295

1296
	if (mask & BIT(NL80211_STA_FLAG_WME)) {
1297
		if (set & BIT(NL80211_STA_FLAG_WME)) {
J
Johannes Berg 已提交
1298
			set_sta_flag(sta, WLAN_STA_WME);
1299
			sta->sta.wme = true;
J
Johannes Berg 已提交
1300 1301 1302
		} else {
			clear_sta_flag(sta, WLAN_STA_WME);
			sta->sta.wme = false;
1303
		}
1304
	}
1305

1306 1307
	if (mask & BIT(NL80211_STA_FLAG_MFP)) {
		if (set & BIT(NL80211_STA_FLAG_MFP))
J
Johannes Berg 已提交
1308 1309 1310
			set_sta_flag(sta, WLAN_STA_MFP);
		else
			clear_sta_flag(sta, WLAN_STA_MFP);
1311
	}
1312

1313 1314
	if (mask & BIT(NL80211_STA_FLAG_TDLS_PEER)) {
		if (set & BIT(NL80211_STA_FLAG_TDLS_PEER))
J
Johannes Berg 已提交
1315 1316 1317
			set_sta_flag(sta, WLAN_STA_TDLS_PEER);
		else
			clear_sta_flag(sta, WLAN_STA_TDLS_PEER);
1318
	}
1319

1320 1321 1322 1323
	if (params->sta_modify_mask & STATION_PARAM_APPLY_UAPSD) {
		sta->sta.uapsd_queues = params->uapsd_queues;
		sta->sta.max_sp = params->max_sp;
	}
1324

1325 1326 1327 1328 1329 1330 1331
	/*
	 * 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 已提交
1332
	/*
1333 1334 1335 1336 1337
	 * 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 已提交
1338 1339
	 */

1340 1341 1342 1343
	if (params->listen_interval >= 0)
		sta->listen_interval = params->listen_interval;

	if (params->supported_rates) {
1344 1345 1346 1347
		ieee80211_parse_bitrates(&sdata->vif.bss_conf.chandef,
					 sband, params->supported_rates,
					 params->supported_rates_len,
					 &sta->sta.supp_rates[band]);
1348
	}
1349

J
Johannes Berg 已提交
1350
	if (params->ht_capa)
B
Ben Greear 已提交
1351
		ieee80211_ht_cap_ie_to_sta_ht_cap(sdata, sband,
1352
						  params->ht_capa, sta);
1353

M
Mahesh Palivela 已提交
1354 1355
	if (params->vht_capa)
		ieee80211_vht_cap_ie_to_sta_vht_cap(sdata, sband,
1356
						    params->vht_capa, sta);
M
Mahesh Palivela 已提交
1357

1358 1359 1360 1361 1362 1363 1364 1365 1366
	if (params->opmode_notif_used) {
		/* returned value is only needed for rc update, but the
		 * rc isn't initialized here yet, so ignore it
		 */
		__ieee80211_vht_handle_opmode(sdata, sta,
					      params->opmode_notif,
					      band, false);
	}

1367
	if (ieee80211_vif_is_mesh(&sdata->vif)) {
1368
#ifdef CONFIG_MAC80211_MESH
1369
		u32 changed = 0;
1370 1371

		if (params->sta_modify_mask & STATION_PARAM_APPLY_PLINK_STATE) {
1372
			switch (params->plink_state) {
1373
			case NL80211_PLINK_ESTAB:
1374 1375 1376 1377
				if (sta->plink_state != NL80211_PLINK_ESTAB)
					changed = mesh_plink_inc_estab_count(
							sdata);
				sta->plink_state = params->plink_state;
M
Marco Porsch 已提交
1378 1379

				ieee80211_mps_sta_status_update(sta);
1380 1381
				changed |= ieee80211_mps_set_sta_local_pm(sta,
					      sdata->u.mesh.mshcfg.power_mode);
1382 1383
				break;
			case NL80211_PLINK_LISTEN:
1384
			case NL80211_PLINK_BLOCKED:
1385 1386 1387 1388 1389 1390 1391
			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);
1392
				sta->plink_state = params->plink_state;
M
Marco Porsch 已提交
1393 1394

				ieee80211_mps_sta_status_update(sta);
1395 1396
				changed |= ieee80211_mps_set_sta_local_pm(sta,
						NL80211_MESH_POWER_UNKNOWN);
1397 1398 1399 1400 1401
				break;
			default:
				/*  nothing  */
				break;
			}
1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413
		}

		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;
1414
		}
M
Marco Porsch 已提交
1415 1416

		if (params->local_pm)
1417 1418 1419
			changed |=
			      ieee80211_mps_set_sta_local_pm(sta,
							     params->local_pm);
1420
		ieee80211_mbss_info_change_notify(sdata, changed);
1421
#endif
J
Johannes Berg 已提交
1422
	}
1423 1424

	return 0;
1425 1426 1427 1428 1429
}

static int ieee80211_add_station(struct wiphy *wiphy, struct net_device *dev,
				 u8 *mac, struct station_parameters *params)
{
1430
	struct ieee80211_local *local = wiphy_priv(wiphy);
1431 1432
	struct sta_info *sta;
	struct ieee80211_sub_if_data *sdata;
J
Johannes Berg 已提交
1433
	int err;
1434
	int layer2_update;
1435 1436 1437 1438

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

1439 1440
		if (sdata->vif.type != NL80211_IFTYPE_AP_VLAN &&
		    sdata->vif.type != NL80211_IFTYPE_AP)
1441 1442 1443 1444
			return -EINVAL;
	} else
		sdata = IEEE80211_DEV_TO_SUB_IF(dev);

1445
	if (ether_addr_equal(mac, sdata->vif.addr))
1446 1447 1448 1449 1450 1451
		return -EINVAL;

	if (is_multicast_ether_addr(mac))
		return -EINVAL;

	sta = sta_info_alloc(sdata, mac, GFP_KERNEL);
J
Johannes Berg 已提交
1452 1453
	if (!sta)
		return -ENOMEM;
1454

1455 1456 1457 1458
	/*
	 * defaults -- if userspace wants something else we'll
	 * change it accordingly in sta_apply_parameters()
	 */
1459 1460 1461 1462
	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);
	}
1463

1464 1465 1466 1467 1468
	err = sta_apply_parameters(local, sta, params);
	if (err) {
		sta_info_free(local, sta);
		return err;
	}
1469

1470
	/*
1471 1472
	 * for TDLS, rate control should be initialized only when
	 * rates are known and station is marked authorized
1473 1474 1475
	 */
	if (!test_sta_flag(sta, WLAN_STA_TDLS_PEER))
		rate_control_rate_init(sta);
1476

1477 1478 1479
	layer2_update = sdata->vif.type == NL80211_IFTYPE_AP_VLAN ||
		sdata->vif.type == NL80211_IFTYPE_AP;

1480
	err = sta_info_insert_rcu(sta);
J
Johannes Berg 已提交
1481 1482 1483 1484 1485
	if (err) {
		rcu_read_unlock();
		return err;
	}

1486
	if (layer2_update)
J
Johannes Berg 已提交
1487 1488 1489 1490
		ieee80211_send_layer2_update(sta);

	rcu_read_unlock();

1491 1492 1493 1494 1495 1496
	return 0;
}

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

1499 1500
	sdata = IEEE80211_DEV_TO_SUB_IF(dev);

1501 1502
	if (mac)
		return sta_info_destroy_addr_bss(sdata, mac);
1503

1504
	sta_info_flush(sdata);
1505 1506 1507 1508
	return 0;
}

static int ieee80211_change_station(struct wiphy *wiphy,
1509
				    struct net_device *dev, u8 *mac,
1510 1511
				    struct station_parameters *params)
{
1512
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1513
	struct ieee80211_local *local = wiphy_priv(wiphy);
1514 1515
	struct sta_info *sta;
	struct ieee80211_sub_if_data *vlansdata;
1516
	enum cfg80211_station_type statype;
1517
	int err;
1518

1519
	mutex_lock(&local->sta_mtx);
J
Johannes Berg 已提交
1520

1521
	sta = sta_info_get_bss(sdata, mac);
J
Johannes Berg 已提交
1522
	if (!sta) {
1523 1524
		err = -ENOENT;
		goto out_err;
J
Johannes Berg 已提交
1525
	}
1526

1527 1528
	switch (sdata->vif.type) {
	case NL80211_IFTYPE_MESH_POINT:
1529
		if (sdata->u.mesh.user_mpm)
1530
			statype = CFG80211_STA_MESH_PEER_USER;
1531
		else
1532
			statype = CFG80211_STA_MESH_PEER_KERNEL;
1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553
		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;
1554 1555
	}

1556 1557 1558 1559
	err = cfg80211_check_station_change(wiphy, params, statype);
	if (err)
		goto out_err;

1560
	if (params->vlan && params->vlan != sta->sdata->dev) {
1561 1562 1563
		bool prev_4addr = false;
		bool new_4addr = false;

1564 1565
		vlansdata = IEEE80211_DEV_TO_SUB_IF(params->vlan);

1566
		if (params->vlan->ieee80211_ptr->use_4addr) {
J
Johannes Berg 已提交
1567
			if (vlansdata->u.vlan.sta) {
1568 1569
				err = -EBUSY;
				goto out_err;
J
Johannes Berg 已提交
1570
			}
1571

1572
			rcu_assign_pointer(vlansdata->u.vlan.sta, sta);
1573 1574 1575 1576 1577
			new_4addr = true;
		}

		if (sta->sdata->vif.type == NL80211_IFTYPE_AP_VLAN &&
		    sta->sdata->u.vlan.sta) {
M
Monam Agarwal 已提交
1578
			RCU_INIT_POINTER(sta->sdata->u.vlan.sta, NULL);
1579
			prev_4addr = true;
1580 1581
		}

1582
		sta->sdata = vlansdata;
1583 1584 1585 1586 1587 1588 1589 1590 1591

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

1592 1593 1594
		ieee80211_send_layer2_update(sta);
	}

1595
	err = sta_apply_parameters(local, sta, params);
1596 1597
	if (err)
		goto out_err;
1598

1599 1600 1601
	/* 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))
1602 1603
		rate_control_rate_init(sta);

1604
	mutex_unlock(&local->sta_mtx);
J
Johannes Berg 已提交
1605

1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619
	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);
	}

1620
	if (sdata->vif.type == NL80211_IFTYPE_STATION &&
E
Eliad Peller 已提交
1621
	    params->sta_flags_mask & BIT(NL80211_STA_FLAG_AUTHORIZED)) {
1622
		ieee80211_recalc_ps(local, -1);
E
Eliad Peller 已提交
1623 1624
		ieee80211_recalc_ps_vif(sdata);
	}
1625

1626
	return 0;
1627 1628 1629
out_err:
	mutex_unlock(&local->sta_mtx);
	return err;
1630 1631
}

1632 1633 1634 1635
#ifdef CONFIG_MAC80211_MESH
static int ieee80211_add_mpath(struct wiphy *wiphy, struct net_device *dev,
				 u8 *dst, u8 *next_hop)
{
1636
	struct ieee80211_sub_if_data *sdata;
1637 1638 1639
	struct mesh_path *mpath;
	struct sta_info *sta;

1640 1641
	sdata = IEEE80211_DEV_TO_SUB_IF(dev);

1642
	rcu_read_lock();
1643
	sta = sta_info_get(sdata, next_hop);
1644 1645
	if (!sta) {
		rcu_read_unlock();
1646
		return -ENOENT;
1647
	}
1648

1649 1650
	mpath = mesh_path_add(sdata, dst);
	if (IS_ERR(mpath)) {
1651
		rcu_read_unlock();
1652
		return PTR_ERR(mpath);
1653
	}
1654 1655

	mesh_path_fix_nexthop(mpath, sta);
1656

1657 1658 1659 1660 1661
	rcu_read_unlock();
	return 0;
}

static int ieee80211_del_mpath(struct wiphy *wiphy, struct net_device *dev,
J
Johannes Berg 已提交
1662
			       u8 *dst)
1663
{
1664 1665
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);

1666
	if (dst)
J
Johannes Berg 已提交
1667
		return mesh_path_del(sdata, dst);
1668

1669
	mesh_path_flush_by_iface(sdata);
1670 1671 1672 1673 1674 1675 1676
	return 0;
}

static int ieee80211_change_mpath(struct wiphy *wiphy,
				    struct net_device *dev,
				    u8 *dst, u8 *next_hop)
{
1677
	struct ieee80211_sub_if_data *sdata;
1678 1679 1680
	struct mesh_path *mpath;
	struct sta_info *sta;

1681 1682
	sdata = IEEE80211_DEV_TO_SUB_IF(dev);

1683 1684
	rcu_read_lock();

1685
	sta = sta_info_get(sdata, next_hop);
1686 1687
	if (!sta) {
		rcu_read_unlock();
1688
		return -ENOENT;
1689
	}
1690

J
Johannes Berg 已提交
1691
	mpath = mesh_path_lookup(sdata, dst);
1692 1693 1694 1695 1696 1697
	if (!mpath) {
		rcu_read_unlock();
		return -ENOENT;
	}

	mesh_path_fix_nexthop(mpath, sta);
1698

1699 1700 1701 1702 1703 1704 1705
	rcu_read_unlock();
	return 0;
}

static void mpath_set_pinfo(struct mesh_path *mpath, u8 *next_hop,
			    struct mpath_info *pinfo)
{
J
Johannes Berg 已提交
1706 1707 1708 1709
	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);
1710 1711 1712
	else
		memset(next_hop, 0, ETH_ALEN);

1713 1714
	memset(pinfo, 0, sizeof(*pinfo));

1715 1716
	pinfo->generation = mesh_paths_generation;

1717
	pinfo->filled = MPATH_INFO_FRAME_QLEN |
1718
			MPATH_INFO_SN |
1719 1720 1721 1722 1723 1724 1725
			MPATH_INFO_METRIC |
			MPATH_INFO_EXPTIME |
			MPATH_INFO_DISCOVERY_TIMEOUT |
			MPATH_INFO_DISCOVERY_RETRIES |
			MPATH_INFO_FLAGS;

	pinfo->frame_qlen = mpath->frame_queue.qlen;
1726
	pinfo->sn = mpath->sn;
1727 1728 1729 1730 1731 1732 1733 1734 1735 1736
	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;
1737 1738
	if (mpath->flags & MESH_PATH_SN_VALID)
		pinfo->flags |= NL80211_MPATH_FLAG_SN_VALID;
1739 1740
	if (mpath->flags & MESH_PATH_FIXED)
		pinfo->flags |= NL80211_MPATH_FLAG_FIXED;
1741 1742
	if (mpath->flags & MESH_PATH_RESOLVED)
		pinfo->flags |= NL80211_MPATH_FLAG_RESOLVED;
1743 1744 1745 1746 1747 1748
}

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

{
1749
	struct ieee80211_sub_if_data *sdata;
1750 1751
	struct mesh_path *mpath;

1752 1753
	sdata = IEEE80211_DEV_TO_SUB_IF(dev);

1754
	rcu_read_lock();
J
Johannes Berg 已提交
1755
	mpath = mesh_path_lookup(sdata, dst);
1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769
	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)
{
1770
	struct ieee80211_sub_if_data *sdata;
1771 1772
	struct mesh_path *mpath;

1773 1774
	sdata = IEEE80211_DEV_TO_SUB_IF(dev);

1775
	rcu_read_lock();
J
Johannes Berg 已提交
1776
	mpath = mesh_path_lookup_by_idx(sdata, idx);
1777 1778 1779 1780 1781 1782 1783 1784 1785
	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;
}
1786

1787
static int ieee80211_get_mesh_config(struct wiphy *wiphy,
1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802
				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;
}

1803 1804 1805 1806 1807
static int copy_mesh_setup(struct ieee80211_if_mesh *ifmsh,
		const struct mesh_setup *setup)
{
	u8 *new_ie;
	const u8 *old_ie;
1808 1809
	struct ieee80211_sub_if_data *sdata = container_of(ifmsh,
					struct ieee80211_sub_if_data, u.mesh);
1810

1811
	/* allocate information elements */
1812
	new_ie = NULL;
1813
	old_ie = ifmsh->ie;
1814

1815 1816
	if (setup->ie_len) {
		new_ie = kmemdup(setup->ie, setup->ie_len,
1817 1818 1819 1820
				GFP_KERNEL);
		if (!new_ie)
			return -ENOMEM;
	}
1821 1822 1823
	ifmsh->ie_len = setup->ie_len;
	ifmsh->ie = new_ie;
	kfree(old_ie);
1824 1825 1826 1827

	/* 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);
1828
	ifmsh->mesh_sp_id = setup->sync_method;
1829 1830
	ifmsh->mesh_pp_id = setup->path_sel_proto;
	ifmsh->mesh_pm_id = setup->path_metric;
1831
	ifmsh->user_mpm = setup->user_mpm;
1832
	ifmsh->mesh_auth_id = setup->auth_id;
1833 1834 1835 1836 1837
	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;
1838

1839 1840 1841
	/* mcast rate setting in Mesh Node */
	memcpy(sdata->vif.bss_conf.mcast_rate, setup->mcast_rate,
						sizeof(setup->mcast_rate));
1842
	sdata->vif.bss_conf.basic_rates = setup->basic_rates;
1843

1844 1845 1846
	sdata->vif.bss_conf.beacon_int = setup->beacon_interval;
	sdata->vif.bss_conf.dtim_period = setup->dtim_period;

1847 1848 1849
	return 0;
}

1850
static int ieee80211_update_mesh_config(struct wiphy *wiphy,
1851 1852
					struct net_device *dev, u32 mask,
					const struct mesh_config *nconf)
1853 1854 1855
{
	struct mesh_config *conf;
	struct ieee80211_sub_if_data *sdata;
1856 1857
	struct ieee80211_if_mesh *ifmsh;

1858
	sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1859
	ifmsh = &sdata->u.mesh;
1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874

	/* 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;
1875
	if (_chg_mesh_attr(NL80211_MESHCONF_ELEMENT_TTL, mask))
1876
		conf->element_ttl = nconf->element_ttl;
1877 1878 1879
	if (_chg_mesh_attr(NL80211_MESHCONF_AUTO_OPEN_PLINKS, mask)) {
		if (ifmsh->user_mpm)
			return -EBUSY;
1880
		conf->auto_open_plinks = nconf->auto_open_plinks;
1881
	}
1882 1883 1884
	if (_chg_mesh_attr(NL80211_MESHCONF_SYNC_OFFSET_MAX_NEIGHBOR, mask))
		conf->dot11MeshNbrOffsetMaxNeighbor =
			nconf->dot11MeshNbrOffsetMaxNeighbor;
1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897
	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;
1898 1899 1900
	if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_PERR_MIN_INTERVAL, mask))
		conf->dot11MeshHWMPperrMinInterval =
			nconf->dot11MeshHWMPperrMinInterval;
1901 1902 1903 1904
	if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME,
			   mask))
		conf->dot11MeshHWMPnetDiameterTraversalTime =
			nconf->dot11MeshHWMPnetDiameterTraversalTime;
1905 1906 1907 1908
	if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_ROOTMODE, mask)) {
		conf->dot11MeshHWMPRootMode = nconf->dot11MeshHWMPRootMode;
		ieee80211_mesh_root_setup(ifmsh);
	}
1909
	if (_chg_mesh_attr(NL80211_MESHCONF_GATE_ANNOUNCEMENTS, mask)) {
T
Thomas Pedersen 已提交
1910 1911 1912 1913
		/* our current gate announcement implementation rides on root
		 * announcements, so require this ifmsh to also be a root node
		 * */
		if (nconf->dot11MeshGateAnnouncementProtocol &&
1914 1915
		    !(conf->dot11MeshHWMPRootMode > IEEE80211_ROOTMODE_ROOT)) {
			conf->dot11MeshHWMPRootMode = IEEE80211_PROACTIVE_RANN;
T
Thomas Pedersen 已提交
1916 1917
			ieee80211_mesh_root_setup(ifmsh);
		}
1918 1919 1920
		conf->dot11MeshGateAnnouncementProtocol =
			nconf->dot11MeshGateAnnouncementProtocol;
	}
1921
	if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_RANN_INTERVAL, mask))
1922 1923
		conf->dot11MeshHWMPRannInterval =
			nconf->dot11MeshHWMPRannInterval;
1924 1925
	if (_chg_mesh_attr(NL80211_MESHCONF_FORWARDING, mask))
		conf->dot11MeshForwarding = nconf->dot11MeshForwarding;
1926 1927 1928 1929 1930 1931 1932 1933
	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;
	}
1934 1935 1936 1937 1938
	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);
	}
1939 1940 1941 1942 1943 1944
	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;
1945 1946 1947
	if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_CONFIRMATION_INTERVAL, mask))
		conf->dot11MeshHWMPconfirmationInterval =
			nconf->dot11MeshHWMPconfirmationInterval;
M
Marco Porsch 已提交
1948 1949 1950 1951
	if (_chg_mesh_attr(NL80211_MESHCONF_POWER_MODE, mask)) {
		conf->power_mode = nconf->power_mode;
		ieee80211_mps_local_status_update(sdata);
	}
T
Thomas Pedersen 已提交
1952
	if (_chg_mesh_attr(NL80211_MESHCONF_AWAKE_WINDOW, mask))
M
Marco Porsch 已提交
1953 1954
		conf->dot11MeshAwakeWindowDuration =
			nconf->dot11MeshAwakeWindowDuration;
1955 1956
	if (_chg_mesh_attr(NL80211_MESHCONF_PLINK_TIMEOUT, mask))
		conf->plink_timeout = nconf->plink_timeout;
T
Thomas Pedersen 已提交
1957
	ieee80211_mbss_info_change_notify(sdata, BSS_CHANGED_BEACON);
1958 1959 1960
	return 0;
}

1961 1962 1963 1964 1965 1966
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;
1967
	int err;
1968

1969 1970 1971 1972
	memcpy(&ifmsh->mshcfg, conf, sizeof(struct mesh_config));
	err = copy_mesh_setup(ifmsh, setup);
	if (err)
		return err;
1973

1974 1975 1976 1977
	/* can mesh use other SMPS modes? */
	sdata->smps_mode = IEEE80211_SMPS_OFF;
	sdata->needed_rx_chains = sdata->local->rx_chains;

1978
	mutex_lock(&sdata->local->mtx);
1979
	err = ieee80211_vif_use_channel(sdata, &setup->chandef,
J
Johannes Berg 已提交
1980
					IEEE80211_CHANCTX_SHARED);
1981
	mutex_unlock(&sdata->local->mtx);
1982 1983 1984
	if (err)
		return err;

T
Thomas Pedersen 已提交
1985
	return ieee80211_start_mesh(sdata);
1986 1987 1988 1989 1990 1991 1992
}

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);
1993
	mutex_lock(&sdata->local->mtx);
J
Johannes Berg 已提交
1994
	ieee80211_vif_release_channel(sdata);
1995
	mutex_unlock(&sdata->local->mtx);
1996 1997 1998

	return 0;
}
1999 2000
#endif

2001 2002 2003 2004
static int ieee80211_change_bss(struct wiphy *wiphy,
				struct net_device *dev,
				struct bss_parameters *params)
{
J
Johannes Berg 已提交
2005 2006
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
	enum ieee80211_band band;
2007 2008
	u32 changed = 0;

2009
	if (!sdata_dereference(sdata->u.ap.beacon, sdata))
J
Johannes Berg 已提交
2010 2011 2012
		return -ENOENT;

	band = ieee80211_get_sdata_band(sdata);
2013 2014

	if (params->use_cts_prot >= 0) {
J
Johannes Berg 已提交
2015
		sdata->vif.bss_conf.use_cts_prot = params->use_cts_prot;
2016 2017 2018
		changed |= BSS_CHANGED_ERP_CTS_PROT;
	}
	if (params->use_short_preamble >= 0) {
J
Johannes Berg 已提交
2019
		sdata->vif.bss_conf.use_short_preamble =
2020 2021 2022
			params->use_short_preamble;
		changed |= BSS_CHANGED_ERP_PREAMBLE;
	}
2023 2024

	if (!sdata->vif.bss_conf.use_short_slot &&
J
Johannes Berg 已提交
2025
	    band == IEEE80211_BAND_5GHZ) {
2026 2027 2028 2029
		sdata->vif.bss_conf.use_short_slot = true;
		changed |= BSS_CHANGED_ERP_SLOT;
	}

2030
	if (params->use_short_slot_time >= 0) {
J
Johannes Berg 已提交
2031
		sdata->vif.bss_conf.use_short_slot =
2032 2033 2034 2035
			params->use_short_slot_time;
		changed |= BSS_CHANGED_ERP_SLOT;
	}

2036
	if (params->basic_rates) {
2037 2038 2039 2040 2041
		ieee80211_parse_bitrates(&sdata->vif.bss_conf.chandef,
					 wiphy->bands[band],
					 params->basic_rates,
					 params->basic_rates_len,
					 &sdata->vif.bss_conf.basic_rates);
2042 2043 2044
		changed |= BSS_CHANGED_BASIC_RATES;
	}

2045 2046 2047 2048 2049 2050 2051
	if (params->ap_isolate >= 0) {
		if (params->ap_isolate)
			sdata->flags |= IEEE80211_SDATA_DONT_BRIDGE_PACKETS;
		else
			sdata->flags &= ~IEEE80211_SDATA_DONT_BRIDGE_PACKETS;
	}

2052 2053 2054 2055 2056 2057
	if (params->ht_opmode >= 0) {
		sdata->vif.bss_conf.ht_operation_mode =
			(u16) params->ht_opmode;
		changed |= BSS_CHANGED_HT;
	}

2058
	if (params->p2p_ctwindow >= 0) {
J
Janusz Dziedzic 已提交
2059 2060 2061 2062
		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;
2063 2064 2065
		changed |= BSS_CHANGED_P2P_PS;
	}

J
Janusz Dziedzic 已提交
2066 2067 2068 2069 2070 2071 2072
	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;
2073 2074 2075
		changed |= BSS_CHANGED_P2P_PS;
	}

2076 2077 2078 2079 2080
	ieee80211_bss_info_change_notify(sdata, changed);

	return 0;
}

2081
static int ieee80211_set_txq_params(struct wiphy *wiphy,
2082
				    struct net_device *dev,
2083 2084 2085
				    struct ieee80211_txq_params *params)
{
	struct ieee80211_local *local = wiphy_priv(wiphy);
2086
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
2087 2088 2089 2090 2091
	struct ieee80211_tx_queue_params p;

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

2092 2093 2094
	if (local->hw.queues < IEEE80211_NUM_ACS)
		return -EOPNOTSUPP;

2095 2096 2097 2098 2099
	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 已提交
2100 2101 2102 2103 2104 2105 2106

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

2107 2108
	sdata->tx_conf[params->ac] = p;
	if (drv_conf_tx(local, sdata, params->ac, &p)) {
J
Joe Perches 已提交
2109
		wiphy_debug(local->hw.wiphy,
2110 2111
			    "failed to set TX queue parameters for AC %d\n",
			    params->ac);
2112 2113 2114
		return -EINVAL;
	}

2115 2116
	ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_QOS);

2117 2118 2119
	return 0;
}

2120
#ifdef CONFIG_PM
J
Johannes Berg 已提交
2121 2122
static int ieee80211_suspend(struct wiphy *wiphy,
			     struct cfg80211_wowlan *wowlan)
2123
{
2124
	return __ieee80211_suspend(wiphy_priv(wiphy), wowlan);
2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135
}

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

2136 2137 2138
static int ieee80211_scan(struct wiphy *wiphy,
			  struct cfg80211_scan_request *req)
{
J
Johannes Berg 已提交
2139 2140 2141
	struct ieee80211_sub_if_data *sdata;

	sdata = IEEE80211_WDEV_TO_SUB_IF(req->wdev);
2142

2143 2144 2145 2146 2147
	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:
2148
	case NL80211_IFTYPE_P2P_DEVICE:
2149 2150 2151 2152
		break;
	case NL80211_IFTYPE_P2P_GO:
		if (sdata->local->ops->hw_scan)
			break;
2153 2154 2155 2156 2157
		/*
		 * FIXME: implement NoA while scanning in software,
		 * for now fall through to allow scanning only when
		 * beaconing hasn't been configured yet
		 */
2158
	case NL80211_IFTYPE_AP:
2159 2160 2161 2162 2163 2164 2165 2166 2167 2168
		/*
		 * 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)))
2169 2170 2171 2172 2173
			return -EOPNOTSUPP;
		break;
	default:
		return -EOPNOTSUPP;
	}
2174 2175 2176 2177

	return ieee80211_request_scan(sdata, req);
}

2178 2179 2180 2181 2182 2183 2184 2185 2186 2187 2188 2189 2190 2191
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
2192
ieee80211_sched_scan_stop(struct wiphy *wiphy, struct net_device *dev)
2193 2194 2195 2196 2197 2198
{
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);

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

2199
	return ieee80211_request_sched_scan_stop(sdata);
2200 2201
}

2202 2203 2204
static int ieee80211_auth(struct wiphy *wiphy, struct net_device *dev,
			  struct cfg80211_auth_request *req)
{
2205
	return ieee80211_mgd_auth(IEEE80211_DEV_TO_SUB_IF(dev), req);
2206 2207 2208 2209 2210
}

static int ieee80211_assoc(struct wiphy *wiphy, struct net_device *dev,
			   struct cfg80211_assoc_request *req)
{
2211
	return ieee80211_mgd_assoc(IEEE80211_DEV_TO_SUB_IF(dev), req);
2212 2213 2214
}

static int ieee80211_deauth(struct wiphy *wiphy, struct net_device *dev,
2215
			    struct cfg80211_deauth_request *req)
2216
{
2217
	return ieee80211_mgd_deauth(IEEE80211_DEV_TO_SUB_IF(dev), req);
2218 2219 2220
}

static int ieee80211_disassoc(struct wiphy *wiphy, struct net_device *dev,
2221
			      struct cfg80211_disassoc_request *req)
2222
{
2223
	return ieee80211_mgd_disassoc(IEEE80211_DEV_TO_SUB_IF(dev), req);
2224 2225
}

2226 2227 2228
static int ieee80211_join_ibss(struct wiphy *wiphy, struct net_device *dev,
			       struct cfg80211_ibss_params *params)
{
J
Johannes Berg 已提交
2229
	return ieee80211_ibss_join(IEEE80211_DEV_TO_SUB_IF(dev), params);
2230 2231 2232 2233
}

static int ieee80211_leave_ibss(struct wiphy *wiphy, struct net_device *dev)
{
J
Johannes Berg 已提交
2234
	return ieee80211_ibss_leave(IEEE80211_DEV_TO_SUB_IF(dev));
2235 2236
}

2237 2238 2239 2240 2241
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);

2242 2243
	memcpy(sdata->vif.bss_conf.mcast_rate, rate,
	       sizeof(int) * IEEE80211_NUM_BANDS);
2244 2245 2246 2247

	return 0;
}

2248 2249 2250
static int ieee80211_set_wiphy_params(struct wiphy *wiphy, u32 changed)
{
	struct ieee80211_local *local = wiphy_priv(wiphy);
2251
	int err;
2252

2253 2254 2255 2256 2257 2258 2259
	if (changed & WIPHY_PARAM_FRAG_THRESHOLD) {
		err = drv_set_frag_threshold(local, wiphy->frag_threshold);

		if (err)
			return err;
	}

2260 2261 2262 2263 2264 2265 2266
	if (changed & WIPHY_PARAM_COVERAGE_CLASS) {
		err = drv_set_coverage_class(local, wiphy->coverage_class);

		if (err)
			return err;
	}

2267
	if (changed & WIPHY_PARAM_RTS_THRESHOLD) {
2268
		err = drv_set_rts_threshold(local, wiphy->rts_threshold);
2269

2270 2271
		if (err)
			return err;
2272 2273
	}

2274 2275 2276
	if (changed & WIPHY_PARAM_RETRY_SHORT) {
		if (wiphy->retry_short > IEEE80211_MAX_TX_RETRY)
			return -EINVAL;
2277
		local->hw.conf.short_frame_max_tx_count = wiphy->retry_short;
2278 2279 2280 2281
	}
	if (changed & WIPHY_PARAM_RETRY_LONG) {
		if (wiphy->retry_long > IEEE80211_MAX_TX_RETRY)
			return -EINVAL;
2282
		local->hw.conf.long_frame_max_tx_count = wiphy->retry_long;
2283
	}
2284 2285 2286 2287 2288 2289 2290
	if (changed &
	    (WIPHY_PARAM_RETRY_SHORT | WIPHY_PARAM_RETRY_LONG))
		ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_RETRY_LIMITS);

	return 0;
}

2291
static int ieee80211_set_tx_power(struct wiphy *wiphy,
2292
				  struct wireless_dev *wdev,
2293
				  enum nl80211_tx_power_setting type, int mbm)
2294 2295
{
	struct ieee80211_local *local = wiphy_priv(wiphy);
2296
	struct ieee80211_sub_if_data *sdata;
2297

2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313 2314 2315 2316
	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 已提交
2317

2318
	switch (type) {
2319
	case NL80211_TX_POWER_AUTOMATIC:
2320
		local->user_power_level = IEEE80211_UNSET_POWER_LEVEL;
2321
		break;
2322 2323 2324 2325 2326
	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);
2327 2328 2329
		break;
	}

2330 2331 2332 2333 2334 2335
	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);
2336 2337 2338 2339

	return 0;
}

2340 2341 2342
static int ieee80211_get_tx_power(struct wiphy *wiphy,
				  struct wireless_dev *wdev,
				  int *dbm)
2343 2344
{
	struct ieee80211_local *local = wiphy_priv(wiphy);
2345
	struct ieee80211_sub_if_data *sdata = IEEE80211_WDEV_TO_SUB_IF(wdev);
2346

2347 2348 2349 2350
	if (!local->use_chanctx)
		*dbm = local->hw.conf.power_level;
	else
		*dbm = sdata->vif.bss_conf.txpower;
2351 2352 2353 2354

	return 0;
}

J
Johannes Berg 已提交
2355
static int ieee80211_set_wds_peer(struct wiphy *wiphy, struct net_device *dev,
J
Johannes Berg 已提交
2356
				  const u8 *addr)
J
Johannes Berg 已提交
2357 2358 2359 2360 2361 2362 2363 2364
{
	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 已提交
2365 2366 2367 2368 2369 2370 2371
static void ieee80211_rfkill_poll(struct wiphy *wiphy)
{
	struct ieee80211_local *local = wiphy_priv(wiphy);

	drv_rfkill_poll(local);
}

2372
#ifdef CONFIG_NL80211_TESTMODE
2373 2374 2375
static int ieee80211_testmode_cmd(struct wiphy *wiphy,
				  struct wireless_dev *wdev,
				  void *data, int len)
2376 2377
{
	struct ieee80211_local *local = wiphy_priv(wiphy);
2378
	struct ieee80211_vif *vif = NULL;
2379 2380 2381 2382

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

2383 2384 2385 2386 2387 2388 2389 2390 2391
	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);
2392
}
W
Wey-Yi Guy 已提交
2393 2394 2395 2396 2397 2398 2399 2400 2401 2402 2403 2404 2405

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);
}
2406 2407
#endif

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 2471 2472 2473 2474 2475 2476 2477 2478 2479 2480 2481 2482 2483 2484 2485 2486 2487 2488 2489 2490 2491 2492 2493
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)
2494 2495 2496 2497 2498
{
	const u8 *ap;
	enum ieee80211_smps_mode old_req;
	int err;

2499
	lockdep_assert_held(&sdata->wdev.mtx);
2500

2501 2502 2503
	if (WARN_ON_ONCE(sdata->vif.type != NL80211_IFTYPE_STATION))
		return -EINVAL;

2504 2505 2506 2507 2508 2509 2510 2511 2512
	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
2513 2514
	 * association, there's no need to do anything, just store
	 * the new value until we associate.
2515 2516
	 */
	if (!sdata->u.mgd.associated ||
2517
	    sdata->vif.bss_conf.chandef.width == NL80211_CHAN_WIDTH_20_NOHT)
2518 2519
		return 0;

2520
	ap = sdata->u.mgd.associated->bssid;
2521 2522 2523 2524 2525 2526 2527 2528 2529 2530 2531 2532 2533 2534 2535 2536 2537

	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 已提交
2538 2539 2540 2541 2542 2543
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);

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

J
Johannes Berg 已提交
2547 2548 2549 2550
	if (!(local->hw.flags & IEEE80211_HW_SUPPORTS_PS))
		return -EOPNOTSUPP;

	if (enabled == sdata->u.mgd.powersave &&
2551
	    timeout == local->dynamic_ps_forced_timeout)
J
Johannes Berg 已提交
2552 2553 2554
		return 0;

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

2557
	/* no change, but if automatic follow powersave */
2558
	sdata_lock(sdata);
2559
	__ieee80211_request_smps_mgd(sdata, sdata->u.mgd.req_smps);
2560
	sdata_unlock(sdata);
2561

J
Johannes Berg 已提交
2562 2563 2564 2565
	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 已提交
2566
	ieee80211_recalc_ps_vif(sdata);
J
Johannes Berg 已提交
2567 2568 2569 2570

	return 0;
}

2571 2572 2573 2574 2575 2576 2577 2578 2579 2580 2581 2582 2583 2584 2585 2586
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 */
2587 2588
	if (sdata->u.mgd.associated &&
	    sdata->vif.driver_flags & IEEE80211_VIF_SUPPORTS_CQM_RSSI)
2589 2590 2591 2592 2593
		ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_CQM);

	return 0;
}

J
Johannes Berg 已提交
2594 2595 2596 2597 2598 2599 2600
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);
2601
	int i, ret;
2602

2603 2604 2605
	if (!ieee80211_sdata_running(sdata))
		return -ENETDOWN;

2606 2607 2608 2609 2610
	if (local->hw.flags & IEEE80211_HW_HAS_RATE_CONTROL) {
		ret = drv_set_bitrate_mask(local, sdata, mask);
		if (ret)
			return ret;
	}
J
Johannes Berg 已提交
2611

2612
	for (i = 0; i < IEEE80211_NUM_BANDS; i++) {
2613 2614 2615
		struct ieee80211_supported_band *sband = wiphy->bands[i];
		int j;

2616
		sdata->rc_rateidx_mask[i] = mask->control[i].legacy;
2617 2618
		memcpy(sdata->rc_rateidx_mcs_mask[i], mask->control[i].ht_mcs,
		       sizeof(mask->control[i].ht_mcs));
2619 2620 2621 2622 2623 2624 2625 2626 2627 2628

		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;
			}
2629
	}
J
Johannes Berg 已提交
2630

2631
	return 0;
J
Johannes Berg 已提交
2632 2633
}

2634 2635 2636 2637
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,
2638 2639
				    struct sk_buff *txskb,
				    enum ieee80211_roc_type type)
2640 2641 2642
{
	struct ieee80211_roc_work *roc, *tmp;
	bool queued = false;
2643 2644 2645 2646
	int ret;

	lockdep_assert_held(&local->mtx);

2647 2648 2649
	if (local->use_chanctx && !local->ops->remain_on_channel)
		return -EOPNOTSUPP;

2650 2651 2652 2653
	roc = kzalloc(sizeof(*roc), GFP_KERNEL);
	if (!roc)
		return -ENOMEM;

2654 2655 2656 2657 2658 2659 2660 2661 2662 2663 2664 2665
	/*
	 * 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;

2666 2667 2668 2669
	roc->chan = channel;
	roc->duration = duration;
	roc->req_duration = duration;
	roc->frame = txskb;
2670
	roc->type = type;
2671 2672 2673 2674 2675
	roc->mgmt_tx_cookie = (unsigned long)txskb;
	roc->sdata = sdata;
	INIT_DELAYED_WORK(&roc->work, ieee80211_sw_roc_work);
	INIT_LIST_HEAD(&roc->dependents);

2676 2677 2678 2679 2680 2681 2682 2683 2684 2685 2686 2687 2688 2689 2690 2691 2692 2693
	/*
	 * cookie is either the roc cookie (for normal roc)
	 * or the SKB (for mgmt TX)
	 */
	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 {
		*cookie = (unsigned long)txskb;
	}

2694
	/* if there's one pending or we're scanning, queue this one */
2695 2696
	if (!list_empty(&local->roc_list) ||
	    local->scanning || local->radar_detect_enabled)
2697 2698 2699 2700 2701 2702 2703 2704 2705 2706
		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) */

2707
	ret = drv_remain_on_channel(local, sdata, channel, duration, type);
2708
	if (ret) {
2709 2710
		kfree(roc);
		return ret;
2711 2712
	}

2713 2714 2715 2716 2717
	roc->started = true;
	goto out_queue;

 out_check_combine:
	list_for_each_entry(tmp, &local->roc_list, list) {
2718
		if (tmp->chan != channel || tmp->sdata != sdata)
2719 2720 2721 2722 2723 2724 2725
			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.
2726 2727
		 * If the type of the new ROC has higher priority, modify the
		 * type of the previous one to match that of the new one.
2728 2729 2730 2731
		 */
		if (!tmp->started) {
			list_add_tail(&roc->list, &tmp->dependents);
			tmp->duration = max(tmp->duration, roc->duration);
2732
			tmp->type = max(tmp->type, roc->type);
2733 2734 2735 2736 2737 2738 2739 2740 2741 2742 2743
			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
2744
			 * when the master one begins. If it has begun,
2745 2746
			 * check that there's still a minimum time left and
			 * if so, start this one, transmitting the frame, but
2747
			 * add it to the list directly after this one with
2748 2749 2750 2751 2752 2753
			 * 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.
2754 2755
			 * TODO: the ROC type is ignored here, assuming that it
			 * is better to immediately use the current ROC.
2756 2757 2758 2759 2760 2761 2762 2763 2764 2765 2766 2767 2768 2769 2770 2771 2772 2773 2774 2775 2776 2777 2778 2779 2780 2781 2782 2783 2784 2785 2786 2787 2788 2789 2790 2791 2792 2793 2794 2795 2796 2797 2798 2799 2800 2801 2802 2803 2804 2805 2806 2807 2808 2809 2810 2811 2812 2813 2814 2815 2816
			 */
			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);

	return 0;
2817 2818
}

2819
static int ieee80211_remain_on_channel(struct wiphy *wiphy,
2820
				       struct wireless_dev *wdev,
2821 2822 2823 2824
				       struct ieee80211_channel *chan,
				       unsigned int duration,
				       u64 *cookie)
{
2825
	struct ieee80211_sub_if_data *sdata = IEEE80211_WDEV_TO_SUB_IF(wdev);
2826
	struct ieee80211_local *local = sdata->local;
2827
	int ret;
2828

2829
	mutex_lock(&local->mtx);
2830
	ret = ieee80211_start_roc_work(local, sdata, chan,
2831 2832
				       duration, cookie, NULL,
				       IEEE80211_ROC_TYPE_NORMAL);
2833
	mutex_unlock(&local->mtx);
2834

2835
	return ret;
2836 2837
}

2838 2839
static int ieee80211_cancel_roc(struct ieee80211_local *local,
				u64 cookie, bool mgmt_tx)
2840
{
2841
	struct ieee80211_roc_work *roc, *tmp, *found = NULL;
2842 2843
	int ret;

2844 2845
	mutex_lock(&local->mtx);
	list_for_each_entry_safe(roc, tmp, &local->roc_list, list) {
2846 2847 2848
		struct ieee80211_roc_work *dep, *tmp2;

		list_for_each_entry_safe(dep, tmp2, &roc->dependents, list) {
2849
			if (!mgmt_tx && dep->cookie != cookie)
2850 2851 2852 2853 2854 2855 2856
				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);

2857
			ieee80211_roc_notify_destroy(dep, true);
2858 2859 2860
			return 0;
		}

2861
		if (!mgmt_tx && roc->cookie != cookie)
2862 2863 2864
			continue;
		else if (mgmt_tx && roc->mgmt_tx_cookie != cookie)
			continue;
2865

2866 2867 2868
		found = roc;
		break;
	}
2869

2870 2871 2872 2873
	if (!found) {
		mutex_unlock(&local->mtx);
		return -ENOENT;
	}
2874

2875 2876 2877 2878 2879 2880 2881
	/*
	 * 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.
	 */

2882 2883 2884 2885 2886 2887 2888 2889
	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;
			}
		}
2890

2891
		list_del(&found->list);
2892

2893 2894
		if (found->started)
			ieee80211_start_next_roc(local);
2895
		mutex_unlock(&local->mtx);
2896

2897
		ieee80211_roc_notify_destroy(found, true);
2898 2899 2900 2901
	} else {
		/* work may be pending so use it all the time */
		found->abort = true;
		ieee80211_queue_delayed_work(&local->hw, &found->work, 0);
2902 2903 2904

		mutex_unlock(&local->mtx);

2905 2906
		/* work will clean up etc */
		flush_delayed_work(&found->work);
2907 2908
		WARN_ON(!found->to_be_freed);
		kfree(found);
2909
	}
2910

2911
	return 0;
2912 2913
}

2914
static int ieee80211_cancel_remain_on_channel(struct wiphy *wiphy,
2915
					      struct wireless_dev *wdev,
2916
					      u64 cookie)
2917
{
2918
	struct ieee80211_sub_if_data *sdata = IEEE80211_WDEV_TO_SUB_IF(wdev);
2919
	struct ieee80211_local *local = sdata->local;
2920

2921
	return ieee80211_cancel_roc(local, cookie, false);
2922 2923
}

2924 2925
static int ieee80211_start_radar_detection(struct wiphy *wiphy,
					   struct net_device *dev,
2926 2927
					   struct cfg80211_chan_def *chandef,
					   u32 cac_time_ms)
2928 2929 2930 2931 2932
{
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
	struct ieee80211_local *local = sdata->local;
	int err;

2933 2934 2935 2936 2937
	mutex_lock(&local->mtx);
	if (!list_empty(&local->roc_list) || local->scanning) {
		err = -EBUSY;
		goto out_unlock;
	}
2938 2939 2940 2941 2942 2943 2944 2945

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

	err = ieee80211_vif_use_channel(sdata, chandef,
					IEEE80211_CHANCTX_SHARED);
	if (err)
2946
		goto out_unlock;
2947 2948

	ieee80211_queue_delayed_work(&sdata->local->hw,
2949 2950
				     &sdata->dfs_cac_timer_work,
				     msecs_to_jiffies(cac_time_ms));
2951

2952 2953 2954
 out_unlock:
	mutex_unlock(&local->mtx);
	return err;
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 2991 2992 2993 2994 2995 2996 2997 2998 2999 3000 3001 3002 3003 3004 3005 3006 3007 3008 3009 3010 3011 3012
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;
}

3013
void ieee80211_csa_finish(struct ieee80211_vif *vif)
3014
{
3015
	struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
3016

3017 3018 3019 3020
	ieee80211_queue_work(&sdata->local->hw,
			     &sdata->csa_finalize_work);
}
EXPORT_SYMBOL(ieee80211_csa_finish);
3021

3022 3023 3024 3025
static void ieee80211_csa_finalize(struct ieee80211_sub_if_data *sdata)
{
	struct ieee80211_local *local = sdata->local;
	int err, changed = 0;
3026

3027 3028
	sdata_assert_lock(sdata);

3029
	mutex_lock(&local->mtx);
3030
	sdata->radar_required = sdata->csa_radar_required;
3031
	err = ieee80211_vif_change_channel(sdata, &changed);
3032
	mutex_unlock(&local->mtx);
3033
	if (WARN_ON(err < 0))
3034
		return;
3035

3036
	if (!local->use_chanctx) {
3037
		local->_oper_chandef = sdata->csa_chandef;
3038 3039 3040
		ieee80211_hw_config(local, 0);
	}

3041
	sdata->vif.csa_active = false;
3042 3043 3044
	switch (sdata->vif.type) {
	case NL80211_IFTYPE_AP:
		err = ieee80211_assign_beacon(sdata, sdata->u.ap.next_beacon);
3045 3046 3047
		kfree(sdata->u.ap.next_beacon);
		sdata->u.ap.next_beacon = NULL;

3048
		if (err < 0)
3049
			return;
3050 3051 3052
		changed |= err;
		break;
	case NL80211_IFTYPE_ADHOC:
3053 3054 3055 3056
		err = ieee80211_ibss_finish_csa(sdata);
		if (err < 0)
			return;
		changed |= err;
3057
		break;
3058 3059 3060 3061
#ifdef CONFIG_MAC80211_MESH
	case NL80211_IFTYPE_MESH_POINT:
		err = ieee80211_mesh_finish_csa(sdata);
		if (err < 0)
3062
			return;
3063
		changed |= err;
3064 3065
		break;
#endif
3066 3067
	default:
		WARN_ON(1);
3068
		return;
3069
	}
3070

3071 3072
	ieee80211_bss_info_change_notify(sdata, changed);

3073 3074 3075 3076
	ieee80211_wake_queues_by_reason(&sdata->local->hw,
					IEEE80211_MAX_QUEUE_MAP,
					IEEE80211_QUEUE_STOP_REASON_CSA);

3077
	cfg80211_ch_switch_notify(sdata->dev, &sdata->csa_chandef);
3078 3079 3080 3081 3082 3083 3084 3085 3086 3087 3088 3089 3090 3091 3092 3093 3094
}

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);
3095 3096 3097

unlock:
	sdata_unlock(sdata);
3098 3099
}

3100 3101 3102
static int ieee80211_set_csa_beacon(struct ieee80211_sub_if_data *sdata,
				    struct cfg80211_csa_settings *params,
				    u32 *changed)
3103
{
3104
	int err;
3105 3106 3107

	switch (sdata->vif.type) {
	case NL80211_IFTYPE_AP:
3108 3109 3110 3111 3112
		sdata->u.ap.next_beacon =
			cfg80211_beacon_dup(&params->beacon_after);
		if (!sdata->u.ap.next_beacon)
			return -ENOMEM;

3113 3114 3115 3116 3117 3118 3119 3120 3121 3122 3123 3124 3125 3126 3127 3128 3129 3130 3131 3132 3133 3134
		/*
		 * 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;
3135 3136 3137 3138 3139
		err = ieee80211_assign_beacon(sdata, &params->beacon_csa);
		if (err < 0) {
			kfree(sdata->u.ap.next_beacon);
			return err;
		}
3140
		*changed |= err;
3141

3142 3143 3144 3145 3146 3147 3148 3149 3150 3151 3152 3153 3154 3155 3156 3157 3158 3159 3160 3161 3162 3163 3164 3165 3166 3167 3168
		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;

3169 3170 3171 3172 3173
		/* see comments in the NL80211_IFTYPE_AP block */
		if (params->count > 1) {
			err = ieee80211_ibss_csa_beacon(sdata, params);
			if (err < 0)
				return err;
3174
			*changed |= err;
3175 3176 3177 3178
		}

		ieee80211_send_action_csa(sdata, params);

3179
		break;
3180
#ifdef CONFIG_MAC80211_MESH
3181 3182
	case NL80211_IFTYPE_MESH_POINT: {
		struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;
3183 3184 3185 3186 3187 3188 3189 3190 3191

		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;

3192
		if (ifmsh->csa_role == IEEE80211_MESH_CSA_ROLE_NONE) {
3193
			ifmsh->csa_role = IEEE80211_MESH_CSA_ROLE_INIT;
3194 3195 3196 3197 3198
			if (!ifmsh->pre_value)
				ifmsh->pre_value = 1;
			else
				ifmsh->pre_value++;
		}
3199

3200 3201 3202 3203 3204 3205 3206
		/* 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;
			}
3207
			*changed |= err;
3208
		}
3209 3210 3211 3212

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

3213
		break;
3214
		}
3215
#endif
3216 3217 3218 3219
	default:
		return -EOPNOTSUPP;
	}

3220 3221 3222 3223 3224 3225 3226 3227
	return 0;
}

int ieee80211_channel_switch(struct wiphy *wiphy, struct net_device *dev,
			     struct cfg80211_csa_settings *params)
{
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
	struct ieee80211_local *local = sdata->local;
3228
	struct ieee80211_chanctx_conf *conf;
3229 3230 3231 3232 3233 3234 3235 3236 3237 3238 3239 3240 3241 3242 3243
	struct ieee80211_chanctx *chanctx;
	int err, num_chanctx, changed = 0;

	sdata_assert_lock(sdata);

	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;

3244 3245 3246 3247 3248
	mutex_lock(&local->chanctx_mtx);
	conf = rcu_dereference_protected(sdata->vif.chanctx_conf,
					 lockdep_is_held(&local->chanctx_mtx));
	if (!conf) {
		mutex_unlock(&local->chanctx_mtx);
3249 3250 3251 3252
		return -EBUSY;
	}

	/* don't handle for multi-VIF cases */
3253
	chanctx = container_of(conf, struct ieee80211_chanctx, conf);
3254
	if (chanctx->refcount > 1) {
3255
		mutex_unlock(&local->chanctx_mtx);
3256 3257 3258 3259 3260
		return -EBUSY;
	}
	num_chanctx = 0;
	list_for_each_entry_rcu(chanctx, &local->chanctx_list, list)
		num_chanctx++;
3261
	mutex_unlock(&local->chanctx_mtx);
3262 3263 3264 3265 3266 3267 3268 3269 3270 3271 3272 3273

	if (num_chanctx > 1)
		return -EBUSY;

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

	err = ieee80211_set_csa_beacon(sdata, params, &changed);
	if (err)
		return err;

3274 3275 3276 3277 3278 3279 3280
	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);

3281
	sdata->csa_chandef = params->chandef;
3282 3283
	sdata->vif.csa_active = true;

3284 3285 3286 3287 3288 3289 3290
	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);
	}
3291 3292 3293 3294

	return 0;
}

3295
static int ieee80211_mgmt_tx(struct wiphy *wiphy, struct wireless_dev *wdev,
3296 3297
			     struct cfg80211_mgmt_tx_params *params,
			     u64 *cookie)
3298
{
3299
	struct ieee80211_sub_if_data *sdata = IEEE80211_WDEV_TO_SUB_IF(wdev);
3300 3301 3302
	struct ieee80211_local *local = sdata->local;
	struct sk_buff *skb;
	struct sta_info *sta;
3303
	const struct ieee80211_mgmt *mgmt = (void *)params->buf;
3304
	bool need_offchan = false;
3305
	u32 flags;
3306
	int ret;
3307

3308
	if (params->dont_wait_for_ack)
3309 3310 3311 3312 3313
		flags = IEEE80211_TX_CTL_NO_ACK;
	else
		flags = IEEE80211_TX_INTFL_NL80211_FRAME_TX |
			IEEE80211_TX_CTL_REQ_TX_STATUS;

3314
	if (params->no_cck)
3315 3316
		flags |= IEEE80211_TX_CTL_NO_CCK_RATE;

3317 3318
	switch (sdata->vif.type) {
	case NL80211_IFTYPE_ADHOC:
3319 3320 3321 3322 3323 3324 3325 3326 3327 3328
		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
3329 3330 3331
	case NL80211_IFTYPE_AP:
	case NL80211_IFTYPE_AP_VLAN:
	case NL80211_IFTYPE_P2P_GO:
3332 3333 3334 3335
		if (sdata->vif.type != NL80211_IFTYPE_ADHOC &&
		    !ieee80211_vif_is_mesh(&sdata->vif) &&
		    !rcu_access_pointer(sdata->bss->beacon))
			need_offchan = true;
3336
		if (!ieee80211_is_action(mgmt->frame_control) ||
3337
		    mgmt->u.action.category == WLAN_CATEGORY_PUBLIC ||
3338 3339
		    mgmt->u.action.category == WLAN_CATEGORY_SELF_PROTECTED ||
		    mgmt->u.action.category == WLAN_CATEGORY_SPECTRUM_MGMT)
3340 3341 3342 3343 3344 3345 3346 3347
			break;
		rcu_read_lock();
		sta = sta_info_get(sdata, mgmt->da);
		rcu_read_unlock();
		if (!sta)
			return -ENOLINK;
		break;
	case NL80211_IFTYPE_STATION:
3348
	case NL80211_IFTYPE_P2P_CLIENT:
3349 3350
		if (!sdata->u.mgd.associated)
			need_offchan = true;
3351
		break;
3352 3353 3354
	case NL80211_IFTYPE_P2P_DEVICE:
		need_offchan = true;
		break;
3355 3356 3357 3358
	default:
		return -EOPNOTSUPP;
	}

3359 3360 3361
	/* configurations requiring offchan cannot work if no channel has been
	 * specified
	 */
3362
	if (need_offchan && !params->chan)
3363 3364
		return -EINVAL;

3365 3366 3367 3368
	mutex_lock(&local->mtx);

	/* Check if the operating channel is the requested channel */
	if (!need_offchan) {
J
Johannes Berg 已提交
3369 3370 3371 3372 3373
		struct ieee80211_chanctx_conf *chanctx_conf;

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

3374
		if (chanctx_conf) {
3375 3376 3377 3378
			need_offchan = params->chan &&
				       (params->chan !=
					chanctx_conf->def.chan);
		} else if (!params->chan) {
3379 3380 3381 3382
			ret = -EINVAL;
			rcu_read_unlock();
			goto out_unlock;
		} else {
3383
			need_offchan = true;
3384
		}
J
Johannes Berg 已提交
3385
		rcu_read_unlock();
3386 3387
	}

3388
	if (need_offchan && !params->offchan) {
3389 3390 3391 3392
		ret = -EBUSY;
		goto out_unlock;
	}

3393
	skb = dev_alloc_skb(local->hw.extra_tx_headroom + params->len);
3394 3395 3396 3397
	if (!skb) {
		ret = -ENOMEM;
		goto out_unlock;
	}
3398 3399
	skb_reserve(skb, local->hw.extra_tx_headroom);

3400
	memcpy(skb_put(skb, params->len), params->buf, params->len);
3401 3402 3403 3404 3405

	IEEE80211_SKB_CB(skb)->flags = flags;

	skb->dev = sdata->dev;

3406
	if (!need_offchan) {
3407
		*cookie = (unsigned long) skb;
3408
		ieee80211_tx_skb(sdata, skb);
3409 3410
		ret = 0;
		goto out_unlock;
3411 3412
	}

3413 3414
	IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_CTL_TX_OFFCHAN |
					IEEE80211_TX_INTFL_OFFCHAN_TX_OK;
3415 3416 3417
	if (local->hw.flags & IEEE80211_HW_QUEUE_CONTROL)
		IEEE80211_SKB_CB(skb)->hw_queue =
			local->hw.offchannel_tx_hw_queue;
3418

3419
	/* This will handle all kinds of coalescing and immediate TX */
3420 3421
	ret = ieee80211_start_roc_work(local, sdata, params->chan,
				       params->wait, cookie, skb,
3422
				       IEEE80211_ROC_TYPE_MGMT_TX);
3423 3424 3425 3426 3427
	if (ret)
		kfree_skb(skb);
 out_unlock:
	mutex_unlock(&local->mtx);
	return ret;
3428 3429
}

3430
static int ieee80211_mgmt_tx_cancel_wait(struct wiphy *wiphy,
3431
					 struct wireless_dev *wdev,
3432 3433
					 u64 cookie)
{
3434
	struct ieee80211_local *local = wiphy_priv(wiphy);
3435

3436
	return ieee80211_cancel_roc(local, cookie, true);
3437 3438
}

3439
static void ieee80211_mgmt_frame_register(struct wiphy *wiphy,
3440
					  struct wireless_dev *wdev,
3441 3442 3443 3444
					  u16 frame_type, bool reg)
{
	struct ieee80211_local *local = wiphy_priv(wiphy);

3445 3446 3447 3448 3449 3450
	switch (frame_type) {
	case IEEE80211_FTYPE_MGMT | IEEE80211_STYPE_PROBE_REQ:
		if (reg)
			local->probe_req_reg++;
		else
			local->probe_req_reg--;
3451

3452 3453 3454
		if (!local->open_count)
			break;

3455 3456 3457 3458 3459
		ieee80211_queue_work(&local->hw, &local->reconfig_filter);
		break;
	default:
		break;
	}
3460 3461
}

3462 3463 3464 3465 3466 3467 3468 3469 3470 3471 3472 3473 3474 3475 3476 3477 3478
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);
}

3479 3480 3481 3482 3483 3484 3485 3486 3487 3488 3489 3490 3491 3492 3493
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);
}

3494 3495 3496 3497 3498 3499 3500 3501 3502 3503 3504 3505 3506 3507 3508
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;
}

3509 3510 3511 3512 3513 3514 3515 3516 3517 3518 3519 3520 3521 3522 3523 3524 3525 3526 3527
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 已提交
3528
	if (ieee80211_get_sdata_band(sdata) != IEEE80211_BAND_2GHZ)
3529 3530 3531 3532 3533 3534 3535 3536 3537 3538 3539 3540 3541 3542 3543 3544 3545 3546 3547 3548 3549 3550 3551 3552 3553 3554 3555 3556 3557 3558 3559
		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 已提交
3560
	enum ieee80211_band band = ieee80211_get_sdata_band(sdata);
3561 3562 3563 3564 3565 3566 3567 3568 3569 3570 3571 3572 3573 3574 3575 3576 3577 3578 3579
	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 已提交
3580 3581
		ieee80211_add_srates_ie(sdata, skb, false, band);
		ieee80211_add_ext_srates_ie(sdata, skb, false, band);
3582 3583 3584 3585 3586 3587 3588 3589 3590 3591 3592 3593
		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 已提交
3594 3595
		ieee80211_add_srates_ie(sdata, skb, false, band);
		ieee80211_add_ext_srates_ie(sdata, skb, false, band);
3596 3597 3598 3599 3600 3601 3602 3603 3604 3605 3606 3607 3608 3609 3610 3611 3612 3613 3614 3615 3616 3617 3618 3619 3620 3621 3622 3623 3624 3625 3626 3627 3628 3629 3630 3631 3632
		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 已提交
3633
	enum ieee80211_band band = ieee80211_get_sdata_band(sdata);
3634 3635 3636 3637 3638 3639 3640 3641 3642 3643 3644 3645 3646 3647 3648 3649 3650 3651 3652 3653 3654 3655
	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 已提交
3656 3657
		ieee80211_add_srates_ie(sdata, skb, false, band);
		ieee80211_add_ext_srates_ie(sdata, skb, false, band);
3658 3659 3660 3661 3662 3663 3664 3665 3666 3667 3668
		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,
3669 3670
			       u16 status_code, u32 peer_capability,
			       const u8 *extra_ies, size_t extra_ies_len)
3671 3672 3673 3674 3675 3676 3677 3678 3679 3680 3681 3682 3683 3684 3685
{
	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 已提交
3686 3687
	tdls_dbg(sdata, "TDLS mgmt action %d peer %pM\n",
		 action_code, peer);
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 3748 3749 3750 3751 3752 3753 3754 3755 3756 3757 3758 3759 3760 3761 3762 3763 3764 3765 3766 3767 3768 3769 3770 3771 3772 3773 3774 3775 3776 3777 3778 3779 3780 3781 3782 3783 3784 3785

	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)
{
3786
	struct sta_info *sta;
3787 3788 3789 3790 3791 3792 3793 3794
	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 已提交
3795
	tdls_dbg(sdata, "TDLS oper %d peer %pM\n", oper, peer);
3796 3797 3798

	switch (oper) {
	case NL80211_TDLS_ENABLE_LINK:
3799 3800 3801 3802 3803 3804 3805
		rcu_read_lock();
		sta = sta_info_get(sdata, peer);
		if (!sta) {
			rcu_read_unlock();
			return -ENOLINK;
		}

J
Johannes Berg 已提交
3806
		set_sta_flag(sta, WLAN_STA_TDLS_PEER_AUTH);
3807
		rcu_read_unlock();
3808 3809 3810 3811 3812 3813 3814 3815 3816 3817 3818 3819 3820 3821 3822
		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 已提交
3823 3824 3825 3826 3827 3828 3829 3830 3831 3832 3833 3834
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 已提交
3835 3836
	struct ieee80211_chanctx_conf *chanctx_conf;
	enum ieee80211_band band;
J
Johannes Berg 已提交
3837 3838

	rcu_read_lock();
J
Johannes Berg 已提交
3839 3840 3841 3842 3843
	chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf);
	if (WARN_ON(!chanctx_conf)) {
		rcu_read_unlock();
		return -EINVAL;
	}
3844
	band = chanctx_conf->def.chan->band;
3845
	sta = sta_info_get_bss(sdata, peer);
3846
	if (sta) {
J
Johannes Berg 已提交
3847
		qos = test_sta_flag(sta, WLAN_STA_WME);
3848 3849
	} else {
		rcu_read_unlock();
J
Johannes Berg 已提交
3850
		return -ENOLINK;
3851
	}
J
Johannes Berg 已提交
3852 3853 3854 3855 3856 3857 3858 3859 3860 3861 3862 3863 3864

	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 已提交
3865 3866
	if (!skb) {
		rcu_read_unlock();
J
Johannes Berg 已提交
3867
		return -ENOMEM;
J
Johannes Berg 已提交
3868
	}
J
Johannes Berg 已提交
3869 3870 3871 3872 3873 3874 3875 3876 3877 3878 3879 3880 3881 3882 3883 3884 3885 3886 3887 3888 3889 3890 3891 3892

	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 已提交
3893
	ieee80211_xmit(sdata, skb, band);
J
Johannes Berg 已提交
3894
	local_bh_enable();
J
Johannes Berg 已提交
3895
	rcu_read_unlock();
J
Johannes Berg 已提交
3896 3897 3898 3899 3900

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

3901 3902 3903
static int ieee80211_cfg_get_channel(struct wiphy *wiphy,
				     struct wireless_dev *wdev,
				     struct cfg80211_chan_def *chandef)
3904
{
J
Johannes Berg 已提交
3905
	struct ieee80211_sub_if_data *sdata = IEEE80211_WDEV_TO_SUB_IF(wdev);
3906
	struct ieee80211_local *local = wiphy_priv(wiphy);
J
Johannes Berg 已提交
3907
	struct ieee80211_chanctx_conf *chanctx_conf;
3908
	int ret = -ENODATA;
J
Johannes Berg 已提交
3909 3910

	rcu_read_lock();
3911 3912 3913 3914 3915 3916 3917 3918 3919 3920
	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
3921
			*chandef = local->_oper_chandef;
3922
		ret = 0;
J
Johannes Berg 已提交
3923 3924
	}
	rcu_read_unlock();
3925

3926
	return ret;
3927 3928
}

3929 3930 3931 3932 3933 3934 3935
#ifdef CONFIG_PM
static void ieee80211_set_wakeup(struct wiphy *wiphy, bool enabled)
{
	drv_set_wakeup(wiphy_priv(wiphy), enabled);
}
#endif

3936 3937 3938 3939 3940 3941 3942 3943 3944 3945 3946 3947 3948 3949 3950 3951 3952
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;
	}

3953
	old_qos_map = sdata_dereference(sdata->qos_map, sdata);
3954 3955 3956 3957 3958 3959 3960
	rcu_assign_pointer(sdata->qos_map, new_qos_map);
	if (old_qos_map)
		kfree_rcu(old_qos_map, rcu_head);

	return 0;
}

3961
const struct cfg80211_ops mac80211_config_ops = {
3962 3963
	.add_virtual_intf = ieee80211_add_iface,
	.del_virtual_intf = ieee80211_del_iface,
3964
	.change_virtual_intf = ieee80211_change_iface,
3965 3966
	.start_p2p_device = ieee80211_start_p2p_device,
	.stop_p2p_device = ieee80211_stop_p2p_device,
3967 3968
	.add_key = ieee80211_add_key,
	.del_key = ieee80211_del_key,
3969
	.get_key = ieee80211_get_key,
3970
	.set_default_key = ieee80211_config_default_key,
3971
	.set_default_mgmt_key = ieee80211_config_default_mgmt_key,
3972 3973 3974
	.start_ap = ieee80211_start_ap,
	.change_beacon = ieee80211_change_beacon,
	.stop_ap = ieee80211_stop_ap,
3975 3976 3977
	.add_station = ieee80211_add_station,
	.del_station = ieee80211_del_station,
	.change_station = ieee80211_change_station,
3978
	.get_station = ieee80211_get_station,
3979
	.dump_station = ieee80211_dump_station,
3980
	.dump_survey = ieee80211_dump_survey,
3981 3982 3983 3984 3985 3986
#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,
3987 3988
	.update_mesh_config = ieee80211_update_mesh_config,
	.get_mesh_config = ieee80211_get_mesh_config,
3989 3990
	.join_mesh = ieee80211_join_mesh,
	.leave_mesh = ieee80211_leave_mesh,
3991
#endif
3992
	.change_bss = ieee80211_change_bss,
3993
	.set_txq_params = ieee80211_set_txq_params,
3994
	.set_monitor_channel = ieee80211_set_monitor_channel,
3995 3996
	.suspend = ieee80211_suspend,
	.resume = ieee80211_resume,
3997
	.scan = ieee80211_scan,
3998 3999
	.sched_scan_start = ieee80211_sched_scan_start,
	.sched_scan_stop = ieee80211_sched_scan_stop,
4000 4001 4002 4003
	.auth = ieee80211_auth,
	.assoc = ieee80211_assoc,
	.deauth = ieee80211_deauth,
	.disassoc = ieee80211_disassoc,
4004 4005
	.join_ibss = ieee80211_join_ibss,
	.leave_ibss = ieee80211_leave_ibss,
4006
	.set_mcast_rate = ieee80211_set_mcast_rate,
4007
	.set_wiphy_params = ieee80211_set_wiphy_params,
4008 4009
	.set_tx_power = ieee80211_set_tx_power,
	.get_tx_power = ieee80211_get_tx_power,
J
Johannes Berg 已提交
4010
	.set_wds_peer = ieee80211_set_wds_peer,
J
Johannes Berg 已提交
4011
	.rfkill_poll = ieee80211_rfkill_poll,
4012
	CFG80211_TESTMODE_CMD(ieee80211_testmode_cmd)
W
Wey-Yi Guy 已提交
4013
	CFG80211_TESTMODE_DUMP(ieee80211_testmode_dump)
J
Johannes Berg 已提交
4014
	.set_power_mgmt = ieee80211_set_power_mgmt,
J
Johannes Berg 已提交
4015
	.set_bitrate_mask = ieee80211_set_bitrate_mask,
4016 4017
	.remain_on_channel = ieee80211_remain_on_channel,
	.cancel_remain_on_channel = ieee80211_cancel_remain_on_channel,
4018
	.mgmt_tx = ieee80211_mgmt_tx,
4019
	.mgmt_tx_cancel_wait = ieee80211_mgmt_tx_cancel_wait,
4020
	.set_cqm_rssi_config = ieee80211_set_cqm_rssi_config,
4021
	.mgmt_frame_register = ieee80211_mgmt_frame_register,
4022 4023
	.set_antenna = ieee80211_set_antenna,
	.get_antenna = ieee80211_get_antenna,
4024 4025
	.set_ringparam = ieee80211_set_ringparam,
	.get_ringparam = ieee80211_get_ringparam,
4026
	.set_rekey_data = ieee80211_set_rekey_data,
4027 4028
	.tdls_oper = ieee80211_tdls_oper,
	.tdls_mgmt = ieee80211_tdls_mgmt,
J
Johannes Berg 已提交
4029
	.probe_client = ieee80211_probe_client,
4030
	.set_noack_map = ieee80211_set_noack_map,
4031 4032 4033
#ifdef CONFIG_PM
	.set_wakeup = ieee80211_set_wakeup,
#endif
4034 4035 4036
	.get_et_sset_count = ieee80211_get_et_sset_count,
	.get_et_stats = ieee80211_get_et_stats,
	.get_et_strings = ieee80211_get_et_strings,
4037
	.get_channel = ieee80211_cfg_get_channel,
4038
	.start_radar_detection = ieee80211_start_radar_detection,
4039
	.channel_switch = ieee80211_channel_switch,
4040
	.set_qos_map = ieee80211_set_qos_map,
4041
};