cfg.c 66.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 25 26
static struct net_device *ieee80211_add_iface(struct wiphy *wiphy, char *name,
					      enum nl80211_iftype type,
					      u32 *flags,
					      struct vif_params *params)
27 28
{
	struct ieee80211_local *local = wiphy_priv(wiphy);
29 30 31
	struct net_device *dev;
	struct ieee80211_sub_if_data *sdata;
	int err;
32

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

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

	return dev;
43 44
}

45
static int ieee80211_del_iface(struct wiphy *wiphy, struct net_device *dev)
46
{
47
	ieee80211_if_remove(IEEE80211_DEV_TO_SUB_IF(dev));
48

49
	return 0;
50 51
}

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

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

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

71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100
	if (sdata->vif.type == NL80211_IFTYPE_MONITOR && flags) {
		struct ieee80211_local *local = sdata->local;

		if (ieee80211_sdata_running(sdata)) {
			/*
			 * Prohibit MONITOR_FLAG_COOK_FRAMES to be
			 * changed while the interface is up.
			 * Else we would need to add a lot of cruft
			 * to update everything:
			 *	cooked_mntrs, monitor and all fif_* counters
			 *	reconfigure hardware
			 */
			if ((*flags & MONITOR_FLAG_COOK_FRAMES) !=
			    (sdata->u.mntr_flags & MONITOR_FLAG_COOK_FRAMES))
				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;
		}
	}
101

102 103 104
	return 0;
}

105
static int ieee80211_add_key(struct wiphy *wiphy, struct net_device *dev,
106
			     u8 key_idx, bool pairwise, const u8 *mac_addr,
107 108
			     struct key_params *params)
{
109
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
110
	struct sta_info *sta = NULL;
111
	struct ieee80211_key *key;
112
	int err;
113

114
	if (!ieee80211_sdata_running(sdata))
J
Johannes Berg 已提交
115 116
		return -ENETDOWN;

117
	/* reject WEP and TKIP keys if WEP failed to initialize */
118 119 120
	switch (params->cipher) {
	case WLAN_CIPHER_SUITE_WEP40:
	case WLAN_CIPHER_SUITE_TKIP:
121 122 123
	case WLAN_CIPHER_SUITE_WEP104:
		if (IS_ERR(sdata->local->wep_tx_tfm))
			return -EINVAL;
124
		break;
125
	default:
126
		break;
127 128
	}

129 130
	key = ieee80211_key_alloc(params->cipher, key_idx, params->key_len,
				  params->key, params->seq_len, params->seq);
131 132
	if (IS_ERR(key))
		return PTR_ERR(key);
133

134 135 136
	if (pairwise)
		key->conf.flags |= IEEE80211_KEY_FLAG_PAIRWISE;

J
Johannes Berg 已提交
137
	mutex_lock(&sdata->local->sta_mtx);
138

139
	if (mac_addr) {
140 141 142 143
		if (ieee80211_vif_is_mesh(&sdata->vif))
			sta = sta_info_get(sdata, mac_addr);
		else
			sta = sta_info_get_bss(sdata, mac_addr);
144
		if (!sta) {
145
			ieee80211_key_free(sdata->local, key);
146 147
			err = -ENOENT;
			goto out_unlock;
148
		}
149 150
	}

151 152 153
	err = ieee80211_key_link(key, sdata, sta);
	if (err)
		ieee80211_key_free(sdata->local, key);
154

155
 out_unlock:
J
Johannes Berg 已提交
156
	mutex_unlock(&sdata->local->sta_mtx);
157 158

	return err;
159 160 161
}

static int ieee80211_del_key(struct wiphy *wiphy, struct net_device *dev,
162
			     u8 key_idx, bool pairwise, const u8 *mac_addr)
163
{
164 165
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
	struct ieee80211_local *local = sdata->local;
166
	struct sta_info *sta;
167
	struct ieee80211_key *key = NULL;
168 169
	int ret;

170 171
	mutex_lock(&local->sta_mtx);
	mutex_lock(&local->key_mtx);
172

173
	if (mac_addr) {
174 175
		ret = -ENOENT;

176
		sta = sta_info_get_bss(sdata, mac_addr);
177
		if (!sta)
178
			goto out_unlock;
179

180
		if (pairwise)
J
Johannes Berg 已提交
181
			key = key_mtx_dereference(local, sta->ptk);
182
		else
J
Johannes Berg 已提交
183
			key = key_mtx_dereference(local, sta->gtk[key_idx]);
184
	} else
J
Johannes Berg 已提交
185
		key = key_mtx_dereference(local, sdata->keys[key_idx]);
186

187
	if (!key) {
188 189 190
		ret = -ENOENT;
		goto out_unlock;
	}
191

192
	__ieee80211_key_free(key);
193

194 195
	ret = 0;
 out_unlock:
196 197
	mutex_unlock(&local->key_mtx);
	mutex_unlock(&local->sta_mtx);
198 199

	return ret;
200 201
}

202
static int ieee80211_get_key(struct wiphy *wiphy, struct net_device *dev,
203 204
			     u8 key_idx, bool pairwise, const u8 *mac_addr,
			     void *cookie,
205 206 207
			     void (*callback)(void *cookie,
					      struct key_params *params))
{
208
	struct ieee80211_sub_if_data *sdata;
209 210 211
	struct sta_info *sta = NULL;
	u8 seq[6] = {0};
	struct key_params params;
212
	struct ieee80211_key *key = NULL;
J
Johannes Berg 已提交
213
	u64 pn64;
214 215 216 217
	u32 iv32;
	u16 iv16;
	int err = -ENOENT;

218 219
	sdata = IEEE80211_DEV_TO_SUB_IF(dev);

220 221
	rcu_read_lock();

222
	if (mac_addr) {
223
		sta = sta_info_get_bss(sdata, mac_addr);
224 225 226
		if (!sta)
			goto out;

227
		if (pairwise)
J
Johannes Berg 已提交
228
			key = rcu_dereference(sta->ptk);
229
		else if (key_idx < NUM_DEFAULT_KEYS)
J
Johannes Berg 已提交
230
			key = rcu_dereference(sta->gtk[key_idx]);
231
	} else
J
Johannes Berg 已提交
232
		key = rcu_dereference(sdata->keys[key_idx]);
233 234 235 236 237 238

	if (!key)
		goto out;

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

239
	params.cipher = key->conf.cipher;
240

241 242
	switch (key->conf.cipher) {
	case WLAN_CIPHER_SUITE_TKIP:
243 244
		iv32 = key->u.tkip.tx.iv32;
		iv16 = key->u.tkip.tx.iv16;
245

246 247 248 249
		if (key->flags & KEY_FLAG_UPLOADED_TO_HARDWARE)
			drv_get_tkip_seq(sdata->local,
					 key->conf.hw_key_idx,
					 &iv32, &iv16);
250 251 252 253 254 255 256 257 258 259

		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;
260
	case WLAN_CIPHER_SUITE_CCMP:
J
Johannes Berg 已提交
261 262 263 264 265 266 267
		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;
268 269 270
		params.seq = seq;
		params.seq_len = 6;
		break;
271
	case WLAN_CIPHER_SUITE_AES_CMAC:
J
Johannes Berg 已提交
272 273 274 275 276 277 278
		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;
279 280 281
		params.seq = seq;
		params.seq_len = 6;
		break;
282 283 284 285 286 287 288 289 290
	}

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

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

 out:
291
	rcu_read_unlock();
292 293 294
	return err;
}

295 296
static int ieee80211_config_default_key(struct wiphy *wiphy,
					struct net_device *dev,
297 298
					u8 key_idx, bool uni,
					bool multi)
299
{
J
Johannes Berg 已提交
300
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
301

302
	ieee80211_set_default_key(sdata, key_idx, uni, multi);
303 304 305 306

	return 0;
}

307 308 309 310
static int ieee80211_config_default_mgmt_key(struct wiphy *wiphy,
					     struct net_device *dev,
					     u8 key_idx)
{
311
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
312 313 314 315 316 317

	ieee80211_set_default_mgmt_key(sdata, key_idx);

	return 0;
}

318 319 320 321 322 323 324 325 326 327 328
static void rate_idx_to_bitrate(struct rate_info *rate, struct sta_info *sta, int idx)
{
	if (!(rate->flags & RATE_INFO_FLAGS_MCS)) {
		struct ieee80211_supported_band *sband;
		sband = sta->local->hw.wiphy->bands[
				sta->local->hw.conf.channel->band];
		rate->legacy = sband->bitrates[idx].bitrate;
	} else
		rate->mcs = idx;
}

329 330
static void sta_set_sinfo(struct sta_info *sta, struct station_info *sinfo)
{
331
	struct ieee80211_sub_if_data *sdata = sta->sdata;
332
	struct timespec uptime;
333

334 335
	sinfo->generation = sdata->local->sta_generation;

336 337
	sinfo->filled = STATION_INFO_INACTIVE_TIME |
			STATION_INFO_RX_BYTES |
338
			STATION_INFO_TX_BYTES |
339 340
			STATION_INFO_RX_PACKETS |
			STATION_INFO_TX_PACKETS |
341 342
			STATION_INFO_TX_RETRIES |
			STATION_INFO_TX_FAILED |
343
			STATION_INFO_TX_BITRATE |
344
			STATION_INFO_RX_BITRATE |
345
			STATION_INFO_RX_DROP_MISC |
346
			STATION_INFO_BSS_PARAM |
347 348
			STATION_INFO_CONNECTED_TIME |
			STATION_INFO_STA_FLAGS;
349 350 351

	do_posix_clock_monotonic_gettime(&uptime);
	sinfo->connected_time = uptime.tv_sec - sta->last_connected;
352 353 354 355

	sinfo->inactive_time = jiffies_to_msecs(jiffies - sta->last_rx);
	sinfo->rx_bytes = sta->rx_bytes;
	sinfo->tx_bytes = sta->tx_bytes;
356 357
	sinfo->rx_packets = sta->rx_packets;
	sinfo->tx_packets = sta->tx_packets;
358 359
	sinfo->tx_retries = sta->tx_retry_count;
	sinfo->tx_failed = sta->tx_retry_failed;
360
	sinfo->rx_dropped_misc = sta->rx_dropped;
361

362 363
	if ((sta->local->hw.flags & IEEE80211_HW_SIGNAL_DBM) ||
	    (sta->local->hw.flags & IEEE80211_HW_SIGNAL_UNSPEC)) {
364
		sinfo->filled |= STATION_INFO_SIGNAL | STATION_INFO_SIGNAL_AVG;
365
		sinfo->signal = (s8)sta->last_signal;
366
		sinfo->signal_avg = (s8) -ewma_read(&sta->avg_signal);
367 368 369 370 371 372 373 374 375
	}

	sinfo->txrate.flags = 0;
	if (sta->last_tx_rate.flags & IEEE80211_TX_RC_MCS)
		sinfo->txrate.flags |= RATE_INFO_FLAGS_MCS;
	if (sta->last_tx_rate.flags & IEEE80211_TX_RC_40_MHZ_WIDTH)
		sinfo->txrate.flags |= RATE_INFO_FLAGS_40_MHZ_WIDTH;
	if (sta->last_tx_rate.flags & IEEE80211_TX_RC_SHORT_GI)
		sinfo->txrate.flags |= RATE_INFO_FLAGS_SHORT_GI;
376 377 378 379 380 381 382 383 384 385
	rate_idx_to_bitrate(&sinfo->txrate, sta, sta->last_tx_rate.idx);

	sinfo->rxrate.flags = 0;
	if (sta->last_rx_rate_flag & RX_FLAG_HT)
		sinfo->rxrate.flags |= RATE_INFO_FLAGS_MCS;
	if (sta->last_rx_rate_flag & RX_FLAG_40MHZ)
		sinfo->rxrate.flags |= RATE_INFO_FLAGS_40_MHZ_WIDTH;
	if (sta->last_rx_rate_flag & RX_FLAG_SHORT_GI)
		sinfo->rxrate.flags |= RATE_INFO_FLAGS_SHORT_GI;
	rate_idx_to_bitrate(&sinfo->rxrate, sta, sta->last_rx_rate_idx);
386

J
Johannes Berg 已提交
387
	if (ieee80211_vif_is_mesh(&sdata->vif)) {
388 389 390 391 392 393 394 395 396
#ifdef CONFIG_MAC80211_MESH
		sinfo->filled |= STATION_INFO_LLID |
				 STATION_INFO_PLID |
				 STATION_INFO_PLINK_STATE;

		sinfo->llid = le16_to_cpu(sta->llid);
		sinfo->plid = le16_to_cpu(sta->plid);
		sinfo->plink_state = sta->plink_state;
#endif
J
Johannes Berg 已提交
397
	}
398 399 400 401 402 403 404 405 406 407

	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;
408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424

	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) |
				BIT(NL80211_STA_FLAG_AUTHENTICATED);
	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);
425 426 427 428 429 430
}


static int ieee80211_dump_station(struct wiphy *wiphy, struct net_device *dev,
				 int idx, u8 *mac, struct station_info *sinfo)
{
431
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
432
	struct sta_info *sta;
433 434 435
	int ret = -ENOENT;

	rcu_read_lock();
436

437
	sta = sta_info_get_by_idx(sdata, idx);
438 439
	if (sta) {
		ret = 0;
440
		memcpy(mac, sta->sta.addr, ETH_ALEN);
441 442
		sta_set_sinfo(sta, sinfo);
	}
443

444
	rcu_read_unlock();
445

446
	return ret;
447 448
}

449 450 451 452 453 454 455 456
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);
}

457
static int ieee80211_get_station(struct wiphy *wiphy, struct net_device *dev,
458
				 u8 *mac, struct station_info *sinfo)
459
{
460
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
461
	struct sta_info *sta;
462
	int ret = -ENOENT;
463

464
	rcu_read_lock();
465

466
	sta = sta_info_get_bss(sdata, mac);
467 468 469 470 471 472 473 474
	if (sta) {
		ret = 0;
		sta_set_sinfo(sta, sinfo);
	}

	rcu_read_unlock();

	return ret;
475 476
}

477 478 479 480 481 482 483 484 485 486 487 488 489 490
static void ieee80211_config_ap_ssid(struct ieee80211_sub_if_data *sdata,
				     struct beacon_parameters *params)
{
	struct ieee80211_bss_conf *bss_conf = &sdata->vif.bss_conf;

	bss_conf->ssid_len = params->ssid_len;

	if (params->ssid_len)
		memcpy(bss_conf->ssid, params->ssid, params->ssid_len);

	bss_conf->hidden_ssid =
		(params->hidden_ssid != NL80211_HIDDEN_SSID_NOT_IN_USE);
}

491 492 493 494 495 496 497 498 499 500 501
/*
 * This handles both adding a beacon and setting new beacon info
 */
static int ieee80211_config_beacon(struct ieee80211_sub_if_data *sdata,
				   struct beacon_parameters *params)
{
	struct beacon_data *new, *old;
	int new_head_len, new_tail_len;
	int size;
	int err = -EINVAL;

J
Johannes Berg 已提交
502
	old = rtnl_dereference(sdata->u.ap.beacon);
503 504 505 506 507 508 509 510 511

	/* head must not be zero-length */
	if (params->head && !params->head_len)
		return -EINVAL;

	/*
	 * This is a kludge. beacon interval should really be part
	 * of the beacon information.
	 */
512 513 514 515 516
	if (params->interval &&
	    (sdata->vif.bss_conf.beacon_int != params->interval)) {
		sdata->vif.bss_conf.beacon_int = params->interval;
		ieee80211_bss_info_change_notify(sdata,
						 BSS_CHANGED_BEACON_INT);
517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575
	}

	/* Need to have a beacon head if we don't have one yet */
	if (!params->head && !old)
		return err;

	/* sorry, no way to start beaconing without dtim period */
	if (!params->dtim_period && !old)
		return err;

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

	/* new or old dtim period? */
	if (params->dtim_period)
		new->dtim_period = params->dtim_period;
	else
		new->dtim_period = old->dtim_period;

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

576 577
	sdata->vif.bss_conf.dtim_period = new->dtim_period;

578
	RCU_INIT_POINTER(sdata->u.ap.beacon, new);
579 580 581 582 583

	synchronize_rcu();

	kfree(old);

584 585
	ieee80211_config_ap_ssid(sdata, params);

586
	ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_BEACON_ENABLED |
587 588
						BSS_CHANGED_BEACON |
						BSS_CHANGED_SSID);
589
	return 0;
590 591 592 593 594
}

static int ieee80211_add_beacon(struct wiphy *wiphy, struct net_device *dev,
				struct beacon_parameters *params)
{
595
	struct ieee80211_sub_if_data *sdata;
596
	struct beacon_data *old;
597 598
	struct ieee80211_sub_if_data *vlan;
	int ret;
599

600 601
	sdata = IEEE80211_DEV_TO_SUB_IF(dev);

J
Johannes Berg 已提交
602
	old = rtnl_dereference(sdata->u.ap.beacon);
603 604 605
	if (old)
		return -EALREADY;

606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623
	ret = ieee80211_config_beacon(sdata, params);
	if (ret)
		return ret;

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

	return 0;
624 625 626 627 628
}

static int ieee80211_set_beacon(struct wiphy *wiphy, struct net_device *dev,
				struct beacon_parameters *params)
{
629
	struct ieee80211_sub_if_data *sdata;
630 631
	struct beacon_data *old;

632 633
	sdata = IEEE80211_DEV_TO_SUB_IF(dev);

J
Johannes Berg 已提交
634
	old = rtnl_dereference(sdata->u.ap.beacon);
635 636 637 638 639 640 641 642
	if (!old)
		return -ENOENT;

	return ieee80211_config_beacon(sdata, params);
}

static int ieee80211_del_beacon(struct wiphy *wiphy, struct net_device *dev)
{
643
	struct ieee80211_sub_if_data *sdata;
644 645
	struct beacon_data *old;

646 647
	sdata = IEEE80211_DEV_TO_SUB_IF(dev);

J
Johannes Berg 已提交
648
	old = rtnl_dereference(sdata->u.ap.beacon);
649 650 651
	if (!old)
		return -ENOENT;

652
	RCU_INIT_POINTER(sdata->u.ap.beacon, NULL);
653 654 655
	synchronize_rcu();
	kfree(old);

656 657
	ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_BEACON_ENABLED);
	return 0;
658 659
}

660 661 662 663 664 665 666 667 668
/* 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 已提交
669
} __packed;
670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687

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

	memset(msg->da, 0xff, ETH_ALEN);
688
	memcpy(msg->sa, sta->sta.addr, ETH_ALEN);
689 690 691 692 693 694 695 696 697
	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) */

698 699
	skb->dev = sta->sdata->dev;
	skb->protocol = eth_type_trans(skb, sta->sdata->dev);
700
	memset(skb->cb, 0, sizeof(skb->cb));
701
	netif_rx_ni(skb);
702 703 704 705 706 707 708 709
}

static void sta_apply_parameters(struct ieee80211_local *local,
				 struct sta_info *sta,
				 struct station_parameters *params)
{
	u32 rates;
	int i, j;
710
	struct ieee80211_supported_band *sband;
711
	struct ieee80211_sub_if_data *sdata = sta->sdata;
712
	u32 mask, set;
713

J
Johannes Berg 已提交
714 715
	sband = local->hw.wiphy->bands[local->oper_channel->band];

716 717
	mask = params->sta_flags_mask;
	set = params->sta_flags_set;
J
Johannes Berg 已提交
718

719 720
	if (mask & BIT(NL80211_STA_FLAG_AUTHORIZED)) {
		if (set & BIT(NL80211_STA_FLAG_AUTHORIZED))
J
Johannes Berg 已提交
721 722 723
			set_sta_flag(sta, WLAN_STA_AUTHORIZED);
		else
			clear_sta_flag(sta, WLAN_STA_AUTHORIZED);
724
	}
725

726 727
	if (mask & BIT(NL80211_STA_FLAG_SHORT_PREAMBLE)) {
		if (set & BIT(NL80211_STA_FLAG_SHORT_PREAMBLE))
J
Johannes Berg 已提交
728 729 730
			set_sta_flag(sta, WLAN_STA_SHORT_PREAMBLE);
		else
			clear_sta_flag(sta, WLAN_STA_SHORT_PREAMBLE);
731
	}
732

733
	if (mask & BIT(NL80211_STA_FLAG_WME)) {
734
		if (set & BIT(NL80211_STA_FLAG_WME)) {
J
Johannes Berg 已提交
735
			set_sta_flag(sta, WLAN_STA_WME);
736
			sta->sta.wme = true;
J
Johannes Berg 已提交
737 738 739
		} else {
			clear_sta_flag(sta, WLAN_STA_WME);
			sta->sta.wme = false;
740
		}
741
	}
742

743 744
	if (mask & BIT(NL80211_STA_FLAG_MFP)) {
		if (set & BIT(NL80211_STA_FLAG_MFP))
J
Johannes Berg 已提交
745 746 747
			set_sta_flag(sta, WLAN_STA_MFP);
		else
			clear_sta_flag(sta, WLAN_STA_MFP);
748
	}
749 750 751

	if (mask & BIT(NL80211_STA_FLAG_AUTHENTICATED)) {
		if (set & BIT(NL80211_STA_FLAG_AUTHENTICATED))
J
Johannes Berg 已提交
752 753 754
			set_sta_flag(sta, WLAN_STA_AUTH);
		else
			clear_sta_flag(sta, WLAN_STA_AUTH);
755
	}
756

757 758
	if (mask & BIT(NL80211_STA_FLAG_TDLS_PEER)) {
		if (set & BIT(NL80211_STA_FLAG_TDLS_PEER))
J
Johannes Berg 已提交
759 760 761
			set_sta_flag(sta, WLAN_STA_TDLS_PEER);
		else
			clear_sta_flag(sta, WLAN_STA_TDLS_PEER);
762
	}
763

764 765 766 767
	if (params->sta_modify_mask & STATION_PARAM_APPLY_UAPSD) {
		sta->sta.uapsd_queues = params->uapsd_queues;
		sta->sta.max_sp = params->max_sp;
	}
768

769 770 771 772 773 774 775
	/*
	 * 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 已提交
776 777 778 779 780 781 782
	/*
	 * FIXME: updating the following information is racy when this
	 *	  function is called from ieee80211_change_station().
	 *	  However, all this information should be static so
	 *	  maybe we should just reject attemps to change it.
	 */

783 784 785 786 787
	if (params->listen_interval >= 0)
		sta->listen_interval = params->listen_interval;

	if (params->supported_rates) {
		rates = 0;
788

789 790
		for (i = 0; i < params->supported_rates_len; i++) {
			int rate = (params->supported_rates[i] & 0x7f) * 5;
791 792
			for (j = 0; j < sband->n_bitrates; j++) {
				if (sband->bitrates[j].bitrate == rate)
793 794 795
					rates |= BIT(j);
			}
		}
J
Johannes Berg 已提交
796
		sta->sta.supp_rates[local->oper_channel->band] = rates;
797
	}
798

J
Johannes Berg 已提交
799
	if (params->ht_capa)
J
Johannes Berg 已提交
800 801
		ieee80211_ht_cap_ie_to_sta_ht_cap(sband,
						  params->ht_capa,
J
Johannes Berg 已提交
802
						  &sta->sta.ht_cap);
803

804
	if (ieee80211_vif_is_mesh(&sdata->vif)) {
805
#ifdef CONFIG_MAC80211_MESH
806 807
		if (sdata->u.mesh.security & IEEE80211_MESH_SEC_SECURED)
			switch (params->plink_state) {
808 809 810
			case NL80211_PLINK_LISTEN:
			case NL80211_PLINK_ESTAB:
			case NL80211_PLINK_BLOCKED:
811 812 813 814 815 816 817 818 819 820 821 822 823 824 825
				sta->plink_state = params->plink_state;
				break;
			default:
				/*  nothing  */
				break;
			}
		else
			switch (params->plink_action) {
			case PLINK_ACTION_OPEN:
				mesh_plink_open(sta);
				break;
			case PLINK_ACTION_BLOCK:
				mesh_plink_block(sta);
				break;
			}
826
#endif
J
Johannes Berg 已提交
827
	}
828 829 830 831 832
}

static int ieee80211_add_station(struct wiphy *wiphy, struct net_device *dev,
				 u8 *mac, struct station_parameters *params)
{
833
	struct ieee80211_local *local = wiphy_priv(wiphy);
834 835
	struct sta_info *sta;
	struct ieee80211_sub_if_data *sdata;
J
Johannes Berg 已提交
836
	int err;
837
	int layer2_update;
838 839 840 841

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

842 843
		if (sdata->vif.type != NL80211_IFTYPE_AP_VLAN &&
		    sdata->vif.type != NL80211_IFTYPE_AP)
844 845 846 847
			return -EINVAL;
	} else
		sdata = IEEE80211_DEV_TO_SUB_IF(dev);

848
	if (compare_ether_addr(mac, sdata->vif.addr) == 0)
849 850 851 852 853
		return -EINVAL;

	if (is_multicast_ether_addr(mac))
		return -EINVAL;

854 855 856 857 858 859
	/* Only TDLS-supporting stations can add TDLS peers */
	if ((params->sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER)) &&
	    !((wiphy->flags & WIPHY_FLAG_SUPPORTS_TDLS) &&
	      sdata->vif.type == NL80211_IFTYPE_STATION))
		return -ENOTSUPP;

860
	sta = sta_info_alloc(sdata, mac, GFP_KERNEL);
J
Johannes Berg 已提交
861 862
	if (!sta)
		return -ENOMEM;
863

J
Johannes Berg 已提交
864 865
	set_sta_flag(sta, WLAN_STA_AUTH);
	set_sta_flag(sta, WLAN_STA_ASSOC);
866 867 868

	sta_apply_parameters(local, sta, params);

869
	rate_control_rate_init(sta);
870

871 872 873
	layer2_update = sdata->vif.type == NL80211_IFTYPE_AP_VLAN ||
		sdata->vif.type == NL80211_IFTYPE_AP;

874
	err = sta_info_insert_rcu(sta);
J
Johannes Berg 已提交
875 876 877 878 879
	if (err) {
		rcu_read_unlock();
		return err;
	}

880
	if (layer2_update)
J
Johannes Berg 已提交
881 882 883 884
		ieee80211_send_layer2_update(sta);

	rcu_read_unlock();

885 886 887 888 889 890
	return 0;
}

static int ieee80211_del_station(struct wiphy *wiphy, struct net_device *dev,
				 u8 *mac)
{
891 892
	struct ieee80211_local *local = wiphy_priv(wiphy);
	struct ieee80211_sub_if_data *sdata;
893

894 895
	sdata = IEEE80211_DEV_TO_SUB_IF(dev);

896 897
	if (mac)
		return sta_info_destroy_addr_bss(sdata, mac);
898

899
	sta_info_flush(local, sdata);
900 901 902 903 904 905 906 907
	return 0;
}

static int ieee80211_change_station(struct wiphy *wiphy,
				    struct net_device *dev,
				    u8 *mac,
				    struct station_parameters *params)
{
908
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
909
	struct ieee80211_local *local = wiphy_priv(wiphy);
910 911 912
	struct sta_info *sta;
	struct ieee80211_sub_if_data *vlansdata;

J
Johannes Berg 已提交
913 914
	rcu_read_lock();

915
	sta = sta_info_get_bss(sdata, mac);
J
Johannes Berg 已提交
916 917
	if (!sta) {
		rcu_read_unlock();
918
		return -ENOENT;
J
Johannes Berg 已提交
919
	}
920

921 922 923
	/* The TDLS bit cannot be toggled after the STA was added */
	if ((params->sta_flags_mask & BIT(NL80211_STA_FLAG_TDLS_PEER)) &&
	    !!(params->sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER)) !=
J
Johannes Berg 已提交
924
	    !!test_sta_flag(sta, WLAN_STA_TDLS_PEER)) {
925 926 927 928
		rcu_read_unlock();
		return -EINVAL;
	}

929
	if (params->vlan && params->vlan != sta->sdata->dev) {
930 931
		vlansdata = IEEE80211_DEV_TO_SUB_IF(params->vlan);

932 933
		if (vlansdata->vif.type != NL80211_IFTYPE_AP_VLAN &&
		    vlansdata->vif.type != NL80211_IFTYPE_AP) {
J
Johannes Berg 已提交
934
			rcu_read_unlock();
935
			return -EINVAL;
J
Johannes Berg 已提交
936
		}
937

938
		if (params->vlan->ieee80211_ptr->use_4addr) {
J
Johannes Berg 已提交
939 940
			if (vlansdata->u.vlan.sta) {
				rcu_read_unlock();
941
				return -EBUSY;
J
Johannes Berg 已提交
942
			}
943

944
			RCU_INIT_POINTER(vlansdata->u.vlan.sta, sta);
945 946
		}

947
		sta->sdata = vlansdata;
948 949 950 951 952
		ieee80211_send_layer2_update(sta);
	}

	sta_apply_parameters(local, sta, params);

J
Johannes Berg 已提交
953 954
	rcu_read_unlock();

955 956 957 958
	if (sdata->vif.type == NL80211_IFTYPE_STATION &&
	    params->sta_flags_mask & BIT(NL80211_STA_FLAG_AUTHORIZED))
		ieee80211_recalc_ps(local, -1);

959 960 961
	return 0;
}

962 963 964 965
#ifdef CONFIG_MAC80211_MESH
static int ieee80211_add_mpath(struct wiphy *wiphy, struct net_device *dev,
				 u8 *dst, u8 *next_hop)
{
966
	struct ieee80211_sub_if_data *sdata;
967 968 969 970
	struct mesh_path *mpath;
	struct sta_info *sta;
	int err;

971 972
	sdata = IEEE80211_DEV_TO_SUB_IF(dev);

973
	rcu_read_lock();
974
	sta = sta_info_get(sdata, next_hop);
975 976
	if (!sta) {
		rcu_read_unlock();
977
		return -ENOENT;
978
	}
979

980
	err = mesh_path_add(dst, sdata);
981 982
	if (err) {
		rcu_read_unlock();
983
		return err;
984
	}
985

986
	mpath = mesh_path_lookup(dst, sdata);
987 988 989 990 991
	if (!mpath) {
		rcu_read_unlock();
		return -ENXIO;
	}
	mesh_path_fix_nexthop(mpath, sta);
992

993 994 995 996 997 998 999
	rcu_read_unlock();
	return 0;
}

static int ieee80211_del_mpath(struct wiphy *wiphy, struct net_device *dev,
				 u8 *dst)
{
1000 1001
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);

1002
	if (dst)
1003
		return mesh_path_del(dst, sdata);
1004

1005
	mesh_path_flush_by_iface(sdata);
1006 1007 1008 1009 1010 1011 1012
	return 0;
}

static int ieee80211_change_mpath(struct wiphy *wiphy,
				    struct net_device *dev,
				    u8 *dst, u8 *next_hop)
{
1013
	struct ieee80211_sub_if_data *sdata;
1014 1015 1016
	struct mesh_path *mpath;
	struct sta_info *sta;

1017 1018
	sdata = IEEE80211_DEV_TO_SUB_IF(dev);

1019 1020
	rcu_read_lock();

1021
	sta = sta_info_get(sdata, next_hop);
1022 1023
	if (!sta) {
		rcu_read_unlock();
1024
		return -ENOENT;
1025
	}
1026

1027
	mpath = mesh_path_lookup(dst, sdata);
1028 1029 1030 1031 1032 1033
	if (!mpath) {
		rcu_read_unlock();
		return -ENOENT;
	}

	mesh_path_fix_nexthop(mpath, sta);
1034

1035 1036 1037 1038 1039 1040 1041
	rcu_read_unlock();
	return 0;
}

static void mpath_set_pinfo(struct mesh_path *mpath, u8 *next_hop,
			    struct mpath_info *pinfo)
{
J
Johannes Berg 已提交
1042 1043 1044 1045
	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);
1046 1047 1048
	else
		memset(next_hop, 0, ETH_ALEN);

1049 1050
	pinfo->generation = mesh_paths_generation;

1051
	pinfo->filled = MPATH_INFO_FRAME_QLEN |
1052
			MPATH_INFO_SN |
1053 1054 1055 1056 1057 1058 1059
			MPATH_INFO_METRIC |
			MPATH_INFO_EXPTIME |
			MPATH_INFO_DISCOVERY_TIMEOUT |
			MPATH_INFO_DISCOVERY_RETRIES |
			MPATH_INFO_FLAGS;

	pinfo->frame_qlen = mpath->frame_queue.qlen;
1060
	pinfo->sn = mpath->sn;
1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071
	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;
	pinfo->flags = 0;
	if (mpath->flags & MESH_PATH_ACTIVE)
		pinfo->flags |= NL80211_MPATH_FLAG_ACTIVE;
	if (mpath->flags & MESH_PATH_RESOLVING)
		pinfo->flags |= NL80211_MPATH_FLAG_RESOLVING;
1072 1073
	if (mpath->flags & MESH_PATH_SN_VALID)
		pinfo->flags |= NL80211_MPATH_FLAG_SN_VALID;
1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085
	if (mpath->flags & MESH_PATH_FIXED)
		pinfo->flags |= NL80211_MPATH_FLAG_FIXED;
	if (mpath->flags & MESH_PATH_RESOLVING)
		pinfo->flags |= NL80211_MPATH_FLAG_RESOLVING;

	pinfo->flags = mpath->flags;
}

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

{
1086
	struct ieee80211_sub_if_data *sdata;
1087 1088
	struct mesh_path *mpath;

1089 1090
	sdata = IEEE80211_DEV_TO_SUB_IF(dev);

1091
	rcu_read_lock();
1092
	mpath = mesh_path_lookup(dst, sdata);
1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106
	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)
{
1107
	struct ieee80211_sub_if_data *sdata;
1108 1109
	struct mesh_path *mpath;

1110 1111
	sdata = IEEE80211_DEV_TO_SUB_IF(dev);

1112
	rcu_read_lock();
1113
	mpath = mesh_path_lookup_by_idx(idx, sdata);
1114 1115 1116 1117 1118 1119 1120 1121 1122
	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;
}
1123

1124
static int ieee80211_get_mesh_config(struct wiphy *wiphy,
1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139
				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;
}

1140 1141 1142 1143 1144 1145
static int copy_mesh_setup(struct ieee80211_if_mesh *ifmsh,
		const struct mesh_setup *setup)
{
	u8 *new_ie;
	const u8 *old_ie;

1146
	/* allocate information elements */
1147
	new_ie = NULL;
1148
	old_ie = ifmsh->ie;
1149

1150 1151
	if (setup->ie_len) {
		new_ie = kmemdup(setup->ie, setup->ie_len,
1152 1153 1154 1155
				GFP_KERNEL);
		if (!new_ie)
			return -ENOMEM;
	}
1156 1157 1158
	ifmsh->ie_len = setup->ie_len;
	ifmsh->ie = new_ie;
	kfree(old_ie);
1159 1160 1161 1162 1163 1164

	/* 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);
	ifmsh->mesh_pp_id = setup->path_sel_proto;
	ifmsh->mesh_pm_id = setup->path_metric;
1165 1166 1167 1168 1169
	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;
1170 1171 1172 1173

	return 0;
}

1174
static int ieee80211_update_mesh_config(struct wiphy *wiphy,
1175 1176
					struct net_device *dev, u32 mask,
					const struct mesh_config *nconf)
1177 1178 1179
{
	struct mesh_config *conf;
	struct ieee80211_sub_if_data *sdata;
1180 1181
	struct ieee80211_if_mesh *ifmsh;

1182
	sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1183
	ifmsh = &sdata->u.mesh;
1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198

	/* 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;
1199 1200
	if (_chg_mesh_attr(NL80211_MESHCONF_ELEMENT_TTL, mask))
		conf->dot11MeshTTL = nconf->element_ttl;
1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219
	if (_chg_mesh_attr(NL80211_MESHCONF_AUTO_OPEN_PLINKS, mask))
		conf->auto_open_plinks = nconf->auto_open_plinks;
	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;
	if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME,
			   mask))
		conf->dot11MeshHWMPnetDiameterTraversalTime =
			nconf->dot11MeshHWMPnetDiameterTraversalTime;
1220 1221 1222 1223
	if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_ROOTMODE, mask)) {
		conf->dot11MeshHWMPRootMode = nconf->dot11MeshHWMPRootMode;
		ieee80211_mesh_root_setup(ifmsh);
	}
1224
	if (_chg_mesh_attr(NL80211_MESHCONF_GATE_ANNOUNCEMENTS, mask)) {
T
Thomas Pedersen 已提交
1225 1226 1227 1228 1229 1230 1231 1232
		/* our current gate announcement implementation rides on root
		 * announcements, so require this ifmsh to also be a root node
		 * */
		if (nconf->dot11MeshGateAnnouncementProtocol &&
		    !conf->dot11MeshHWMPRootMode) {
			conf->dot11MeshHWMPRootMode = 1;
			ieee80211_mesh_root_setup(ifmsh);
		}
1233 1234 1235
		conf->dot11MeshGateAnnouncementProtocol =
			nconf->dot11MeshGateAnnouncementProtocol;
	}
1236 1237 1238 1239
	if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_RANN_INTERVAL, mask)) {
		conf->dot11MeshHWMPRannInterval =
			nconf->dot11MeshHWMPRannInterval;
	}
1240 1241 1242
	return 0;
}

1243 1244 1245 1246 1247 1248
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;
1249
	int err;
1250

1251 1252 1253 1254
	memcpy(&ifmsh->mshcfg, conf, sizeof(struct mesh_config));
	err = copy_mesh_setup(ifmsh, setup);
	if (err)
		return err;
1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267
	ieee80211_start_mesh(sdata);

	return 0;
}

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

	return 0;
}
1268 1269
#endif

1270 1271 1272 1273 1274 1275 1276 1277 1278 1279
static int ieee80211_change_bss(struct wiphy *wiphy,
				struct net_device *dev,
				struct bss_parameters *params)
{
	struct ieee80211_sub_if_data *sdata;
	u32 changed = 0;

	sdata = IEEE80211_DEV_TO_SUB_IF(dev);

	if (params->use_cts_prot >= 0) {
J
Johannes Berg 已提交
1280
		sdata->vif.bss_conf.use_cts_prot = params->use_cts_prot;
1281 1282 1283
		changed |= BSS_CHANGED_ERP_CTS_PROT;
	}
	if (params->use_short_preamble >= 0) {
J
Johannes Berg 已提交
1284
		sdata->vif.bss_conf.use_short_preamble =
1285 1286 1287
			params->use_short_preamble;
		changed |= BSS_CHANGED_ERP_PREAMBLE;
	}
1288 1289 1290 1291 1292 1293 1294

	if (!sdata->vif.bss_conf.use_short_slot &&
	    sdata->local->hw.conf.channel->band == IEEE80211_BAND_5GHZ) {
		sdata->vif.bss_conf.use_short_slot = true;
		changed |= BSS_CHANGED_ERP_SLOT;
	}

1295
	if (params->use_short_slot_time >= 0) {
J
Johannes Berg 已提交
1296
		sdata->vif.bss_conf.use_short_slot =
1297 1298 1299 1300
			params->use_short_slot_time;
		changed |= BSS_CHANGED_ERP_SLOT;
	}

1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318
	if (params->basic_rates) {
		int i, j;
		u32 rates = 0;
		struct ieee80211_local *local = wiphy_priv(wiphy);
		struct ieee80211_supported_band *sband =
			wiphy->bands[local->oper_channel->band];

		for (i = 0; i < params->basic_rates_len; i++) {
			int rate = (params->basic_rates[i] & 0x7f) * 5;
			for (j = 0; j < sband->n_bitrates; j++) {
				if (sband->bitrates[j].bitrate == rate)
					rates |= BIT(j);
			}
		}
		sdata->vif.bss_conf.basic_rates = rates;
		changed |= BSS_CHANGED_BASIC_RATES;
	}

1319 1320 1321 1322 1323 1324 1325
	if (params->ap_isolate >= 0) {
		if (params->ap_isolate)
			sdata->flags |= IEEE80211_SDATA_DONT_BRIDGE_PACKETS;
		else
			sdata->flags &= ~IEEE80211_SDATA_DONT_BRIDGE_PACKETS;
	}

1326 1327 1328 1329 1330 1331
	if (params->ht_opmode >= 0) {
		sdata->vif.bss_conf.ht_operation_mode =
			(u16) params->ht_opmode;
		changed |= BSS_CHANGED_HT;
	}

1332 1333 1334 1335 1336
	ieee80211_bss_info_change_notify(sdata, changed);

	return 0;
}

1337
static int ieee80211_set_txq_params(struct wiphy *wiphy,
1338
				    struct net_device *dev,
1339 1340 1341
				    struct ieee80211_txq_params *params)
{
	struct ieee80211_local *local = wiphy_priv(wiphy);
1342
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1343 1344 1345 1346 1347 1348 1349 1350 1351 1352
	struct ieee80211_tx_queue_params p;

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

	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 已提交
1353 1354 1355 1356 1357 1358 1359

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

1360 1361 1362
	if (params->queue >= local->hw.queues)
		return -EINVAL;

1363 1364
	sdata->tx_conf[params->queue] = p;
	if (drv_conf_tx(local, sdata, params->queue, &p)) {
J
Joe Perches 已提交
1365 1366 1367
		wiphy_debug(local->hw.wiphy,
			    "failed to set TX queue parameters for queue %d\n",
			    params->queue);
1368 1369 1370 1371 1372 1373
		return -EINVAL;
	}

	return 0;
}

1374
static int ieee80211_set_channel(struct wiphy *wiphy,
1375
				 struct net_device *netdev,
1376
				 struct ieee80211_channel *chan,
S
Sujith 已提交
1377
				 enum nl80211_channel_type channel_type)
1378 1379
{
	struct ieee80211_local *local = wiphy_priv(wiphy);
1380
	struct ieee80211_sub_if_data *sdata = NULL;
1381 1382 1383
	struct ieee80211_channel *old_oper;
	enum nl80211_channel_type old_oper_type;
	enum nl80211_channel_type old_vif_oper_type= NL80211_CHAN_NO_HT;
1384 1385 1386

	if (netdev)
		sdata = IEEE80211_DEV_TO_SUB_IF(netdev);
1387

1388 1389 1390 1391
	switch (ieee80211_get_channel_mode(local, NULL)) {
	case CHAN_MODE_HOPPING:
		return -EBUSY;
	case CHAN_MODE_FIXED:
1392 1393 1394
		if (local->oper_channel != chan)
			return -EBUSY;
		if (!sdata && local->_oper_channel_type == channel_type)
1395
			return 0;
1396
		break;
1397 1398 1399
	case CHAN_MODE_UNDEFINED:
		break;
	}
1400

1401 1402 1403
	if (sdata)
		old_vif_oper_type = sdata->vif.bss_conf.channel_type;
	old_oper_type = local->_oper_channel_type;
1404

1405 1406 1407
	if (!ieee80211_set_channel_type(local, sdata, channel_type))
		return -EBUSY;

1408 1409 1410 1411 1412 1413 1414 1415
	old_oper = local->oper_channel;
	local->oper_channel = chan;

	/* Update driver if changes were actually made. */
	if ((old_oper != local->oper_channel) ||
	    (old_oper_type != local->_oper_channel_type))
		ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_CHANNEL);

1416
	if (sdata && sdata->vif.type != NL80211_IFTYPE_MONITOR &&
1417
	    old_vif_oper_type != sdata->vif.bss_conf.channel_type)
1418 1419 1420
		ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_HT);

	return 0;
1421 1422
}

1423
#ifdef CONFIG_PM
J
Johannes Berg 已提交
1424 1425
static int ieee80211_suspend(struct wiphy *wiphy,
			     struct cfg80211_wowlan *wowlan)
1426
{
1427
	return __ieee80211_suspend(wiphy_priv(wiphy), wowlan);
1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438
}

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

1439 1440 1441 1442
static int ieee80211_scan(struct wiphy *wiphy,
			  struct net_device *dev,
			  struct cfg80211_scan_request *req)
{
1443
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1444

1445 1446 1447 1448 1449 1450 1451 1452 1453
	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:
		break;
	case NL80211_IFTYPE_P2P_GO:
		if (sdata->local->ops->hw_scan)
			break;
1454 1455 1456 1457 1458
		/*
		 * FIXME: implement NoA while scanning in software,
		 * for now fall through to allow scanning only when
		 * beaconing hasn't been configured yet
		 */
1459 1460 1461 1462 1463 1464 1465
	case NL80211_IFTYPE_AP:
		if (sdata->u.ap.beacon)
			return -EOPNOTSUPP;
		break;
	default:
		return -EOPNOTSUPP;
	}
1466 1467 1468 1469

	return ieee80211_request_scan(sdata, req);
}

1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483
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
1484
ieee80211_sched_scan_stop(struct wiphy *wiphy, struct net_device *dev)
1485 1486 1487 1488 1489 1490
{
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);

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

1491
	return ieee80211_request_sched_scan_stop(sdata);
1492 1493
}

1494 1495 1496
static int ieee80211_auth(struct wiphy *wiphy, struct net_device *dev,
			  struct cfg80211_auth_request *req)
{
1497
	return ieee80211_mgd_auth(IEEE80211_DEV_TO_SUB_IF(dev), req);
1498 1499 1500 1501 1502
}

static int ieee80211_assoc(struct wiphy *wiphy, struct net_device *dev,
			   struct cfg80211_assoc_request *req)
{
1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516
	struct ieee80211_local *local = wiphy_priv(wiphy);
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);

	switch (ieee80211_get_channel_mode(local, sdata)) {
	case CHAN_MODE_HOPPING:
		return -EBUSY;
	case CHAN_MODE_FIXED:
		if (local->oper_channel == req->bss->channel)
			break;
		return -EBUSY;
	case CHAN_MODE_UNDEFINED:
		break;
	}

1517
	return ieee80211_mgd_assoc(IEEE80211_DEV_TO_SUB_IF(dev), req);
1518 1519 1520
}

static int ieee80211_deauth(struct wiphy *wiphy, struct net_device *dev,
J
Johannes Berg 已提交
1521 1522
			    struct cfg80211_deauth_request *req,
			    void *cookie)
1523
{
J
Johannes Berg 已提交
1524 1525
	return ieee80211_mgd_deauth(IEEE80211_DEV_TO_SUB_IF(dev),
				    req, cookie);
1526 1527 1528
}

static int ieee80211_disassoc(struct wiphy *wiphy, struct net_device *dev,
J
Johannes Berg 已提交
1529 1530
			      struct cfg80211_disassoc_request *req,
			      void *cookie)
1531
{
J
Johannes Berg 已提交
1532 1533
	return ieee80211_mgd_disassoc(IEEE80211_DEV_TO_SUB_IF(dev),
				      req, cookie);
1534 1535
}

1536 1537 1538
static int ieee80211_join_ibss(struct wiphy *wiphy, struct net_device *dev,
			       struct cfg80211_ibss_params *params)
{
1539
	struct ieee80211_local *local = wiphy_priv(wiphy);
1540 1541
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);

1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554
	switch (ieee80211_get_channel_mode(local, sdata)) {
	case CHAN_MODE_HOPPING:
		return -EBUSY;
	case CHAN_MODE_FIXED:
		if (!params->channel_fixed)
			return -EBUSY;
		if (local->oper_channel == params->channel)
			break;
		return -EBUSY;
	case CHAN_MODE_UNDEFINED:
		break;
	}

1555 1556 1557 1558 1559 1560 1561 1562 1563 1564
	return ieee80211_ibss_join(sdata, params);
}

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

	return ieee80211_ibss_leave(sdata);
}

1565 1566 1567
static int ieee80211_set_wiphy_params(struct wiphy *wiphy, u32 changed)
{
	struct ieee80211_local *local = wiphy_priv(wiphy);
1568
	int err;
1569

1570 1571 1572 1573 1574 1575 1576
	if (changed & WIPHY_PARAM_FRAG_THRESHOLD) {
		err = drv_set_frag_threshold(local, wiphy->frag_threshold);

		if (err)
			return err;
	}

1577 1578 1579 1580 1581 1582 1583
	if (changed & WIPHY_PARAM_COVERAGE_CLASS) {
		err = drv_set_coverage_class(local, wiphy->coverage_class);

		if (err)
			return err;
	}

1584
	if (changed & WIPHY_PARAM_RTS_THRESHOLD) {
1585
		err = drv_set_rts_threshold(local, wiphy->rts_threshold);
1586

1587 1588
		if (err)
			return err;
1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601
	}

	if (changed & WIPHY_PARAM_RETRY_SHORT)
		local->hw.conf.short_frame_max_tx_count = wiphy->retry_short;
	if (changed & WIPHY_PARAM_RETRY_LONG)
		local->hw.conf.long_frame_max_tx_count = wiphy->retry_long;
	if (changed &
	    (WIPHY_PARAM_RETRY_SHORT | WIPHY_PARAM_RETRY_LONG))
		ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_RETRY_LIMITS);

	return 0;
}

1602
static int ieee80211_set_tx_power(struct wiphy *wiphy,
1603
				  enum nl80211_tx_power_setting type, int mbm)
1604 1605 1606 1607 1608 1609
{
	struct ieee80211_local *local = wiphy_priv(wiphy);
	struct ieee80211_channel *chan = local->hw.conf.channel;
	u32 changes = 0;

	switch (type) {
1610
	case NL80211_TX_POWER_AUTOMATIC:
1611 1612
		local->user_power_level = -1;
		break;
1613 1614 1615 1616
	case NL80211_TX_POWER_LIMITED:
		if (mbm < 0 || (mbm % 100))
			return -EOPNOTSUPP;
		local->user_power_level = MBM_TO_DBM(mbm);
1617
		break;
1618 1619 1620
	case NL80211_TX_POWER_FIXED:
		if (mbm < 0 || (mbm % 100))
			return -EOPNOTSUPP;
1621
		/* TODO: move to cfg80211 when it knows the channel */
1622
		if (MBM_TO_DBM(mbm) > chan->max_power)
1623
			return -EINVAL;
1624
		local->user_power_level = MBM_TO_DBM(mbm);
1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641
		break;
	}

	ieee80211_hw_config(local, changes);

	return 0;
}

static int ieee80211_get_tx_power(struct wiphy *wiphy, int *dbm)
{
	struct ieee80211_local *local = wiphy_priv(wiphy);

	*dbm = local->hw.conf.power_level;

	return 0;
}

J
Johannes Berg 已提交
1642
static int ieee80211_set_wds_peer(struct wiphy *wiphy, struct net_device *dev,
J
Johannes Berg 已提交
1643
				  const u8 *addr)
J
Johannes Berg 已提交
1644 1645 1646 1647 1648 1649 1650 1651
{
	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 已提交
1652 1653 1654 1655 1656 1657 1658
static void ieee80211_rfkill_poll(struct wiphy *wiphy)
{
	struct ieee80211_local *local = wiphy_priv(wiphy);

	drv_rfkill_poll(local);
}

1659
#ifdef CONFIG_NL80211_TESTMODE
J
Johannes Berg 已提交
1660
static int ieee80211_testmode_cmd(struct wiphy *wiphy, void *data, int len)
1661 1662 1663 1664 1665 1666 1667 1668
{
	struct ieee80211_local *local = wiphy_priv(wiphy);

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

	return local->ops->testmode_cmd(&local->hw, data, len);
}
W
Wey-Yi Guy 已提交
1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681

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);
}
1682 1683
#endif

1684 1685 1686 1687 1688 1689 1690
int __ieee80211_request_smps(struct ieee80211_sub_if_data *sdata,
			     enum ieee80211_smps_mode smps_mode)
{
	const u8 *ap;
	enum ieee80211_smps_mode old_req;
	int err;

1691 1692
	lockdep_assert_held(&sdata->u.mgd.mtx);

1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704
	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
	 * association, there's no need to send an action frame.
	 */
	if (!sdata->u.mgd.associated ||
1705
	    sdata->vif.bss_conf.channel_type == NL80211_CHAN_NO_HT) {
1706
		mutex_lock(&sdata->local->iflist_mtx);
1707
		ieee80211_recalc_smps(sdata->local);
1708 1709 1710 1711
		mutex_unlock(&sdata->local->iflist_mtx);
		return 0;
	}

1712
	ap = sdata->u.mgd.associated->bssid;
1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729

	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 已提交
1730 1731 1732 1733 1734 1735
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);

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

J
Johannes Berg 已提交
1739 1740 1741 1742
	if (!(local->hw.flags & IEEE80211_HW_SUPPORTS_PS))
		return -EOPNOTSUPP;

	if (enabled == sdata->u.mgd.powersave &&
1743
	    timeout == local->dynamic_ps_forced_timeout)
J
Johannes Berg 已提交
1744 1745 1746
		return 0;

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

1749 1750 1751 1752 1753
	/* no change, but if automatic follow powersave */
	mutex_lock(&sdata->u.mgd.mtx);
	__ieee80211_request_smps(sdata, sdata->u.mgd.req_smps);
	mutex_unlock(&sdata->u.mgd.mtx);

J
Johannes Berg 已提交
1754 1755 1756 1757 1758 1759 1760 1761
	if (local->hw.flags & IEEE80211_HW_SUPPORTS_DYNAMIC_PS)
		ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_PS);

	ieee80211_recalc_ps(local, -1);

	return 0;
}

1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777
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_local *local = wdev_priv(dev->ieee80211_ptr);
	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;

1778 1779 1780 1781 1782 1783
	if (!(local->hw.flags & IEEE80211_HW_SUPPORTS_CQM_RSSI)) {
		if (sdata->vif.type != NL80211_IFTYPE_STATION)
			return -EOPNOTSUPP;
		return 0;
	}

1784 1785 1786 1787 1788 1789 1790
	/* tell the driver upon association, unless already associated */
	if (sdata->u.mgd.associated)
		ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_CQM);

	return 0;
}

J
Johannes Berg 已提交
1791 1792 1793 1794 1795 1796 1797
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);
1798
	int i, ret;
1799

1800 1801 1802 1803 1804
	if (local->hw.flags & IEEE80211_HW_HAS_RATE_CONTROL) {
		ret = drv_set_bitrate_mask(local, sdata, mask);
		if (ret)
			return ret;
	}
J
Johannes Berg 已提交
1805

1806 1807
	for (i = 0; i < IEEE80211_NUM_BANDS; i++)
		sdata->rc_rateidx_mask[i] = mask->control[i].legacy;
J
Johannes Berg 已提交
1808

1809
	return 0;
J
Johannes Berg 已提交
1810 1811
}

1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842
static int ieee80211_remain_on_channel_hw(struct ieee80211_local *local,
					  struct net_device *dev,
					  struct ieee80211_channel *chan,
					  enum nl80211_channel_type chantype,
					  unsigned int duration, u64 *cookie)
{
	int ret;
	u32 random_cookie;

	lockdep_assert_held(&local->mtx);

	if (local->hw_roc_cookie)
		return -EBUSY;
	/* must be nonzero */
	random_cookie = random32() | 1;

	*cookie = random_cookie;
	local->hw_roc_dev = dev;
	local->hw_roc_cookie = random_cookie;
	local->hw_roc_channel = chan;
	local->hw_roc_channel_type = chantype;
	local->hw_roc_duration = duration;
	ret = drv_remain_on_channel(local, chan, chantype, duration);
	if (ret) {
		local->hw_roc_channel = NULL;
		local->hw_roc_cookie = 0;
	}

	return ret;
}

1843 1844 1845 1846 1847 1848 1849 1850
static int ieee80211_remain_on_channel(struct wiphy *wiphy,
				       struct net_device *dev,
				       struct ieee80211_channel *chan,
				       enum nl80211_channel_type channel_type,
				       unsigned int duration,
				       u64 *cookie)
{
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1851 1852 1853 1854 1855 1856 1857 1858 1859
	struct ieee80211_local *local = sdata->local;

	if (local->ops->remain_on_channel) {
		int ret;

		mutex_lock(&local->mtx);
		ret = ieee80211_remain_on_channel_hw(local, dev,
						     chan, channel_type,
						     duration, cookie);
1860
		local->hw_roc_for_tx = false;
1861 1862 1863 1864
		mutex_unlock(&local->mtx);

		return ret;
	}
1865 1866 1867 1868 1869

	return ieee80211_wk_remain_on_channel(sdata, chan, channel_type,
					      duration, cookie);
}

1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891
static int ieee80211_cancel_remain_on_channel_hw(struct ieee80211_local *local,
						 u64 cookie)
{
	int ret;

	lockdep_assert_held(&local->mtx);

	if (local->hw_roc_cookie != cookie)
		return -ENOENT;

	ret = drv_cancel_remain_on_channel(local);
	if (ret)
		return ret;

	local->hw_roc_cookie = 0;
	local->hw_roc_channel = NULL;

	ieee80211_recalc_idle(local);

	return 0;
}

1892 1893 1894 1895 1896
static int ieee80211_cancel_remain_on_channel(struct wiphy *wiphy,
					      struct net_device *dev,
					      u64 cookie)
{
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1897 1898 1899 1900 1901 1902 1903 1904 1905 1906 1907
	struct ieee80211_local *local = sdata->local;

	if (local->ops->cancel_remain_on_channel) {
		int ret;

		mutex_lock(&local->mtx);
		ret = ieee80211_cancel_remain_on_channel_hw(local, cookie);
		mutex_unlock(&local->mtx);

		return ret;
	}
1908 1909 1910 1911

	return ieee80211_wk_cancel_remain_on_channel(sdata, cookie);
}

1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925
static enum work_done_result
ieee80211_offchan_tx_done(struct ieee80211_work *wk, struct sk_buff *skb)
{
	/*
	 * Use the data embedded in the work struct for reporting
	 * here so if the driver mangled the SKB before dropping
	 * it (which is the only way we really should get here)
	 * then we don't report mangled data.
	 *
	 * If there was no wait time, then by the time we get here
	 * the driver will likely not have reported the status yet,
	 * so in that case userspace will have to deal with it.
	 */

1926
	if (wk->offchan_tx.wait && !wk->offchan_tx.status)
1927 1928 1929 1930 1931 1932 1933
		cfg80211_mgmt_tx_status(wk->sdata->dev,
					(unsigned long) wk->offchan_tx.frame,
					wk->ie, wk->ie_len, false, GFP_KERNEL);

	return WORK_DONE_DESTROY;
}

1934
static int ieee80211_mgmt_tx(struct wiphy *wiphy, struct net_device *dev,
1935
			     struct ieee80211_channel *chan, bool offchan,
1936
			     enum nl80211_channel_type channel_type,
1937
			     bool channel_type_valid, unsigned int wait,
1938 1939
			     const u8 *buf, size_t len, bool no_cck,
			     u64 *cookie)
1940
{
1941 1942 1943 1944
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
	struct ieee80211_local *local = sdata->local;
	struct sk_buff *skb;
	struct sta_info *sta;
1945
	struct ieee80211_work *wk;
1946 1947 1948
	const struct ieee80211_mgmt *mgmt = (void *)buf;
	u32 flags = IEEE80211_TX_INTFL_NL80211_FRAME_TX |
		    IEEE80211_TX_CTL_REQ_TX_STATUS;
1949
	bool is_offchan = false;
1950

1951 1952 1953
	/* Check that we are on the requested channel for transmission */
	if (chan != local->tmp_channel &&
	    chan != local->oper_channel)
1954
		is_offchan = true;
1955 1956 1957
	if (channel_type_valid &&
	    (channel_type != local->tmp_channel_type &&
	     channel_type != local->_oper_channel_type))
1958 1959
		is_offchan = true;

1960 1961 1962 1963 1964 1965
	if (chan == local->hw_roc_channel) {
		/* TODO: check channel type? */
		is_offchan = false;
		flags |= IEEE80211_TX_CTL_TX_OFFCHAN;
	}

1966 1967 1968
	if (no_cck)
		flags |= IEEE80211_TX_CTL_NO_CCK_RATE;

1969
	if (is_offchan && !offchan)
1970 1971 1972 1973
		return -EBUSY;

	switch (sdata->vif.type) {
	case NL80211_IFTYPE_ADHOC:
1974 1975 1976
	case NL80211_IFTYPE_AP:
	case NL80211_IFTYPE_AP_VLAN:
	case NL80211_IFTYPE_P2P_GO:
1977
	case NL80211_IFTYPE_MESH_POINT:
1978 1979
		if (!ieee80211_is_action(mgmt->frame_control) ||
		    mgmt->u.action.category == WLAN_CATEGORY_PUBLIC)
1980 1981 1982 1983 1984 1985 1986 1987
			break;
		rcu_read_lock();
		sta = sta_info_get(sdata, mgmt->da);
		rcu_read_unlock();
		if (!sta)
			return -ENOLINK;
		break;
	case NL80211_IFTYPE_STATION:
1988
	case NL80211_IFTYPE_P2P_CLIENT:
1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005
		break;
	default:
		return -EOPNOTSUPP;
	}

	skb = dev_alloc_skb(local->hw.extra_tx_headroom + len);
	if (!skb)
		return -ENOMEM;
	skb_reserve(skb, local->hw.extra_tx_headroom);

	memcpy(skb_put(skb, len), buf, len);

	IEEE80211_SKB_CB(skb)->flags = flags;

	skb->dev = sdata->dev;

	*cookie = (unsigned long) skb;
2006

2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044
	if (is_offchan && local->ops->remain_on_channel) {
		unsigned int duration;
		int ret;

		mutex_lock(&local->mtx);
		/*
		 * If the duration is zero, then the driver
		 * wouldn't actually do anything. Set it to
		 * 100 for now.
		 *
		 * TODO: cancel the off-channel operation
		 *       when we get the SKB's TX status and
		 *       the wait time was zero before.
		 */
		duration = 100;
		if (wait)
			duration = wait;
		ret = ieee80211_remain_on_channel_hw(local, dev, chan,
						     channel_type,
						     duration, cookie);
		if (ret) {
			kfree_skb(skb);
			mutex_unlock(&local->mtx);
			return ret;
		}

		local->hw_roc_for_tx = true;
		local->hw_roc_duration = wait;

		/*
		 * queue up frame for transmission after
		 * ieee80211_ready_on_channel call
		 */

		/* modify cookie to prevent API mismatches */
		*cookie ^= 2;
		IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_CTL_TX_OFFCHAN;
		local->hw_roc_skb = skb;
2045
		local->hw_roc_skb_for_status = skb;
2046 2047 2048 2049 2050
		mutex_unlock(&local->mtx);

		return 0;
	}

2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069
	/*
	 * Can transmit right away if the channel was the
	 * right one and there's no wait involved... If a
	 * wait is involved, we might otherwise not be on
	 * the right channel for long enough!
	 */
	if (!is_offchan && !wait && !sdata->vif.bss_conf.idle) {
		ieee80211_tx_skb(sdata, skb);
		return 0;
	}

	wk = kzalloc(sizeof(*wk) + len, GFP_KERNEL);
	if (!wk) {
		kfree_skb(skb);
		return -ENOMEM;
	}

	wk->type = IEEE80211_WORK_OFFCHANNEL_TX;
	wk->chan = chan;
2070
	wk->chan_type = channel_type;
2071 2072 2073 2074 2075 2076 2077 2078
	wk->sdata = sdata;
	wk->done = ieee80211_offchan_tx_done;
	wk->offchan_tx.frame = skb;
	wk->offchan_tx.wait = wait;
	wk->ie_len = len;
	memcpy(wk->ie, buf, len);

	ieee80211_add_work(wk);
2079
	return 0;
2080 2081
}

2082 2083 2084 2085 2086 2087 2088 2089 2090 2091
static int ieee80211_mgmt_tx_cancel_wait(struct wiphy *wiphy,
					 struct net_device *dev,
					 u64 cookie)
{
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
	struct ieee80211_local *local = sdata->local;
	struct ieee80211_work *wk;
	int ret = -ENOENT;

	mutex_lock(&local->mtx);
2092 2093 2094 2095 2096 2097 2098 2099

	if (local->ops->cancel_remain_on_channel) {
		cookie ^= 2;
		ret = ieee80211_cancel_remain_on_channel_hw(local, cookie);

		if (ret == 0) {
			kfree_skb(local->hw_roc_skb);
			local->hw_roc_skb = NULL;
2100
			local->hw_roc_skb_for_status = NULL;
2101 2102 2103 2104 2105 2106 2107
		}

		mutex_unlock(&local->mtx);

		return ret;
	}

2108 2109 2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128
	list_for_each_entry(wk, &local->work_list, list) {
		if (wk->sdata != sdata)
			continue;

		if (wk->type != IEEE80211_WORK_OFFCHANNEL_TX)
			continue;

		if (cookie != (unsigned long) wk->offchan_tx.frame)
			continue;

		wk->timeout = jiffies;

		ieee80211_queue_work(&local->hw, &local->work_work);
		ret = 0;
		break;
	}
	mutex_unlock(&local->mtx);

	return ret;
}

2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143 2144 2145
static void ieee80211_mgmt_frame_register(struct wiphy *wiphy,
					  struct net_device *dev,
					  u16 frame_type, bool reg)
{
	struct ieee80211_local *local = wiphy_priv(wiphy);

	if (frame_type != (IEEE80211_FTYPE_MGMT | IEEE80211_STYPE_PROBE_REQ))
		return;

	if (reg)
		local->probe_req_reg++;
	else
		local->probe_req_reg--;

	ieee80211_queue_work(&local->hw, &local->reconfig_filter);
}

2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159 2160 2161 2162
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);
}

2163 2164 2165 2166 2167 2168 2169 2170 2171 2172 2173 2174 2175 2176 2177
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);
}

2178 2179 2180 2181 2182 2183 2184 2185 2186 2187 2188 2189 2190 2191 2192
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;
}

2193 2194 2195 2196 2197 2198 2199 2200 2201 2202 2203 2204 2205 2206 2207 2208 2209 2210 2211 2212 2213 2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232 2233 2234 2235 2236 2237 2238 2239 2240 2241 2242 2243 2244 2245 2246 2247 2248 2249 2250 2251 2252 2253 2254 2255 2256 2257 2258 2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 2269 2270 2271 2272 2273 2274 2275 2276 2277 2278 2279 2280 2281 2282 2283 2284 2285 2286 2287 2288 2289 2290 2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313 2314 2315 2316 2317 2318 2319 2320 2321 2322 2323 2324 2325 2326 2327 2328 2329 2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341 2342 2343 2344 2345 2346 2347 2348 2349 2350 2351 2352 2353 2354 2355 2356 2357 2358 2359 2360 2361 2362 2363 2364 2365 2366 2367 2368 2369 2370 2371 2372 2373 2374 2375 2376 2377 2378 2379 2380 2381 2382 2383 2384 2385 2386 2387 2388 2389 2390 2391 2392 2393 2394 2395 2396 2397 2398 2399 2400 2401 2402 2403 2404 2405 2406 2407 2408 2409 2410 2411 2412 2413 2414 2415 2416 2417 2418 2419 2420 2421 2422 2423 2424 2425 2426 2427 2428 2429 2430 2431 2432 2433 2434 2435 2436 2437 2438 2439 2440 2441 2442 2443 2444 2445 2446 2447 2448 2449 2450 2451 2452 2453 2454 2455 2456 2457 2458 2459 2460 2461 2462 2463 2464 2465 2466 2467 2468 2469 2470
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;
	if (local->oper_channel->band != IEEE80211_BAND_2GHZ)
		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);
	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));

		ieee80211_add_srates_ie(&sdata->vif, skb);
		ieee80211_add_ext_srates_ie(&sdata->vif, skb);
		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));

		ieee80211_add_srates_ie(&sdata->vif, skb);
		ieee80211_add_ext_srates_ie(&sdata->vif, skb);
		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);
	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));

		ieee80211_add_srates_ie(&sdata->vif, skb);
		ieee80211_add_ext_srates_ie(&sdata->vif, skb);
		ieee80211_tdls_add_ext_capab(skb);
		break;
	default:
		return -EINVAL;
	}

	return 0;
}

static int ieee80211_tdls_mgmt(struct wiphy *wiphy, struct net_device *dev,
			       u8 *peer, u8 action_code, u8 dialog_token,
			       u16 status_code, const u8 *extra_ies,
			       size_t extra_ies_len)
{
	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
	struct ieee80211_local *local = sdata->local;
	struct ieee80211_tx_info *info;
	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;

#ifdef CONFIG_MAC80211_VERBOSE_TDLS_DEBUG
	printk(KERN_DEBUG "TDLS mgmt action %d peer %pM\n", action_code, peer);
#endif

	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;

	info = IEEE80211_SKB_CB(skb);
	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)
{
2471
	struct sta_info *sta;
2472 2473 2474 2475 2476 2477 2478 2479 2480 2481 2482 2483 2484 2485
	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;

#ifdef CONFIG_MAC80211_VERBOSE_TDLS_DEBUG
	printk(KERN_DEBUG "TDLS oper %d peer %pM\n", oper, peer);
#endif

	switch (oper) {
	case NL80211_TDLS_ENABLE_LINK:
2486 2487 2488 2489 2490 2491 2492
		rcu_read_lock();
		sta = sta_info_get(sdata, peer);
		if (!sta) {
			rcu_read_unlock();
			return -ENOLINK;
		}

J
Johannes Berg 已提交
2493
		set_sta_flag(sta, WLAN_STA_TDLS_PEER_AUTH);
2494
		rcu_read_unlock();
2495 2496 2497 2498 2499 2500 2501 2502 2503 2504 2505 2506 2507 2508 2509
		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;
}

2510 2511 2512
struct cfg80211_ops mac80211_config_ops = {
	.add_virtual_intf = ieee80211_add_iface,
	.del_virtual_intf = ieee80211_del_iface,
2513
	.change_virtual_intf = ieee80211_change_iface,
2514 2515
	.add_key = ieee80211_add_key,
	.del_key = ieee80211_del_key,
2516
	.get_key = ieee80211_get_key,
2517
	.set_default_key = ieee80211_config_default_key,
2518
	.set_default_mgmt_key = ieee80211_config_default_mgmt_key,
2519 2520 2521
	.add_beacon = ieee80211_add_beacon,
	.set_beacon = ieee80211_set_beacon,
	.del_beacon = ieee80211_del_beacon,
2522 2523 2524
	.add_station = ieee80211_add_station,
	.del_station = ieee80211_del_station,
	.change_station = ieee80211_change_station,
2525
	.get_station = ieee80211_get_station,
2526
	.dump_station = ieee80211_dump_station,
2527
	.dump_survey = ieee80211_dump_survey,
2528 2529 2530 2531 2532 2533
#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,
2534 2535
	.update_mesh_config = ieee80211_update_mesh_config,
	.get_mesh_config = ieee80211_get_mesh_config,
2536 2537
	.join_mesh = ieee80211_join_mesh,
	.leave_mesh = ieee80211_leave_mesh,
2538
#endif
2539
	.change_bss = ieee80211_change_bss,
2540
	.set_txq_params = ieee80211_set_txq_params,
2541
	.set_channel = ieee80211_set_channel,
2542 2543
	.suspend = ieee80211_suspend,
	.resume = ieee80211_resume,
2544
	.scan = ieee80211_scan,
2545 2546
	.sched_scan_start = ieee80211_sched_scan_start,
	.sched_scan_stop = ieee80211_sched_scan_stop,
2547 2548 2549 2550
	.auth = ieee80211_auth,
	.assoc = ieee80211_assoc,
	.deauth = ieee80211_deauth,
	.disassoc = ieee80211_disassoc,
2551 2552
	.join_ibss = ieee80211_join_ibss,
	.leave_ibss = ieee80211_leave_ibss,
2553
	.set_wiphy_params = ieee80211_set_wiphy_params,
2554 2555
	.set_tx_power = ieee80211_set_tx_power,
	.get_tx_power = ieee80211_get_tx_power,
J
Johannes Berg 已提交
2556
	.set_wds_peer = ieee80211_set_wds_peer,
J
Johannes Berg 已提交
2557
	.rfkill_poll = ieee80211_rfkill_poll,
2558
	CFG80211_TESTMODE_CMD(ieee80211_testmode_cmd)
W
Wey-Yi Guy 已提交
2559
	CFG80211_TESTMODE_DUMP(ieee80211_testmode_dump)
J
Johannes Berg 已提交
2560
	.set_power_mgmt = ieee80211_set_power_mgmt,
J
Johannes Berg 已提交
2561
	.set_bitrate_mask = ieee80211_set_bitrate_mask,
2562 2563
	.remain_on_channel = ieee80211_remain_on_channel,
	.cancel_remain_on_channel = ieee80211_cancel_remain_on_channel,
2564
	.mgmt_tx = ieee80211_mgmt_tx,
2565
	.mgmt_tx_cancel_wait = ieee80211_mgmt_tx_cancel_wait,
2566
	.set_cqm_rssi_config = ieee80211_set_cqm_rssi_config,
2567
	.mgmt_frame_register = ieee80211_mgmt_frame_register,
2568 2569
	.set_antenna = ieee80211_set_antenna,
	.get_antenna = ieee80211_get_antenna,
2570 2571
	.set_ringparam = ieee80211_set_ringparam,
	.get_ringparam = ieee80211_get_ringparam,
2572
	.set_rekey_data = ieee80211_set_rekey_data,
2573 2574
	.tdls_oper = ieee80211_tdls_oper,
	.tdls_mgmt = ieee80211_tdls_mgmt,
2575
};