2 * mac80211 TDLS handling code
4 * Copyright 2006-2010 Johannes Berg <johannes@sipsolutions.net>
5 * Copyright 2014, Intel Corporation
6 * Copyright 2014 Intel Mobile Communications GmbH
7 * Copyright 2015 Intel Deutschland GmbH
9 * This file is GPLv2 as found in COPYING.
12 #include <linux/ieee80211.h>
13 #include <linux/log2.h>
14 #include <net/cfg80211.h>
15 #include <linux/rtnetlink.h>
16 #include "ieee80211_i.h"
17 #include "driver-ops.h"
19 /* give usermode some time for retries in setting up the TDLS session */
20 #define TDLS_PEER_SETUP_TIMEOUT (15 * HZ)
22 void ieee80211_tdls_peer_del_work(struct work_struct
*wk
)
24 struct ieee80211_sub_if_data
*sdata
;
25 struct ieee80211_local
*local
;
27 sdata
= container_of(wk
, struct ieee80211_sub_if_data
,
28 u
.mgd
.tdls_peer_del_work
.work
);
31 mutex_lock(&local
->mtx
);
32 if (!is_zero_ether_addr(sdata
->u
.mgd
.tdls_peer
)) {
33 tdls_dbg(sdata
, "TDLS del peer %pM\n", sdata
->u
.mgd
.tdls_peer
);
34 sta_info_destroy_addr(sdata
, sdata
->u
.mgd
.tdls_peer
);
35 eth_zero_addr(sdata
->u
.mgd
.tdls_peer
);
37 mutex_unlock(&local
->mtx
);
40 static void ieee80211_tdls_add_ext_capab(struct ieee80211_sub_if_data
*sdata
,
43 struct ieee80211_local
*local
= sdata
->local
;
44 struct ieee80211_if_managed
*ifmgd
= &sdata
->u
.mgd
;
45 bool chan_switch
= local
->hw
.wiphy
->features
&
46 NL80211_FEATURE_TDLS_CHANNEL_SWITCH
;
47 bool wider_band
= ieee80211_hw_check(&local
->hw
, TDLS_WIDER_BW
) &&
48 !ifmgd
->tdls_wider_bw_prohibited
;
49 enum ieee80211_band band
= ieee80211_get_sdata_band(sdata
);
50 struct ieee80211_supported_band
*sband
= local
->hw
.wiphy
->bands
[band
];
51 bool vht
= sband
&& sband
->vht_cap
.vht_supported
;
52 u8
*pos
= (void *)skb_put(skb
, 10);
54 *pos
++ = WLAN_EID_EXT_CAPABILITY
;
59 *pos
++ = chan_switch
? WLAN_EXT_CAPA4_TDLS_CHAN_SWITCH
: 0;
60 *pos
++ = WLAN_EXT_CAPA5_TDLS_ENABLED
;
63 *pos
++ = (vht
&& wider_band
) ? WLAN_EXT_CAPA8_TDLS_WIDE_BW_ENABLED
: 0;
67 ieee80211_tdls_add_subband(struct ieee80211_sub_if_data
*sdata
,
68 struct sk_buff
*skb
, u16 start
, u16 end
,
71 u8 subband_cnt
= 0, ch_cnt
= 0;
72 struct ieee80211_channel
*ch
;
73 struct cfg80211_chan_def chandef
;
75 struct wiphy
*wiphy
= sdata
->local
->hw
.wiphy
;
77 for (i
= start
; i
<= end
; i
+= spacing
) {
81 ch
= ieee80211_get_channel(sdata
->local
->hw
.wiphy
, i
);
83 /* we will be active on the channel */
84 cfg80211_chandef_create(&chandef
, ch
,
86 if (cfg80211_reg_can_beacon_relax(wiphy
, &chandef
,
87 sdata
->wdev
.iftype
)) {
90 * check if the next channel is also part of
98 * we've reached the end of a range, with allowed channels
102 u8
*pos
= skb_put(skb
, 2);
103 *pos
++ = ieee80211_frequency_to_channel(subband_start
);
111 /* all channels in the requested range are allowed - add them here */
113 u8
*pos
= skb_put(skb
, 2);
114 *pos
++ = ieee80211_frequency_to_channel(subband_start
);
124 ieee80211_tdls_add_supp_channels(struct ieee80211_sub_if_data
*sdata
,
128 * Add possible channels for TDLS. These are channels that are allowed
132 u8
*pos
= skb_put(skb
, 2);
134 *pos
++ = WLAN_EID_SUPPORTED_CHANNELS
;
137 * 5GHz and 2GHz channels numbers can overlap. Ignore this for now, as
138 * this doesn't happen in real world scenarios.
141 /* 2GHz, with 5MHz spacing */
142 subband_cnt
= ieee80211_tdls_add_subband(sdata
, skb
, 2412, 2472, 5);
144 /* 5GHz, with 20MHz spacing */
145 subband_cnt
+= ieee80211_tdls_add_subband(sdata
, skb
, 5000, 5825, 20);
148 *pos
= 2 * subband_cnt
;
151 static void ieee80211_tdls_add_oper_classes(struct ieee80211_sub_if_data
*sdata
,
157 if (!ieee80211_chandef_to_operating_class(&sdata
->vif
.bss_conf
.chandef
,
161 pos
= skb_put(skb
, 4);
162 *pos
++ = WLAN_EID_SUPPORTED_REGULATORY_CLASSES
;
163 *pos
++ = 2; /* len */
166 *pos
++ = op_class
; /* give current operating class as alternate too */
169 static void ieee80211_tdls_add_bss_coex_ie(struct sk_buff
*skb
)
171 u8
*pos
= (void *)skb_put(skb
, 3);
173 *pos
++ = WLAN_EID_BSS_COEX_2040
;
174 *pos
++ = 1; /* len */
176 *pos
++ = WLAN_BSS_COEX_INFORMATION_REQUEST
;
179 static u16
ieee80211_get_tdls_sta_capab(struct ieee80211_sub_if_data
*sdata
,
182 /* The capability will be 0 when sending a failure code */
183 if (status_code
!= 0)
186 if (ieee80211_get_sdata_band(sdata
) == IEEE80211_BAND_2GHZ
) {
187 return WLAN_CAPABILITY_SHORT_SLOT_TIME
|
188 WLAN_CAPABILITY_SHORT_PREAMBLE
;
194 static void ieee80211_tdls_add_link_ie(struct ieee80211_sub_if_data
*sdata
,
195 struct sk_buff
*skb
, const u8
*peer
,
198 struct ieee80211_tdls_lnkie
*lnkid
;
199 const u8
*init_addr
, *rsp_addr
;
202 init_addr
= sdata
->vif
.addr
;
206 rsp_addr
= sdata
->vif
.addr
;
209 lnkid
= (void *)skb_put(skb
, sizeof(struct ieee80211_tdls_lnkie
));
211 lnkid
->ie_type
= WLAN_EID_LINK_ID
;
212 lnkid
->ie_len
= sizeof(struct ieee80211_tdls_lnkie
) - 2;
214 memcpy(lnkid
->bssid
, sdata
->u
.mgd
.bssid
, ETH_ALEN
);
215 memcpy(lnkid
->init_sta
, init_addr
, ETH_ALEN
);
216 memcpy(lnkid
->resp_sta
, rsp_addr
, ETH_ALEN
);
220 ieee80211_tdls_add_aid(struct ieee80211_sub_if_data
*sdata
, struct sk_buff
*skb
)
222 struct ieee80211_if_managed
*ifmgd
= &sdata
->u
.mgd
;
223 u8
*pos
= (void *)skb_put(skb
, 4);
225 *pos
++ = WLAN_EID_AID
;
226 *pos
++ = 2; /* len */
227 put_unaligned_le16(ifmgd
->aid
, pos
);
230 /* translate numbering in the WMM parameter IE to the mac80211 notation */
231 static enum ieee80211_ac_numbers
ieee80211_ac_from_wmm(int ac
)
237 return IEEE80211_AC_BE
;
239 return IEEE80211_AC_BK
;
241 return IEEE80211_AC_VI
;
243 return IEEE80211_AC_VO
;
247 static u8
ieee80211_wmm_aci_aifsn(int aifsn
, bool acm
, int aci
)
254 ret
|= (aci
<< 5) & 0x60;
258 static u8
ieee80211_wmm_ecw(u16 cw_min
, u16 cw_max
)
260 return ((ilog2(cw_min
+ 1) << 0x0) & 0x0f) |
261 ((ilog2(cw_max
+ 1) << 0x4) & 0xf0);
264 static void ieee80211_tdls_add_wmm_param_ie(struct ieee80211_sub_if_data
*sdata
,
267 struct ieee80211_wmm_param_ie
*wmm
;
268 struct ieee80211_tx_queue_params
*txq
;
271 wmm
= (void *)skb_put(skb
, sizeof(*wmm
));
272 memset(wmm
, 0, sizeof(*wmm
));
274 wmm
->element_id
= WLAN_EID_VENDOR_SPECIFIC
;
275 wmm
->len
= sizeof(*wmm
) - 2;
277 wmm
->oui
[0] = 0x00; /* Microsoft OUI 00:50:F2 */
280 wmm
->oui_type
= 2; /* WME */
281 wmm
->oui_subtype
= 1; /* WME param */
282 wmm
->version
= 1; /* WME ver */
283 wmm
->qos_info
= 0; /* U-APSD not in use */
286 * Use the EDCA parameters defined for the BSS, or default if the AP
287 * doesn't support it, as mandated by 802.11-2012 section 10.22.4
289 for (i
= 0; i
< IEEE80211_NUM_ACS
; i
++) {
290 txq
= &sdata
->tx_conf
[ieee80211_ac_from_wmm(i
)];
291 wmm
->ac
[i
].aci_aifsn
= ieee80211_wmm_aci_aifsn(txq
->aifs
,
293 wmm
->ac
[i
].cw
= ieee80211_wmm_ecw(txq
->cw_min
, txq
->cw_max
);
294 wmm
->ac
[i
].txop_limit
= cpu_to_le16(txq
->txop
);
299 ieee80211_tdls_chandef_vht_upgrade(struct ieee80211_sub_if_data
*sdata
,
300 struct sta_info
*sta
)
302 /* IEEE802.11ac-2013 Table E-4 */
303 u16 centers_80mhz
[] = { 5210, 5290, 5530, 5610, 5690, 5775 };
304 struct cfg80211_chan_def uc
= sta
->tdls_chandef
;
305 enum nl80211_chan_width max_width
= ieee80211_get_sta_bw(&sta
->sta
);
308 /* only support upgrading non-narrow channels up to 80Mhz */
309 if (max_width
== NL80211_CHAN_WIDTH_5
||
310 max_width
== NL80211_CHAN_WIDTH_10
)
313 if (max_width
> NL80211_CHAN_WIDTH_80
)
314 max_width
= NL80211_CHAN_WIDTH_80
;
316 if (uc
.width
== max_width
)
319 * Channel usage constrains in the IEEE802.11ac-2013 specification only
320 * allow expanding a 20MHz channel to 80MHz in a single way. In
321 * addition, there are no 40MHz allowed channels that are not part of
322 * the allowed 80MHz range in the 5GHz spectrum (the relevant one here).
324 for (i
= 0; i
< ARRAY_SIZE(centers_80mhz
); i
++)
325 if (abs(uc
.chan
->center_freq
- centers_80mhz
[i
]) <= 30) {
326 uc
.center_freq1
= centers_80mhz
[i
];
327 uc
.width
= NL80211_CHAN_WIDTH_80
;
331 if (!uc
.center_freq1
)
334 /* proceed to downgrade the chandef until usable or the same */
335 while (uc
.width
> max_width
&&
336 !cfg80211_reg_can_beacon_relax(sdata
->local
->hw
.wiphy
, &uc
,
338 ieee80211_chandef_downgrade(&uc
);
340 if (!cfg80211_chandef_identical(&uc
, &sta
->tdls_chandef
)) {
341 tdls_dbg(sdata
, "TDLS ch width upgraded %d -> %d\n",
342 sta
->tdls_chandef
.width
, uc
.width
);
345 * the station is not yet authorized when BW upgrade is done,
346 * locking is not required
348 sta
->tdls_chandef
= uc
;
353 ieee80211_tdls_add_setup_start_ies(struct ieee80211_sub_if_data
*sdata
,
354 struct sk_buff
*skb
, const u8
*peer
,
355 u8 action_code
, bool initiator
,
356 const u8
*extra_ies
, size_t extra_ies_len
)
358 enum ieee80211_band band
= ieee80211_get_sdata_band(sdata
);
359 struct ieee80211_local
*local
= sdata
->local
;
360 struct ieee80211_supported_band
*sband
;
361 struct ieee80211_sta_ht_cap ht_cap
;
362 struct ieee80211_sta_vht_cap vht_cap
;
363 struct sta_info
*sta
= NULL
;
364 size_t offset
= 0, noffset
;
367 ieee80211_add_srates_ie(sdata
, skb
, false, band
);
368 ieee80211_add_ext_srates_ie(sdata
, skb
, false, band
);
369 ieee80211_tdls_add_supp_channels(sdata
, skb
);
371 /* add any custom IEs that go before Extended Capabilities */
373 static const u8 before_ext_cap
[] = {
376 WLAN_EID_EXT_SUPP_RATES
,
377 WLAN_EID_SUPPORTED_CHANNELS
,
380 noffset
= ieee80211_ie_split(extra_ies
, extra_ies_len
,
382 ARRAY_SIZE(before_ext_cap
),
384 pos
= skb_put(skb
, noffset
- offset
);
385 memcpy(pos
, extra_ies
+ offset
, noffset
- offset
);
389 ieee80211_tdls_add_ext_capab(sdata
, skb
);
391 /* add the QoS element if we support it */
392 if (local
->hw
.queues
>= IEEE80211_NUM_ACS
&&
393 action_code
!= WLAN_PUB_ACTION_TDLS_DISCOVER_RES
)
394 ieee80211_add_wmm_info_ie(skb_put(skb
, 9), 0); /* no U-APSD */
396 /* add any custom IEs that go before HT capabilities */
398 static const u8 before_ht_cap
[] = {
401 WLAN_EID_EXT_SUPP_RATES
,
402 WLAN_EID_SUPPORTED_CHANNELS
,
404 WLAN_EID_EXT_CAPABILITY
,
406 WLAN_EID_FAST_BSS_TRANSITION
,
407 WLAN_EID_TIMEOUT_INTERVAL
,
408 WLAN_EID_SUPPORTED_REGULATORY_CLASSES
,
410 noffset
= ieee80211_ie_split(extra_ies
, extra_ies_len
,
412 ARRAY_SIZE(before_ht_cap
),
414 pos
= skb_put(skb
, noffset
- offset
);
415 memcpy(pos
, extra_ies
+ offset
, noffset
- offset
);
419 mutex_lock(&local
->sta_mtx
);
421 /* we should have the peer STA if we're already responding */
422 if (action_code
== WLAN_TDLS_SETUP_RESPONSE
) {
423 sta
= sta_info_get(sdata
, peer
);
424 if (WARN_ON_ONCE(!sta
)) {
425 mutex_unlock(&local
->sta_mtx
);
429 sta
->tdls_chandef
= sdata
->vif
.bss_conf
.chandef
;
432 ieee80211_tdls_add_oper_classes(sdata
, skb
);
435 * with TDLS we can switch channels, and HT-caps are not necessarily
436 * the same on all bands. The specification limits the setup to a
437 * single HT-cap, so use the current band for now.
439 sband
= local
->hw
.wiphy
->bands
[band
];
440 memcpy(&ht_cap
, &sband
->ht_cap
, sizeof(ht_cap
));
442 if ((action_code
== WLAN_TDLS_SETUP_REQUEST
||
443 action_code
== WLAN_PUB_ACTION_TDLS_DISCOVER_RES
) &&
444 ht_cap
.ht_supported
) {
445 ieee80211_apply_htcap_overrides(sdata
, &ht_cap
);
447 /* disable SMPS in TDLS initiator */
448 ht_cap
.cap
|= WLAN_HT_CAP_SM_PS_DISABLED
449 << IEEE80211_HT_CAP_SM_PS_SHIFT
;
451 pos
= skb_put(skb
, sizeof(struct ieee80211_ht_cap
) + 2);
452 ieee80211_ie_build_ht_cap(pos
, &ht_cap
, ht_cap
.cap
);
453 } else if (action_code
== WLAN_TDLS_SETUP_RESPONSE
&&
454 ht_cap
.ht_supported
&& sta
->sta
.ht_cap
.ht_supported
) {
455 /* the peer caps are already intersected with our own */
456 memcpy(&ht_cap
, &sta
->sta
.ht_cap
, sizeof(ht_cap
));
458 pos
= skb_put(skb
, sizeof(struct ieee80211_ht_cap
) + 2);
459 ieee80211_ie_build_ht_cap(pos
, &ht_cap
, ht_cap
.cap
);
462 if (ht_cap
.ht_supported
&&
463 (ht_cap
.cap
& IEEE80211_HT_CAP_SUP_WIDTH_20_40
))
464 ieee80211_tdls_add_bss_coex_ie(skb
);
466 ieee80211_tdls_add_link_ie(sdata
, skb
, peer
, initiator
);
468 /* add any custom IEs that go before VHT capabilities */
470 static const u8 before_vht_cap
[] = {
473 WLAN_EID_EXT_SUPP_RATES
,
474 WLAN_EID_SUPPORTED_CHANNELS
,
476 WLAN_EID_EXT_CAPABILITY
,
478 WLAN_EID_FAST_BSS_TRANSITION
,
479 WLAN_EID_TIMEOUT_INTERVAL
,
480 WLAN_EID_SUPPORTED_REGULATORY_CLASSES
,
483 noffset
= ieee80211_ie_split(extra_ies
, extra_ies_len
,
485 ARRAY_SIZE(before_vht_cap
),
487 pos
= skb_put(skb
, noffset
- offset
);
488 memcpy(pos
, extra_ies
+ offset
, noffset
- offset
);
492 /* build the VHT-cap similarly to the HT-cap */
493 memcpy(&vht_cap
, &sband
->vht_cap
, sizeof(vht_cap
));
494 if ((action_code
== WLAN_TDLS_SETUP_REQUEST
||
495 action_code
== WLAN_PUB_ACTION_TDLS_DISCOVER_RES
) &&
496 vht_cap
.vht_supported
) {
497 ieee80211_apply_vhtcap_overrides(sdata
, &vht_cap
);
499 /* the AID is present only when VHT is implemented */
500 if (action_code
== WLAN_TDLS_SETUP_REQUEST
)
501 ieee80211_tdls_add_aid(sdata
, skb
);
503 pos
= skb_put(skb
, sizeof(struct ieee80211_vht_cap
) + 2);
504 ieee80211_ie_build_vht_cap(pos
, &vht_cap
, vht_cap
.cap
);
505 } else if (action_code
== WLAN_TDLS_SETUP_RESPONSE
&&
506 vht_cap
.vht_supported
&& sta
->sta
.vht_cap
.vht_supported
) {
507 /* the peer caps are already intersected with our own */
508 memcpy(&vht_cap
, &sta
->sta
.vht_cap
, sizeof(vht_cap
));
510 /* the AID is present only when VHT is implemented */
511 ieee80211_tdls_add_aid(sdata
, skb
);
513 pos
= skb_put(skb
, sizeof(struct ieee80211_vht_cap
) + 2);
514 ieee80211_ie_build_vht_cap(pos
, &vht_cap
, vht_cap
.cap
);
517 * if both peers support WIDER_BW, we can expand the chandef to
518 * a wider compatible one, up to 80MHz
520 if (test_sta_flag(sta
, WLAN_STA_TDLS_WIDER_BW
))
521 ieee80211_tdls_chandef_vht_upgrade(sdata
, sta
);
524 mutex_unlock(&local
->sta_mtx
);
526 /* add any remaining IEs */
528 noffset
= extra_ies_len
;
529 pos
= skb_put(skb
, noffset
- offset
);
530 memcpy(pos
, extra_ies
+ offset
, noffset
- offset
);
536 ieee80211_tdls_add_setup_cfm_ies(struct ieee80211_sub_if_data
*sdata
,
537 struct sk_buff
*skb
, const u8
*peer
,
538 bool initiator
, const u8
*extra_ies
,
539 size_t extra_ies_len
)
541 struct ieee80211_local
*local
= sdata
->local
;
542 struct ieee80211_if_managed
*ifmgd
= &sdata
->u
.mgd
;
543 size_t offset
= 0, noffset
;
544 struct sta_info
*sta
, *ap_sta
;
545 enum ieee80211_band band
= ieee80211_get_sdata_band(sdata
);
548 mutex_lock(&local
->sta_mtx
);
550 sta
= sta_info_get(sdata
, peer
);
551 ap_sta
= sta_info_get(sdata
, ifmgd
->bssid
);
552 if (WARN_ON_ONCE(!sta
|| !ap_sta
)) {
553 mutex_unlock(&local
->sta_mtx
);
557 sta
->tdls_chandef
= sdata
->vif
.bss_conf
.chandef
;
559 /* add any custom IEs that go before the QoS IE */
561 static const u8 before_qos
[] = {
564 noffset
= ieee80211_ie_split(extra_ies
, extra_ies_len
,
566 ARRAY_SIZE(before_qos
),
568 pos
= skb_put(skb
, noffset
- offset
);
569 memcpy(pos
, extra_ies
+ offset
, noffset
- offset
);
573 /* add the QoS param IE if both the peer and we support it */
574 if (local
->hw
.queues
>= IEEE80211_NUM_ACS
&& sta
->sta
.wme
)
575 ieee80211_tdls_add_wmm_param_ie(sdata
, skb
);
577 /* add any custom IEs that go before HT operation */
579 static const u8 before_ht_op
[] = {
582 WLAN_EID_FAST_BSS_TRANSITION
,
583 WLAN_EID_TIMEOUT_INTERVAL
,
585 noffset
= ieee80211_ie_split(extra_ies
, extra_ies_len
,
587 ARRAY_SIZE(before_ht_op
),
589 pos
= skb_put(skb
, noffset
- offset
);
590 memcpy(pos
, extra_ies
+ offset
, noffset
- offset
);
594 /* if HT support is only added in TDLS, we need an HT-operation IE */
595 if (!ap_sta
->sta
.ht_cap
.ht_supported
&& sta
->sta
.ht_cap
.ht_supported
) {
596 pos
= skb_put(skb
, 2 + sizeof(struct ieee80211_ht_operation
));
597 /* send an empty HT operation IE */
598 ieee80211_ie_build_ht_oper(pos
, &sta
->sta
.ht_cap
,
599 &sdata
->vif
.bss_conf
.chandef
, 0);
602 ieee80211_tdls_add_link_ie(sdata
, skb
, peer
, initiator
);
604 /* only include VHT-operation if not on the 2.4GHz band */
605 if (band
!= IEEE80211_BAND_2GHZ
&& sta
->sta
.vht_cap
.vht_supported
) {
607 * if both peers support WIDER_BW, we can expand the chandef to
608 * a wider compatible one, up to 80MHz
610 if (test_sta_flag(sta
, WLAN_STA_TDLS_WIDER_BW
))
611 ieee80211_tdls_chandef_vht_upgrade(sdata
, sta
);
613 pos
= skb_put(skb
, 2 + sizeof(struct ieee80211_vht_operation
));
614 ieee80211_ie_build_vht_oper(pos
, &sta
->sta
.vht_cap
,
618 mutex_unlock(&local
->sta_mtx
);
620 /* add any remaining IEs */
622 noffset
= extra_ies_len
;
623 pos
= skb_put(skb
, noffset
- offset
);
624 memcpy(pos
, extra_ies
+ offset
, noffset
- offset
);
629 ieee80211_tdls_add_chan_switch_req_ies(struct ieee80211_sub_if_data
*sdata
,
630 struct sk_buff
*skb
, const u8
*peer
,
631 bool initiator
, const u8
*extra_ies
,
632 size_t extra_ies_len
, u8 oper_class
,
633 struct cfg80211_chan_def
*chandef
)
635 struct ieee80211_tdls_data
*tf
;
636 size_t offset
= 0, noffset
;
639 if (WARN_ON_ONCE(!chandef
))
642 tf
= (void *)skb
->data
;
643 tf
->u
.chan_switch_req
.target_channel
=
644 ieee80211_frequency_to_channel(chandef
->chan
->center_freq
);
645 tf
->u
.chan_switch_req
.oper_class
= oper_class
;
648 static const u8 before_lnkie
[] = {
649 WLAN_EID_SECONDARY_CHANNEL_OFFSET
,
651 noffset
= ieee80211_ie_split(extra_ies
, extra_ies_len
,
653 ARRAY_SIZE(before_lnkie
),
655 pos
= skb_put(skb
, noffset
- offset
);
656 memcpy(pos
, extra_ies
+ offset
, noffset
- offset
);
660 ieee80211_tdls_add_link_ie(sdata
, skb
, peer
, initiator
);
662 /* add any remaining IEs */
664 noffset
= extra_ies_len
;
665 pos
= skb_put(skb
, noffset
- offset
);
666 memcpy(pos
, extra_ies
+ offset
, noffset
- offset
);
671 ieee80211_tdls_add_chan_switch_resp_ies(struct ieee80211_sub_if_data
*sdata
,
672 struct sk_buff
*skb
, const u8
*peer
,
673 u16 status_code
, bool initiator
,
675 size_t extra_ies_len
)
677 if (status_code
== 0)
678 ieee80211_tdls_add_link_ie(sdata
, skb
, peer
, initiator
);
681 memcpy(skb_put(skb
, extra_ies_len
), extra_ies
, extra_ies_len
);
684 static void ieee80211_tdls_add_ies(struct ieee80211_sub_if_data
*sdata
,
685 struct sk_buff
*skb
, const u8
*peer
,
686 u8 action_code
, u16 status_code
,
687 bool initiator
, const u8
*extra_ies
,
688 size_t extra_ies_len
, u8 oper_class
,
689 struct cfg80211_chan_def
*chandef
)
691 switch (action_code
) {
692 case WLAN_TDLS_SETUP_REQUEST
:
693 case WLAN_TDLS_SETUP_RESPONSE
:
694 case WLAN_PUB_ACTION_TDLS_DISCOVER_RES
:
695 if (status_code
== 0)
696 ieee80211_tdls_add_setup_start_ies(sdata
, skb
, peer
,
702 case WLAN_TDLS_SETUP_CONFIRM
:
703 if (status_code
== 0)
704 ieee80211_tdls_add_setup_cfm_ies(sdata
, skb
, peer
,
705 initiator
, extra_ies
,
708 case WLAN_TDLS_TEARDOWN
:
709 case WLAN_TDLS_DISCOVERY_REQUEST
:
711 memcpy(skb_put(skb
, extra_ies_len
), extra_ies
,
713 if (status_code
== 0 || action_code
== WLAN_TDLS_TEARDOWN
)
714 ieee80211_tdls_add_link_ie(sdata
, skb
, peer
, initiator
);
716 case WLAN_TDLS_CHANNEL_SWITCH_REQUEST
:
717 ieee80211_tdls_add_chan_switch_req_ies(sdata
, skb
, peer
,
718 initiator
, extra_ies
,
720 oper_class
, chandef
);
722 case WLAN_TDLS_CHANNEL_SWITCH_RESPONSE
:
723 ieee80211_tdls_add_chan_switch_resp_ies(sdata
, skb
, peer
,
725 initiator
, extra_ies
,
733 ieee80211_prep_tdls_encap_data(struct wiphy
*wiphy
, struct net_device
*dev
,
734 const u8
*peer
, u8 action_code
, u8 dialog_token
,
735 u16 status_code
, struct sk_buff
*skb
)
737 struct ieee80211_sub_if_data
*sdata
= IEEE80211_DEV_TO_SUB_IF(dev
);
738 struct ieee80211_tdls_data
*tf
;
740 tf
= (void *)skb_put(skb
, offsetof(struct ieee80211_tdls_data
, u
));
742 memcpy(tf
->da
, peer
, ETH_ALEN
);
743 memcpy(tf
->sa
, sdata
->vif
.addr
, ETH_ALEN
);
744 tf
->ether_type
= cpu_to_be16(ETH_P_TDLS
);
745 tf
->payload_type
= WLAN_TDLS_SNAP_RFTYPE
;
747 /* network header is after the ethernet header */
748 skb_set_network_header(skb
, ETH_HLEN
);
750 switch (action_code
) {
751 case WLAN_TDLS_SETUP_REQUEST
:
752 tf
->category
= WLAN_CATEGORY_TDLS
;
753 tf
->action_code
= WLAN_TDLS_SETUP_REQUEST
;
755 skb_put(skb
, sizeof(tf
->u
.setup_req
));
756 tf
->u
.setup_req
.dialog_token
= dialog_token
;
757 tf
->u
.setup_req
.capability
=
758 cpu_to_le16(ieee80211_get_tdls_sta_capab(sdata
,
761 case WLAN_TDLS_SETUP_RESPONSE
:
762 tf
->category
= WLAN_CATEGORY_TDLS
;
763 tf
->action_code
= WLAN_TDLS_SETUP_RESPONSE
;
765 skb_put(skb
, sizeof(tf
->u
.setup_resp
));
766 tf
->u
.setup_resp
.status_code
= cpu_to_le16(status_code
);
767 tf
->u
.setup_resp
.dialog_token
= dialog_token
;
768 tf
->u
.setup_resp
.capability
=
769 cpu_to_le16(ieee80211_get_tdls_sta_capab(sdata
,
772 case WLAN_TDLS_SETUP_CONFIRM
:
773 tf
->category
= WLAN_CATEGORY_TDLS
;
774 tf
->action_code
= WLAN_TDLS_SETUP_CONFIRM
;
776 skb_put(skb
, sizeof(tf
->u
.setup_cfm
));
777 tf
->u
.setup_cfm
.status_code
= cpu_to_le16(status_code
);
778 tf
->u
.setup_cfm
.dialog_token
= dialog_token
;
780 case WLAN_TDLS_TEARDOWN
:
781 tf
->category
= WLAN_CATEGORY_TDLS
;
782 tf
->action_code
= WLAN_TDLS_TEARDOWN
;
784 skb_put(skb
, sizeof(tf
->u
.teardown
));
785 tf
->u
.teardown
.reason_code
= cpu_to_le16(status_code
);
787 case WLAN_TDLS_DISCOVERY_REQUEST
:
788 tf
->category
= WLAN_CATEGORY_TDLS
;
789 tf
->action_code
= WLAN_TDLS_DISCOVERY_REQUEST
;
791 skb_put(skb
, sizeof(tf
->u
.discover_req
));
792 tf
->u
.discover_req
.dialog_token
= dialog_token
;
794 case WLAN_TDLS_CHANNEL_SWITCH_REQUEST
:
795 tf
->category
= WLAN_CATEGORY_TDLS
;
796 tf
->action_code
= WLAN_TDLS_CHANNEL_SWITCH_REQUEST
;
798 skb_put(skb
, sizeof(tf
->u
.chan_switch_req
));
800 case WLAN_TDLS_CHANNEL_SWITCH_RESPONSE
:
801 tf
->category
= WLAN_CATEGORY_TDLS
;
802 tf
->action_code
= WLAN_TDLS_CHANNEL_SWITCH_RESPONSE
;
804 skb_put(skb
, sizeof(tf
->u
.chan_switch_resp
));
805 tf
->u
.chan_switch_resp
.status_code
= cpu_to_le16(status_code
);
815 ieee80211_prep_tdls_direct(struct wiphy
*wiphy
, struct net_device
*dev
,
816 const u8
*peer
, u8 action_code
, u8 dialog_token
,
817 u16 status_code
, struct sk_buff
*skb
)
819 struct ieee80211_sub_if_data
*sdata
= IEEE80211_DEV_TO_SUB_IF(dev
);
820 struct ieee80211_mgmt
*mgmt
;
822 mgmt
= (void *)skb_put(skb
, 24);
824 memcpy(mgmt
->da
, peer
, ETH_ALEN
);
825 memcpy(mgmt
->sa
, sdata
->vif
.addr
, ETH_ALEN
);
826 memcpy(mgmt
->bssid
, sdata
->u
.mgd
.bssid
, ETH_ALEN
);
828 mgmt
->frame_control
= cpu_to_le16(IEEE80211_FTYPE_MGMT
|
829 IEEE80211_STYPE_ACTION
);
831 switch (action_code
) {
832 case WLAN_PUB_ACTION_TDLS_DISCOVER_RES
:
833 skb_put(skb
, 1 + sizeof(mgmt
->u
.action
.u
.tdls_discover_resp
));
834 mgmt
->u
.action
.category
= WLAN_CATEGORY_PUBLIC
;
835 mgmt
->u
.action
.u
.tdls_discover_resp
.action_code
=
836 WLAN_PUB_ACTION_TDLS_DISCOVER_RES
;
837 mgmt
->u
.action
.u
.tdls_discover_resp
.dialog_token
=
839 mgmt
->u
.action
.u
.tdls_discover_resp
.capability
=
840 cpu_to_le16(ieee80211_get_tdls_sta_capab(sdata
,
850 static struct sk_buff
*
851 ieee80211_tdls_build_mgmt_packet_data(struct ieee80211_sub_if_data
*sdata
,
852 const u8
*peer
, u8 action_code
,
853 u8 dialog_token
, u16 status_code
,
854 bool initiator
, const u8
*extra_ies
,
855 size_t extra_ies_len
, u8 oper_class
,
856 struct cfg80211_chan_def
*chandef
)
858 struct ieee80211_local
*local
= sdata
->local
;
862 skb
= netdev_alloc_skb(sdata
->dev
,
863 local
->hw
.extra_tx_headroom
+
864 max(sizeof(struct ieee80211_mgmt
),
865 sizeof(struct ieee80211_tdls_data
)) +
866 50 + /* supported rates */
868 26 + /* max(WMM-info, WMM-param) */
869 2 + max(sizeof(struct ieee80211_ht_cap
),
870 sizeof(struct ieee80211_ht_operation
)) +
871 2 + max(sizeof(struct ieee80211_vht_cap
),
872 sizeof(struct ieee80211_vht_operation
)) +
873 50 + /* supported channels */
874 3 + /* 40/20 BSS coex */
876 4 + /* oper classes */
878 sizeof(struct ieee80211_tdls_lnkie
));
882 skb_reserve(skb
, local
->hw
.extra_tx_headroom
);
884 switch (action_code
) {
885 case WLAN_TDLS_SETUP_REQUEST
:
886 case WLAN_TDLS_SETUP_RESPONSE
:
887 case WLAN_TDLS_SETUP_CONFIRM
:
888 case WLAN_TDLS_TEARDOWN
:
889 case WLAN_TDLS_DISCOVERY_REQUEST
:
890 case WLAN_TDLS_CHANNEL_SWITCH_REQUEST
:
891 case WLAN_TDLS_CHANNEL_SWITCH_RESPONSE
:
892 ret
= ieee80211_prep_tdls_encap_data(local
->hw
.wiphy
,
894 action_code
, dialog_token
,
897 case WLAN_PUB_ACTION_TDLS_DISCOVER_RES
:
898 ret
= ieee80211_prep_tdls_direct(local
->hw
.wiphy
, sdata
->dev
,
900 dialog_token
, status_code
,
911 ieee80211_tdls_add_ies(sdata
, skb
, peer
, action_code
, status_code
,
912 initiator
, extra_ies
, extra_ies_len
, oper_class
,
922 ieee80211_tdls_prep_mgmt_packet(struct wiphy
*wiphy
, struct net_device
*dev
,
923 const u8
*peer
, u8 action_code
, u8 dialog_token
,
924 u16 status_code
, u32 peer_capability
,
925 bool initiator
, const u8
*extra_ies
,
926 size_t extra_ies_len
, u8 oper_class
,
927 struct cfg80211_chan_def
*chandef
)
929 struct ieee80211_sub_if_data
*sdata
= IEEE80211_DEV_TO_SUB_IF(dev
);
930 struct sk_buff
*skb
= NULL
;
931 struct sta_info
*sta
;
936 sta
= sta_info_get(sdata
, peer
);
938 /* infer the initiator if we can, to support old userspace */
939 switch (action_code
) {
940 case WLAN_TDLS_SETUP_REQUEST
:
942 set_sta_flag(sta
, WLAN_STA_TDLS_INITIATOR
);
943 sta
->sta
.tdls_initiator
= false;
946 case WLAN_TDLS_SETUP_CONFIRM
:
947 case WLAN_TDLS_DISCOVERY_REQUEST
:
950 case WLAN_TDLS_SETUP_RESPONSE
:
952 * In some testing scenarios, we send a request and response.
953 * Make the last packet sent take effect for the initiator
957 clear_sta_flag(sta
, WLAN_STA_TDLS_INITIATOR
);
958 sta
->sta
.tdls_initiator
= true;
961 case WLAN_PUB_ACTION_TDLS_DISCOVER_RES
:
964 case WLAN_TDLS_TEARDOWN
:
965 case WLAN_TDLS_CHANNEL_SWITCH_REQUEST
:
966 case WLAN_TDLS_CHANNEL_SWITCH_RESPONSE
:
967 /* any value is ok */
974 if (sta
&& test_sta_flag(sta
, WLAN_STA_TDLS_INITIATOR
))
981 skb
= ieee80211_tdls_build_mgmt_packet_data(sdata
, peer
, action_code
,
982 dialog_token
, status_code
,
983 initiator
, extra_ies
,
984 extra_ies_len
, oper_class
,
991 if (action_code
== WLAN_PUB_ACTION_TDLS_DISCOVER_RES
) {
992 ieee80211_tx_skb(sdata
, skb
);
997 * According to 802.11z: Setup req/resp are sent in AC_BK, otherwise
998 * we should default to AC_VI.
1000 switch (action_code
) {
1001 case WLAN_TDLS_SETUP_REQUEST
:
1002 case WLAN_TDLS_SETUP_RESPONSE
:
1003 skb_set_queue_mapping(skb
, IEEE80211_AC_BK
);
1007 skb_set_queue_mapping(skb
, IEEE80211_AC_VI
);
1013 * Set the WLAN_TDLS_TEARDOWN flag to indicate a teardown in progress.
1014 * Later, if no ACK is returned from peer, we will re-send the teardown
1015 * packet through the AP.
1017 if ((action_code
== WLAN_TDLS_TEARDOWN
) &&
1018 ieee80211_hw_check(&sdata
->local
->hw
, REPORTS_TX_ACK_STATUS
)) {
1019 bool try_resend
; /* Should we keep skb for possible resend */
1021 /* If not sending directly to peer - no point in keeping skb */
1023 sta
= sta_info_get(sdata
, peer
);
1024 try_resend
= sta
&& test_sta_flag(sta
, WLAN_STA_TDLS_PEER_AUTH
);
1027 spin_lock_bh(&sdata
->u
.mgd
.teardown_lock
);
1028 if (try_resend
&& !sdata
->u
.mgd
.teardown_skb
) {
1029 /* Mark it as requiring TX status callback */
1030 flags
|= IEEE80211_TX_CTL_REQ_TX_STATUS
|
1031 IEEE80211_TX_INTFL_MLME_CONN_TX
;
1034 * skb is copied since mac80211 will later set
1035 * properties that might not be the same as the AP,
1036 * such as encryption, QoS, addresses, etc.
1038 * No problem if skb_copy() fails, so no need to check.
1040 sdata
->u
.mgd
.teardown_skb
= skb_copy(skb
, GFP_ATOMIC
);
1041 sdata
->u
.mgd
.orig_teardown_skb
= skb
;
1043 spin_unlock_bh(&sdata
->u
.mgd
.teardown_lock
);
1046 /* disable bottom halves when entering the Tx path */
1048 __ieee80211_subif_start_xmit(skb
, dev
, flags
);
1059 ieee80211_tdls_mgmt_setup(struct wiphy
*wiphy
, struct net_device
*dev
,
1060 const u8
*peer
, u8 action_code
, u8 dialog_token
,
1061 u16 status_code
, u32 peer_capability
, bool initiator
,
1062 const u8
*extra_ies
, size_t extra_ies_len
)
1064 struct ieee80211_sub_if_data
*sdata
= IEEE80211_DEV_TO_SUB_IF(dev
);
1065 struct ieee80211_local
*local
= sdata
->local
;
1066 enum ieee80211_smps_mode smps_mode
= sdata
->u
.mgd
.driver_smps_mode
;
1069 /* don't support setup with forced SMPS mode that's not off */
1070 if (smps_mode
!= IEEE80211_SMPS_AUTOMATIC
&&
1071 smps_mode
!= IEEE80211_SMPS_OFF
) {
1072 tdls_dbg(sdata
, "Aborting TDLS setup due to SMPS mode %d\n",
1077 mutex_lock(&local
->mtx
);
1079 /* we don't support concurrent TDLS peer setups */
1080 if (!is_zero_ether_addr(sdata
->u
.mgd
.tdls_peer
) &&
1081 !ether_addr_equal(sdata
->u
.mgd
.tdls_peer
, peer
)) {
1087 * make sure we have a STA representing the peer so we drop or buffer
1088 * non-TDLS-setup frames to the peer. We can't send other packets
1089 * during setup through the AP path.
1090 * Allow error packets to be sent - sometimes we don't even add a STA
1091 * before failing the setup.
1093 if (status_code
== 0) {
1095 if (!sta_info_get(sdata
, peer
)) {
1103 ieee80211_flush_queues(local
, sdata
, false);
1104 memcpy(sdata
->u
.mgd
.tdls_peer
, peer
, ETH_ALEN
);
1105 mutex_unlock(&local
->mtx
);
1107 /* we cannot take the mutex while preparing the setup packet */
1108 ret
= ieee80211_tdls_prep_mgmt_packet(wiphy
, dev
, peer
, action_code
,
1109 dialog_token
, status_code
,
1110 peer_capability
, initiator
,
1111 extra_ies
, extra_ies_len
, 0,
1114 mutex_lock(&local
->mtx
);
1115 eth_zero_addr(sdata
->u
.mgd
.tdls_peer
);
1116 mutex_unlock(&local
->mtx
);
1120 ieee80211_queue_delayed_work(&sdata
->local
->hw
,
1121 &sdata
->u
.mgd
.tdls_peer_del_work
,
1122 TDLS_PEER_SETUP_TIMEOUT
);
1126 mutex_unlock(&local
->mtx
);
1131 ieee80211_tdls_mgmt_teardown(struct wiphy
*wiphy
, struct net_device
*dev
,
1132 const u8
*peer
, u8 action_code
, u8 dialog_token
,
1133 u16 status_code
, u32 peer_capability
,
1134 bool initiator
, const u8
*extra_ies
,
1135 size_t extra_ies_len
)
1137 struct ieee80211_sub_if_data
*sdata
= IEEE80211_DEV_TO_SUB_IF(dev
);
1138 struct ieee80211_local
*local
= sdata
->local
;
1139 struct sta_info
*sta
;
1143 * No packets can be transmitted to the peer via the AP during setup -
1144 * the STA is set as a TDLS peer, but is not authorized.
1145 * During teardown, we prevent direct transmissions by stopping the
1146 * queues and flushing all direct packets.
1148 ieee80211_stop_vif_queues(local
, sdata
,
1149 IEEE80211_QUEUE_STOP_REASON_TDLS_TEARDOWN
);
1150 ieee80211_flush_queues(local
, sdata
, false);
1152 ret
= ieee80211_tdls_prep_mgmt_packet(wiphy
, dev
, peer
, action_code
,
1153 dialog_token
, status_code
,
1154 peer_capability
, initiator
,
1155 extra_ies
, extra_ies_len
, 0,
1158 sdata_err(sdata
, "Failed sending TDLS teardown packet %d\n",
1162 * Remove the STA AUTH flag to force further traffic through the AP. If
1163 * the STA was unreachable, it was already removed.
1166 sta
= sta_info_get(sdata
, peer
);
1168 clear_sta_flag(sta
, WLAN_STA_TDLS_PEER_AUTH
);
1171 ieee80211_wake_vif_queues(local
, sdata
,
1172 IEEE80211_QUEUE_STOP_REASON_TDLS_TEARDOWN
);
1177 int ieee80211_tdls_mgmt(struct wiphy
*wiphy
, struct net_device
*dev
,
1178 const u8
*peer
, u8 action_code
, u8 dialog_token
,
1179 u16 status_code
, u32 peer_capability
,
1180 bool initiator
, const u8
*extra_ies
,
1181 size_t extra_ies_len
)
1183 struct ieee80211_sub_if_data
*sdata
= IEEE80211_DEV_TO_SUB_IF(dev
);
1186 if (!(wiphy
->flags
& WIPHY_FLAG_SUPPORTS_TDLS
))
1189 /* make sure we are in managed mode, and associated */
1190 if (sdata
->vif
.type
!= NL80211_IFTYPE_STATION
||
1191 !sdata
->u
.mgd
.associated
)
1194 switch (action_code
) {
1195 case WLAN_TDLS_SETUP_REQUEST
:
1196 case WLAN_TDLS_SETUP_RESPONSE
:
1197 ret
= ieee80211_tdls_mgmt_setup(wiphy
, dev
, peer
, action_code
,
1198 dialog_token
, status_code
,
1199 peer_capability
, initiator
,
1200 extra_ies
, extra_ies_len
);
1202 case WLAN_TDLS_TEARDOWN
:
1203 ret
= ieee80211_tdls_mgmt_teardown(wiphy
, dev
, peer
,
1204 action_code
, dialog_token
,
1206 peer_capability
, initiator
,
1207 extra_ies
, extra_ies_len
);
1209 case WLAN_TDLS_DISCOVERY_REQUEST
:
1211 * Protect the discovery so we can hear the TDLS discovery
1212 * response frame. It is transmitted directly and not buffered
1215 drv_mgd_protect_tdls_discover(sdata
->local
, sdata
);
1217 case WLAN_TDLS_SETUP_CONFIRM
:
1218 case WLAN_PUB_ACTION_TDLS_DISCOVER_RES
:
1219 /* no special handling */
1220 ret
= ieee80211_tdls_prep_mgmt_packet(wiphy
, dev
, peer
,
1225 initiator
, extra_ies
,
1226 extra_ies_len
, 0, NULL
);
1233 tdls_dbg(sdata
, "TDLS mgmt action %d peer %pM status %d\n",
1234 action_code
, peer
, ret
);
1238 static void iee80211_tdls_recalc_chanctx(struct ieee80211_sub_if_data
*sdata
)
1240 struct ieee80211_local
*local
= sdata
->local
;
1241 struct ieee80211_chanctx_conf
*conf
;
1242 struct ieee80211_chanctx
*ctx
;
1244 mutex_lock(&local
->chanctx_mtx
);
1245 conf
= rcu_dereference_protected(sdata
->vif
.chanctx_conf
,
1246 lockdep_is_held(&local
->chanctx_mtx
));
1248 ctx
= container_of(conf
, struct ieee80211_chanctx
, conf
);
1249 ieee80211_recalc_chanctx_chantype(local
, ctx
);
1251 mutex_unlock(&local
->chanctx_mtx
);
1254 static int iee80211_tdls_have_ht_peers(struct ieee80211_sub_if_data
*sdata
)
1256 struct sta_info
*sta
;
1257 bool result
= false;
1260 list_for_each_entry_rcu(sta
, &sdata
->local
->sta_list
, list
) {
1261 if (!sta
->sta
.tdls
|| sta
->sdata
!= sdata
|| !sta
->uploaded
||
1262 !test_sta_flag(sta
, WLAN_STA_AUTHORIZED
) ||
1263 !test_sta_flag(sta
, WLAN_STA_TDLS_PEER_AUTH
) ||
1264 !sta
->sta
.ht_cap
.ht_supported
)
1275 iee80211_tdls_recalc_ht_protection(struct ieee80211_sub_if_data
*sdata
,
1276 struct sta_info
*sta
)
1278 struct ieee80211_if_managed
*ifmgd
= &sdata
->u
.mgd
;
1280 u16 protection
= IEEE80211_HT_OP_MODE_PROTECTION_NONHT_MIXED
|
1281 IEEE80211_HT_OP_MODE_NON_GF_STA_PRSNT
|
1282 IEEE80211_HT_OP_MODE_NON_HT_STA_PRSNT
;
1285 /* Nothing to do if the BSS connection uses HT */
1286 if (!(ifmgd
->flags
& IEEE80211_STA_DISABLE_HT
))
1289 tdls_ht
= (sta
&& sta
->sta
.ht_cap
.ht_supported
) ||
1290 iee80211_tdls_have_ht_peers(sdata
);
1292 opmode
= sdata
->vif
.bss_conf
.ht_operation_mode
;
1295 opmode
|= protection
;
1297 opmode
&= ~protection
;
1299 if (opmode
== sdata
->vif
.bss_conf
.ht_operation_mode
)
1302 sdata
->vif
.bss_conf
.ht_operation_mode
= opmode
;
1303 ieee80211_bss_info_change_notify(sdata
, BSS_CHANGED_HT
);
1306 int ieee80211_tdls_oper(struct wiphy
*wiphy
, struct net_device
*dev
,
1307 const u8
*peer
, enum nl80211_tdls_operation oper
)
1309 struct sta_info
*sta
;
1310 struct ieee80211_sub_if_data
*sdata
= IEEE80211_DEV_TO_SUB_IF(dev
);
1311 struct ieee80211_local
*local
= sdata
->local
;
1314 if (!(wiphy
->flags
& WIPHY_FLAG_SUPPORTS_TDLS
))
1317 if (sdata
->vif
.type
!= NL80211_IFTYPE_STATION
)
1321 case NL80211_TDLS_ENABLE_LINK
:
1322 case NL80211_TDLS_DISABLE_LINK
:
1324 case NL80211_TDLS_TEARDOWN
:
1325 case NL80211_TDLS_SETUP
:
1326 case NL80211_TDLS_DISCOVERY_REQ
:
1327 /* We don't support in-driver setup/teardown/discovery */
1331 /* protect possible bss_conf changes and avoid concurrency in
1332 * ieee80211_bss_info_change_notify()
1335 mutex_lock(&local
->mtx
);
1336 tdls_dbg(sdata
, "TDLS oper %d peer %pM\n", oper
, peer
);
1339 case NL80211_TDLS_ENABLE_LINK
:
1340 if (sdata
->vif
.csa_active
) {
1341 tdls_dbg(sdata
, "TDLS: disallow link during CSA\n");
1346 iee80211_tdls_recalc_chanctx(sdata
);
1348 mutex_lock(&local
->sta_mtx
);
1349 sta
= sta_info_get(sdata
, peer
);
1351 mutex_unlock(&local
->sta_mtx
);
1356 iee80211_tdls_recalc_ht_protection(sdata
, sta
);
1358 set_sta_flag(sta
, WLAN_STA_TDLS_PEER_AUTH
);
1359 mutex_unlock(&local
->sta_mtx
);
1361 WARN_ON_ONCE(is_zero_ether_addr(sdata
->u
.mgd
.tdls_peer
) ||
1362 !ether_addr_equal(sdata
->u
.mgd
.tdls_peer
, peer
));
1365 case NL80211_TDLS_DISABLE_LINK
:
1367 * The teardown message in ieee80211_tdls_mgmt_teardown() was
1368 * created while the queues were stopped, so it might still be
1369 * pending. Before flushing the queues we need to be sure the
1370 * message is handled by the tasklet handling pending messages,
1371 * otherwise we might start destroying the station before
1372 * sending the teardown packet.
1373 * Note that this only forces the tasklet to flush pendings -
1374 * not to stop the tasklet from rescheduling itself.
1376 tasklet_kill(&local
->tx_pending_tasklet
);
1377 /* flush a potentially queued teardown packet */
1378 ieee80211_flush_queues(local
, sdata
, false);
1380 ret
= sta_info_destroy_addr(sdata
, peer
);
1382 mutex_lock(&local
->sta_mtx
);
1383 iee80211_tdls_recalc_ht_protection(sdata
, NULL
);
1384 mutex_unlock(&local
->sta_mtx
);
1386 iee80211_tdls_recalc_chanctx(sdata
);
1393 if (ret
== 0 && ether_addr_equal(sdata
->u
.mgd
.tdls_peer
, peer
)) {
1394 cancel_delayed_work(&sdata
->u
.mgd
.tdls_peer_del_work
);
1395 eth_zero_addr(sdata
->u
.mgd
.tdls_peer
);
1399 ieee80211_queue_work(&sdata
->local
->hw
,
1400 &sdata
->u
.mgd
.request_smps_work
);
1402 mutex_unlock(&local
->mtx
);
1403 sdata_unlock(sdata
);
1407 void ieee80211_tdls_oper_request(struct ieee80211_vif
*vif
, const u8
*peer
,
1408 enum nl80211_tdls_operation oper
,
1409 u16 reason_code
, gfp_t gfp
)
1411 struct ieee80211_sub_if_data
*sdata
= vif_to_sdata(vif
);
1413 if (vif
->type
!= NL80211_IFTYPE_STATION
|| !vif
->bss_conf
.assoc
) {
1414 sdata_err(sdata
, "Discarding TDLS oper %d - not STA or disconnected\n",
1419 cfg80211_tdls_oper_request(sdata
->dev
, peer
, oper
, reason_code
, gfp
);
1421 EXPORT_SYMBOL(ieee80211_tdls_oper_request
);
1424 iee80211_tdls_add_ch_switch_timing(u8
*buf
, u16 switch_time
, u16 switch_timeout
)
1426 struct ieee80211_ch_switch_timing
*ch_sw
;
1428 *buf
++ = WLAN_EID_CHAN_SWITCH_TIMING
;
1429 *buf
++ = sizeof(struct ieee80211_ch_switch_timing
);
1431 ch_sw
= (void *)buf
;
1432 ch_sw
->switch_time
= cpu_to_le16(switch_time
);
1433 ch_sw
->switch_timeout
= cpu_to_le16(switch_timeout
);
1436 /* find switch timing IE in SKB ready for Tx */
1437 static const u8
*ieee80211_tdls_find_sw_timing_ie(struct sk_buff
*skb
)
1439 struct ieee80211_tdls_data
*tf
;
1443 * Get the offset for the new location of the switch timing IE.
1444 * The SKB network header will now point to the "payload_type"
1445 * element of the TDLS data frame struct.
1447 tf
= container_of(skb
->data
+ skb_network_offset(skb
),
1448 struct ieee80211_tdls_data
, payload_type
);
1449 ie_start
= tf
->u
.chan_switch_req
.variable
;
1450 return cfg80211_find_ie(WLAN_EID_CHAN_SWITCH_TIMING
, ie_start
,
1451 skb
->len
- (ie_start
- skb
->data
));
1454 static struct sk_buff
*
1455 ieee80211_tdls_ch_sw_tmpl_get(struct sta_info
*sta
, u8 oper_class
,
1456 struct cfg80211_chan_def
*chandef
,
1457 u32
*ch_sw_tm_ie_offset
)
1459 struct ieee80211_sub_if_data
*sdata
= sta
->sdata
;
1460 u8 extra_ies
[2 + sizeof(struct ieee80211_sec_chan_offs_ie
) +
1461 2 + sizeof(struct ieee80211_ch_switch_timing
)];
1462 int extra_ies_len
= 2 + sizeof(struct ieee80211_ch_switch_timing
);
1463 u8
*pos
= extra_ies
;
1464 struct sk_buff
*skb
;
1467 * if chandef points to a wide channel add a Secondary-Channel
1468 * Offset information element
1470 if (chandef
->width
== NL80211_CHAN_WIDTH_40
) {
1471 struct ieee80211_sec_chan_offs_ie
*sec_chan_ie
;
1474 *pos
++ = WLAN_EID_SECONDARY_CHANNEL_OFFSET
;
1475 *pos
++ = sizeof(*sec_chan_ie
);
1476 sec_chan_ie
= (void *)pos
;
1478 ht40plus
= cfg80211_get_chandef_type(chandef
) ==
1479 NL80211_CHAN_HT40PLUS
;
1480 sec_chan_ie
->sec_chan_offs
= ht40plus
?
1481 IEEE80211_HT_PARAM_CHA_SEC_ABOVE
:
1482 IEEE80211_HT_PARAM_CHA_SEC_BELOW
;
1483 pos
+= sizeof(*sec_chan_ie
);
1485 extra_ies_len
+= 2 + sizeof(struct ieee80211_sec_chan_offs_ie
);
1488 /* just set the values to 0, this is a template */
1489 iee80211_tdls_add_ch_switch_timing(pos
, 0, 0);
1491 skb
= ieee80211_tdls_build_mgmt_packet_data(sdata
, sta
->sta
.addr
,
1492 WLAN_TDLS_CHANNEL_SWITCH_REQUEST
,
1493 0, 0, !sta
->sta
.tdls_initiator
,
1494 extra_ies
, extra_ies_len
,
1495 oper_class
, chandef
);
1499 skb
= ieee80211_build_data_template(sdata
, skb
, 0);
1501 tdls_dbg(sdata
, "Failed building TDLS channel switch frame\n");
1505 if (ch_sw_tm_ie_offset
) {
1506 const u8
*tm_ie
= ieee80211_tdls_find_sw_timing_ie(skb
);
1509 tdls_dbg(sdata
, "No switch timing IE in TDLS switch\n");
1510 dev_kfree_skb_any(skb
);
1514 *ch_sw_tm_ie_offset
= tm_ie
- skb
->data
;
1518 "TDLS channel switch request template for %pM ch %d width %d\n",
1519 sta
->sta
.addr
, chandef
->chan
->center_freq
, chandef
->width
);
1524 ieee80211_tdls_channel_switch(struct wiphy
*wiphy
, struct net_device
*dev
,
1525 const u8
*addr
, u8 oper_class
,
1526 struct cfg80211_chan_def
*chandef
)
1528 struct ieee80211_sub_if_data
*sdata
= IEEE80211_DEV_TO_SUB_IF(dev
);
1529 struct ieee80211_local
*local
= sdata
->local
;
1530 struct sta_info
*sta
;
1531 struct sk_buff
*skb
= NULL
;
1535 mutex_lock(&local
->sta_mtx
);
1536 sta
= sta_info_get(sdata
, addr
);
1539 "Invalid TDLS peer %pM for channel switch request\n",
1545 if (!test_sta_flag(sta
, WLAN_STA_TDLS_CHAN_SWITCH
)) {
1546 tdls_dbg(sdata
, "TDLS channel switch unsupported by %pM\n",
1552 skb
= ieee80211_tdls_ch_sw_tmpl_get(sta
, oper_class
, chandef
,
1559 ret
= drv_tdls_channel_switch(local
, sdata
, &sta
->sta
, oper_class
,
1560 chandef
, skb
, ch_sw_tm_ie
);
1562 set_sta_flag(sta
, WLAN_STA_TDLS_OFF_CHANNEL
);
1565 mutex_unlock(&local
->sta_mtx
);
1566 dev_kfree_skb_any(skb
);
1571 ieee80211_tdls_cancel_channel_switch(struct wiphy
*wiphy
,
1572 struct net_device
*dev
,
1575 struct ieee80211_sub_if_data
*sdata
= IEEE80211_DEV_TO_SUB_IF(dev
);
1576 struct ieee80211_local
*local
= sdata
->local
;
1577 struct sta_info
*sta
;
1579 mutex_lock(&local
->sta_mtx
);
1580 sta
= sta_info_get(sdata
, addr
);
1583 "Invalid TDLS peer %pM for channel switch cancel\n",
1588 if (!test_sta_flag(sta
, WLAN_STA_TDLS_OFF_CHANNEL
)) {
1589 tdls_dbg(sdata
, "TDLS channel switch not initiated by %pM\n",
1594 drv_tdls_cancel_channel_switch(local
, sdata
, &sta
->sta
);
1595 clear_sta_flag(sta
, WLAN_STA_TDLS_OFF_CHANNEL
);
1598 mutex_unlock(&local
->sta_mtx
);
1601 static struct sk_buff
*
1602 ieee80211_tdls_ch_sw_resp_tmpl_get(struct sta_info
*sta
,
1603 u32
*ch_sw_tm_ie_offset
)
1605 struct ieee80211_sub_if_data
*sdata
= sta
->sdata
;
1606 struct sk_buff
*skb
;
1607 u8 extra_ies
[2 + sizeof(struct ieee80211_ch_switch_timing
)];
1609 /* initial timing are always zero in the template */
1610 iee80211_tdls_add_ch_switch_timing(extra_ies
, 0, 0);
1612 skb
= ieee80211_tdls_build_mgmt_packet_data(sdata
, sta
->sta
.addr
,
1613 WLAN_TDLS_CHANNEL_SWITCH_RESPONSE
,
1614 0, 0, !sta
->sta
.tdls_initiator
,
1615 extra_ies
, sizeof(extra_ies
), 0, NULL
);
1619 skb
= ieee80211_build_data_template(sdata
, skb
, 0);
1622 "Failed building TDLS channel switch resp frame\n");
1626 if (ch_sw_tm_ie_offset
) {
1627 const u8
*tm_ie
= ieee80211_tdls_find_sw_timing_ie(skb
);
1631 "No switch timing IE in TDLS switch resp\n");
1632 dev_kfree_skb_any(skb
);
1636 *ch_sw_tm_ie_offset
= tm_ie
- skb
->data
;
1639 tdls_dbg(sdata
, "TDLS get channel switch response template for %pM\n",
1645 ieee80211_process_tdls_channel_switch_resp(struct ieee80211_sub_if_data
*sdata
,
1646 struct sk_buff
*skb
)
1648 struct ieee80211_local
*local
= sdata
->local
;
1649 struct ieee802_11_elems elems
;
1650 struct sta_info
*sta
;
1651 struct ieee80211_tdls_data
*tf
= (void *)skb
->data
;
1652 bool local_initiator
;
1653 struct ieee80211_rx_status
*rx_status
= IEEE80211_SKB_RXCB(skb
);
1654 int baselen
= offsetof(typeof(*tf
), u
.chan_switch_resp
.variable
);
1655 struct ieee80211_tdls_ch_sw_params params
= {};
1658 params
.action_code
= WLAN_TDLS_CHANNEL_SWITCH_RESPONSE
;
1659 params
.timestamp
= rx_status
->device_timestamp
;
1661 if (skb
->len
< baselen
) {
1662 tdls_dbg(sdata
, "TDLS channel switch resp too short: %d\n",
1667 mutex_lock(&local
->sta_mtx
);
1668 sta
= sta_info_get(sdata
, tf
->sa
);
1669 if (!sta
|| !test_sta_flag(sta
, WLAN_STA_TDLS_PEER_AUTH
)) {
1670 tdls_dbg(sdata
, "TDLS chan switch from non-peer sta %pM\n",
1676 params
.sta
= &sta
->sta
;
1677 params
.status
= le16_to_cpu(tf
->u
.chan_switch_resp
.status_code
);
1678 if (params
.status
!= 0) {
1683 ieee802_11_parse_elems(tf
->u
.chan_switch_resp
.variable
,
1684 skb
->len
- baselen
, false, &elems
);
1685 if (elems
.parse_error
) {
1686 tdls_dbg(sdata
, "Invalid IEs in TDLS channel switch resp\n");
1691 if (!elems
.ch_sw_timing
|| !elems
.lnk_id
) {
1692 tdls_dbg(sdata
, "TDLS channel switch resp - missing IEs\n");
1697 /* validate the initiator is set correctly */
1699 !memcmp(elems
.lnk_id
->init_sta
, sdata
->vif
.addr
, ETH_ALEN
);
1700 if (local_initiator
== sta
->sta
.tdls_initiator
) {
1701 tdls_dbg(sdata
, "TDLS chan switch invalid lnk-id initiator\n");
1706 params
.switch_time
= le16_to_cpu(elems
.ch_sw_timing
->switch_time
);
1707 params
.switch_timeout
= le16_to_cpu(elems
.ch_sw_timing
->switch_timeout
);
1710 ieee80211_tdls_ch_sw_resp_tmpl_get(sta
, ¶ms
.ch_sw_tm_ie
);
1711 if (!params
.tmpl_skb
) {
1717 drv_tdls_recv_channel_switch(sdata
->local
, sdata
, ¶ms
);
1720 "TDLS channel switch response received from %pM status %d\n",
1721 tf
->sa
, params
.status
);
1724 mutex_unlock(&local
->sta_mtx
);
1725 dev_kfree_skb_any(params
.tmpl_skb
);
1730 ieee80211_process_tdls_channel_switch_req(struct ieee80211_sub_if_data
*sdata
,
1731 struct sk_buff
*skb
)
1733 struct ieee80211_local
*local
= sdata
->local
;
1734 struct ieee802_11_elems elems
;
1735 struct cfg80211_chan_def chandef
;
1736 struct ieee80211_channel
*chan
;
1737 enum nl80211_channel_type chan_type
;
1739 u8 target_channel
, oper_class
;
1740 bool local_initiator
;
1741 struct sta_info
*sta
;
1742 enum ieee80211_band band
;
1743 struct ieee80211_tdls_data
*tf
= (void *)skb
->data
;
1744 struct ieee80211_rx_status
*rx_status
= IEEE80211_SKB_RXCB(skb
);
1745 int baselen
= offsetof(typeof(*tf
), u
.chan_switch_req
.variable
);
1746 struct ieee80211_tdls_ch_sw_params params
= {};
1749 params
.action_code
= WLAN_TDLS_CHANNEL_SWITCH_REQUEST
;
1750 params
.timestamp
= rx_status
->device_timestamp
;
1752 if (skb
->len
< baselen
) {
1753 tdls_dbg(sdata
, "TDLS channel switch req too short: %d\n",
1758 target_channel
= tf
->u
.chan_switch_req
.target_channel
;
1759 oper_class
= tf
->u
.chan_switch_req
.oper_class
;
1762 * We can't easily infer the channel band. The operating class is
1763 * ambiguous - there are multiple tables (US/Europe/JP/Global). The
1764 * solution here is to treat channels with number >14 as 5GHz ones,
1765 * and specifically check for the (oper_class, channel) combinations
1766 * where this doesn't hold. These are thankfully unique according to
1768 * We consider only the 2GHz and 5GHz bands and 20MHz+ channels as
1771 if ((oper_class
== 112 || oper_class
== 2 || oper_class
== 3 ||
1772 oper_class
== 4 || oper_class
== 5 || oper_class
== 6) &&
1773 target_channel
< 14)
1774 band
= IEEE80211_BAND_5GHZ
;
1776 band
= target_channel
< 14 ? IEEE80211_BAND_2GHZ
:
1777 IEEE80211_BAND_5GHZ
;
1779 freq
= ieee80211_channel_to_frequency(target_channel
, band
);
1781 tdls_dbg(sdata
, "Invalid channel in TDLS chan switch: %d\n",
1786 chan
= ieee80211_get_channel(sdata
->local
->hw
.wiphy
, freq
);
1789 "Unsupported channel for TDLS chan switch: %d\n",
1794 ieee802_11_parse_elems(tf
->u
.chan_switch_req
.variable
,
1795 skb
->len
- baselen
, false, &elems
);
1796 if (elems
.parse_error
) {
1797 tdls_dbg(sdata
, "Invalid IEs in TDLS channel switch req\n");
1801 if (!elems
.ch_sw_timing
|| !elems
.lnk_id
) {
1802 tdls_dbg(sdata
, "TDLS channel switch req - missing IEs\n");
1806 if (!elems
.sec_chan_offs
) {
1807 chan_type
= NL80211_CHAN_HT20
;
1809 switch (elems
.sec_chan_offs
->sec_chan_offs
) {
1810 case IEEE80211_HT_PARAM_CHA_SEC_ABOVE
:
1811 chan_type
= NL80211_CHAN_HT40PLUS
;
1813 case IEEE80211_HT_PARAM_CHA_SEC_BELOW
:
1814 chan_type
= NL80211_CHAN_HT40MINUS
;
1817 chan_type
= NL80211_CHAN_HT20
;
1822 cfg80211_chandef_create(&chandef
, chan
, chan_type
);
1824 /* we will be active on the TDLS link */
1825 if (!cfg80211_reg_can_beacon_relax(sdata
->local
->hw
.wiphy
, &chandef
,
1826 sdata
->wdev
.iftype
)) {
1827 tdls_dbg(sdata
, "TDLS chan switch to forbidden channel\n");
1831 mutex_lock(&local
->sta_mtx
);
1832 sta
= sta_info_get(sdata
, tf
->sa
);
1833 if (!sta
|| !test_sta_flag(sta
, WLAN_STA_TDLS_PEER_AUTH
)) {
1834 tdls_dbg(sdata
, "TDLS chan switch from non-peer sta %pM\n",
1840 params
.sta
= &sta
->sta
;
1842 /* validate the initiator is set correctly */
1844 !memcmp(elems
.lnk_id
->init_sta
, sdata
->vif
.addr
, ETH_ALEN
);
1845 if (local_initiator
== sta
->sta
.tdls_initiator
) {
1846 tdls_dbg(sdata
, "TDLS chan switch invalid lnk-id initiator\n");
1851 /* peer should have known better */
1852 if (!sta
->sta
.ht_cap
.ht_supported
&& elems
.sec_chan_offs
&&
1853 elems
.sec_chan_offs
->sec_chan_offs
) {
1854 tdls_dbg(sdata
, "TDLS chan switch - wide chan unsupported\n");
1859 params
.chandef
= &chandef
;
1860 params
.switch_time
= le16_to_cpu(elems
.ch_sw_timing
->switch_time
);
1861 params
.switch_timeout
= le16_to_cpu(elems
.ch_sw_timing
->switch_timeout
);
1864 ieee80211_tdls_ch_sw_resp_tmpl_get(sta
,
1865 ¶ms
.ch_sw_tm_ie
);
1866 if (!params
.tmpl_skb
) {
1871 drv_tdls_recv_channel_switch(sdata
->local
, sdata
, ¶ms
);
1874 "TDLS ch switch request received from %pM ch %d width %d\n",
1875 tf
->sa
, params
.chandef
->chan
->center_freq
,
1876 params
.chandef
->width
);
1878 mutex_unlock(&local
->sta_mtx
);
1879 dev_kfree_skb_any(params
.tmpl_skb
);
1884 ieee80211_process_tdls_channel_switch(struct ieee80211_sub_if_data
*sdata
,
1885 struct sk_buff
*skb
)
1887 struct ieee80211_tdls_data
*tf
= (void *)skb
->data
;
1888 struct wiphy
*wiphy
= sdata
->local
->hw
.wiphy
;
1892 /* make sure the driver supports it */
1893 if (!(wiphy
->features
& NL80211_FEATURE_TDLS_CHANNEL_SWITCH
))
1896 /* we want to access the entire packet */
1897 if (skb_linearize(skb
))
1900 * The packet/size was already validated by mac80211 Rx path, only look
1901 * at the action type.
1903 switch (tf
->action_code
) {
1904 case WLAN_TDLS_CHANNEL_SWITCH_REQUEST
:
1905 ieee80211_process_tdls_channel_switch_req(sdata
, skb
);
1907 case WLAN_TDLS_CHANNEL_SWITCH_RESPONSE
:
1908 ieee80211_process_tdls_channel_switch_resp(sdata
, skb
);
1916 void ieee80211_teardown_tdls_peers(struct ieee80211_sub_if_data
*sdata
)
1918 struct sta_info
*sta
;
1919 u16 reason
= WLAN_REASON_TDLS_TEARDOWN_UNSPECIFIED
;
1922 list_for_each_entry_rcu(sta
, &sdata
->local
->sta_list
, list
) {
1923 if (!sta
->sta
.tdls
|| sta
->sdata
!= sdata
|| !sta
->uploaded
||
1924 !test_sta_flag(sta
, WLAN_STA_AUTHORIZED
))
1927 ieee80211_tdls_oper_request(&sdata
->vif
, sta
->sta
.addr
,
1928 NL80211_TDLS_TEARDOWN
, reason
,
1934 void ieee80211_tdls_chsw_work(struct work_struct
*wk
)
1936 struct ieee80211_local
*local
=
1937 container_of(wk
, struct ieee80211_local
, tdls_chsw_work
);
1938 struct ieee80211_sub_if_data
*sdata
;
1939 struct sk_buff
*skb
;
1940 struct ieee80211_tdls_data
*tf
;
1943 while ((skb
= skb_dequeue(&local
->skb_queue_tdls_chsw
))) {
1944 tf
= (struct ieee80211_tdls_data
*)skb
->data
;
1945 list_for_each_entry(sdata
, &local
->interfaces
, list
) {
1946 if (!ieee80211_sdata_running(sdata
) ||
1947 sdata
->vif
.type
!= NL80211_IFTYPE_STATION
||
1948 !ether_addr_equal(tf
->da
, sdata
->vif
.addr
))
1951 ieee80211_process_tdls_channel_switch(sdata
, skb
);