xref: /openbmc/linux/net/mac80211/cfg.c (revision a2fb4d78)
1 /*
2  * mac80211 configuration hooks for cfg80211
3  *
4  * Copyright 2006-2010	Johannes Berg <johannes@sipsolutions.net>
5  *
6  * This file is GPLv2 as found in COPYING.
7  */
8 
9 #include <linux/ieee80211.h>
10 #include <linux/nl80211.h>
11 #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 #include <net/cfg80211.h>
17 #include "ieee80211_i.h"
18 #include "driver-ops.h"
19 #include "cfg.h"
20 #include "rate.h"
21 #include "mesh.h"
22 
23 static struct wireless_dev *ieee80211_add_iface(struct wiphy *wiphy,
24 						const char *name,
25 						enum nl80211_iftype type,
26 						u32 *flags,
27 						struct vif_params *params)
28 {
29 	struct ieee80211_local *local = wiphy_priv(wiphy);
30 	struct wireless_dev *wdev;
31 	struct ieee80211_sub_if_data *sdata;
32 	int err;
33 
34 	err = ieee80211_if_add(local, name, &wdev, type, params);
35 	if (err)
36 		return ERR_PTR(err);
37 
38 	if (type == NL80211_IFTYPE_MONITOR && flags) {
39 		sdata = IEEE80211_WDEV_TO_SUB_IF(wdev);
40 		sdata->u.mntr_flags = *flags;
41 	}
42 
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 static int ieee80211_change_iface(struct wiphy *wiphy,
54 				  struct net_device *dev,
55 				  enum nl80211_iftype type, u32 *flags,
56 				  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 	if (ret)
63 		return ret;
64 
65 	if (type == NL80211_IFTYPE_AP_VLAN &&
66 	    params && params->use_4addr == 0)
67 		RCU_INIT_POINTER(sdata->u.vlan.sta, NULL);
68 	else if (type == NL80211_IFTYPE_STATION &&
69 		 params && params->use_4addr >= 0)
70 		sdata->u.mgd.use_4addr = params->use_4addr;
71 
72 	if (sdata->vif.type == NL80211_IFTYPE_MONITOR && flags) {
73 		struct ieee80211_local *local = sdata->local;
74 
75 		if (ieee80211_sdata_running(sdata)) {
76 			u32 mask = MONITOR_FLAG_COOK_FRAMES |
77 				   MONITOR_FLAG_ACTIVE;
78 
79 			/*
80 			 * Prohibit MONITOR_FLAG_COOK_FRAMES and
81 			 * MONITOR_FLAG_ACTIVE to be changed while the
82 			 * interface is up.
83 			 * Else we would need to add a lot of cruft
84 			 * to update everything:
85 			 *	cooked_mntrs, monitor and all fif_* counters
86 			 *	reconfigure hardware
87 			 */
88 			if ((*flags & mask) != (sdata->u.mntr_flags & mask))
89 				return -EBUSY;
90 
91 			ieee80211_adjust_monitor_flags(sdata, -1);
92 			sdata->u.mntr_flags = *flags;
93 			ieee80211_adjust_monitor_flags(sdata, 1);
94 
95 			ieee80211_configure_filter(local);
96 		} else {
97 			/*
98 			 * Because the interface is down, ieee80211_do_stop
99 			 * and ieee80211_do_open take care of "everything"
100 			 * mentioned in the comment above.
101 			 */
102 			sdata->u.mntr_flags = *flags;
103 		}
104 	}
105 
106 	return 0;
107 }
108 
109 static int ieee80211_start_p2p_device(struct wiphy *wiphy,
110 				      struct wireless_dev *wdev)
111 {
112 	return ieee80211_do_open(wdev, true);
113 }
114 
115 static void ieee80211_stop_p2p_device(struct wiphy *wiphy,
116 				      struct wireless_dev *wdev)
117 {
118 	ieee80211_sdata_stop(IEEE80211_WDEV_TO_SUB_IF(wdev));
119 }
120 
121 static int ieee80211_set_noack_map(struct wiphy *wiphy,
122 				  struct net_device *dev,
123 				  u16 noack_map)
124 {
125 	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
126 
127 	sdata->noack_map = noack_map;
128 	return 0;
129 }
130 
131 static int ieee80211_add_key(struct wiphy *wiphy, struct net_device *dev,
132 			     u8 key_idx, bool pairwise, const u8 *mac_addr,
133 			     struct key_params *params)
134 {
135 	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
136 	struct ieee80211_local *local = sdata->local;
137 	struct sta_info *sta = NULL;
138 	const struct ieee80211_cipher_scheme *cs = NULL;
139 	struct ieee80211_key *key;
140 	int err;
141 
142 	if (!ieee80211_sdata_running(sdata))
143 		return -ENETDOWN;
144 
145 	/* reject WEP and TKIP keys if WEP failed to initialize */
146 	switch (params->cipher) {
147 	case WLAN_CIPHER_SUITE_WEP40:
148 	case WLAN_CIPHER_SUITE_TKIP:
149 	case WLAN_CIPHER_SUITE_WEP104:
150 		if (IS_ERR(local->wep_tx_tfm))
151 			return -EINVAL;
152 		break;
153 	case WLAN_CIPHER_SUITE_CCMP:
154 	case WLAN_CIPHER_SUITE_AES_CMAC:
155 	case WLAN_CIPHER_SUITE_GCMP:
156 		break;
157 	default:
158 		cs = ieee80211_cs_get(local, params->cipher, sdata->vif.type);
159 		break;
160 	}
161 
162 	key = ieee80211_key_alloc(params->cipher, key_idx, params->key_len,
163 				  params->key, params->seq_len, params->seq,
164 				  cs);
165 	if (IS_ERR(key))
166 		return PTR_ERR(key);
167 
168 	if (pairwise)
169 		key->conf.flags |= IEEE80211_KEY_FLAG_PAIRWISE;
170 
171 	mutex_lock(&local->sta_mtx);
172 
173 	if (mac_addr) {
174 		if (ieee80211_vif_is_mesh(&sdata->vif))
175 			sta = sta_info_get(sdata, mac_addr);
176 		else
177 			sta = sta_info_get_bss(sdata, mac_addr);
178 		/*
179 		 * The ASSOC test makes sure the driver is ready to
180 		 * receive the key. When wpa_supplicant has roamed
181 		 * using FT, it attempts to set the key before
182 		 * association has completed, this rejects that attempt
183 		 * so it will set the key again after assocation.
184 		 *
185 		 * TODO: accept the key if we have a station entry and
186 		 *       add it to the device after the station.
187 		 */
188 		if (!sta || !test_sta_flag(sta, WLAN_STA_ASSOC)) {
189 			ieee80211_key_free_unused(key);
190 			err = -ENOENT;
191 			goto out_unlock;
192 		}
193 	}
194 
195 	switch (sdata->vif.type) {
196 	case NL80211_IFTYPE_STATION:
197 		if (sdata->u.mgd.mfp != IEEE80211_MFP_DISABLED)
198 			key->conf.flags |= IEEE80211_KEY_FLAG_RX_MGMT;
199 		break;
200 	case NL80211_IFTYPE_AP:
201 	case NL80211_IFTYPE_AP_VLAN:
202 		/* Keys without a station are used for TX only */
203 		if (key->sta && test_sta_flag(key->sta, WLAN_STA_MFP))
204 			key->conf.flags |= IEEE80211_KEY_FLAG_RX_MGMT;
205 		break;
206 	case NL80211_IFTYPE_ADHOC:
207 		/* no MFP (yet) */
208 		break;
209 	case NL80211_IFTYPE_MESH_POINT:
210 #ifdef CONFIG_MAC80211_MESH
211 		if (sdata->u.mesh.security != IEEE80211_MESH_SEC_NONE)
212 			key->conf.flags |= IEEE80211_KEY_FLAG_RX_MGMT;
213 		break;
214 #endif
215 	case NL80211_IFTYPE_WDS:
216 	case NL80211_IFTYPE_MONITOR:
217 	case NL80211_IFTYPE_P2P_DEVICE:
218 	case NL80211_IFTYPE_UNSPECIFIED:
219 	case NUM_NL80211_IFTYPES:
220 	case NL80211_IFTYPE_P2P_CLIENT:
221 	case NL80211_IFTYPE_P2P_GO:
222 		/* shouldn't happen */
223 		WARN_ON_ONCE(1);
224 		break;
225 	}
226 
227 	if (sta)
228 		sta->cipher_scheme = cs;
229 
230 	err = ieee80211_key_link(key, sdata, sta);
231 
232  out_unlock:
233 	mutex_unlock(&local->sta_mtx);
234 
235 	return err;
236 }
237 
238 static int ieee80211_del_key(struct wiphy *wiphy, struct net_device *dev,
239 			     u8 key_idx, bool pairwise, const u8 *mac_addr)
240 {
241 	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
242 	struct ieee80211_local *local = sdata->local;
243 	struct sta_info *sta;
244 	struct ieee80211_key *key = NULL;
245 	int ret;
246 
247 	mutex_lock(&local->sta_mtx);
248 	mutex_lock(&local->key_mtx);
249 
250 	if (mac_addr) {
251 		ret = -ENOENT;
252 
253 		sta = sta_info_get_bss(sdata, mac_addr);
254 		if (!sta)
255 			goto out_unlock;
256 
257 		if (pairwise)
258 			key = key_mtx_dereference(local, sta->ptk[key_idx]);
259 		else
260 			key = key_mtx_dereference(local, sta->gtk[key_idx]);
261 	} else
262 		key = key_mtx_dereference(local, sdata->keys[key_idx]);
263 
264 	if (!key) {
265 		ret = -ENOENT;
266 		goto out_unlock;
267 	}
268 
269 	ieee80211_key_free(key, true);
270 
271 	ret = 0;
272  out_unlock:
273 	mutex_unlock(&local->key_mtx);
274 	mutex_unlock(&local->sta_mtx);
275 
276 	return ret;
277 }
278 
279 static int ieee80211_get_key(struct wiphy *wiphy, struct net_device *dev,
280 			     u8 key_idx, bool pairwise, const u8 *mac_addr,
281 			     void *cookie,
282 			     void (*callback)(void *cookie,
283 					      struct key_params *params))
284 {
285 	struct ieee80211_sub_if_data *sdata;
286 	struct sta_info *sta = NULL;
287 	u8 seq[6] = {0};
288 	struct key_params params;
289 	struct ieee80211_key *key = NULL;
290 	u64 pn64;
291 	u32 iv32;
292 	u16 iv16;
293 	int err = -ENOENT;
294 
295 	sdata = IEEE80211_DEV_TO_SUB_IF(dev);
296 
297 	rcu_read_lock();
298 
299 	if (mac_addr) {
300 		sta = sta_info_get_bss(sdata, mac_addr);
301 		if (!sta)
302 			goto out;
303 
304 		if (pairwise && key_idx < NUM_DEFAULT_KEYS)
305 			key = rcu_dereference(sta->ptk[key_idx]);
306 		else if (!pairwise &&
307 			 key_idx < NUM_DEFAULT_KEYS + NUM_DEFAULT_MGMT_KEYS)
308 			key = rcu_dereference(sta->gtk[key_idx]);
309 	} else
310 		key = rcu_dereference(sdata->keys[key_idx]);
311 
312 	if (!key)
313 		goto out;
314 
315 	memset(&params, 0, sizeof(params));
316 
317 	params.cipher = key->conf.cipher;
318 
319 	switch (key->conf.cipher) {
320 	case WLAN_CIPHER_SUITE_TKIP:
321 		iv32 = key->u.tkip.tx.iv32;
322 		iv16 = key->u.tkip.tx.iv16;
323 
324 		if (key->flags & KEY_FLAG_UPLOADED_TO_HARDWARE)
325 			drv_get_tkip_seq(sdata->local,
326 					 key->conf.hw_key_idx,
327 					 &iv32, &iv16);
328 
329 		seq[0] = iv16 & 0xff;
330 		seq[1] = (iv16 >> 8) & 0xff;
331 		seq[2] = iv32 & 0xff;
332 		seq[3] = (iv32 >> 8) & 0xff;
333 		seq[4] = (iv32 >> 16) & 0xff;
334 		seq[5] = (iv32 >> 24) & 0xff;
335 		params.seq = seq;
336 		params.seq_len = 6;
337 		break;
338 	case WLAN_CIPHER_SUITE_CCMP:
339 		pn64 = atomic64_read(&key->u.ccmp.tx_pn);
340 		seq[0] = pn64;
341 		seq[1] = pn64 >> 8;
342 		seq[2] = pn64 >> 16;
343 		seq[3] = pn64 >> 24;
344 		seq[4] = pn64 >> 32;
345 		seq[5] = pn64 >> 40;
346 		params.seq = seq;
347 		params.seq_len = 6;
348 		break;
349 	case WLAN_CIPHER_SUITE_AES_CMAC:
350 		pn64 = atomic64_read(&key->u.aes_cmac.tx_pn);
351 		seq[0] = pn64;
352 		seq[1] = pn64 >> 8;
353 		seq[2] = pn64 >> 16;
354 		seq[3] = pn64 >> 24;
355 		seq[4] = pn64 >> 32;
356 		seq[5] = pn64 >> 40;
357 		params.seq = seq;
358 		params.seq_len = 6;
359 		break;
360 	}
361 
362 	params.key = key->conf.key;
363 	params.key_len = key->conf.keylen;
364 
365 	callback(cookie, &params);
366 	err = 0;
367 
368  out:
369 	rcu_read_unlock();
370 	return err;
371 }
372 
373 static int ieee80211_config_default_key(struct wiphy *wiphy,
374 					struct net_device *dev,
375 					u8 key_idx, bool uni,
376 					bool multi)
377 {
378 	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
379 
380 	ieee80211_set_default_key(sdata, key_idx, uni, multi);
381 
382 	return 0;
383 }
384 
385 static int ieee80211_config_default_mgmt_key(struct wiphy *wiphy,
386 					     struct net_device *dev,
387 					     u8 key_idx)
388 {
389 	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
390 
391 	ieee80211_set_default_mgmt_key(sdata, key_idx);
392 
393 	return 0;
394 }
395 
396 void sta_set_rate_info_tx(struct sta_info *sta,
397 			  const struct ieee80211_tx_rate *rate,
398 			  struct rate_info *rinfo)
399 {
400 	rinfo->flags = 0;
401 	if (rate->flags & IEEE80211_TX_RC_MCS) {
402 		rinfo->flags |= RATE_INFO_FLAGS_MCS;
403 		rinfo->mcs = rate->idx;
404 	} else if (rate->flags & IEEE80211_TX_RC_VHT_MCS) {
405 		rinfo->flags |= RATE_INFO_FLAGS_VHT_MCS;
406 		rinfo->mcs = ieee80211_rate_get_vht_mcs(rate);
407 		rinfo->nss = ieee80211_rate_get_vht_nss(rate);
408 	} else {
409 		struct ieee80211_supported_band *sband;
410 		int shift = ieee80211_vif_get_shift(&sta->sdata->vif);
411 		u16 brate;
412 
413 		sband = sta->local->hw.wiphy->bands[
414 				ieee80211_get_sdata_band(sta->sdata)];
415 		brate = sband->bitrates[rate->idx].bitrate;
416 		rinfo->legacy = DIV_ROUND_UP(brate, 1 << shift);
417 	}
418 	if (rate->flags & IEEE80211_TX_RC_40_MHZ_WIDTH)
419 		rinfo->flags |= RATE_INFO_FLAGS_40_MHZ_WIDTH;
420 	if (rate->flags & IEEE80211_TX_RC_80_MHZ_WIDTH)
421 		rinfo->flags |= RATE_INFO_FLAGS_80_MHZ_WIDTH;
422 	if (rate->flags & IEEE80211_TX_RC_160_MHZ_WIDTH)
423 		rinfo->flags |= RATE_INFO_FLAGS_160_MHZ_WIDTH;
424 	if (rate->flags & IEEE80211_TX_RC_SHORT_GI)
425 		rinfo->flags |= RATE_INFO_FLAGS_SHORT_GI;
426 }
427 
428 void sta_set_rate_info_rx(struct sta_info *sta, struct rate_info *rinfo)
429 {
430 	rinfo->flags = 0;
431 
432 	if (sta->last_rx_rate_flag & RX_FLAG_HT) {
433 		rinfo->flags |= RATE_INFO_FLAGS_MCS;
434 		rinfo->mcs = sta->last_rx_rate_idx;
435 	} else if (sta->last_rx_rate_flag & RX_FLAG_VHT) {
436 		rinfo->flags |= RATE_INFO_FLAGS_VHT_MCS;
437 		rinfo->nss = sta->last_rx_rate_vht_nss;
438 		rinfo->mcs = sta->last_rx_rate_idx;
439 	} else {
440 		struct ieee80211_supported_band *sband;
441 		int shift = ieee80211_vif_get_shift(&sta->sdata->vif);
442 		u16 brate;
443 
444 		sband = sta->local->hw.wiphy->bands[
445 				ieee80211_get_sdata_band(sta->sdata)];
446 		brate = sband->bitrates[sta->last_rx_rate_idx].bitrate;
447 		rinfo->legacy = DIV_ROUND_UP(brate, 1 << shift);
448 	}
449 
450 	if (sta->last_rx_rate_flag & RX_FLAG_40MHZ)
451 		rinfo->flags |= RATE_INFO_FLAGS_40_MHZ_WIDTH;
452 	if (sta->last_rx_rate_flag & RX_FLAG_SHORT_GI)
453 		rinfo->flags |= RATE_INFO_FLAGS_SHORT_GI;
454 	if (sta->last_rx_rate_flag & RX_FLAG_80MHZ)
455 		rinfo->flags |= RATE_INFO_FLAGS_80_MHZ_WIDTH;
456 	if (sta->last_rx_rate_flag & RX_FLAG_80P80MHZ)
457 		rinfo->flags |= RATE_INFO_FLAGS_80P80_MHZ_WIDTH;
458 	if (sta->last_rx_rate_flag & RX_FLAG_160MHZ)
459 		rinfo->flags |= RATE_INFO_FLAGS_160_MHZ_WIDTH;
460 }
461 
462 static void sta_set_sinfo(struct sta_info *sta, struct station_info *sinfo)
463 {
464 	struct ieee80211_sub_if_data *sdata = sta->sdata;
465 	struct ieee80211_local *local = sdata->local;
466 	struct timespec uptime;
467 	u64 packets = 0;
468 	int i, ac;
469 
470 	sinfo->generation = sdata->local->sta_generation;
471 
472 	sinfo->filled = STATION_INFO_INACTIVE_TIME |
473 			STATION_INFO_RX_BYTES64 |
474 			STATION_INFO_TX_BYTES64 |
475 			STATION_INFO_RX_PACKETS |
476 			STATION_INFO_TX_PACKETS |
477 			STATION_INFO_TX_RETRIES |
478 			STATION_INFO_TX_FAILED |
479 			STATION_INFO_TX_BITRATE |
480 			STATION_INFO_RX_BITRATE |
481 			STATION_INFO_RX_DROP_MISC |
482 			STATION_INFO_BSS_PARAM |
483 			STATION_INFO_CONNECTED_TIME |
484 			STATION_INFO_STA_FLAGS |
485 			STATION_INFO_BEACON_LOSS_COUNT;
486 
487 	do_posix_clock_monotonic_gettime(&uptime);
488 	sinfo->connected_time = uptime.tv_sec - sta->last_connected;
489 
490 	sinfo->inactive_time = jiffies_to_msecs(jiffies - sta->last_rx);
491 	sinfo->tx_bytes = 0;
492 	for (ac = 0; ac < IEEE80211_NUM_ACS; ac++) {
493 		sinfo->tx_bytes += sta->tx_bytes[ac];
494 		packets += sta->tx_packets[ac];
495 	}
496 	sinfo->tx_packets = packets;
497 	sinfo->rx_bytes = sta->rx_bytes;
498 	sinfo->rx_packets = sta->rx_packets;
499 	sinfo->tx_retries = sta->tx_retry_count;
500 	sinfo->tx_failed = sta->tx_retry_failed;
501 	sinfo->rx_dropped_misc = sta->rx_dropped;
502 	sinfo->beacon_loss_count = sta->beacon_loss_count;
503 
504 	if ((sta->local->hw.flags & IEEE80211_HW_SIGNAL_DBM) ||
505 	    (sta->local->hw.flags & IEEE80211_HW_SIGNAL_UNSPEC)) {
506 		sinfo->filled |= STATION_INFO_SIGNAL | STATION_INFO_SIGNAL_AVG;
507 		if (!local->ops->get_rssi ||
508 		    drv_get_rssi(local, sdata, &sta->sta, &sinfo->signal))
509 			sinfo->signal = (s8)sta->last_signal;
510 		sinfo->signal_avg = (s8) -ewma_read(&sta->avg_signal);
511 	}
512 	if (sta->chains) {
513 		sinfo->filled |= STATION_INFO_CHAIN_SIGNAL |
514 				 STATION_INFO_CHAIN_SIGNAL_AVG;
515 
516 		sinfo->chains = sta->chains;
517 		for (i = 0; i < ARRAY_SIZE(sinfo->chain_signal); i++) {
518 			sinfo->chain_signal[i] = sta->chain_signal_last[i];
519 			sinfo->chain_signal_avg[i] =
520 				(s8) -ewma_read(&sta->chain_signal_avg[i]);
521 		}
522 	}
523 
524 	sta_set_rate_info_tx(sta, &sta->last_tx_rate, &sinfo->txrate);
525 	sta_set_rate_info_rx(sta, &sinfo->rxrate);
526 
527 	if (ieee80211_vif_is_mesh(&sdata->vif)) {
528 #ifdef CONFIG_MAC80211_MESH
529 		sinfo->filled |= STATION_INFO_LLID |
530 				 STATION_INFO_PLID |
531 				 STATION_INFO_PLINK_STATE |
532 				 STATION_INFO_LOCAL_PM |
533 				 STATION_INFO_PEER_PM |
534 				 STATION_INFO_NONPEER_PM;
535 
536 		sinfo->llid = sta->llid;
537 		sinfo->plid = sta->plid;
538 		sinfo->plink_state = sta->plink_state;
539 		if (test_sta_flag(sta, WLAN_STA_TOFFSET_KNOWN)) {
540 			sinfo->filled |= STATION_INFO_T_OFFSET;
541 			sinfo->t_offset = sta->t_offset;
542 		}
543 		sinfo->local_pm = sta->local_pm;
544 		sinfo->peer_pm = sta->peer_pm;
545 		sinfo->nonpeer_pm = sta->nonpeer_pm;
546 #endif
547 	}
548 
549 	sinfo->bss_param.flags = 0;
550 	if (sdata->vif.bss_conf.use_cts_prot)
551 		sinfo->bss_param.flags |= BSS_PARAM_FLAGS_CTS_PROT;
552 	if (sdata->vif.bss_conf.use_short_preamble)
553 		sinfo->bss_param.flags |= BSS_PARAM_FLAGS_SHORT_PREAMBLE;
554 	if (sdata->vif.bss_conf.use_short_slot)
555 		sinfo->bss_param.flags |= BSS_PARAM_FLAGS_SHORT_SLOT_TIME;
556 	sinfo->bss_param.dtim_period = sdata->local->hw.conf.ps_dtim_period;
557 	sinfo->bss_param.beacon_interval = sdata->vif.bss_conf.beacon_int;
558 
559 	sinfo->sta_flags.set = 0;
560 	sinfo->sta_flags.mask = BIT(NL80211_STA_FLAG_AUTHORIZED) |
561 				BIT(NL80211_STA_FLAG_SHORT_PREAMBLE) |
562 				BIT(NL80211_STA_FLAG_WME) |
563 				BIT(NL80211_STA_FLAG_MFP) |
564 				BIT(NL80211_STA_FLAG_AUTHENTICATED) |
565 				BIT(NL80211_STA_FLAG_ASSOCIATED) |
566 				BIT(NL80211_STA_FLAG_TDLS_PEER);
567 	if (test_sta_flag(sta, WLAN_STA_AUTHORIZED))
568 		sinfo->sta_flags.set |= BIT(NL80211_STA_FLAG_AUTHORIZED);
569 	if (test_sta_flag(sta, WLAN_STA_SHORT_PREAMBLE))
570 		sinfo->sta_flags.set |= BIT(NL80211_STA_FLAG_SHORT_PREAMBLE);
571 	if (test_sta_flag(sta, WLAN_STA_WME))
572 		sinfo->sta_flags.set |= BIT(NL80211_STA_FLAG_WME);
573 	if (test_sta_flag(sta, WLAN_STA_MFP))
574 		sinfo->sta_flags.set |= BIT(NL80211_STA_FLAG_MFP);
575 	if (test_sta_flag(sta, WLAN_STA_AUTH))
576 		sinfo->sta_flags.set |= BIT(NL80211_STA_FLAG_AUTHENTICATED);
577 	if (test_sta_flag(sta, WLAN_STA_ASSOC))
578 		sinfo->sta_flags.set |= BIT(NL80211_STA_FLAG_ASSOCIATED);
579 	if (test_sta_flag(sta, WLAN_STA_TDLS_PEER))
580 		sinfo->sta_flags.set |= BIT(NL80211_STA_FLAG_TDLS_PEER);
581 }
582 
583 static const char ieee80211_gstrings_sta_stats[][ETH_GSTRING_LEN] = {
584 	"rx_packets", "rx_bytes", "wep_weak_iv_count",
585 	"rx_duplicates", "rx_fragments", "rx_dropped",
586 	"tx_packets", "tx_bytes", "tx_fragments",
587 	"tx_filtered", "tx_retry_failed", "tx_retries",
588 	"beacon_loss", "sta_state", "txrate", "rxrate", "signal",
589 	"channel", "noise", "ch_time", "ch_time_busy",
590 	"ch_time_ext_busy", "ch_time_rx", "ch_time_tx"
591 };
592 #define STA_STATS_LEN	ARRAY_SIZE(ieee80211_gstrings_sta_stats)
593 
594 static int ieee80211_get_et_sset_count(struct wiphy *wiphy,
595 				       struct net_device *dev,
596 				       int sset)
597 {
598 	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
599 	int rv = 0;
600 
601 	if (sset == ETH_SS_STATS)
602 		rv += STA_STATS_LEN;
603 
604 	rv += drv_get_et_sset_count(sdata, sset);
605 
606 	if (rv == 0)
607 		return -EOPNOTSUPP;
608 	return rv;
609 }
610 
611 static void ieee80211_get_et_stats(struct wiphy *wiphy,
612 				   struct net_device *dev,
613 				   struct ethtool_stats *stats,
614 				   u64 *data)
615 {
616 	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
617 	struct ieee80211_chanctx_conf *chanctx_conf;
618 	struct ieee80211_channel *channel;
619 	struct sta_info *sta;
620 	struct ieee80211_local *local = sdata->local;
621 	struct station_info sinfo;
622 	struct survey_info survey;
623 	int i, q;
624 #define STA_STATS_SURVEY_LEN 7
625 
626 	memset(data, 0, sizeof(u64) * STA_STATS_LEN);
627 
628 #define ADD_STA_STATS(sta)				\
629 	do {						\
630 		data[i++] += sta->rx_packets;		\
631 		data[i++] += sta->rx_bytes;		\
632 		data[i++] += sta->wep_weak_iv_count;	\
633 		data[i++] += sta->num_duplicates;	\
634 		data[i++] += sta->rx_fragments;		\
635 		data[i++] += sta->rx_dropped;		\
636 							\
637 		data[i++] += sinfo.tx_packets;		\
638 		data[i++] += sinfo.tx_bytes;		\
639 		data[i++] += sta->tx_fragments;		\
640 		data[i++] += sta->tx_filtered_count;	\
641 		data[i++] += sta->tx_retry_failed;	\
642 		data[i++] += sta->tx_retry_count;	\
643 		data[i++] += sta->beacon_loss_count;	\
644 	} while (0)
645 
646 	/* For Managed stations, find the single station based on BSSID
647 	 * and use that.  For interface types, iterate through all available
648 	 * stations and add stats for any station that is assigned to this
649 	 * network device.
650 	 */
651 
652 	mutex_lock(&local->sta_mtx);
653 
654 	if (sdata->vif.type == NL80211_IFTYPE_STATION) {
655 		sta = sta_info_get_bss(sdata, sdata->u.mgd.bssid);
656 
657 		if (!(sta && !WARN_ON(sta->sdata->dev != dev)))
658 			goto do_survey;
659 
660 		sinfo.filled = 0;
661 		sta_set_sinfo(sta, &sinfo);
662 
663 		i = 0;
664 		ADD_STA_STATS(sta);
665 
666 		data[i++] = sta->sta_state;
667 
668 
669 		if (sinfo.filled & STATION_INFO_TX_BITRATE)
670 			data[i] = 100000 *
671 				cfg80211_calculate_bitrate(&sinfo.txrate);
672 		i++;
673 		if (sinfo.filled & STATION_INFO_RX_BITRATE)
674 			data[i] = 100000 *
675 				cfg80211_calculate_bitrate(&sinfo.rxrate);
676 		i++;
677 
678 		if (sinfo.filled & STATION_INFO_SIGNAL_AVG)
679 			data[i] = (u8)sinfo.signal_avg;
680 		i++;
681 	} else {
682 		list_for_each_entry(sta, &local->sta_list, list) {
683 			/* Make sure this station belongs to the proper dev */
684 			if (sta->sdata->dev != dev)
685 				continue;
686 
687 			sinfo.filled = 0;
688 			sta_set_sinfo(sta, &sinfo);
689 			i = 0;
690 			ADD_STA_STATS(sta);
691 		}
692 	}
693 
694 do_survey:
695 	i = STA_STATS_LEN - STA_STATS_SURVEY_LEN;
696 	/* Get survey stats for current channel */
697 	survey.filled = 0;
698 
699 	rcu_read_lock();
700 	chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf);
701 	if (chanctx_conf)
702 		channel = chanctx_conf->def.chan;
703 	else
704 		channel = NULL;
705 	rcu_read_unlock();
706 
707 	if (channel) {
708 		q = 0;
709 		do {
710 			survey.filled = 0;
711 			if (drv_get_survey(local, q, &survey) != 0) {
712 				survey.filled = 0;
713 				break;
714 			}
715 			q++;
716 		} while (channel != survey.channel);
717 	}
718 
719 	if (survey.filled)
720 		data[i++] = survey.channel->center_freq;
721 	else
722 		data[i++] = 0;
723 	if (survey.filled & SURVEY_INFO_NOISE_DBM)
724 		data[i++] = (u8)survey.noise;
725 	else
726 		data[i++] = -1LL;
727 	if (survey.filled & SURVEY_INFO_CHANNEL_TIME)
728 		data[i++] = survey.channel_time;
729 	else
730 		data[i++] = -1LL;
731 	if (survey.filled & SURVEY_INFO_CHANNEL_TIME_BUSY)
732 		data[i++] = survey.channel_time_busy;
733 	else
734 		data[i++] = -1LL;
735 	if (survey.filled & SURVEY_INFO_CHANNEL_TIME_EXT_BUSY)
736 		data[i++] = survey.channel_time_ext_busy;
737 	else
738 		data[i++] = -1LL;
739 	if (survey.filled & SURVEY_INFO_CHANNEL_TIME_RX)
740 		data[i++] = survey.channel_time_rx;
741 	else
742 		data[i++] = -1LL;
743 	if (survey.filled & SURVEY_INFO_CHANNEL_TIME_TX)
744 		data[i++] = survey.channel_time_tx;
745 	else
746 		data[i++] = -1LL;
747 
748 	mutex_unlock(&local->sta_mtx);
749 
750 	if (WARN_ON(i != STA_STATS_LEN))
751 		return;
752 
753 	drv_get_et_stats(sdata, stats, &(data[STA_STATS_LEN]));
754 }
755 
756 static void ieee80211_get_et_strings(struct wiphy *wiphy,
757 				     struct net_device *dev,
758 				     u32 sset, u8 *data)
759 {
760 	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
761 	int sz_sta_stats = 0;
762 
763 	if (sset == ETH_SS_STATS) {
764 		sz_sta_stats = sizeof(ieee80211_gstrings_sta_stats);
765 		memcpy(data, ieee80211_gstrings_sta_stats, sz_sta_stats);
766 	}
767 	drv_get_et_strings(sdata, sset, &(data[sz_sta_stats]));
768 }
769 
770 static int ieee80211_dump_station(struct wiphy *wiphy, struct net_device *dev,
771 				 int idx, u8 *mac, struct station_info *sinfo)
772 {
773 	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
774 	struct ieee80211_local *local = sdata->local;
775 	struct sta_info *sta;
776 	int ret = -ENOENT;
777 
778 	mutex_lock(&local->sta_mtx);
779 
780 	sta = sta_info_get_by_idx(sdata, idx);
781 	if (sta) {
782 		ret = 0;
783 		memcpy(mac, sta->sta.addr, ETH_ALEN);
784 		sta_set_sinfo(sta, sinfo);
785 	}
786 
787 	mutex_unlock(&local->sta_mtx);
788 
789 	return ret;
790 }
791 
792 static int ieee80211_dump_survey(struct wiphy *wiphy, struct net_device *dev,
793 				 int idx, struct survey_info *survey)
794 {
795 	struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
796 
797 	return drv_get_survey(local, idx, survey);
798 }
799 
800 static int ieee80211_get_station(struct wiphy *wiphy, struct net_device *dev,
801 				 u8 *mac, struct station_info *sinfo)
802 {
803 	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
804 	struct ieee80211_local *local = sdata->local;
805 	struct sta_info *sta;
806 	int ret = -ENOENT;
807 
808 	mutex_lock(&local->sta_mtx);
809 
810 	sta = sta_info_get_bss(sdata, mac);
811 	if (sta) {
812 		ret = 0;
813 		sta_set_sinfo(sta, sinfo);
814 	}
815 
816 	mutex_unlock(&local->sta_mtx);
817 
818 	return ret;
819 }
820 
821 static int ieee80211_set_monitor_channel(struct wiphy *wiphy,
822 					 struct cfg80211_chan_def *chandef)
823 {
824 	struct ieee80211_local *local = wiphy_priv(wiphy);
825 	struct ieee80211_sub_if_data *sdata;
826 	int ret = 0;
827 
828 	if (cfg80211_chandef_identical(&local->monitor_chandef, chandef))
829 		return 0;
830 
831 	mutex_lock(&local->mtx);
832 	mutex_lock(&local->iflist_mtx);
833 	if (local->use_chanctx) {
834 		sdata = rcu_dereference_protected(
835 				local->monitor_sdata,
836 				lockdep_is_held(&local->iflist_mtx));
837 		if (sdata) {
838 			ieee80211_vif_release_channel(sdata);
839 			ret = ieee80211_vif_use_channel(sdata, chandef,
840 					IEEE80211_CHANCTX_EXCLUSIVE);
841 		}
842 	} else if (local->open_count == local->monitors) {
843 		local->_oper_chandef = *chandef;
844 		ieee80211_hw_config(local, 0);
845 	}
846 
847 	if (ret == 0)
848 		local->monitor_chandef = *chandef;
849 	mutex_unlock(&local->iflist_mtx);
850 	mutex_unlock(&local->mtx);
851 
852 	return ret;
853 }
854 
855 static int ieee80211_set_probe_resp(struct ieee80211_sub_if_data *sdata,
856 				    const u8 *resp, size_t resp_len)
857 {
858 	struct probe_resp *new, *old;
859 
860 	if (!resp || !resp_len)
861 		return 1;
862 
863 	old = sdata_dereference(sdata->u.ap.probe_resp, sdata);
864 
865 	new = kzalloc(sizeof(struct probe_resp) + resp_len, GFP_KERNEL);
866 	if (!new)
867 		return -ENOMEM;
868 
869 	new->len = resp_len;
870 	memcpy(new->data, resp, resp_len);
871 
872 	rcu_assign_pointer(sdata->u.ap.probe_resp, new);
873 	if (old)
874 		kfree_rcu(old, rcu_head);
875 
876 	return 0;
877 }
878 
879 static int ieee80211_assign_beacon(struct ieee80211_sub_if_data *sdata,
880 				   struct cfg80211_beacon_data *params)
881 {
882 	struct beacon_data *new, *old;
883 	int new_head_len, new_tail_len;
884 	int size, err;
885 	u32 changed = BSS_CHANGED_BEACON;
886 
887 	old = sdata_dereference(sdata->u.ap.beacon, sdata);
888 
889 
890 	/* Need to have a beacon head if we don't have one yet */
891 	if (!params->head && !old)
892 		return -EINVAL;
893 
894 	/* new or old head? */
895 	if (params->head)
896 		new_head_len = params->head_len;
897 	else
898 		new_head_len = old->head_len;
899 
900 	/* new or old tail? */
901 	if (params->tail || !old)
902 		/* params->tail_len will be zero for !params->tail */
903 		new_tail_len = params->tail_len;
904 	else
905 		new_tail_len = old->tail_len;
906 
907 	size = sizeof(*new) + new_head_len + new_tail_len;
908 
909 	new = kzalloc(size, GFP_KERNEL);
910 	if (!new)
911 		return -ENOMEM;
912 
913 	/* start filling the new info now */
914 
915 	/*
916 	 * pointers go into the block we allocated,
917 	 * memory is | beacon_data | head | tail |
918 	 */
919 	new->head = ((u8 *) new) + sizeof(*new);
920 	new->tail = new->head + new_head_len;
921 	new->head_len = new_head_len;
922 	new->tail_len = new_tail_len;
923 
924 	/* copy in head */
925 	if (params->head)
926 		memcpy(new->head, params->head, new_head_len);
927 	else
928 		memcpy(new->head, old->head, new_head_len);
929 
930 	/* copy in optional tail */
931 	if (params->tail)
932 		memcpy(new->tail, params->tail, new_tail_len);
933 	else
934 		if (old)
935 			memcpy(new->tail, old->tail, new_tail_len);
936 
937 	err = ieee80211_set_probe_resp(sdata, params->probe_resp,
938 				       params->probe_resp_len);
939 	if (err < 0)
940 		return err;
941 	if (err == 0)
942 		changed |= BSS_CHANGED_AP_PROBE_RESP;
943 
944 	rcu_assign_pointer(sdata->u.ap.beacon, new);
945 
946 	if (old)
947 		kfree_rcu(old, rcu_head);
948 
949 	return changed;
950 }
951 
952 static int ieee80211_start_ap(struct wiphy *wiphy, struct net_device *dev,
953 			      struct cfg80211_ap_settings *params)
954 {
955 	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
956 	struct ieee80211_local *local = sdata->local;
957 	struct beacon_data *old;
958 	struct ieee80211_sub_if_data *vlan;
959 	u32 changed = BSS_CHANGED_BEACON_INT |
960 		      BSS_CHANGED_BEACON_ENABLED |
961 		      BSS_CHANGED_BEACON |
962 		      BSS_CHANGED_SSID |
963 		      BSS_CHANGED_P2P_PS;
964 	int err;
965 
966 	old = sdata_dereference(sdata->u.ap.beacon, sdata);
967 	if (old)
968 		return -EALREADY;
969 
970 	/* TODO: make hostapd tell us what it wants */
971 	sdata->smps_mode = IEEE80211_SMPS_OFF;
972 	sdata->needed_rx_chains = sdata->local->rx_chains;
973 	sdata->radar_required = params->radar_required;
974 
975 	mutex_lock(&local->mtx);
976 	err = ieee80211_vif_use_channel(sdata, &params->chandef,
977 					IEEE80211_CHANCTX_SHARED);
978 	mutex_unlock(&local->mtx);
979 	if (err)
980 		return err;
981 	ieee80211_vif_copy_chanctx_to_vlans(sdata, false);
982 
983 	/*
984 	 * Apply control port protocol, this allows us to
985 	 * not encrypt dynamic WEP control frames.
986 	 */
987 	sdata->control_port_protocol = params->crypto.control_port_ethertype;
988 	sdata->control_port_no_encrypt = params->crypto.control_port_no_encrypt;
989 	sdata->encrypt_headroom = ieee80211_cs_headroom(sdata->local,
990 							&params->crypto,
991 							sdata->vif.type);
992 
993 	list_for_each_entry(vlan, &sdata->u.ap.vlans, u.vlan.list) {
994 		vlan->control_port_protocol =
995 			params->crypto.control_port_ethertype;
996 		vlan->control_port_no_encrypt =
997 			params->crypto.control_port_no_encrypt;
998 		vlan->encrypt_headroom =
999 			ieee80211_cs_headroom(sdata->local,
1000 					      &params->crypto,
1001 					      vlan->vif.type);
1002 	}
1003 
1004 	sdata->vif.bss_conf.beacon_int = params->beacon_interval;
1005 	sdata->vif.bss_conf.dtim_period = params->dtim_period;
1006 	sdata->vif.bss_conf.enable_beacon = true;
1007 
1008 	sdata->vif.bss_conf.ssid_len = params->ssid_len;
1009 	if (params->ssid_len)
1010 		memcpy(sdata->vif.bss_conf.ssid, params->ssid,
1011 		       params->ssid_len);
1012 	sdata->vif.bss_conf.hidden_ssid =
1013 		(params->hidden_ssid != NL80211_HIDDEN_SSID_NOT_IN_USE);
1014 
1015 	memset(&sdata->vif.bss_conf.p2p_noa_attr, 0,
1016 	       sizeof(sdata->vif.bss_conf.p2p_noa_attr));
1017 	sdata->vif.bss_conf.p2p_noa_attr.oppps_ctwindow =
1018 		params->p2p_ctwindow & IEEE80211_P2P_OPPPS_CTWINDOW_MASK;
1019 	if (params->p2p_opp_ps)
1020 		sdata->vif.bss_conf.p2p_noa_attr.oppps_ctwindow |=
1021 					IEEE80211_P2P_OPPPS_ENABLE_BIT;
1022 
1023 	err = ieee80211_assign_beacon(sdata, &params->beacon);
1024 	if (err < 0) {
1025 		ieee80211_vif_release_channel(sdata);
1026 		return err;
1027 	}
1028 	changed |= err;
1029 
1030 	err = drv_start_ap(sdata->local, sdata);
1031 	if (err) {
1032 		old = sdata_dereference(sdata->u.ap.beacon, sdata);
1033 
1034 		if (old)
1035 			kfree_rcu(old, rcu_head);
1036 		RCU_INIT_POINTER(sdata->u.ap.beacon, NULL);
1037 		ieee80211_vif_release_channel(sdata);
1038 		return err;
1039 	}
1040 
1041 	ieee80211_recalc_dtim(local, sdata);
1042 	ieee80211_bss_info_change_notify(sdata, changed);
1043 
1044 	netif_carrier_on(dev);
1045 	list_for_each_entry(vlan, &sdata->u.ap.vlans, u.vlan.list)
1046 		netif_carrier_on(vlan->dev);
1047 
1048 	return 0;
1049 }
1050 
1051 static int ieee80211_change_beacon(struct wiphy *wiphy, struct net_device *dev,
1052 				   struct cfg80211_beacon_data *params)
1053 {
1054 	struct ieee80211_sub_if_data *sdata;
1055 	struct beacon_data *old;
1056 	int err;
1057 
1058 	sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1059 
1060 	/* don't allow changing the beacon while CSA is in place - offset
1061 	 * of channel switch counter may change
1062 	 */
1063 	if (sdata->vif.csa_active)
1064 		return -EBUSY;
1065 
1066 	old = sdata_dereference(sdata->u.ap.beacon, sdata);
1067 	if (!old)
1068 		return -ENOENT;
1069 
1070 	err = ieee80211_assign_beacon(sdata, params);
1071 	if (err < 0)
1072 		return err;
1073 	ieee80211_bss_info_change_notify(sdata, err);
1074 	return 0;
1075 }
1076 
1077 static int ieee80211_stop_ap(struct wiphy *wiphy, struct net_device *dev)
1078 {
1079 	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1080 	struct ieee80211_sub_if_data *vlan;
1081 	struct ieee80211_local *local = sdata->local;
1082 	struct beacon_data *old_beacon;
1083 	struct probe_resp *old_probe_resp;
1084 	struct cfg80211_chan_def chandef;
1085 
1086 	old_beacon = sdata_dereference(sdata->u.ap.beacon, sdata);
1087 	if (!old_beacon)
1088 		return -ENOENT;
1089 	old_probe_resp = sdata_dereference(sdata->u.ap.probe_resp, sdata);
1090 
1091 	/* abort any running channel switch */
1092 	sdata->vif.csa_active = false;
1093 	kfree(sdata->u.ap.next_beacon);
1094 	sdata->u.ap.next_beacon = NULL;
1095 
1096 	/* turn off carrier for this interface and dependent VLANs */
1097 	list_for_each_entry(vlan, &sdata->u.ap.vlans, u.vlan.list)
1098 		netif_carrier_off(vlan->dev);
1099 	netif_carrier_off(dev);
1100 
1101 	/* remove beacon and probe response */
1102 	RCU_INIT_POINTER(sdata->u.ap.beacon, NULL);
1103 	RCU_INIT_POINTER(sdata->u.ap.probe_resp, NULL);
1104 	kfree_rcu(old_beacon, rcu_head);
1105 	if (old_probe_resp)
1106 		kfree_rcu(old_probe_resp, rcu_head);
1107 	sdata->u.ap.driver_smps_mode = IEEE80211_SMPS_OFF;
1108 
1109 	__sta_info_flush(sdata, true);
1110 	ieee80211_free_keys(sdata, true);
1111 
1112 	sdata->vif.bss_conf.enable_beacon = false;
1113 	sdata->vif.bss_conf.ssid_len = 0;
1114 	clear_bit(SDATA_STATE_OFFCHANNEL_BEACON_STOPPED, &sdata->state);
1115 	ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_BEACON_ENABLED);
1116 
1117 	if (sdata->wdev.cac_started) {
1118 		chandef = sdata->vif.bss_conf.chandef;
1119 		cancel_delayed_work_sync(&sdata->dfs_cac_timer_work);
1120 		cfg80211_cac_event(sdata->dev, &chandef,
1121 				   NL80211_RADAR_CAC_ABORTED,
1122 				   GFP_KERNEL);
1123 	}
1124 
1125 	drv_stop_ap(sdata->local, sdata);
1126 
1127 	/* free all potentially still buffered bcast frames */
1128 	local->total_ps_buffered -= skb_queue_len(&sdata->u.ap.ps.bc_buf);
1129 	skb_queue_purge(&sdata->u.ap.ps.bc_buf);
1130 
1131 	ieee80211_vif_copy_chanctx_to_vlans(sdata, true);
1132 	mutex_lock(&local->mtx);
1133 	ieee80211_vif_release_channel(sdata);
1134 	mutex_unlock(&local->mtx);
1135 
1136 	return 0;
1137 }
1138 
1139 /* Layer 2 Update frame (802.2 Type 1 LLC XID Update response) */
1140 struct iapp_layer2_update {
1141 	u8 da[ETH_ALEN];	/* broadcast */
1142 	u8 sa[ETH_ALEN];	/* STA addr */
1143 	__be16 len;		/* 6 */
1144 	u8 dsap;		/* 0 */
1145 	u8 ssap;		/* 0 */
1146 	u8 control;
1147 	u8 xid_info[3];
1148 } __packed;
1149 
1150 static void ieee80211_send_layer2_update(struct sta_info *sta)
1151 {
1152 	struct iapp_layer2_update *msg;
1153 	struct sk_buff *skb;
1154 
1155 	/* Send Level 2 Update Frame to update forwarding tables in layer 2
1156 	 * bridge devices */
1157 
1158 	skb = dev_alloc_skb(sizeof(*msg));
1159 	if (!skb)
1160 		return;
1161 	msg = (struct iapp_layer2_update *)skb_put(skb, sizeof(*msg));
1162 
1163 	/* 802.2 Type 1 Logical Link Control (LLC) Exchange Identifier (XID)
1164 	 * Update response frame; IEEE Std 802.2-1998, 5.4.1.2.1 */
1165 
1166 	eth_broadcast_addr(msg->da);
1167 	memcpy(msg->sa, sta->sta.addr, ETH_ALEN);
1168 	msg->len = htons(6);
1169 	msg->dsap = 0;
1170 	msg->ssap = 0x01;	/* NULL LSAP, CR Bit: Response */
1171 	msg->control = 0xaf;	/* XID response lsb.1111F101.
1172 				 * F=0 (no poll command; unsolicited frame) */
1173 	msg->xid_info[0] = 0x81;	/* XID format identifier */
1174 	msg->xid_info[1] = 1;	/* LLC types/classes: Type 1 LLC */
1175 	msg->xid_info[2] = 0;	/* XID sender's receive window size (RW) */
1176 
1177 	skb->dev = sta->sdata->dev;
1178 	skb->protocol = eth_type_trans(skb, sta->sdata->dev);
1179 	memset(skb->cb, 0, sizeof(skb->cb));
1180 	netif_rx_ni(skb);
1181 }
1182 
1183 static int sta_apply_auth_flags(struct ieee80211_local *local,
1184 				struct sta_info *sta,
1185 				u32 mask, u32 set)
1186 {
1187 	int ret;
1188 
1189 	if (mask & BIT(NL80211_STA_FLAG_AUTHENTICATED) &&
1190 	    set & BIT(NL80211_STA_FLAG_AUTHENTICATED) &&
1191 	    !test_sta_flag(sta, WLAN_STA_AUTH)) {
1192 		ret = sta_info_move_state(sta, IEEE80211_STA_AUTH);
1193 		if (ret)
1194 			return ret;
1195 	}
1196 
1197 	if (mask & BIT(NL80211_STA_FLAG_ASSOCIATED) &&
1198 	    set & BIT(NL80211_STA_FLAG_ASSOCIATED) &&
1199 	    !test_sta_flag(sta, WLAN_STA_ASSOC)) {
1200 		ret = sta_info_move_state(sta, IEEE80211_STA_ASSOC);
1201 		if (ret)
1202 			return ret;
1203 	}
1204 
1205 	if (mask & BIT(NL80211_STA_FLAG_AUTHORIZED)) {
1206 		if (set & BIT(NL80211_STA_FLAG_AUTHORIZED))
1207 			ret = sta_info_move_state(sta, IEEE80211_STA_AUTHORIZED);
1208 		else if (test_sta_flag(sta, WLAN_STA_AUTHORIZED))
1209 			ret = sta_info_move_state(sta, IEEE80211_STA_ASSOC);
1210 		else
1211 			ret = 0;
1212 		if (ret)
1213 			return ret;
1214 	}
1215 
1216 	if (mask & BIT(NL80211_STA_FLAG_ASSOCIATED) &&
1217 	    !(set & BIT(NL80211_STA_FLAG_ASSOCIATED)) &&
1218 	    test_sta_flag(sta, WLAN_STA_ASSOC)) {
1219 		ret = sta_info_move_state(sta, IEEE80211_STA_AUTH);
1220 		if (ret)
1221 			return ret;
1222 	}
1223 
1224 	if (mask & BIT(NL80211_STA_FLAG_AUTHENTICATED) &&
1225 	    !(set & BIT(NL80211_STA_FLAG_AUTHENTICATED)) &&
1226 	    test_sta_flag(sta, WLAN_STA_AUTH)) {
1227 		ret = sta_info_move_state(sta, IEEE80211_STA_NONE);
1228 		if (ret)
1229 			return ret;
1230 	}
1231 
1232 	return 0;
1233 }
1234 
1235 static int sta_apply_parameters(struct ieee80211_local *local,
1236 				struct sta_info *sta,
1237 				struct station_parameters *params)
1238 {
1239 	int ret = 0;
1240 	struct ieee80211_supported_band *sband;
1241 	struct ieee80211_sub_if_data *sdata = sta->sdata;
1242 	enum ieee80211_band band = ieee80211_get_sdata_band(sdata);
1243 	u32 mask, set;
1244 
1245 	sband = local->hw.wiphy->bands[band];
1246 
1247 	mask = params->sta_flags_mask;
1248 	set = params->sta_flags_set;
1249 
1250 	if (ieee80211_vif_is_mesh(&sdata->vif)) {
1251 		/*
1252 		 * In mesh mode, ASSOCIATED isn't part of the nl80211
1253 		 * API but must follow AUTHENTICATED for driver state.
1254 		 */
1255 		if (mask & BIT(NL80211_STA_FLAG_AUTHENTICATED))
1256 			mask |= BIT(NL80211_STA_FLAG_ASSOCIATED);
1257 		if (set & BIT(NL80211_STA_FLAG_AUTHENTICATED))
1258 			set |= BIT(NL80211_STA_FLAG_ASSOCIATED);
1259 	} else if (test_sta_flag(sta, WLAN_STA_TDLS_PEER)) {
1260 		/*
1261 		 * TDLS -- everything follows authorized, but
1262 		 * only becoming authorized is possible, not
1263 		 * going back
1264 		 */
1265 		if (set & BIT(NL80211_STA_FLAG_AUTHORIZED)) {
1266 			set |= BIT(NL80211_STA_FLAG_AUTHENTICATED) |
1267 			       BIT(NL80211_STA_FLAG_ASSOCIATED);
1268 			mask |= BIT(NL80211_STA_FLAG_AUTHENTICATED) |
1269 				BIT(NL80211_STA_FLAG_ASSOCIATED);
1270 		}
1271 	}
1272 
1273 	ret = sta_apply_auth_flags(local, sta, mask, set);
1274 	if (ret)
1275 		return ret;
1276 
1277 	if (mask & BIT(NL80211_STA_FLAG_SHORT_PREAMBLE)) {
1278 		if (set & BIT(NL80211_STA_FLAG_SHORT_PREAMBLE))
1279 			set_sta_flag(sta, WLAN_STA_SHORT_PREAMBLE);
1280 		else
1281 			clear_sta_flag(sta, WLAN_STA_SHORT_PREAMBLE);
1282 	}
1283 
1284 	if (mask & BIT(NL80211_STA_FLAG_WME)) {
1285 		if (set & BIT(NL80211_STA_FLAG_WME)) {
1286 			set_sta_flag(sta, WLAN_STA_WME);
1287 			sta->sta.wme = true;
1288 		} else {
1289 			clear_sta_flag(sta, WLAN_STA_WME);
1290 			sta->sta.wme = false;
1291 		}
1292 	}
1293 
1294 	if (mask & BIT(NL80211_STA_FLAG_MFP)) {
1295 		if (set & BIT(NL80211_STA_FLAG_MFP))
1296 			set_sta_flag(sta, WLAN_STA_MFP);
1297 		else
1298 			clear_sta_flag(sta, WLAN_STA_MFP);
1299 	}
1300 
1301 	if (mask & BIT(NL80211_STA_FLAG_TDLS_PEER)) {
1302 		if (set & BIT(NL80211_STA_FLAG_TDLS_PEER))
1303 			set_sta_flag(sta, WLAN_STA_TDLS_PEER);
1304 		else
1305 			clear_sta_flag(sta, WLAN_STA_TDLS_PEER);
1306 	}
1307 
1308 	if (params->sta_modify_mask & STATION_PARAM_APPLY_UAPSD) {
1309 		sta->sta.uapsd_queues = params->uapsd_queues;
1310 		sta->sta.max_sp = params->max_sp;
1311 	}
1312 
1313 	/*
1314 	 * cfg80211 validates this (1-2007) and allows setting the AID
1315 	 * only when creating a new station entry
1316 	 */
1317 	if (params->aid)
1318 		sta->sta.aid = params->aid;
1319 
1320 	/*
1321 	 * Some of the following updates would be racy if called on an
1322 	 * existing station, via ieee80211_change_station(). However,
1323 	 * all such changes are rejected by cfg80211 except for updates
1324 	 * changing the supported rates on an existing but not yet used
1325 	 * TDLS peer.
1326 	 */
1327 
1328 	if (params->listen_interval >= 0)
1329 		sta->listen_interval = params->listen_interval;
1330 
1331 	if (params->supported_rates) {
1332 		ieee80211_parse_bitrates(&sdata->vif.bss_conf.chandef,
1333 					 sband, params->supported_rates,
1334 					 params->supported_rates_len,
1335 					 &sta->sta.supp_rates[band]);
1336 	}
1337 
1338 	if (params->ht_capa)
1339 		ieee80211_ht_cap_ie_to_sta_ht_cap(sdata, sband,
1340 						  params->ht_capa, sta);
1341 
1342 	if (params->vht_capa)
1343 		ieee80211_vht_cap_ie_to_sta_vht_cap(sdata, sband,
1344 						    params->vht_capa, sta);
1345 
1346 	if (ieee80211_vif_is_mesh(&sdata->vif)) {
1347 #ifdef CONFIG_MAC80211_MESH
1348 		u32 changed = 0;
1349 
1350 		if (params->sta_modify_mask & STATION_PARAM_APPLY_PLINK_STATE) {
1351 			switch (params->plink_state) {
1352 			case NL80211_PLINK_ESTAB:
1353 				if (sta->plink_state != NL80211_PLINK_ESTAB)
1354 					changed = mesh_plink_inc_estab_count(
1355 							sdata);
1356 				sta->plink_state = params->plink_state;
1357 
1358 				ieee80211_mps_sta_status_update(sta);
1359 				changed |= ieee80211_mps_set_sta_local_pm(sta,
1360 					      sdata->u.mesh.mshcfg.power_mode);
1361 				break;
1362 			case NL80211_PLINK_LISTEN:
1363 			case NL80211_PLINK_BLOCKED:
1364 			case NL80211_PLINK_OPN_SNT:
1365 			case NL80211_PLINK_OPN_RCVD:
1366 			case NL80211_PLINK_CNF_RCVD:
1367 			case NL80211_PLINK_HOLDING:
1368 				if (sta->plink_state == NL80211_PLINK_ESTAB)
1369 					changed = mesh_plink_dec_estab_count(
1370 							sdata);
1371 				sta->plink_state = params->plink_state;
1372 
1373 				ieee80211_mps_sta_status_update(sta);
1374 				changed |= ieee80211_mps_set_sta_local_pm(sta,
1375 						NL80211_MESH_POWER_UNKNOWN);
1376 				break;
1377 			default:
1378 				/*  nothing  */
1379 				break;
1380 			}
1381 		}
1382 
1383 		switch (params->plink_action) {
1384 		case NL80211_PLINK_ACTION_NO_ACTION:
1385 			/* nothing */
1386 			break;
1387 		case NL80211_PLINK_ACTION_OPEN:
1388 			changed |= mesh_plink_open(sta);
1389 			break;
1390 		case NL80211_PLINK_ACTION_BLOCK:
1391 			changed |= mesh_plink_block(sta);
1392 			break;
1393 		}
1394 
1395 		if (params->local_pm)
1396 			changed |=
1397 			      ieee80211_mps_set_sta_local_pm(sta,
1398 							     params->local_pm);
1399 		ieee80211_mbss_info_change_notify(sdata, changed);
1400 #endif
1401 	}
1402 
1403 	return 0;
1404 }
1405 
1406 static int ieee80211_add_station(struct wiphy *wiphy, struct net_device *dev,
1407 				 u8 *mac, struct station_parameters *params)
1408 {
1409 	struct ieee80211_local *local = wiphy_priv(wiphy);
1410 	struct sta_info *sta;
1411 	struct ieee80211_sub_if_data *sdata;
1412 	int err;
1413 	int layer2_update;
1414 
1415 	if (params->vlan) {
1416 		sdata = IEEE80211_DEV_TO_SUB_IF(params->vlan);
1417 
1418 		if (sdata->vif.type != NL80211_IFTYPE_AP_VLAN &&
1419 		    sdata->vif.type != NL80211_IFTYPE_AP)
1420 			return -EINVAL;
1421 	} else
1422 		sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1423 
1424 	if (ether_addr_equal(mac, sdata->vif.addr))
1425 		return -EINVAL;
1426 
1427 	if (is_multicast_ether_addr(mac))
1428 		return -EINVAL;
1429 
1430 	sta = sta_info_alloc(sdata, mac, GFP_KERNEL);
1431 	if (!sta)
1432 		return -ENOMEM;
1433 
1434 	/*
1435 	 * defaults -- if userspace wants something else we'll
1436 	 * change it accordingly in sta_apply_parameters()
1437 	 */
1438 	if (!(params->sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER))) {
1439 		sta_info_pre_move_state(sta, IEEE80211_STA_AUTH);
1440 		sta_info_pre_move_state(sta, IEEE80211_STA_ASSOC);
1441 	}
1442 
1443 	err = sta_apply_parameters(local, sta, params);
1444 	if (err) {
1445 		sta_info_free(local, sta);
1446 		return err;
1447 	}
1448 
1449 	/*
1450 	 * for TDLS, rate control should be initialized only when
1451 	 * rates are known and station is marked authorized
1452 	 */
1453 	if (!test_sta_flag(sta, WLAN_STA_TDLS_PEER))
1454 		rate_control_rate_init(sta);
1455 
1456 	layer2_update = sdata->vif.type == NL80211_IFTYPE_AP_VLAN ||
1457 		sdata->vif.type == NL80211_IFTYPE_AP;
1458 
1459 	err = sta_info_insert_rcu(sta);
1460 	if (err) {
1461 		rcu_read_unlock();
1462 		return err;
1463 	}
1464 
1465 	if (layer2_update)
1466 		ieee80211_send_layer2_update(sta);
1467 
1468 	rcu_read_unlock();
1469 
1470 	return 0;
1471 }
1472 
1473 static int ieee80211_del_station(struct wiphy *wiphy, struct net_device *dev,
1474 				 u8 *mac)
1475 {
1476 	struct ieee80211_sub_if_data *sdata;
1477 
1478 	sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1479 
1480 	if (mac)
1481 		return sta_info_destroy_addr_bss(sdata, mac);
1482 
1483 	sta_info_flush(sdata);
1484 	return 0;
1485 }
1486 
1487 static int ieee80211_change_station(struct wiphy *wiphy,
1488 				    struct net_device *dev, u8 *mac,
1489 				    struct station_parameters *params)
1490 {
1491 	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1492 	struct ieee80211_local *local = wiphy_priv(wiphy);
1493 	struct sta_info *sta;
1494 	struct ieee80211_sub_if_data *vlansdata;
1495 	enum cfg80211_station_type statype;
1496 	int err;
1497 
1498 	mutex_lock(&local->sta_mtx);
1499 
1500 	sta = sta_info_get_bss(sdata, mac);
1501 	if (!sta) {
1502 		err = -ENOENT;
1503 		goto out_err;
1504 	}
1505 
1506 	switch (sdata->vif.type) {
1507 	case NL80211_IFTYPE_MESH_POINT:
1508 		if (sdata->u.mesh.user_mpm)
1509 			statype = CFG80211_STA_MESH_PEER_USER;
1510 		else
1511 			statype = CFG80211_STA_MESH_PEER_KERNEL;
1512 		break;
1513 	case NL80211_IFTYPE_ADHOC:
1514 		statype = CFG80211_STA_IBSS;
1515 		break;
1516 	case NL80211_IFTYPE_STATION:
1517 		if (!test_sta_flag(sta, WLAN_STA_TDLS_PEER)) {
1518 			statype = CFG80211_STA_AP_STA;
1519 			break;
1520 		}
1521 		if (test_sta_flag(sta, WLAN_STA_AUTHORIZED))
1522 			statype = CFG80211_STA_TDLS_PEER_ACTIVE;
1523 		else
1524 			statype = CFG80211_STA_TDLS_PEER_SETUP;
1525 		break;
1526 	case NL80211_IFTYPE_AP:
1527 	case NL80211_IFTYPE_AP_VLAN:
1528 		statype = CFG80211_STA_AP_CLIENT;
1529 		break;
1530 	default:
1531 		err = -EOPNOTSUPP;
1532 		goto out_err;
1533 	}
1534 
1535 	err = cfg80211_check_station_change(wiphy, params, statype);
1536 	if (err)
1537 		goto out_err;
1538 
1539 	if (params->vlan && params->vlan != sta->sdata->dev) {
1540 		bool prev_4addr = false;
1541 		bool new_4addr = false;
1542 
1543 		vlansdata = IEEE80211_DEV_TO_SUB_IF(params->vlan);
1544 
1545 		if (params->vlan->ieee80211_ptr->use_4addr) {
1546 			if (vlansdata->u.vlan.sta) {
1547 				err = -EBUSY;
1548 				goto out_err;
1549 			}
1550 
1551 			rcu_assign_pointer(vlansdata->u.vlan.sta, sta);
1552 			new_4addr = true;
1553 		}
1554 
1555 		if (sta->sdata->vif.type == NL80211_IFTYPE_AP_VLAN &&
1556 		    sta->sdata->u.vlan.sta) {
1557 			rcu_assign_pointer(sta->sdata->u.vlan.sta, NULL);
1558 			prev_4addr = true;
1559 		}
1560 
1561 		sta->sdata = vlansdata;
1562 
1563 		if (sta->sta_state == IEEE80211_STA_AUTHORIZED &&
1564 		    prev_4addr != new_4addr) {
1565 			if (new_4addr)
1566 				atomic_dec(&sta->sdata->bss->num_mcast_sta);
1567 			else
1568 				atomic_inc(&sta->sdata->bss->num_mcast_sta);
1569 		}
1570 
1571 		ieee80211_send_layer2_update(sta);
1572 	}
1573 
1574 	err = sta_apply_parameters(local, sta, params);
1575 	if (err)
1576 		goto out_err;
1577 
1578 	/* When peer becomes authorized, init rate control as well */
1579 	if (test_sta_flag(sta, WLAN_STA_TDLS_PEER) &&
1580 	    test_sta_flag(sta, WLAN_STA_AUTHORIZED))
1581 		rate_control_rate_init(sta);
1582 
1583 	mutex_unlock(&local->sta_mtx);
1584 
1585 	if ((sdata->vif.type == NL80211_IFTYPE_AP ||
1586 	     sdata->vif.type == NL80211_IFTYPE_AP_VLAN) &&
1587 	    sta->known_smps_mode != sta->sdata->bss->req_smps &&
1588 	    test_sta_flag(sta, WLAN_STA_AUTHORIZED) &&
1589 	    sta_info_tx_streams(sta) != 1) {
1590 		ht_dbg(sta->sdata,
1591 		       "%pM just authorized and MIMO capable - update SMPS\n",
1592 		       sta->sta.addr);
1593 		ieee80211_send_smps_action(sta->sdata,
1594 			sta->sdata->bss->req_smps,
1595 			sta->sta.addr,
1596 			sta->sdata->vif.bss_conf.bssid);
1597 	}
1598 
1599 	if (sdata->vif.type == NL80211_IFTYPE_STATION &&
1600 	    params->sta_flags_mask & BIT(NL80211_STA_FLAG_AUTHORIZED)) {
1601 		ieee80211_recalc_ps(local, -1);
1602 		ieee80211_recalc_ps_vif(sdata);
1603 	}
1604 
1605 	return 0;
1606 out_err:
1607 	mutex_unlock(&local->sta_mtx);
1608 	return err;
1609 }
1610 
1611 #ifdef CONFIG_MAC80211_MESH
1612 static int ieee80211_add_mpath(struct wiphy *wiphy, struct net_device *dev,
1613 				 u8 *dst, u8 *next_hop)
1614 {
1615 	struct ieee80211_sub_if_data *sdata;
1616 	struct mesh_path *mpath;
1617 	struct sta_info *sta;
1618 
1619 	sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1620 
1621 	rcu_read_lock();
1622 	sta = sta_info_get(sdata, next_hop);
1623 	if (!sta) {
1624 		rcu_read_unlock();
1625 		return -ENOENT;
1626 	}
1627 
1628 	mpath = mesh_path_add(sdata, dst);
1629 	if (IS_ERR(mpath)) {
1630 		rcu_read_unlock();
1631 		return PTR_ERR(mpath);
1632 	}
1633 
1634 	mesh_path_fix_nexthop(mpath, sta);
1635 
1636 	rcu_read_unlock();
1637 	return 0;
1638 }
1639 
1640 static int ieee80211_del_mpath(struct wiphy *wiphy, struct net_device *dev,
1641 			       u8 *dst)
1642 {
1643 	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1644 
1645 	if (dst)
1646 		return mesh_path_del(sdata, dst);
1647 
1648 	mesh_path_flush_by_iface(sdata);
1649 	return 0;
1650 }
1651 
1652 static int ieee80211_change_mpath(struct wiphy *wiphy,
1653 				    struct net_device *dev,
1654 				    u8 *dst, u8 *next_hop)
1655 {
1656 	struct ieee80211_sub_if_data *sdata;
1657 	struct mesh_path *mpath;
1658 	struct sta_info *sta;
1659 
1660 	sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1661 
1662 	rcu_read_lock();
1663 
1664 	sta = sta_info_get(sdata, next_hop);
1665 	if (!sta) {
1666 		rcu_read_unlock();
1667 		return -ENOENT;
1668 	}
1669 
1670 	mpath = mesh_path_lookup(sdata, dst);
1671 	if (!mpath) {
1672 		rcu_read_unlock();
1673 		return -ENOENT;
1674 	}
1675 
1676 	mesh_path_fix_nexthop(mpath, sta);
1677 
1678 	rcu_read_unlock();
1679 	return 0;
1680 }
1681 
1682 static void mpath_set_pinfo(struct mesh_path *mpath, u8 *next_hop,
1683 			    struct mpath_info *pinfo)
1684 {
1685 	struct sta_info *next_hop_sta = rcu_dereference(mpath->next_hop);
1686 
1687 	if (next_hop_sta)
1688 		memcpy(next_hop, next_hop_sta->sta.addr, ETH_ALEN);
1689 	else
1690 		memset(next_hop, 0, ETH_ALEN);
1691 
1692 	memset(pinfo, 0, sizeof(*pinfo));
1693 
1694 	pinfo->generation = mesh_paths_generation;
1695 
1696 	pinfo->filled = MPATH_INFO_FRAME_QLEN |
1697 			MPATH_INFO_SN |
1698 			MPATH_INFO_METRIC |
1699 			MPATH_INFO_EXPTIME |
1700 			MPATH_INFO_DISCOVERY_TIMEOUT |
1701 			MPATH_INFO_DISCOVERY_RETRIES |
1702 			MPATH_INFO_FLAGS;
1703 
1704 	pinfo->frame_qlen = mpath->frame_queue.qlen;
1705 	pinfo->sn = mpath->sn;
1706 	pinfo->metric = mpath->metric;
1707 	if (time_before(jiffies, mpath->exp_time))
1708 		pinfo->exptime = jiffies_to_msecs(mpath->exp_time - jiffies);
1709 	pinfo->discovery_timeout =
1710 			jiffies_to_msecs(mpath->discovery_timeout);
1711 	pinfo->discovery_retries = mpath->discovery_retries;
1712 	if (mpath->flags & MESH_PATH_ACTIVE)
1713 		pinfo->flags |= NL80211_MPATH_FLAG_ACTIVE;
1714 	if (mpath->flags & MESH_PATH_RESOLVING)
1715 		pinfo->flags |= NL80211_MPATH_FLAG_RESOLVING;
1716 	if (mpath->flags & MESH_PATH_SN_VALID)
1717 		pinfo->flags |= NL80211_MPATH_FLAG_SN_VALID;
1718 	if (mpath->flags & MESH_PATH_FIXED)
1719 		pinfo->flags |= NL80211_MPATH_FLAG_FIXED;
1720 	if (mpath->flags & MESH_PATH_RESOLVED)
1721 		pinfo->flags |= NL80211_MPATH_FLAG_RESOLVED;
1722 }
1723 
1724 static int ieee80211_get_mpath(struct wiphy *wiphy, struct net_device *dev,
1725 			       u8 *dst, u8 *next_hop, struct mpath_info *pinfo)
1726 
1727 {
1728 	struct ieee80211_sub_if_data *sdata;
1729 	struct mesh_path *mpath;
1730 
1731 	sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1732 
1733 	rcu_read_lock();
1734 	mpath = mesh_path_lookup(sdata, dst);
1735 	if (!mpath) {
1736 		rcu_read_unlock();
1737 		return -ENOENT;
1738 	}
1739 	memcpy(dst, mpath->dst, ETH_ALEN);
1740 	mpath_set_pinfo(mpath, next_hop, pinfo);
1741 	rcu_read_unlock();
1742 	return 0;
1743 }
1744 
1745 static int ieee80211_dump_mpath(struct wiphy *wiphy, struct net_device *dev,
1746 				 int idx, u8 *dst, u8 *next_hop,
1747 				 struct mpath_info *pinfo)
1748 {
1749 	struct ieee80211_sub_if_data *sdata;
1750 	struct mesh_path *mpath;
1751 
1752 	sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1753 
1754 	rcu_read_lock();
1755 	mpath = mesh_path_lookup_by_idx(sdata, idx);
1756 	if (!mpath) {
1757 		rcu_read_unlock();
1758 		return -ENOENT;
1759 	}
1760 	memcpy(dst, mpath->dst, ETH_ALEN);
1761 	mpath_set_pinfo(mpath, next_hop, pinfo);
1762 	rcu_read_unlock();
1763 	return 0;
1764 }
1765 
1766 static int ieee80211_get_mesh_config(struct wiphy *wiphy,
1767 				struct net_device *dev,
1768 				struct mesh_config *conf)
1769 {
1770 	struct ieee80211_sub_if_data *sdata;
1771 	sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1772 
1773 	memcpy(conf, &(sdata->u.mesh.mshcfg), sizeof(struct mesh_config));
1774 	return 0;
1775 }
1776 
1777 static inline bool _chg_mesh_attr(enum nl80211_meshconf_params parm, u32 mask)
1778 {
1779 	return (mask >> (parm-1)) & 0x1;
1780 }
1781 
1782 static int copy_mesh_setup(struct ieee80211_if_mesh *ifmsh,
1783 		const struct mesh_setup *setup)
1784 {
1785 	u8 *new_ie;
1786 	const u8 *old_ie;
1787 	struct ieee80211_sub_if_data *sdata = container_of(ifmsh,
1788 					struct ieee80211_sub_if_data, u.mesh);
1789 
1790 	/* allocate information elements */
1791 	new_ie = NULL;
1792 	old_ie = ifmsh->ie;
1793 
1794 	if (setup->ie_len) {
1795 		new_ie = kmemdup(setup->ie, setup->ie_len,
1796 				GFP_KERNEL);
1797 		if (!new_ie)
1798 			return -ENOMEM;
1799 	}
1800 	ifmsh->ie_len = setup->ie_len;
1801 	ifmsh->ie = new_ie;
1802 	kfree(old_ie);
1803 
1804 	/* now copy the rest of the setup parameters */
1805 	ifmsh->mesh_id_len = setup->mesh_id_len;
1806 	memcpy(ifmsh->mesh_id, setup->mesh_id, ifmsh->mesh_id_len);
1807 	ifmsh->mesh_sp_id = setup->sync_method;
1808 	ifmsh->mesh_pp_id = setup->path_sel_proto;
1809 	ifmsh->mesh_pm_id = setup->path_metric;
1810 	ifmsh->user_mpm = setup->user_mpm;
1811 	ifmsh->mesh_auth_id = setup->auth_id;
1812 	ifmsh->security = IEEE80211_MESH_SEC_NONE;
1813 	if (setup->is_authenticated)
1814 		ifmsh->security |= IEEE80211_MESH_SEC_AUTHED;
1815 	if (setup->is_secure)
1816 		ifmsh->security |= IEEE80211_MESH_SEC_SECURED;
1817 
1818 	/* mcast rate setting in Mesh Node */
1819 	memcpy(sdata->vif.bss_conf.mcast_rate, setup->mcast_rate,
1820 						sizeof(setup->mcast_rate));
1821 	sdata->vif.bss_conf.basic_rates = setup->basic_rates;
1822 
1823 	sdata->vif.bss_conf.beacon_int = setup->beacon_interval;
1824 	sdata->vif.bss_conf.dtim_period = setup->dtim_period;
1825 
1826 	return 0;
1827 }
1828 
1829 static int ieee80211_update_mesh_config(struct wiphy *wiphy,
1830 					struct net_device *dev, u32 mask,
1831 					const struct mesh_config *nconf)
1832 {
1833 	struct mesh_config *conf;
1834 	struct ieee80211_sub_if_data *sdata;
1835 	struct ieee80211_if_mesh *ifmsh;
1836 
1837 	sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1838 	ifmsh = &sdata->u.mesh;
1839 
1840 	/* Set the config options which we are interested in setting */
1841 	conf = &(sdata->u.mesh.mshcfg);
1842 	if (_chg_mesh_attr(NL80211_MESHCONF_RETRY_TIMEOUT, mask))
1843 		conf->dot11MeshRetryTimeout = nconf->dot11MeshRetryTimeout;
1844 	if (_chg_mesh_attr(NL80211_MESHCONF_CONFIRM_TIMEOUT, mask))
1845 		conf->dot11MeshConfirmTimeout = nconf->dot11MeshConfirmTimeout;
1846 	if (_chg_mesh_attr(NL80211_MESHCONF_HOLDING_TIMEOUT, mask))
1847 		conf->dot11MeshHoldingTimeout = nconf->dot11MeshHoldingTimeout;
1848 	if (_chg_mesh_attr(NL80211_MESHCONF_MAX_PEER_LINKS, mask))
1849 		conf->dot11MeshMaxPeerLinks = nconf->dot11MeshMaxPeerLinks;
1850 	if (_chg_mesh_attr(NL80211_MESHCONF_MAX_RETRIES, mask))
1851 		conf->dot11MeshMaxRetries = nconf->dot11MeshMaxRetries;
1852 	if (_chg_mesh_attr(NL80211_MESHCONF_TTL, mask))
1853 		conf->dot11MeshTTL = nconf->dot11MeshTTL;
1854 	if (_chg_mesh_attr(NL80211_MESHCONF_ELEMENT_TTL, mask))
1855 		conf->element_ttl = nconf->element_ttl;
1856 	if (_chg_mesh_attr(NL80211_MESHCONF_AUTO_OPEN_PLINKS, mask)) {
1857 		if (ifmsh->user_mpm)
1858 			return -EBUSY;
1859 		conf->auto_open_plinks = nconf->auto_open_plinks;
1860 	}
1861 	if (_chg_mesh_attr(NL80211_MESHCONF_SYNC_OFFSET_MAX_NEIGHBOR, mask))
1862 		conf->dot11MeshNbrOffsetMaxNeighbor =
1863 			nconf->dot11MeshNbrOffsetMaxNeighbor;
1864 	if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES, mask))
1865 		conf->dot11MeshHWMPmaxPREQretries =
1866 			nconf->dot11MeshHWMPmaxPREQretries;
1867 	if (_chg_mesh_attr(NL80211_MESHCONF_PATH_REFRESH_TIME, mask))
1868 		conf->path_refresh_time = nconf->path_refresh_time;
1869 	if (_chg_mesh_attr(NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT, mask))
1870 		conf->min_discovery_timeout = nconf->min_discovery_timeout;
1871 	if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT, mask))
1872 		conf->dot11MeshHWMPactivePathTimeout =
1873 			nconf->dot11MeshHWMPactivePathTimeout;
1874 	if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL, mask))
1875 		conf->dot11MeshHWMPpreqMinInterval =
1876 			nconf->dot11MeshHWMPpreqMinInterval;
1877 	if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_PERR_MIN_INTERVAL, mask))
1878 		conf->dot11MeshHWMPperrMinInterval =
1879 			nconf->dot11MeshHWMPperrMinInterval;
1880 	if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME,
1881 			   mask))
1882 		conf->dot11MeshHWMPnetDiameterTraversalTime =
1883 			nconf->dot11MeshHWMPnetDiameterTraversalTime;
1884 	if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_ROOTMODE, mask)) {
1885 		conf->dot11MeshHWMPRootMode = nconf->dot11MeshHWMPRootMode;
1886 		ieee80211_mesh_root_setup(ifmsh);
1887 	}
1888 	if (_chg_mesh_attr(NL80211_MESHCONF_GATE_ANNOUNCEMENTS, mask)) {
1889 		/* our current gate announcement implementation rides on root
1890 		 * announcements, so require this ifmsh to also be a root node
1891 		 * */
1892 		if (nconf->dot11MeshGateAnnouncementProtocol &&
1893 		    !(conf->dot11MeshHWMPRootMode > IEEE80211_ROOTMODE_ROOT)) {
1894 			conf->dot11MeshHWMPRootMode = IEEE80211_PROACTIVE_RANN;
1895 			ieee80211_mesh_root_setup(ifmsh);
1896 		}
1897 		conf->dot11MeshGateAnnouncementProtocol =
1898 			nconf->dot11MeshGateAnnouncementProtocol;
1899 	}
1900 	if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_RANN_INTERVAL, mask))
1901 		conf->dot11MeshHWMPRannInterval =
1902 			nconf->dot11MeshHWMPRannInterval;
1903 	if (_chg_mesh_attr(NL80211_MESHCONF_FORWARDING, mask))
1904 		conf->dot11MeshForwarding = nconf->dot11MeshForwarding;
1905 	if (_chg_mesh_attr(NL80211_MESHCONF_RSSI_THRESHOLD, mask)) {
1906 		/* our RSSI threshold implementation is supported only for
1907 		 * devices that report signal in dBm.
1908 		 */
1909 		if (!(sdata->local->hw.flags & IEEE80211_HW_SIGNAL_DBM))
1910 			return -ENOTSUPP;
1911 		conf->rssi_threshold = nconf->rssi_threshold;
1912 	}
1913 	if (_chg_mesh_attr(NL80211_MESHCONF_HT_OPMODE, mask)) {
1914 		conf->ht_opmode = nconf->ht_opmode;
1915 		sdata->vif.bss_conf.ht_operation_mode = nconf->ht_opmode;
1916 		ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_HT);
1917 	}
1918 	if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_PATH_TO_ROOT_TIMEOUT, mask))
1919 		conf->dot11MeshHWMPactivePathToRootTimeout =
1920 			nconf->dot11MeshHWMPactivePathToRootTimeout;
1921 	if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_ROOT_INTERVAL, mask))
1922 		conf->dot11MeshHWMProotInterval =
1923 			nconf->dot11MeshHWMProotInterval;
1924 	if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_CONFIRMATION_INTERVAL, mask))
1925 		conf->dot11MeshHWMPconfirmationInterval =
1926 			nconf->dot11MeshHWMPconfirmationInterval;
1927 	if (_chg_mesh_attr(NL80211_MESHCONF_POWER_MODE, mask)) {
1928 		conf->power_mode = nconf->power_mode;
1929 		ieee80211_mps_local_status_update(sdata);
1930 	}
1931 	if (_chg_mesh_attr(NL80211_MESHCONF_AWAKE_WINDOW, mask))
1932 		conf->dot11MeshAwakeWindowDuration =
1933 			nconf->dot11MeshAwakeWindowDuration;
1934 	if (_chg_mesh_attr(NL80211_MESHCONF_PLINK_TIMEOUT, mask))
1935 		conf->plink_timeout = nconf->plink_timeout;
1936 	ieee80211_mbss_info_change_notify(sdata, BSS_CHANGED_BEACON);
1937 	return 0;
1938 }
1939 
1940 static int ieee80211_join_mesh(struct wiphy *wiphy, struct net_device *dev,
1941 			       const struct mesh_config *conf,
1942 			       const struct mesh_setup *setup)
1943 {
1944 	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1945 	struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;
1946 	int err;
1947 
1948 	memcpy(&ifmsh->mshcfg, conf, sizeof(struct mesh_config));
1949 	err = copy_mesh_setup(ifmsh, setup);
1950 	if (err)
1951 		return err;
1952 
1953 	/* can mesh use other SMPS modes? */
1954 	sdata->smps_mode = IEEE80211_SMPS_OFF;
1955 	sdata->needed_rx_chains = sdata->local->rx_chains;
1956 
1957 	mutex_lock(&sdata->local->mtx);
1958 	err = ieee80211_vif_use_channel(sdata, &setup->chandef,
1959 					IEEE80211_CHANCTX_SHARED);
1960 	mutex_unlock(&sdata->local->mtx);
1961 	if (err)
1962 		return err;
1963 
1964 	return ieee80211_start_mesh(sdata);
1965 }
1966 
1967 static int ieee80211_leave_mesh(struct wiphy *wiphy, struct net_device *dev)
1968 {
1969 	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1970 
1971 	ieee80211_stop_mesh(sdata);
1972 	mutex_lock(&sdata->local->mtx);
1973 	ieee80211_vif_release_channel(sdata);
1974 	mutex_unlock(&sdata->local->mtx);
1975 
1976 	return 0;
1977 }
1978 #endif
1979 
1980 static int ieee80211_change_bss(struct wiphy *wiphy,
1981 				struct net_device *dev,
1982 				struct bss_parameters *params)
1983 {
1984 	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1985 	enum ieee80211_band band;
1986 	u32 changed = 0;
1987 
1988 	if (!sdata_dereference(sdata->u.ap.beacon, sdata))
1989 		return -ENOENT;
1990 
1991 	band = ieee80211_get_sdata_band(sdata);
1992 
1993 	if (params->use_cts_prot >= 0) {
1994 		sdata->vif.bss_conf.use_cts_prot = params->use_cts_prot;
1995 		changed |= BSS_CHANGED_ERP_CTS_PROT;
1996 	}
1997 	if (params->use_short_preamble >= 0) {
1998 		sdata->vif.bss_conf.use_short_preamble =
1999 			params->use_short_preamble;
2000 		changed |= BSS_CHANGED_ERP_PREAMBLE;
2001 	}
2002 
2003 	if (!sdata->vif.bss_conf.use_short_slot &&
2004 	    band == IEEE80211_BAND_5GHZ) {
2005 		sdata->vif.bss_conf.use_short_slot = true;
2006 		changed |= BSS_CHANGED_ERP_SLOT;
2007 	}
2008 
2009 	if (params->use_short_slot_time >= 0) {
2010 		sdata->vif.bss_conf.use_short_slot =
2011 			params->use_short_slot_time;
2012 		changed |= BSS_CHANGED_ERP_SLOT;
2013 	}
2014 
2015 	if (params->basic_rates) {
2016 		ieee80211_parse_bitrates(&sdata->vif.bss_conf.chandef,
2017 					 wiphy->bands[band],
2018 					 params->basic_rates,
2019 					 params->basic_rates_len,
2020 					 &sdata->vif.bss_conf.basic_rates);
2021 		changed |= BSS_CHANGED_BASIC_RATES;
2022 	}
2023 
2024 	if (params->ap_isolate >= 0) {
2025 		if (params->ap_isolate)
2026 			sdata->flags |= IEEE80211_SDATA_DONT_BRIDGE_PACKETS;
2027 		else
2028 			sdata->flags &= ~IEEE80211_SDATA_DONT_BRIDGE_PACKETS;
2029 	}
2030 
2031 	if (params->ht_opmode >= 0) {
2032 		sdata->vif.bss_conf.ht_operation_mode =
2033 			(u16) params->ht_opmode;
2034 		changed |= BSS_CHANGED_HT;
2035 	}
2036 
2037 	if (params->p2p_ctwindow >= 0) {
2038 		sdata->vif.bss_conf.p2p_noa_attr.oppps_ctwindow &=
2039 					~IEEE80211_P2P_OPPPS_CTWINDOW_MASK;
2040 		sdata->vif.bss_conf.p2p_noa_attr.oppps_ctwindow |=
2041 			params->p2p_ctwindow & IEEE80211_P2P_OPPPS_CTWINDOW_MASK;
2042 		changed |= BSS_CHANGED_P2P_PS;
2043 	}
2044 
2045 	if (params->p2p_opp_ps > 0) {
2046 		sdata->vif.bss_conf.p2p_noa_attr.oppps_ctwindow |=
2047 					IEEE80211_P2P_OPPPS_ENABLE_BIT;
2048 		changed |= BSS_CHANGED_P2P_PS;
2049 	} else if (params->p2p_opp_ps == 0) {
2050 		sdata->vif.bss_conf.p2p_noa_attr.oppps_ctwindow &=
2051 					~IEEE80211_P2P_OPPPS_ENABLE_BIT;
2052 		changed |= BSS_CHANGED_P2P_PS;
2053 	}
2054 
2055 	ieee80211_bss_info_change_notify(sdata, changed);
2056 
2057 	return 0;
2058 }
2059 
2060 static int ieee80211_set_txq_params(struct wiphy *wiphy,
2061 				    struct net_device *dev,
2062 				    struct ieee80211_txq_params *params)
2063 {
2064 	struct ieee80211_local *local = wiphy_priv(wiphy);
2065 	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
2066 	struct ieee80211_tx_queue_params p;
2067 
2068 	if (!local->ops->conf_tx)
2069 		return -EOPNOTSUPP;
2070 
2071 	if (local->hw.queues < IEEE80211_NUM_ACS)
2072 		return -EOPNOTSUPP;
2073 
2074 	memset(&p, 0, sizeof(p));
2075 	p.aifs = params->aifs;
2076 	p.cw_max = params->cwmax;
2077 	p.cw_min = params->cwmin;
2078 	p.txop = params->txop;
2079 
2080 	/*
2081 	 * Setting tx queue params disables u-apsd because it's only
2082 	 * called in master mode.
2083 	 */
2084 	p.uapsd = false;
2085 
2086 	sdata->tx_conf[params->ac] = p;
2087 	if (drv_conf_tx(local, sdata, params->ac, &p)) {
2088 		wiphy_debug(local->hw.wiphy,
2089 			    "failed to set TX queue parameters for AC %d\n",
2090 			    params->ac);
2091 		return -EINVAL;
2092 	}
2093 
2094 	ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_QOS);
2095 
2096 	return 0;
2097 }
2098 
2099 #ifdef CONFIG_PM
2100 static int ieee80211_suspend(struct wiphy *wiphy,
2101 			     struct cfg80211_wowlan *wowlan)
2102 {
2103 	return __ieee80211_suspend(wiphy_priv(wiphy), wowlan);
2104 }
2105 
2106 static int ieee80211_resume(struct wiphy *wiphy)
2107 {
2108 	return __ieee80211_resume(wiphy_priv(wiphy));
2109 }
2110 #else
2111 #define ieee80211_suspend NULL
2112 #define ieee80211_resume NULL
2113 #endif
2114 
2115 static int ieee80211_scan(struct wiphy *wiphy,
2116 			  struct cfg80211_scan_request *req)
2117 {
2118 	struct ieee80211_sub_if_data *sdata;
2119 
2120 	sdata = IEEE80211_WDEV_TO_SUB_IF(req->wdev);
2121 
2122 	switch (ieee80211_vif_type_p2p(&sdata->vif)) {
2123 	case NL80211_IFTYPE_STATION:
2124 	case NL80211_IFTYPE_ADHOC:
2125 	case NL80211_IFTYPE_MESH_POINT:
2126 	case NL80211_IFTYPE_P2P_CLIENT:
2127 	case NL80211_IFTYPE_P2P_DEVICE:
2128 		break;
2129 	case NL80211_IFTYPE_P2P_GO:
2130 		if (sdata->local->ops->hw_scan)
2131 			break;
2132 		/*
2133 		 * FIXME: implement NoA while scanning in software,
2134 		 * for now fall through to allow scanning only when
2135 		 * beaconing hasn't been configured yet
2136 		 */
2137 	case NL80211_IFTYPE_AP:
2138 		/*
2139 		 * If the scan has been forced (and the driver supports
2140 		 * forcing), don't care about being beaconing already.
2141 		 * This will create problems to the attached stations (e.g. all
2142 		 * the  frames sent while scanning on other channel will be
2143 		 * lost)
2144 		 */
2145 		if (sdata->u.ap.beacon &&
2146 		    (!(wiphy->features & NL80211_FEATURE_AP_SCAN) ||
2147 		     !(req->flags & NL80211_SCAN_FLAG_AP)))
2148 			return -EOPNOTSUPP;
2149 		break;
2150 	default:
2151 		return -EOPNOTSUPP;
2152 	}
2153 
2154 	return ieee80211_request_scan(sdata, req);
2155 }
2156 
2157 static int
2158 ieee80211_sched_scan_start(struct wiphy *wiphy,
2159 			   struct net_device *dev,
2160 			   struct cfg80211_sched_scan_request *req)
2161 {
2162 	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
2163 
2164 	if (!sdata->local->ops->sched_scan_start)
2165 		return -EOPNOTSUPP;
2166 
2167 	return ieee80211_request_sched_scan_start(sdata, req);
2168 }
2169 
2170 static int
2171 ieee80211_sched_scan_stop(struct wiphy *wiphy, struct net_device *dev)
2172 {
2173 	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
2174 
2175 	if (!sdata->local->ops->sched_scan_stop)
2176 		return -EOPNOTSUPP;
2177 
2178 	return ieee80211_request_sched_scan_stop(sdata);
2179 }
2180 
2181 static int ieee80211_auth(struct wiphy *wiphy, struct net_device *dev,
2182 			  struct cfg80211_auth_request *req)
2183 {
2184 	return ieee80211_mgd_auth(IEEE80211_DEV_TO_SUB_IF(dev), req);
2185 }
2186 
2187 static int ieee80211_assoc(struct wiphy *wiphy, struct net_device *dev,
2188 			   struct cfg80211_assoc_request *req)
2189 {
2190 	return ieee80211_mgd_assoc(IEEE80211_DEV_TO_SUB_IF(dev), req);
2191 }
2192 
2193 static int ieee80211_deauth(struct wiphy *wiphy, struct net_device *dev,
2194 			    struct cfg80211_deauth_request *req)
2195 {
2196 	return ieee80211_mgd_deauth(IEEE80211_DEV_TO_SUB_IF(dev), req);
2197 }
2198 
2199 static int ieee80211_disassoc(struct wiphy *wiphy, struct net_device *dev,
2200 			      struct cfg80211_disassoc_request *req)
2201 {
2202 	return ieee80211_mgd_disassoc(IEEE80211_DEV_TO_SUB_IF(dev), req);
2203 }
2204 
2205 static int ieee80211_join_ibss(struct wiphy *wiphy, struct net_device *dev,
2206 			       struct cfg80211_ibss_params *params)
2207 {
2208 	return ieee80211_ibss_join(IEEE80211_DEV_TO_SUB_IF(dev), params);
2209 }
2210 
2211 static int ieee80211_leave_ibss(struct wiphy *wiphy, struct net_device *dev)
2212 {
2213 	return ieee80211_ibss_leave(IEEE80211_DEV_TO_SUB_IF(dev));
2214 }
2215 
2216 static int ieee80211_set_mcast_rate(struct wiphy *wiphy, struct net_device *dev,
2217 				    int rate[IEEE80211_NUM_BANDS])
2218 {
2219 	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
2220 
2221 	memcpy(sdata->vif.bss_conf.mcast_rate, rate,
2222 	       sizeof(int) * IEEE80211_NUM_BANDS);
2223 
2224 	return 0;
2225 }
2226 
2227 static int ieee80211_set_wiphy_params(struct wiphy *wiphy, u32 changed)
2228 {
2229 	struct ieee80211_local *local = wiphy_priv(wiphy);
2230 	int err;
2231 
2232 	if (changed & WIPHY_PARAM_FRAG_THRESHOLD) {
2233 		err = drv_set_frag_threshold(local, wiphy->frag_threshold);
2234 
2235 		if (err)
2236 			return err;
2237 	}
2238 
2239 	if (changed & WIPHY_PARAM_COVERAGE_CLASS) {
2240 		err = drv_set_coverage_class(local, wiphy->coverage_class);
2241 
2242 		if (err)
2243 			return err;
2244 	}
2245 
2246 	if (changed & WIPHY_PARAM_RTS_THRESHOLD) {
2247 		err = drv_set_rts_threshold(local, wiphy->rts_threshold);
2248 
2249 		if (err)
2250 			return err;
2251 	}
2252 
2253 	if (changed & WIPHY_PARAM_RETRY_SHORT) {
2254 		if (wiphy->retry_short > IEEE80211_MAX_TX_RETRY)
2255 			return -EINVAL;
2256 		local->hw.conf.short_frame_max_tx_count = wiphy->retry_short;
2257 	}
2258 	if (changed & WIPHY_PARAM_RETRY_LONG) {
2259 		if (wiphy->retry_long > IEEE80211_MAX_TX_RETRY)
2260 			return -EINVAL;
2261 		local->hw.conf.long_frame_max_tx_count = wiphy->retry_long;
2262 	}
2263 	if (changed &
2264 	    (WIPHY_PARAM_RETRY_SHORT | WIPHY_PARAM_RETRY_LONG))
2265 		ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_RETRY_LIMITS);
2266 
2267 	return 0;
2268 }
2269 
2270 static int ieee80211_set_tx_power(struct wiphy *wiphy,
2271 				  struct wireless_dev *wdev,
2272 				  enum nl80211_tx_power_setting type, int mbm)
2273 {
2274 	struct ieee80211_local *local = wiphy_priv(wiphy);
2275 	struct ieee80211_sub_if_data *sdata;
2276 
2277 	if (wdev) {
2278 		sdata = IEEE80211_WDEV_TO_SUB_IF(wdev);
2279 
2280 		switch (type) {
2281 		case NL80211_TX_POWER_AUTOMATIC:
2282 			sdata->user_power_level = IEEE80211_UNSET_POWER_LEVEL;
2283 			break;
2284 		case NL80211_TX_POWER_LIMITED:
2285 		case NL80211_TX_POWER_FIXED:
2286 			if (mbm < 0 || (mbm % 100))
2287 				return -EOPNOTSUPP;
2288 			sdata->user_power_level = MBM_TO_DBM(mbm);
2289 			break;
2290 		}
2291 
2292 		ieee80211_recalc_txpower(sdata);
2293 
2294 		return 0;
2295 	}
2296 
2297 	switch (type) {
2298 	case NL80211_TX_POWER_AUTOMATIC:
2299 		local->user_power_level = IEEE80211_UNSET_POWER_LEVEL;
2300 		break;
2301 	case NL80211_TX_POWER_LIMITED:
2302 	case NL80211_TX_POWER_FIXED:
2303 		if (mbm < 0 || (mbm % 100))
2304 			return -EOPNOTSUPP;
2305 		local->user_power_level = MBM_TO_DBM(mbm);
2306 		break;
2307 	}
2308 
2309 	mutex_lock(&local->iflist_mtx);
2310 	list_for_each_entry(sdata, &local->interfaces, list)
2311 		sdata->user_power_level = local->user_power_level;
2312 	list_for_each_entry(sdata, &local->interfaces, list)
2313 		ieee80211_recalc_txpower(sdata);
2314 	mutex_unlock(&local->iflist_mtx);
2315 
2316 	return 0;
2317 }
2318 
2319 static int ieee80211_get_tx_power(struct wiphy *wiphy,
2320 				  struct wireless_dev *wdev,
2321 				  int *dbm)
2322 {
2323 	struct ieee80211_local *local = wiphy_priv(wiphy);
2324 	struct ieee80211_sub_if_data *sdata = IEEE80211_WDEV_TO_SUB_IF(wdev);
2325 
2326 	if (!local->use_chanctx)
2327 		*dbm = local->hw.conf.power_level;
2328 	else
2329 		*dbm = sdata->vif.bss_conf.txpower;
2330 
2331 	return 0;
2332 }
2333 
2334 static int ieee80211_set_wds_peer(struct wiphy *wiphy, struct net_device *dev,
2335 				  const u8 *addr)
2336 {
2337 	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
2338 
2339 	memcpy(&sdata->u.wds.remote_addr, addr, ETH_ALEN);
2340 
2341 	return 0;
2342 }
2343 
2344 static void ieee80211_rfkill_poll(struct wiphy *wiphy)
2345 {
2346 	struct ieee80211_local *local = wiphy_priv(wiphy);
2347 
2348 	drv_rfkill_poll(local);
2349 }
2350 
2351 #ifdef CONFIG_NL80211_TESTMODE
2352 static int ieee80211_testmode_cmd(struct wiphy *wiphy,
2353 				  struct wireless_dev *wdev,
2354 				  void *data, int len)
2355 {
2356 	struct ieee80211_local *local = wiphy_priv(wiphy);
2357 	struct ieee80211_vif *vif = NULL;
2358 
2359 	if (!local->ops->testmode_cmd)
2360 		return -EOPNOTSUPP;
2361 
2362 	if (wdev) {
2363 		struct ieee80211_sub_if_data *sdata;
2364 
2365 		sdata = IEEE80211_WDEV_TO_SUB_IF(wdev);
2366 		if (sdata->flags & IEEE80211_SDATA_IN_DRIVER)
2367 			vif = &sdata->vif;
2368 	}
2369 
2370 	return local->ops->testmode_cmd(&local->hw, vif, data, len);
2371 }
2372 
2373 static int ieee80211_testmode_dump(struct wiphy *wiphy,
2374 				   struct sk_buff *skb,
2375 				   struct netlink_callback *cb,
2376 				   void *data, int len)
2377 {
2378 	struct ieee80211_local *local = wiphy_priv(wiphy);
2379 
2380 	if (!local->ops->testmode_dump)
2381 		return -EOPNOTSUPP;
2382 
2383 	return local->ops->testmode_dump(&local->hw, skb, cb, data, len);
2384 }
2385 #endif
2386 
2387 int __ieee80211_request_smps_ap(struct ieee80211_sub_if_data *sdata,
2388 				enum ieee80211_smps_mode smps_mode)
2389 {
2390 	struct sta_info *sta;
2391 	enum ieee80211_smps_mode old_req;
2392 	int i;
2393 
2394 	if (WARN_ON_ONCE(sdata->vif.type != NL80211_IFTYPE_AP))
2395 		return -EINVAL;
2396 
2397 	if (sdata->vif.bss_conf.chandef.width == NL80211_CHAN_WIDTH_20_NOHT)
2398 		return 0;
2399 
2400 	old_req = sdata->u.ap.req_smps;
2401 	sdata->u.ap.req_smps = smps_mode;
2402 
2403 	/* AUTOMATIC doesn't mean much for AP - don't allow it */
2404 	if (old_req == smps_mode ||
2405 	    smps_mode == IEEE80211_SMPS_AUTOMATIC)
2406 		return 0;
2407 
2408 	 /* If no associated stations, there's no need to do anything */
2409 	if (!atomic_read(&sdata->u.ap.num_mcast_sta)) {
2410 		sdata->smps_mode = smps_mode;
2411 		ieee80211_queue_work(&sdata->local->hw, &sdata->recalc_smps);
2412 		return 0;
2413 	}
2414 
2415 	ht_dbg(sdata,
2416 	       "SMSP %d requested in AP mode, sending Action frame to %d stations\n",
2417 	       smps_mode, atomic_read(&sdata->u.ap.num_mcast_sta));
2418 
2419 	mutex_lock(&sdata->local->sta_mtx);
2420 	for (i = 0; i < STA_HASH_SIZE; i++) {
2421 		for (sta = rcu_dereference_protected(sdata->local->sta_hash[i],
2422 				lockdep_is_held(&sdata->local->sta_mtx));
2423 		     sta;
2424 		     sta = rcu_dereference_protected(sta->hnext,
2425 				lockdep_is_held(&sdata->local->sta_mtx))) {
2426 			/*
2427 			 * Only stations associated to our AP and
2428 			 * associated VLANs
2429 			 */
2430 			if (sta->sdata->bss != &sdata->u.ap)
2431 				continue;
2432 
2433 			/* This station doesn't support MIMO - skip it */
2434 			if (sta_info_tx_streams(sta) == 1)
2435 				continue;
2436 
2437 			/*
2438 			 * Don't wake up a STA just to send the action frame
2439 			 * unless we are getting more restrictive.
2440 			 */
2441 			if (test_sta_flag(sta, WLAN_STA_PS_STA) &&
2442 			    !ieee80211_smps_is_restrictive(sta->known_smps_mode,
2443 							   smps_mode)) {
2444 				ht_dbg(sdata,
2445 				       "Won't send SMPS to sleeping STA %pM\n",
2446 				       sta->sta.addr);
2447 				continue;
2448 			}
2449 
2450 			/*
2451 			 * If the STA is not authorized, wait until it gets
2452 			 * authorized and the action frame will be sent then.
2453 			 */
2454 			if (!test_sta_flag(sta, WLAN_STA_AUTHORIZED))
2455 				continue;
2456 
2457 			ht_dbg(sdata, "Sending SMPS to %pM\n", sta->sta.addr);
2458 			ieee80211_send_smps_action(sdata, smps_mode,
2459 						   sta->sta.addr,
2460 						   sdata->vif.bss_conf.bssid);
2461 		}
2462 	}
2463 	mutex_unlock(&sdata->local->sta_mtx);
2464 
2465 	sdata->smps_mode = smps_mode;
2466 	ieee80211_queue_work(&sdata->local->hw, &sdata->recalc_smps);
2467 
2468 	return 0;
2469 }
2470 
2471 int __ieee80211_request_smps_mgd(struct ieee80211_sub_if_data *sdata,
2472 				 enum ieee80211_smps_mode smps_mode)
2473 {
2474 	const u8 *ap;
2475 	enum ieee80211_smps_mode old_req;
2476 	int err;
2477 
2478 	lockdep_assert_held(&sdata->wdev.mtx);
2479 
2480 	if (WARN_ON_ONCE(sdata->vif.type != NL80211_IFTYPE_STATION))
2481 		return -EINVAL;
2482 
2483 	old_req = sdata->u.mgd.req_smps;
2484 	sdata->u.mgd.req_smps = smps_mode;
2485 
2486 	if (old_req == smps_mode &&
2487 	    smps_mode != IEEE80211_SMPS_AUTOMATIC)
2488 		return 0;
2489 
2490 	/*
2491 	 * If not associated, or current association is not an HT
2492 	 * association, there's no need to do anything, just store
2493 	 * the new value until we associate.
2494 	 */
2495 	if (!sdata->u.mgd.associated ||
2496 	    sdata->vif.bss_conf.chandef.width == NL80211_CHAN_WIDTH_20_NOHT)
2497 		return 0;
2498 
2499 	ap = sdata->u.mgd.associated->bssid;
2500 
2501 	if (smps_mode == IEEE80211_SMPS_AUTOMATIC) {
2502 		if (sdata->u.mgd.powersave)
2503 			smps_mode = IEEE80211_SMPS_DYNAMIC;
2504 		else
2505 			smps_mode = IEEE80211_SMPS_OFF;
2506 	}
2507 
2508 	/* send SM PS frame to AP */
2509 	err = ieee80211_send_smps_action(sdata, smps_mode,
2510 					 ap, ap);
2511 	if (err)
2512 		sdata->u.mgd.req_smps = old_req;
2513 
2514 	return err;
2515 }
2516 
2517 static int ieee80211_set_power_mgmt(struct wiphy *wiphy, struct net_device *dev,
2518 				    bool enabled, int timeout)
2519 {
2520 	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
2521 	struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
2522 
2523 	if (sdata->vif.type != NL80211_IFTYPE_STATION)
2524 		return -EOPNOTSUPP;
2525 
2526 	if (!(local->hw.flags & IEEE80211_HW_SUPPORTS_PS))
2527 		return -EOPNOTSUPP;
2528 
2529 	if (enabled == sdata->u.mgd.powersave &&
2530 	    timeout == local->dynamic_ps_forced_timeout)
2531 		return 0;
2532 
2533 	sdata->u.mgd.powersave = enabled;
2534 	local->dynamic_ps_forced_timeout = timeout;
2535 
2536 	/* no change, but if automatic follow powersave */
2537 	sdata_lock(sdata);
2538 	__ieee80211_request_smps_mgd(sdata, sdata->u.mgd.req_smps);
2539 	sdata_unlock(sdata);
2540 
2541 	if (local->hw.flags & IEEE80211_HW_SUPPORTS_DYNAMIC_PS)
2542 		ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_PS);
2543 
2544 	ieee80211_recalc_ps(local, -1);
2545 	ieee80211_recalc_ps_vif(sdata);
2546 
2547 	return 0;
2548 }
2549 
2550 static int ieee80211_set_cqm_rssi_config(struct wiphy *wiphy,
2551 					 struct net_device *dev,
2552 					 s32 rssi_thold, u32 rssi_hyst)
2553 {
2554 	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
2555 	struct ieee80211_vif *vif = &sdata->vif;
2556 	struct ieee80211_bss_conf *bss_conf = &vif->bss_conf;
2557 
2558 	if (rssi_thold == bss_conf->cqm_rssi_thold &&
2559 	    rssi_hyst == bss_conf->cqm_rssi_hyst)
2560 		return 0;
2561 
2562 	bss_conf->cqm_rssi_thold = rssi_thold;
2563 	bss_conf->cqm_rssi_hyst = rssi_hyst;
2564 
2565 	/* tell the driver upon association, unless already associated */
2566 	if (sdata->u.mgd.associated &&
2567 	    sdata->vif.driver_flags & IEEE80211_VIF_SUPPORTS_CQM_RSSI)
2568 		ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_CQM);
2569 
2570 	return 0;
2571 }
2572 
2573 static int ieee80211_set_bitrate_mask(struct wiphy *wiphy,
2574 				      struct net_device *dev,
2575 				      const u8 *addr,
2576 				      const struct cfg80211_bitrate_mask *mask)
2577 {
2578 	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
2579 	struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
2580 	int i, ret;
2581 
2582 	if (!ieee80211_sdata_running(sdata))
2583 		return -ENETDOWN;
2584 
2585 	if (local->hw.flags & IEEE80211_HW_HAS_RATE_CONTROL) {
2586 		ret = drv_set_bitrate_mask(local, sdata, mask);
2587 		if (ret)
2588 			return ret;
2589 	}
2590 
2591 	for (i = 0; i < IEEE80211_NUM_BANDS; i++) {
2592 		struct ieee80211_supported_band *sband = wiphy->bands[i];
2593 		int j;
2594 
2595 		sdata->rc_rateidx_mask[i] = mask->control[i].legacy;
2596 		memcpy(sdata->rc_rateidx_mcs_mask[i], mask->control[i].ht_mcs,
2597 		       sizeof(mask->control[i].ht_mcs));
2598 
2599 		sdata->rc_has_mcs_mask[i] = false;
2600 		if (!sband)
2601 			continue;
2602 
2603 		for (j = 0; j < IEEE80211_HT_MCS_MASK_LEN; j++)
2604 			if (~sdata->rc_rateidx_mcs_mask[i][j]) {
2605 				sdata->rc_has_mcs_mask[i] = true;
2606 				break;
2607 			}
2608 	}
2609 
2610 	return 0;
2611 }
2612 
2613 static int ieee80211_start_roc_work(struct ieee80211_local *local,
2614 				    struct ieee80211_sub_if_data *sdata,
2615 				    struct ieee80211_channel *channel,
2616 				    unsigned int duration, u64 *cookie,
2617 				    struct sk_buff *txskb,
2618 				    enum ieee80211_roc_type type)
2619 {
2620 	struct ieee80211_roc_work *roc, *tmp;
2621 	bool queued = false;
2622 	int ret;
2623 
2624 	lockdep_assert_held(&local->mtx);
2625 
2626 	if (local->use_chanctx && !local->ops->remain_on_channel)
2627 		return -EOPNOTSUPP;
2628 
2629 	roc = kzalloc(sizeof(*roc), GFP_KERNEL);
2630 	if (!roc)
2631 		return -ENOMEM;
2632 
2633 	roc->chan = channel;
2634 	roc->duration = duration;
2635 	roc->req_duration = duration;
2636 	roc->frame = txskb;
2637 	roc->type = type;
2638 	roc->mgmt_tx_cookie = (unsigned long)txskb;
2639 	roc->sdata = sdata;
2640 	INIT_DELAYED_WORK(&roc->work, ieee80211_sw_roc_work);
2641 	INIT_LIST_HEAD(&roc->dependents);
2642 
2643 	/*
2644 	 * cookie is either the roc cookie (for normal roc)
2645 	 * or the SKB (for mgmt TX)
2646 	 */
2647 	if (!txskb) {
2648 		/* local->mtx protects this */
2649 		local->roc_cookie_counter++;
2650 		roc->cookie = local->roc_cookie_counter;
2651 		/* wow, you wrapped 64 bits ... more likely a bug */
2652 		if (WARN_ON(roc->cookie == 0)) {
2653 			roc->cookie = 1;
2654 			local->roc_cookie_counter++;
2655 		}
2656 		*cookie = roc->cookie;
2657 	} else {
2658 		*cookie = (unsigned long)txskb;
2659 	}
2660 
2661 	/* if there's one pending or we're scanning, queue this one */
2662 	if (!list_empty(&local->roc_list) ||
2663 	    local->scanning || local->radar_detect_enabled)
2664 		goto out_check_combine;
2665 
2666 	/* if not HW assist, just queue & schedule work */
2667 	if (!local->ops->remain_on_channel) {
2668 		ieee80211_queue_delayed_work(&local->hw, &roc->work, 0);
2669 		goto out_queue;
2670 	}
2671 
2672 	/* otherwise actually kick it off here (for error handling) */
2673 
2674 	/*
2675 	 * If the duration is zero, then the driver
2676 	 * wouldn't actually do anything. Set it to
2677 	 * 10 for now.
2678 	 *
2679 	 * TODO: cancel the off-channel operation
2680 	 *       when we get the SKB's TX status and
2681 	 *       the wait time was zero before.
2682 	 */
2683 	if (!duration)
2684 		duration = 10;
2685 
2686 	ret = drv_remain_on_channel(local, sdata, channel, duration, type);
2687 	if (ret) {
2688 		kfree(roc);
2689 		return ret;
2690 	}
2691 
2692 	roc->started = true;
2693 	goto out_queue;
2694 
2695  out_check_combine:
2696 	list_for_each_entry(tmp, &local->roc_list, list) {
2697 		if (tmp->chan != channel || tmp->sdata != sdata)
2698 			continue;
2699 
2700 		/*
2701 		 * Extend this ROC if possible:
2702 		 *
2703 		 * If it hasn't started yet, just increase the duration
2704 		 * and add the new one to the list of dependents.
2705 		 * If the type of the new ROC has higher priority, modify the
2706 		 * type of the previous one to match that of the new one.
2707 		 */
2708 		if (!tmp->started) {
2709 			list_add_tail(&roc->list, &tmp->dependents);
2710 			tmp->duration = max(tmp->duration, roc->duration);
2711 			tmp->type = max(tmp->type, roc->type);
2712 			queued = true;
2713 			break;
2714 		}
2715 
2716 		/* If it has already started, it's more difficult ... */
2717 		if (local->ops->remain_on_channel) {
2718 			unsigned long j = jiffies;
2719 
2720 			/*
2721 			 * In the offloaded ROC case, if it hasn't begun, add
2722 			 * this new one to the dependent list to be handled
2723 			 * when the master one begins. If it has begun,
2724 			 * check that there's still a minimum time left and
2725 			 * if so, start this one, transmitting the frame, but
2726 			 * add it to the list directly after this one with
2727 			 * a reduced time so we'll ask the driver to execute
2728 			 * it right after finishing the previous one, in the
2729 			 * hope that it'll also be executed right afterwards,
2730 			 * effectively extending the old one.
2731 			 * If there's no minimum time left, just add it to the
2732 			 * normal list.
2733 			 * TODO: the ROC type is ignored here, assuming that it
2734 			 * is better to immediately use the current ROC.
2735 			 */
2736 			if (!tmp->hw_begun) {
2737 				list_add_tail(&roc->list, &tmp->dependents);
2738 				queued = true;
2739 				break;
2740 			}
2741 
2742 			if (time_before(j + IEEE80211_ROC_MIN_LEFT,
2743 					tmp->hw_start_time +
2744 					msecs_to_jiffies(tmp->duration))) {
2745 				int new_dur;
2746 
2747 				ieee80211_handle_roc_started(roc);
2748 
2749 				new_dur = roc->duration -
2750 					  jiffies_to_msecs(tmp->hw_start_time +
2751 							   msecs_to_jiffies(
2752 								tmp->duration) -
2753 							   j);
2754 
2755 				if (new_dur > 0) {
2756 					/* add right after tmp */
2757 					list_add(&roc->list, &tmp->list);
2758 				} else {
2759 					list_add_tail(&roc->list,
2760 						      &tmp->dependents);
2761 				}
2762 				queued = true;
2763 			}
2764 		} else if (del_timer_sync(&tmp->work.timer)) {
2765 			unsigned long new_end;
2766 
2767 			/*
2768 			 * In the software ROC case, cancel the timer, if
2769 			 * that fails then the finish work is already
2770 			 * queued/pending and thus we queue the new ROC
2771 			 * normally, if that succeeds then we can extend
2772 			 * the timer duration and TX the frame (if any.)
2773 			 */
2774 
2775 			list_add_tail(&roc->list, &tmp->dependents);
2776 			queued = true;
2777 
2778 			new_end = jiffies + msecs_to_jiffies(roc->duration);
2779 
2780 			/* ok, it was started & we canceled timer */
2781 			if (time_after(new_end, tmp->work.timer.expires))
2782 				mod_timer(&tmp->work.timer, new_end);
2783 			else
2784 				add_timer(&tmp->work.timer);
2785 
2786 			ieee80211_handle_roc_started(roc);
2787 		}
2788 		break;
2789 	}
2790 
2791  out_queue:
2792 	if (!queued)
2793 		list_add_tail(&roc->list, &local->roc_list);
2794 
2795 	return 0;
2796 }
2797 
2798 static int ieee80211_remain_on_channel(struct wiphy *wiphy,
2799 				       struct wireless_dev *wdev,
2800 				       struct ieee80211_channel *chan,
2801 				       unsigned int duration,
2802 				       u64 *cookie)
2803 {
2804 	struct ieee80211_sub_if_data *sdata = IEEE80211_WDEV_TO_SUB_IF(wdev);
2805 	struct ieee80211_local *local = sdata->local;
2806 	int ret;
2807 
2808 	mutex_lock(&local->mtx);
2809 	ret = ieee80211_start_roc_work(local, sdata, chan,
2810 				       duration, cookie, NULL,
2811 				       IEEE80211_ROC_TYPE_NORMAL);
2812 	mutex_unlock(&local->mtx);
2813 
2814 	return ret;
2815 }
2816 
2817 static int ieee80211_cancel_roc(struct ieee80211_local *local,
2818 				u64 cookie, bool mgmt_tx)
2819 {
2820 	struct ieee80211_roc_work *roc, *tmp, *found = NULL;
2821 	int ret;
2822 
2823 	mutex_lock(&local->mtx);
2824 	list_for_each_entry_safe(roc, tmp, &local->roc_list, list) {
2825 		struct ieee80211_roc_work *dep, *tmp2;
2826 
2827 		list_for_each_entry_safe(dep, tmp2, &roc->dependents, list) {
2828 			if (!mgmt_tx && dep->cookie != cookie)
2829 				continue;
2830 			else if (mgmt_tx && dep->mgmt_tx_cookie != cookie)
2831 				continue;
2832 			/* found dependent item -- just remove it */
2833 			list_del(&dep->list);
2834 			mutex_unlock(&local->mtx);
2835 
2836 			ieee80211_roc_notify_destroy(dep, true);
2837 			return 0;
2838 		}
2839 
2840 		if (!mgmt_tx && roc->cookie != cookie)
2841 			continue;
2842 		else if (mgmt_tx && roc->mgmt_tx_cookie != cookie)
2843 			continue;
2844 
2845 		found = roc;
2846 		break;
2847 	}
2848 
2849 	if (!found) {
2850 		mutex_unlock(&local->mtx);
2851 		return -ENOENT;
2852 	}
2853 
2854 	/*
2855 	 * We found the item to cancel, so do that. Note that it
2856 	 * may have dependents, which we also cancel (and send
2857 	 * the expired signal for.) Not doing so would be quite
2858 	 * tricky here, but we may need to fix it later.
2859 	 */
2860 
2861 	if (local->ops->remain_on_channel) {
2862 		if (found->started) {
2863 			ret = drv_cancel_remain_on_channel(local);
2864 			if (WARN_ON_ONCE(ret)) {
2865 				mutex_unlock(&local->mtx);
2866 				return ret;
2867 			}
2868 		}
2869 
2870 		list_del(&found->list);
2871 
2872 		if (found->started)
2873 			ieee80211_start_next_roc(local);
2874 		mutex_unlock(&local->mtx);
2875 
2876 		ieee80211_roc_notify_destroy(found, true);
2877 	} else {
2878 		/* work may be pending so use it all the time */
2879 		found->abort = true;
2880 		ieee80211_queue_delayed_work(&local->hw, &found->work, 0);
2881 
2882 		mutex_unlock(&local->mtx);
2883 
2884 		/* work will clean up etc */
2885 		flush_delayed_work(&found->work);
2886 		WARN_ON(!found->to_be_freed);
2887 		kfree(found);
2888 	}
2889 
2890 	return 0;
2891 }
2892 
2893 static int ieee80211_cancel_remain_on_channel(struct wiphy *wiphy,
2894 					      struct wireless_dev *wdev,
2895 					      u64 cookie)
2896 {
2897 	struct ieee80211_sub_if_data *sdata = IEEE80211_WDEV_TO_SUB_IF(wdev);
2898 	struct ieee80211_local *local = sdata->local;
2899 
2900 	return ieee80211_cancel_roc(local, cookie, false);
2901 }
2902 
2903 static int ieee80211_start_radar_detection(struct wiphy *wiphy,
2904 					   struct net_device *dev,
2905 					   struct cfg80211_chan_def *chandef)
2906 {
2907 	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
2908 	struct ieee80211_local *local = sdata->local;
2909 	unsigned long timeout;
2910 	int err;
2911 
2912 	mutex_lock(&local->mtx);
2913 	if (!list_empty(&local->roc_list) || local->scanning) {
2914 		err = -EBUSY;
2915 		goto out_unlock;
2916 	}
2917 
2918 	/* whatever, but channel contexts should not complain about that one */
2919 	sdata->smps_mode = IEEE80211_SMPS_OFF;
2920 	sdata->needed_rx_chains = local->rx_chains;
2921 	sdata->radar_required = true;
2922 
2923 	err = ieee80211_vif_use_channel(sdata, chandef,
2924 					IEEE80211_CHANCTX_SHARED);
2925 	if (err)
2926 		goto out_unlock;
2927 
2928 	timeout = msecs_to_jiffies(IEEE80211_DFS_MIN_CAC_TIME_MS);
2929 	ieee80211_queue_delayed_work(&sdata->local->hw,
2930 				     &sdata->dfs_cac_timer_work, timeout);
2931 
2932  out_unlock:
2933 	mutex_unlock(&local->mtx);
2934 	return err;
2935 }
2936 
2937 static struct cfg80211_beacon_data *
2938 cfg80211_beacon_dup(struct cfg80211_beacon_data *beacon)
2939 {
2940 	struct cfg80211_beacon_data *new_beacon;
2941 	u8 *pos;
2942 	int len;
2943 
2944 	len = beacon->head_len + beacon->tail_len + beacon->beacon_ies_len +
2945 	      beacon->proberesp_ies_len + beacon->assocresp_ies_len +
2946 	      beacon->probe_resp_len;
2947 
2948 	new_beacon = kzalloc(sizeof(*new_beacon) + len, GFP_KERNEL);
2949 	if (!new_beacon)
2950 		return NULL;
2951 
2952 	pos = (u8 *)(new_beacon + 1);
2953 	if (beacon->head_len) {
2954 		new_beacon->head_len = beacon->head_len;
2955 		new_beacon->head = pos;
2956 		memcpy(pos, beacon->head, beacon->head_len);
2957 		pos += beacon->head_len;
2958 	}
2959 	if (beacon->tail_len) {
2960 		new_beacon->tail_len = beacon->tail_len;
2961 		new_beacon->tail = pos;
2962 		memcpy(pos, beacon->tail, beacon->tail_len);
2963 		pos += beacon->tail_len;
2964 	}
2965 	if (beacon->beacon_ies_len) {
2966 		new_beacon->beacon_ies_len = beacon->beacon_ies_len;
2967 		new_beacon->beacon_ies = pos;
2968 		memcpy(pos, beacon->beacon_ies, beacon->beacon_ies_len);
2969 		pos += beacon->beacon_ies_len;
2970 	}
2971 	if (beacon->proberesp_ies_len) {
2972 		new_beacon->proberesp_ies_len = beacon->proberesp_ies_len;
2973 		new_beacon->proberesp_ies = pos;
2974 		memcpy(pos, beacon->proberesp_ies, beacon->proberesp_ies_len);
2975 		pos += beacon->proberesp_ies_len;
2976 	}
2977 	if (beacon->assocresp_ies_len) {
2978 		new_beacon->assocresp_ies_len = beacon->assocresp_ies_len;
2979 		new_beacon->assocresp_ies = pos;
2980 		memcpy(pos, beacon->assocresp_ies, beacon->assocresp_ies_len);
2981 		pos += beacon->assocresp_ies_len;
2982 	}
2983 	if (beacon->probe_resp_len) {
2984 		new_beacon->probe_resp_len = beacon->probe_resp_len;
2985 		beacon->probe_resp = pos;
2986 		memcpy(pos, beacon->probe_resp, beacon->probe_resp_len);
2987 		pos += beacon->probe_resp_len;
2988 	}
2989 
2990 	return new_beacon;
2991 }
2992 
2993 void ieee80211_csa_finalize_work(struct work_struct *work)
2994 {
2995 	struct ieee80211_sub_if_data *sdata =
2996 		container_of(work, struct ieee80211_sub_if_data,
2997 			     csa_finalize_work);
2998 	struct ieee80211_local *local = sdata->local;
2999 	int err, changed = 0;
3000 
3001 	sdata_lock(sdata);
3002 	/* AP might have been stopped while waiting for the lock. */
3003 	if (!sdata->vif.csa_active)
3004 		goto unlock;
3005 
3006 	if (!ieee80211_sdata_running(sdata))
3007 		goto unlock;
3008 
3009 	sdata->radar_required = sdata->csa_radar_required;
3010 	mutex_lock(&local->mtx);
3011 	err = ieee80211_vif_change_channel(sdata, &changed);
3012 	mutex_unlock(&local->mtx);
3013 	if (WARN_ON(err < 0))
3014 		goto unlock;
3015 
3016 	if (!local->use_chanctx) {
3017 		local->_oper_chandef = sdata->csa_chandef;
3018 		ieee80211_hw_config(local, 0);
3019 	}
3020 
3021 	ieee80211_bss_info_change_notify(sdata, changed);
3022 
3023 	sdata->vif.csa_active = false;
3024 	switch (sdata->vif.type) {
3025 	case NL80211_IFTYPE_AP:
3026 		err = ieee80211_assign_beacon(sdata, sdata->u.ap.next_beacon);
3027 		if (err < 0)
3028 			goto unlock;
3029 
3030 		changed |= err;
3031 		kfree(sdata->u.ap.next_beacon);
3032 		sdata->u.ap.next_beacon = NULL;
3033 
3034 		ieee80211_bss_info_change_notify(sdata, err);
3035 		break;
3036 	case NL80211_IFTYPE_ADHOC:
3037 		ieee80211_ibss_finish_csa(sdata);
3038 		break;
3039 #ifdef CONFIG_MAC80211_MESH
3040 	case NL80211_IFTYPE_MESH_POINT:
3041 		err = ieee80211_mesh_finish_csa(sdata);
3042 		if (err < 0)
3043 			goto unlock;
3044 		break;
3045 #endif
3046 	default:
3047 		WARN_ON(1);
3048 		goto unlock;
3049 	}
3050 
3051 	ieee80211_wake_queues_by_reason(&sdata->local->hw,
3052 					IEEE80211_MAX_QUEUE_MAP,
3053 					IEEE80211_QUEUE_STOP_REASON_CSA);
3054 
3055 	cfg80211_ch_switch_notify(sdata->dev, &sdata->csa_chandef);
3056 
3057 unlock:
3058 	sdata_unlock(sdata);
3059 }
3060 
3061 int ieee80211_channel_switch(struct wiphy *wiphy, struct net_device *dev,
3062 			     struct cfg80211_csa_settings *params)
3063 {
3064 	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
3065 	struct ieee80211_local *local = sdata->local;
3066 	struct ieee80211_chanctx_conf *chanctx_conf;
3067 	struct ieee80211_chanctx *chanctx;
3068 	struct ieee80211_if_mesh __maybe_unused *ifmsh;
3069 	int err, num_chanctx;
3070 
3071 	lockdep_assert_held(&sdata->wdev.mtx);
3072 
3073 	if (!list_empty(&local->roc_list) || local->scanning)
3074 		return -EBUSY;
3075 
3076 	if (sdata->wdev.cac_started)
3077 		return -EBUSY;
3078 
3079 	if (cfg80211_chandef_identical(&params->chandef,
3080 				       &sdata->vif.bss_conf.chandef))
3081 		return -EINVAL;
3082 
3083 	rcu_read_lock();
3084 	chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf);
3085 	if (!chanctx_conf) {
3086 		rcu_read_unlock();
3087 		return -EBUSY;
3088 	}
3089 
3090 	/* don't handle for multi-VIF cases */
3091 	chanctx = container_of(chanctx_conf, struct ieee80211_chanctx, conf);
3092 	if (chanctx->refcount > 1) {
3093 		rcu_read_unlock();
3094 		return -EBUSY;
3095 	}
3096 	num_chanctx = 0;
3097 	list_for_each_entry_rcu(chanctx, &local->chanctx_list, list)
3098 		num_chanctx++;
3099 	rcu_read_unlock();
3100 
3101 	if (num_chanctx > 1)
3102 		return -EBUSY;
3103 
3104 	/* don't allow another channel switch if one is already active. */
3105 	if (sdata->vif.csa_active)
3106 		return -EBUSY;
3107 
3108 	switch (sdata->vif.type) {
3109 	case NL80211_IFTYPE_AP:
3110 		sdata->csa_counter_offset_beacon =
3111 			params->counter_offset_beacon;
3112 		sdata->csa_counter_offset_presp = params->counter_offset_presp;
3113 		sdata->u.ap.next_beacon =
3114 			cfg80211_beacon_dup(&params->beacon_after);
3115 		if (!sdata->u.ap.next_beacon)
3116 			return -ENOMEM;
3117 
3118 		err = ieee80211_assign_beacon(sdata, &params->beacon_csa);
3119 		if (err < 0) {
3120 			kfree(sdata->u.ap.next_beacon);
3121 			return err;
3122 		}
3123 		break;
3124 	case NL80211_IFTYPE_ADHOC:
3125 		if (!sdata->vif.bss_conf.ibss_joined)
3126 			return -EINVAL;
3127 
3128 		if (params->chandef.width != sdata->u.ibss.chandef.width)
3129 			return -EINVAL;
3130 
3131 		switch (params->chandef.width) {
3132 		case NL80211_CHAN_WIDTH_40:
3133 			if (cfg80211_get_chandef_type(&params->chandef) !=
3134 			    cfg80211_get_chandef_type(&sdata->u.ibss.chandef))
3135 				return -EINVAL;
3136 		case NL80211_CHAN_WIDTH_5:
3137 		case NL80211_CHAN_WIDTH_10:
3138 		case NL80211_CHAN_WIDTH_20_NOHT:
3139 		case NL80211_CHAN_WIDTH_20:
3140 			break;
3141 		default:
3142 			return -EINVAL;
3143 		}
3144 
3145 		/* changes into another band are not supported */
3146 		if (sdata->u.ibss.chandef.chan->band !=
3147 		    params->chandef.chan->band)
3148 			return -EINVAL;
3149 
3150 		err = ieee80211_ibss_csa_beacon(sdata, params);
3151 		if (err < 0)
3152 			return err;
3153 		break;
3154 #ifdef CONFIG_MAC80211_MESH
3155 	case NL80211_IFTYPE_MESH_POINT:
3156 		ifmsh = &sdata->u.mesh;
3157 
3158 		if (!ifmsh->mesh_id)
3159 			return -EINVAL;
3160 
3161 		if (params->chandef.width != sdata->vif.bss_conf.chandef.width)
3162 			return -EINVAL;
3163 
3164 		/* changes into another band are not supported */
3165 		if (sdata->vif.bss_conf.chandef.chan->band !=
3166 		    params->chandef.chan->band)
3167 			return -EINVAL;
3168 
3169 		ifmsh->chsw_init = true;
3170 		if (!ifmsh->pre_value)
3171 			ifmsh->pre_value = 1;
3172 		else
3173 			ifmsh->pre_value++;
3174 
3175 		err = ieee80211_mesh_csa_beacon(sdata, params, true);
3176 		if (err < 0) {
3177 			ifmsh->chsw_init = false;
3178 			return err;
3179 		}
3180 		break;
3181 #endif
3182 	default:
3183 		return -EOPNOTSUPP;
3184 	}
3185 
3186 	sdata->csa_radar_required = params->radar_required;
3187 
3188 	if (params->block_tx)
3189 		ieee80211_stop_queues_by_reason(&local->hw,
3190 				IEEE80211_MAX_QUEUE_MAP,
3191 				IEEE80211_QUEUE_STOP_REASON_CSA);
3192 
3193 	sdata->csa_chandef = params->chandef;
3194 	sdata->vif.csa_active = true;
3195 
3196 	ieee80211_bss_info_change_notify(sdata, err);
3197 	drv_channel_switch_beacon(sdata, &params->chandef);
3198 
3199 	return 0;
3200 }
3201 
3202 static int ieee80211_mgmt_tx(struct wiphy *wiphy, struct wireless_dev *wdev,
3203 			     struct cfg80211_mgmt_tx_params *params,
3204 			     u64 *cookie)
3205 {
3206 	struct ieee80211_sub_if_data *sdata = IEEE80211_WDEV_TO_SUB_IF(wdev);
3207 	struct ieee80211_local *local = sdata->local;
3208 	struct sk_buff *skb;
3209 	struct sta_info *sta;
3210 	const struct ieee80211_mgmt *mgmt = (void *)params->buf;
3211 	bool need_offchan = false;
3212 	u32 flags;
3213 	int ret;
3214 
3215 	if (params->dont_wait_for_ack)
3216 		flags = IEEE80211_TX_CTL_NO_ACK;
3217 	else
3218 		flags = IEEE80211_TX_INTFL_NL80211_FRAME_TX |
3219 			IEEE80211_TX_CTL_REQ_TX_STATUS;
3220 
3221 	if (params->no_cck)
3222 		flags |= IEEE80211_TX_CTL_NO_CCK_RATE;
3223 
3224 	switch (sdata->vif.type) {
3225 	case NL80211_IFTYPE_ADHOC:
3226 		if (!sdata->vif.bss_conf.ibss_joined)
3227 			need_offchan = true;
3228 		/* fall through */
3229 #ifdef CONFIG_MAC80211_MESH
3230 	case NL80211_IFTYPE_MESH_POINT:
3231 		if (ieee80211_vif_is_mesh(&sdata->vif) &&
3232 		    !sdata->u.mesh.mesh_id_len)
3233 			need_offchan = true;
3234 		/* fall through */
3235 #endif
3236 	case NL80211_IFTYPE_AP:
3237 	case NL80211_IFTYPE_AP_VLAN:
3238 	case NL80211_IFTYPE_P2P_GO:
3239 		if (sdata->vif.type != NL80211_IFTYPE_ADHOC &&
3240 		    !ieee80211_vif_is_mesh(&sdata->vif) &&
3241 		    !rcu_access_pointer(sdata->bss->beacon))
3242 			need_offchan = true;
3243 		if (!ieee80211_is_action(mgmt->frame_control) ||
3244 		    mgmt->u.action.category == WLAN_CATEGORY_PUBLIC ||
3245 		    mgmt->u.action.category == WLAN_CATEGORY_SELF_PROTECTED ||
3246 		    mgmt->u.action.category == WLAN_CATEGORY_SPECTRUM_MGMT)
3247 			break;
3248 		rcu_read_lock();
3249 		sta = sta_info_get(sdata, mgmt->da);
3250 		rcu_read_unlock();
3251 		if (!sta)
3252 			return -ENOLINK;
3253 		break;
3254 	case NL80211_IFTYPE_STATION:
3255 	case NL80211_IFTYPE_P2P_CLIENT:
3256 		if (!sdata->u.mgd.associated)
3257 			need_offchan = true;
3258 		break;
3259 	case NL80211_IFTYPE_P2P_DEVICE:
3260 		need_offchan = true;
3261 		break;
3262 	default:
3263 		return -EOPNOTSUPP;
3264 	}
3265 
3266 	/* configurations requiring offchan cannot work if no channel has been
3267 	 * specified
3268 	 */
3269 	if (need_offchan && !params->chan)
3270 		return -EINVAL;
3271 
3272 	mutex_lock(&local->mtx);
3273 
3274 	/* Check if the operating channel is the requested channel */
3275 	if (!need_offchan) {
3276 		struct ieee80211_chanctx_conf *chanctx_conf;
3277 
3278 		rcu_read_lock();
3279 		chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf);
3280 
3281 		if (chanctx_conf) {
3282 			need_offchan = params->chan &&
3283 				       (params->chan !=
3284 					chanctx_conf->def.chan);
3285 		} else if (!params->chan) {
3286 			ret = -EINVAL;
3287 			rcu_read_unlock();
3288 			goto out_unlock;
3289 		} else {
3290 			need_offchan = true;
3291 		}
3292 		rcu_read_unlock();
3293 	}
3294 
3295 	if (need_offchan && !params->offchan) {
3296 		ret = -EBUSY;
3297 		goto out_unlock;
3298 	}
3299 
3300 	skb = dev_alloc_skb(local->hw.extra_tx_headroom + params->len);
3301 	if (!skb) {
3302 		ret = -ENOMEM;
3303 		goto out_unlock;
3304 	}
3305 	skb_reserve(skb, local->hw.extra_tx_headroom);
3306 
3307 	memcpy(skb_put(skb, params->len), params->buf, params->len);
3308 
3309 	IEEE80211_SKB_CB(skb)->flags = flags;
3310 
3311 	skb->dev = sdata->dev;
3312 
3313 	if (!need_offchan) {
3314 		*cookie = (unsigned long) skb;
3315 		ieee80211_tx_skb(sdata, skb);
3316 		ret = 0;
3317 		goto out_unlock;
3318 	}
3319 
3320 	IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_CTL_TX_OFFCHAN |
3321 					IEEE80211_TX_INTFL_OFFCHAN_TX_OK;
3322 	if (local->hw.flags & IEEE80211_HW_QUEUE_CONTROL)
3323 		IEEE80211_SKB_CB(skb)->hw_queue =
3324 			local->hw.offchannel_tx_hw_queue;
3325 
3326 	/* This will handle all kinds of coalescing and immediate TX */
3327 	ret = ieee80211_start_roc_work(local, sdata, params->chan,
3328 				       params->wait, cookie, skb,
3329 				       IEEE80211_ROC_TYPE_MGMT_TX);
3330 	if (ret)
3331 		kfree_skb(skb);
3332  out_unlock:
3333 	mutex_unlock(&local->mtx);
3334 	return ret;
3335 }
3336 
3337 static int ieee80211_mgmt_tx_cancel_wait(struct wiphy *wiphy,
3338 					 struct wireless_dev *wdev,
3339 					 u64 cookie)
3340 {
3341 	struct ieee80211_local *local = wiphy_priv(wiphy);
3342 
3343 	return ieee80211_cancel_roc(local, cookie, true);
3344 }
3345 
3346 static void ieee80211_mgmt_frame_register(struct wiphy *wiphy,
3347 					  struct wireless_dev *wdev,
3348 					  u16 frame_type, bool reg)
3349 {
3350 	struct ieee80211_local *local = wiphy_priv(wiphy);
3351 
3352 	switch (frame_type) {
3353 	case IEEE80211_FTYPE_MGMT | IEEE80211_STYPE_PROBE_REQ:
3354 		if (reg)
3355 			local->probe_req_reg++;
3356 		else
3357 			local->probe_req_reg--;
3358 
3359 		if (!local->open_count)
3360 			break;
3361 
3362 		ieee80211_queue_work(&local->hw, &local->reconfig_filter);
3363 		break;
3364 	default:
3365 		break;
3366 	}
3367 }
3368 
3369 static int ieee80211_set_antenna(struct wiphy *wiphy, u32 tx_ant, u32 rx_ant)
3370 {
3371 	struct ieee80211_local *local = wiphy_priv(wiphy);
3372 
3373 	if (local->started)
3374 		return -EOPNOTSUPP;
3375 
3376 	return drv_set_antenna(local, tx_ant, rx_ant);
3377 }
3378 
3379 static int ieee80211_get_antenna(struct wiphy *wiphy, u32 *tx_ant, u32 *rx_ant)
3380 {
3381 	struct ieee80211_local *local = wiphy_priv(wiphy);
3382 
3383 	return drv_get_antenna(local, tx_ant, rx_ant);
3384 }
3385 
3386 static int ieee80211_set_ringparam(struct wiphy *wiphy, u32 tx, u32 rx)
3387 {
3388 	struct ieee80211_local *local = wiphy_priv(wiphy);
3389 
3390 	return drv_set_ringparam(local, tx, rx);
3391 }
3392 
3393 static void ieee80211_get_ringparam(struct wiphy *wiphy,
3394 				    u32 *tx, u32 *tx_max, u32 *rx, u32 *rx_max)
3395 {
3396 	struct ieee80211_local *local = wiphy_priv(wiphy);
3397 
3398 	drv_get_ringparam(local, tx, tx_max, rx, rx_max);
3399 }
3400 
3401 static int ieee80211_set_rekey_data(struct wiphy *wiphy,
3402 				    struct net_device *dev,
3403 				    struct cfg80211_gtk_rekey_data *data)
3404 {
3405 	struct ieee80211_local *local = wiphy_priv(wiphy);
3406 	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
3407 
3408 	if (!local->ops->set_rekey_data)
3409 		return -EOPNOTSUPP;
3410 
3411 	drv_set_rekey_data(local, sdata, data);
3412 
3413 	return 0;
3414 }
3415 
3416 static void ieee80211_tdls_add_ext_capab(struct sk_buff *skb)
3417 {
3418 	u8 *pos = (void *)skb_put(skb, 7);
3419 
3420 	*pos++ = WLAN_EID_EXT_CAPABILITY;
3421 	*pos++ = 5; /* len */
3422 	*pos++ = 0x0;
3423 	*pos++ = 0x0;
3424 	*pos++ = 0x0;
3425 	*pos++ = 0x0;
3426 	*pos++ = WLAN_EXT_CAPA5_TDLS_ENABLED;
3427 }
3428 
3429 static u16 ieee80211_get_tdls_sta_capab(struct ieee80211_sub_if_data *sdata)
3430 {
3431 	struct ieee80211_local *local = sdata->local;
3432 	u16 capab;
3433 
3434 	capab = 0;
3435 	if (ieee80211_get_sdata_band(sdata) != IEEE80211_BAND_2GHZ)
3436 		return capab;
3437 
3438 	if (!(local->hw.flags & IEEE80211_HW_2GHZ_SHORT_SLOT_INCAPABLE))
3439 		capab |= WLAN_CAPABILITY_SHORT_SLOT_TIME;
3440 	if (!(local->hw.flags & IEEE80211_HW_2GHZ_SHORT_PREAMBLE_INCAPABLE))
3441 		capab |= WLAN_CAPABILITY_SHORT_PREAMBLE;
3442 
3443 	return capab;
3444 }
3445 
3446 static void ieee80211_tdls_add_link_ie(struct sk_buff *skb, u8 *src_addr,
3447 				       u8 *peer, u8 *bssid)
3448 {
3449 	struct ieee80211_tdls_lnkie *lnkid;
3450 
3451 	lnkid = (void *)skb_put(skb, sizeof(struct ieee80211_tdls_lnkie));
3452 
3453 	lnkid->ie_type = WLAN_EID_LINK_ID;
3454 	lnkid->ie_len = sizeof(struct ieee80211_tdls_lnkie) - 2;
3455 
3456 	memcpy(lnkid->bssid, bssid, ETH_ALEN);
3457 	memcpy(lnkid->init_sta, src_addr, ETH_ALEN);
3458 	memcpy(lnkid->resp_sta, peer, ETH_ALEN);
3459 }
3460 
3461 static int
3462 ieee80211_prep_tdls_encap_data(struct wiphy *wiphy, struct net_device *dev,
3463 			       u8 *peer, u8 action_code, u8 dialog_token,
3464 			       u16 status_code, struct sk_buff *skb)
3465 {
3466 	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
3467 	enum ieee80211_band band = ieee80211_get_sdata_band(sdata);
3468 	struct ieee80211_tdls_data *tf;
3469 
3470 	tf = (void *)skb_put(skb, offsetof(struct ieee80211_tdls_data, u));
3471 
3472 	memcpy(tf->da, peer, ETH_ALEN);
3473 	memcpy(tf->sa, sdata->vif.addr, ETH_ALEN);
3474 	tf->ether_type = cpu_to_be16(ETH_P_TDLS);
3475 	tf->payload_type = WLAN_TDLS_SNAP_RFTYPE;
3476 
3477 	switch (action_code) {
3478 	case WLAN_TDLS_SETUP_REQUEST:
3479 		tf->category = WLAN_CATEGORY_TDLS;
3480 		tf->action_code = WLAN_TDLS_SETUP_REQUEST;
3481 
3482 		skb_put(skb, sizeof(tf->u.setup_req));
3483 		tf->u.setup_req.dialog_token = dialog_token;
3484 		tf->u.setup_req.capability =
3485 			cpu_to_le16(ieee80211_get_tdls_sta_capab(sdata));
3486 
3487 		ieee80211_add_srates_ie(sdata, skb, false, band);
3488 		ieee80211_add_ext_srates_ie(sdata, skb, false, band);
3489 		ieee80211_tdls_add_ext_capab(skb);
3490 		break;
3491 	case WLAN_TDLS_SETUP_RESPONSE:
3492 		tf->category = WLAN_CATEGORY_TDLS;
3493 		tf->action_code = WLAN_TDLS_SETUP_RESPONSE;
3494 
3495 		skb_put(skb, sizeof(tf->u.setup_resp));
3496 		tf->u.setup_resp.status_code = cpu_to_le16(status_code);
3497 		tf->u.setup_resp.dialog_token = dialog_token;
3498 		tf->u.setup_resp.capability =
3499 			cpu_to_le16(ieee80211_get_tdls_sta_capab(sdata));
3500 
3501 		ieee80211_add_srates_ie(sdata, skb, false, band);
3502 		ieee80211_add_ext_srates_ie(sdata, skb, false, band);
3503 		ieee80211_tdls_add_ext_capab(skb);
3504 		break;
3505 	case WLAN_TDLS_SETUP_CONFIRM:
3506 		tf->category = WLAN_CATEGORY_TDLS;
3507 		tf->action_code = WLAN_TDLS_SETUP_CONFIRM;
3508 
3509 		skb_put(skb, sizeof(tf->u.setup_cfm));
3510 		tf->u.setup_cfm.status_code = cpu_to_le16(status_code);
3511 		tf->u.setup_cfm.dialog_token = dialog_token;
3512 		break;
3513 	case WLAN_TDLS_TEARDOWN:
3514 		tf->category = WLAN_CATEGORY_TDLS;
3515 		tf->action_code = WLAN_TDLS_TEARDOWN;
3516 
3517 		skb_put(skb, sizeof(tf->u.teardown));
3518 		tf->u.teardown.reason_code = cpu_to_le16(status_code);
3519 		break;
3520 	case WLAN_TDLS_DISCOVERY_REQUEST:
3521 		tf->category = WLAN_CATEGORY_TDLS;
3522 		tf->action_code = WLAN_TDLS_DISCOVERY_REQUEST;
3523 
3524 		skb_put(skb, sizeof(tf->u.discover_req));
3525 		tf->u.discover_req.dialog_token = dialog_token;
3526 		break;
3527 	default:
3528 		return -EINVAL;
3529 	}
3530 
3531 	return 0;
3532 }
3533 
3534 static int
3535 ieee80211_prep_tdls_direct(struct wiphy *wiphy, struct net_device *dev,
3536 			   u8 *peer, u8 action_code, u8 dialog_token,
3537 			   u16 status_code, struct sk_buff *skb)
3538 {
3539 	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
3540 	enum ieee80211_band band = ieee80211_get_sdata_band(sdata);
3541 	struct ieee80211_mgmt *mgmt;
3542 
3543 	mgmt = (void *)skb_put(skb, 24);
3544 	memset(mgmt, 0, 24);
3545 	memcpy(mgmt->da, peer, ETH_ALEN);
3546 	memcpy(mgmt->sa, sdata->vif.addr, ETH_ALEN);
3547 	memcpy(mgmt->bssid, sdata->u.mgd.bssid, ETH_ALEN);
3548 
3549 	mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
3550 					  IEEE80211_STYPE_ACTION);
3551 
3552 	switch (action_code) {
3553 	case WLAN_PUB_ACTION_TDLS_DISCOVER_RES:
3554 		skb_put(skb, 1 + sizeof(mgmt->u.action.u.tdls_discover_resp));
3555 		mgmt->u.action.category = WLAN_CATEGORY_PUBLIC;
3556 		mgmt->u.action.u.tdls_discover_resp.action_code =
3557 			WLAN_PUB_ACTION_TDLS_DISCOVER_RES;
3558 		mgmt->u.action.u.tdls_discover_resp.dialog_token =
3559 			dialog_token;
3560 		mgmt->u.action.u.tdls_discover_resp.capability =
3561 			cpu_to_le16(ieee80211_get_tdls_sta_capab(sdata));
3562 
3563 		ieee80211_add_srates_ie(sdata, skb, false, band);
3564 		ieee80211_add_ext_srates_ie(sdata, skb, false, band);
3565 		ieee80211_tdls_add_ext_capab(skb);
3566 		break;
3567 	default:
3568 		return -EINVAL;
3569 	}
3570 
3571 	return 0;
3572 }
3573 
3574 static int ieee80211_tdls_mgmt(struct wiphy *wiphy, struct net_device *dev,
3575 			       u8 *peer, u8 action_code, u8 dialog_token,
3576 			       u16 status_code, const u8 *extra_ies,
3577 			       size_t extra_ies_len)
3578 {
3579 	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
3580 	struct ieee80211_local *local = sdata->local;
3581 	struct sk_buff *skb = NULL;
3582 	bool send_direct;
3583 	int ret;
3584 
3585 	if (!(wiphy->flags & WIPHY_FLAG_SUPPORTS_TDLS))
3586 		return -ENOTSUPP;
3587 
3588 	/* make sure we are in managed mode, and associated */
3589 	if (sdata->vif.type != NL80211_IFTYPE_STATION ||
3590 	    !sdata->u.mgd.associated)
3591 		return -EINVAL;
3592 
3593 	tdls_dbg(sdata, "TDLS mgmt action %d peer %pM\n",
3594 		 action_code, peer);
3595 
3596 	skb = dev_alloc_skb(local->hw.extra_tx_headroom +
3597 			    max(sizeof(struct ieee80211_mgmt),
3598 				sizeof(struct ieee80211_tdls_data)) +
3599 			    50 + /* supported rates */
3600 			    7 + /* ext capab */
3601 			    extra_ies_len +
3602 			    sizeof(struct ieee80211_tdls_lnkie));
3603 	if (!skb)
3604 		return -ENOMEM;
3605 
3606 	skb_reserve(skb, local->hw.extra_tx_headroom);
3607 
3608 	switch (action_code) {
3609 	case WLAN_TDLS_SETUP_REQUEST:
3610 	case WLAN_TDLS_SETUP_RESPONSE:
3611 	case WLAN_TDLS_SETUP_CONFIRM:
3612 	case WLAN_TDLS_TEARDOWN:
3613 	case WLAN_TDLS_DISCOVERY_REQUEST:
3614 		ret = ieee80211_prep_tdls_encap_data(wiphy, dev, peer,
3615 						     action_code, dialog_token,
3616 						     status_code, skb);
3617 		send_direct = false;
3618 		break;
3619 	case WLAN_PUB_ACTION_TDLS_DISCOVER_RES:
3620 		ret = ieee80211_prep_tdls_direct(wiphy, dev, peer, action_code,
3621 						 dialog_token, status_code,
3622 						 skb);
3623 		send_direct = true;
3624 		break;
3625 	default:
3626 		ret = -ENOTSUPP;
3627 		break;
3628 	}
3629 
3630 	if (ret < 0)
3631 		goto fail;
3632 
3633 	if (extra_ies_len)
3634 		memcpy(skb_put(skb, extra_ies_len), extra_ies, extra_ies_len);
3635 
3636 	/* the TDLS link IE is always added last */
3637 	switch (action_code) {
3638 	case WLAN_TDLS_SETUP_REQUEST:
3639 	case WLAN_TDLS_SETUP_CONFIRM:
3640 	case WLAN_TDLS_TEARDOWN:
3641 	case WLAN_TDLS_DISCOVERY_REQUEST:
3642 		/* we are the initiator */
3643 		ieee80211_tdls_add_link_ie(skb, sdata->vif.addr, peer,
3644 					   sdata->u.mgd.bssid);
3645 		break;
3646 	case WLAN_TDLS_SETUP_RESPONSE:
3647 	case WLAN_PUB_ACTION_TDLS_DISCOVER_RES:
3648 		/* we are the responder */
3649 		ieee80211_tdls_add_link_ie(skb, peer, sdata->vif.addr,
3650 					   sdata->u.mgd.bssid);
3651 		break;
3652 	default:
3653 		ret = -ENOTSUPP;
3654 		goto fail;
3655 	}
3656 
3657 	if (send_direct) {
3658 		ieee80211_tx_skb(sdata, skb);
3659 		return 0;
3660 	}
3661 
3662 	/*
3663 	 * According to 802.11z: Setup req/resp are sent in AC_BK, otherwise
3664 	 * we should default to AC_VI.
3665 	 */
3666 	switch (action_code) {
3667 	case WLAN_TDLS_SETUP_REQUEST:
3668 	case WLAN_TDLS_SETUP_RESPONSE:
3669 		skb_set_queue_mapping(skb, IEEE80211_AC_BK);
3670 		skb->priority = 2;
3671 		break;
3672 	default:
3673 		skb_set_queue_mapping(skb, IEEE80211_AC_VI);
3674 		skb->priority = 5;
3675 		break;
3676 	}
3677 
3678 	/* disable bottom halves when entering the Tx path */
3679 	local_bh_disable();
3680 	ret = ieee80211_subif_start_xmit(skb, dev);
3681 	local_bh_enable();
3682 
3683 	return ret;
3684 
3685 fail:
3686 	dev_kfree_skb(skb);
3687 	return ret;
3688 }
3689 
3690 static int ieee80211_tdls_oper(struct wiphy *wiphy, struct net_device *dev,
3691 			       u8 *peer, enum nl80211_tdls_operation oper)
3692 {
3693 	struct sta_info *sta;
3694 	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
3695 
3696 	if (!(wiphy->flags & WIPHY_FLAG_SUPPORTS_TDLS))
3697 		return -ENOTSUPP;
3698 
3699 	if (sdata->vif.type != NL80211_IFTYPE_STATION)
3700 		return -EINVAL;
3701 
3702 	tdls_dbg(sdata, "TDLS oper %d peer %pM\n", oper, peer);
3703 
3704 	switch (oper) {
3705 	case NL80211_TDLS_ENABLE_LINK:
3706 		rcu_read_lock();
3707 		sta = sta_info_get(sdata, peer);
3708 		if (!sta) {
3709 			rcu_read_unlock();
3710 			return -ENOLINK;
3711 		}
3712 
3713 		set_sta_flag(sta, WLAN_STA_TDLS_PEER_AUTH);
3714 		rcu_read_unlock();
3715 		break;
3716 	case NL80211_TDLS_DISABLE_LINK:
3717 		return sta_info_destroy_addr(sdata, peer);
3718 	case NL80211_TDLS_TEARDOWN:
3719 	case NL80211_TDLS_SETUP:
3720 	case NL80211_TDLS_DISCOVERY_REQ:
3721 		/* We don't support in-driver setup/teardown/discovery */
3722 		return -ENOTSUPP;
3723 	default:
3724 		return -ENOTSUPP;
3725 	}
3726 
3727 	return 0;
3728 }
3729 
3730 static int ieee80211_probe_client(struct wiphy *wiphy, struct net_device *dev,
3731 				  const u8 *peer, u64 *cookie)
3732 {
3733 	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
3734 	struct ieee80211_local *local = sdata->local;
3735 	struct ieee80211_qos_hdr *nullfunc;
3736 	struct sk_buff *skb;
3737 	int size = sizeof(*nullfunc);
3738 	__le16 fc;
3739 	bool qos;
3740 	struct ieee80211_tx_info *info;
3741 	struct sta_info *sta;
3742 	struct ieee80211_chanctx_conf *chanctx_conf;
3743 	enum ieee80211_band band;
3744 
3745 	rcu_read_lock();
3746 	chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf);
3747 	if (WARN_ON(!chanctx_conf)) {
3748 		rcu_read_unlock();
3749 		return -EINVAL;
3750 	}
3751 	band = chanctx_conf->def.chan->band;
3752 	sta = sta_info_get_bss(sdata, peer);
3753 	if (sta) {
3754 		qos = test_sta_flag(sta, WLAN_STA_WME);
3755 	} else {
3756 		rcu_read_unlock();
3757 		return -ENOLINK;
3758 	}
3759 
3760 	if (qos) {
3761 		fc = cpu_to_le16(IEEE80211_FTYPE_DATA |
3762 				 IEEE80211_STYPE_QOS_NULLFUNC |
3763 				 IEEE80211_FCTL_FROMDS);
3764 	} else {
3765 		size -= 2;
3766 		fc = cpu_to_le16(IEEE80211_FTYPE_DATA |
3767 				 IEEE80211_STYPE_NULLFUNC |
3768 				 IEEE80211_FCTL_FROMDS);
3769 	}
3770 
3771 	skb = dev_alloc_skb(local->hw.extra_tx_headroom + size);
3772 	if (!skb) {
3773 		rcu_read_unlock();
3774 		return -ENOMEM;
3775 	}
3776 
3777 	skb->dev = dev;
3778 
3779 	skb_reserve(skb, local->hw.extra_tx_headroom);
3780 
3781 	nullfunc = (void *) skb_put(skb, size);
3782 	nullfunc->frame_control = fc;
3783 	nullfunc->duration_id = 0;
3784 	memcpy(nullfunc->addr1, sta->sta.addr, ETH_ALEN);
3785 	memcpy(nullfunc->addr2, sdata->vif.addr, ETH_ALEN);
3786 	memcpy(nullfunc->addr3, sdata->vif.addr, ETH_ALEN);
3787 	nullfunc->seq_ctrl = 0;
3788 
3789 	info = IEEE80211_SKB_CB(skb);
3790 
3791 	info->flags |= IEEE80211_TX_CTL_REQ_TX_STATUS |
3792 		       IEEE80211_TX_INTFL_NL80211_FRAME_TX;
3793 
3794 	skb_set_queue_mapping(skb, IEEE80211_AC_VO);
3795 	skb->priority = 7;
3796 	if (qos)
3797 		nullfunc->qos_ctrl = cpu_to_le16(7);
3798 
3799 	local_bh_disable();
3800 	ieee80211_xmit(sdata, skb, band);
3801 	local_bh_enable();
3802 	rcu_read_unlock();
3803 
3804 	*cookie = (unsigned long) skb;
3805 	return 0;
3806 }
3807 
3808 static int ieee80211_cfg_get_channel(struct wiphy *wiphy,
3809 				     struct wireless_dev *wdev,
3810 				     struct cfg80211_chan_def *chandef)
3811 {
3812 	struct ieee80211_sub_if_data *sdata = IEEE80211_WDEV_TO_SUB_IF(wdev);
3813 	struct ieee80211_local *local = wiphy_priv(wiphy);
3814 	struct ieee80211_chanctx_conf *chanctx_conf;
3815 	int ret = -ENODATA;
3816 
3817 	rcu_read_lock();
3818 	chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf);
3819 	if (chanctx_conf) {
3820 		*chandef = chanctx_conf->def;
3821 		ret = 0;
3822 	} else if (local->open_count > 0 &&
3823 		   local->open_count == local->monitors &&
3824 		   sdata->vif.type == NL80211_IFTYPE_MONITOR) {
3825 		if (local->use_chanctx)
3826 			*chandef = local->monitor_chandef;
3827 		else
3828 			*chandef = local->_oper_chandef;
3829 		ret = 0;
3830 	}
3831 	rcu_read_unlock();
3832 
3833 	return ret;
3834 }
3835 
3836 #ifdef CONFIG_PM
3837 static void ieee80211_set_wakeup(struct wiphy *wiphy, bool enabled)
3838 {
3839 	drv_set_wakeup(wiphy_priv(wiphy), enabled);
3840 }
3841 #endif
3842 
3843 static int ieee80211_set_qos_map(struct wiphy *wiphy,
3844 				 struct net_device *dev,
3845 				 struct cfg80211_qos_map *qos_map)
3846 {
3847 	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
3848 	struct mac80211_qos_map *new_qos_map, *old_qos_map;
3849 
3850 	if (qos_map) {
3851 		new_qos_map = kzalloc(sizeof(*new_qos_map), GFP_KERNEL);
3852 		if (!new_qos_map)
3853 			return -ENOMEM;
3854 		memcpy(&new_qos_map->qos_map, qos_map, sizeof(*qos_map));
3855 	} else {
3856 		/* A NULL qos_map was passed to disable QoS mapping */
3857 		new_qos_map = NULL;
3858 	}
3859 
3860 	old_qos_map = sdata_dereference(sdata->qos_map, sdata);
3861 	rcu_assign_pointer(sdata->qos_map, new_qos_map);
3862 	if (old_qos_map)
3863 		kfree_rcu(old_qos_map, rcu_head);
3864 
3865 	return 0;
3866 }
3867 
3868 struct cfg80211_ops mac80211_config_ops = {
3869 	.add_virtual_intf = ieee80211_add_iface,
3870 	.del_virtual_intf = ieee80211_del_iface,
3871 	.change_virtual_intf = ieee80211_change_iface,
3872 	.start_p2p_device = ieee80211_start_p2p_device,
3873 	.stop_p2p_device = ieee80211_stop_p2p_device,
3874 	.add_key = ieee80211_add_key,
3875 	.del_key = ieee80211_del_key,
3876 	.get_key = ieee80211_get_key,
3877 	.set_default_key = ieee80211_config_default_key,
3878 	.set_default_mgmt_key = ieee80211_config_default_mgmt_key,
3879 	.start_ap = ieee80211_start_ap,
3880 	.change_beacon = ieee80211_change_beacon,
3881 	.stop_ap = ieee80211_stop_ap,
3882 	.add_station = ieee80211_add_station,
3883 	.del_station = ieee80211_del_station,
3884 	.change_station = ieee80211_change_station,
3885 	.get_station = ieee80211_get_station,
3886 	.dump_station = ieee80211_dump_station,
3887 	.dump_survey = ieee80211_dump_survey,
3888 #ifdef CONFIG_MAC80211_MESH
3889 	.add_mpath = ieee80211_add_mpath,
3890 	.del_mpath = ieee80211_del_mpath,
3891 	.change_mpath = ieee80211_change_mpath,
3892 	.get_mpath = ieee80211_get_mpath,
3893 	.dump_mpath = ieee80211_dump_mpath,
3894 	.update_mesh_config = ieee80211_update_mesh_config,
3895 	.get_mesh_config = ieee80211_get_mesh_config,
3896 	.join_mesh = ieee80211_join_mesh,
3897 	.leave_mesh = ieee80211_leave_mesh,
3898 #endif
3899 	.change_bss = ieee80211_change_bss,
3900 	.set_txq_params = ieee80211_set_txq_params,
3901 	.set_monitor_channel = ieee80211_set_monitor_channel,
3902 	.suspend = ieee80211_suspend,
3903 	.resume = ieee80211_resume,
3904 	.scan = ieee80211_scan,
3905 	.sched_scan_start = ieee80211_sched_scan_start,
3906 	.sched_scan_stop = ieee80211_sched_scan_stop,
3907 	.auth = ieee80211_auth,
3908 	.assoc = ieee80211_assoc,
3909 	.deauth = ieee80211_deauth,
3910 	.disassoc = ieee80211_disassoc,
3911 	.join_ibss = ieee80211_join_ibss,
3912 	.leave_ibss = ieee80211_leave_ibss,
3913 	.set_mcast_rate = ieee80211_set_mcast_rate,
3914 	.set_wiphy_params = ieee80211_set_wiphy_params,
3915 	.set_tx_power = ieee80211_set_tx_power,
3916 	.get_tx_power = ieee80211_get_tx_power,
3917 	.set_wds_peer = ieee80211_set_wds_peer,
3918 	.rfkill_poll = ieee80211_rfkill_poll,
3919 	CFG80211_TESTMODE_CMD(ieee80211_testmode_cmd)
3920 	CFG80211_TESTMODE_DUMP(ieee80211_testmode_dump)
3921 	.set_power_mgmt = ieee80211_set_power_mgmt,
3922 	.set_bitrate_mask = ieee80211_set_bitrate_mask,
3923 	.remain_on_channel = ieee80211_remain_on_channel,
3924 	.cancel_remain_on_channel = ieee80211_cancel_remain_on_channel,
3925 	.mgmt_tx = ieee80211_mgmt_tx,
3926 	.mgmt_tx_cancel_wait = ieee80211_mgmt_tx_cancel_wait,
3927 	.set_cqm_rssi_config = ieee80211_set_cqm_rssi_config,
3928 	.mgmt_frame_register = ieee80211_mgmt_frame_register,
3929 	.set_antenna = ieee80211_set_antenna,
3930 	.get_antenna = ieee80211_get_antenna,
3931 	.set_ringparam = ieee80211_set_ringparam,
3932 	.get_ringparam = ieee80211_get_ringparam,
3933 	.set_rekey_data = ieee80211_set_rekey_data,
3934 	.tdls_oper = ieee80211_tdls_oper,
3935 	.tdls_mgmt = ieee80211_tdls_mgmt,
3936 	.probe_client = ieee80211_probe_client,
3937 	.set_noack_map = ieee80211_set_noack_map,
3938 #ifdef CONFIG_PM
3939 	.set_wakeup = ieee80211_set_wakeup,
3940 #endif
3941 	.get_et_sset_count = ieee80211_get_et_sset_count,
3942 	.get_et_stats = ieee80211_get_et_stats,
3943 	.get_et_strings = ieee80211_get_et_strings,
3944 	.get_channel = ieee80211_cfg_get_channel,
3945 	.start_radar_detection = ieee80211_start_radar_detection,
3946 	.channel_switch = ieee80211_channel_switch,
3947 	.set_qos_map = ieee80211_set_qos_map,
3948 };
3949