1 /******************************************************************************
3 * This file is provided under a dual BSD/GPLv2 license. When using or
4 * redistributing this file, you may do so under either license.
8 * Copyright(c) 2014 Intel Mobile Communications GmbH
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of version 2 of the GNU General Public License as
12 * published by the Free Software Foundation.
14 * This program is distributed in the hope that it will be useful, but
15 * WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * General Public License for more details.
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110,
24 * The full GNU General Public License is included in this distribution
25 * in the file called COPYING.
27 * Contact Information:
28 * Intel Linux Wireless <ilw@linux.intel.com>
29 * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
33 * Copyright(c) 2014 Intel Mobile Communications GmbH
34 * All rights reserved.
36 * Redistribution and use in source and binary forms, with or without
37 * modification, are permitted provided that the following conditions
40 * * Redistributions of source code must retain the above copyright
41 * notice, this list of conditions and the following disclaimer.
42 * * Redistributions in binary form must reproduce the above copyright
43 * notice, this list of conditions and the following disclaimer in
44 * the documentation and/or other materials provided with the
46 * * Neither the name Intel Corporation nor the names of its
47 * contributors may be used to endorse or promote products derived
48 * from this software without specific prior written permission.
50 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
51 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
52 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
53 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
54 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
55 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
56 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
57 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
58 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
59 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
60 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
62 *****************************************************************************/
64 #include <linux/etherdevice.h>
66 #include "time-event.h"
70 #define TU_TO_US(x) (x * 1024)
71 #define TU_TO_MS(x) (TU_TO_US(x) / 1000)
73 void iwl_mvm_teardown_tdls_peers(struct iwl_mvm
*mvm
)
75 struct ieee80211_sta
*sta
;
76 struct iwl_mvm_sta
*mvmsta
;
79 lockdep_assert_held(&mvm
->mutex
);
81 for (i
= 0; i
< IWL_MVM_STATION_COUNT
; i
++) {
82 sta
= rcu_dereference_protected(mvm
->fw_id_to_mac_id
[i
],
83 lockdep_is_held(&mvm
->mutex
));
84 if (!sta
|| IS_ERR(sta
) || !sta
->tdls
)
87 mvmsta
= iwl_mvm_sta_from_mac80211(sta
);
88 ieee80211_tdls_oper_request(mvmsta
->vif
, sta
->addr
,
89 NL80211_TDLS_TEARDOWN
,
90 WLAN_REASON_TDLS_TEARDOWN_UNSPECIFIED
,
95 int iwl_mvm_tdls_sta_count(struct iwl_mvm
*mvm
, struct ieee80211_vif
*vif
)
97 struct ieee80211_sta
*sta
;
98 struct iwl_mvm_sta
*mvmsta
;
102 lockdep_assert_held(&mvm
->mutex
);
104 for (i
= 0; i
< IWL_MVM_STATION_COUNT
; i
++) {
105 sta
= rcu_dereference_protected(mvm
->fw_id_to_mac_id
[i
],
106 lockdep_is_held(&mvm
->mutex
));
107 if (!sta
|| IS_ERR(sta
) || !sta
->tdls
)
111 mvmsta
= iwl_mvm_sta_from_mac80211(sta
);
112 if (mvmsta
->vif
!= vif
)
122 static void iwl_mvm_tdls_config(struct iwl_mvm
*mvm
, struct ieee80211_vif
*vif
)
124 struct iwl_rx_packet
*pkt
;
125 struct iwl_tdls_config_res
*resp
;
126 struct iwl_tdls_config_cmd tdls_cfg_cmd
= {};
127 struct iwl_host_cmd cmd
= {
128 .id
= TDLS_CONFIG_CMD
,
129 .flags
= CMD_WANT_SKB
,
130 .data
= { &tdls_cfg_cmd
, },
131 .len
= { sizeof(struct iwl_tdls_config_cmd
), },
133 struct ieee80211_sta
*sta
;
135 struct iwl_mvm_vif
*mvmvif
= iwl_mvm_vif_from_mac80211(vif
);
137 lockdep_assert_held(&mvm
->mutex
);
139 tdls_cfg_cmd
.id_and_color
=
140 cpu_to_le32(FW_CMD_ID_AND_COLOR(mvmvif
->id
, mvmvif
->color
));
141 tdls_cfg_cmd
.tx_to_ap_tid
= IWL_MVM_TDLS_FW_TID
;
142 tdls_cfg_cmd
.tx_to_ap_ssn
= cpu_to_le16(0); /* not used for now */
144 /* for now the Tx cmd is empty and unused */
146 /* populate TDLS peer data */
148 for (i
= 0; i
< IWL_MVM_STATION_COUNT
; i
++) {
149 sta
= rcu_dereference_protected(mvm
->fw_id_to_mac_id
[i
],
150 lockdep_is_held(&mvm
->mutex
));
151 if (IS_ERR_OR_NULL(sta
) || !sta
->tdls
)
154 tdls_cfg_cmd
.sta_info
[cnt
].sta_id
= i
;
155 tdls_cfg_cmd
.sta_info
[cnt
].tx_to_peer_tid
=
157 tdls_cfg_cmd
.sta_info
[cnt
].tx_to_peer_ssn
= cpu_to_le16(0);
158 tdls_cfg_cmd
.sta_info
[cnt
].is_initiator
=
159 cpu_to_le32(sta
->tdls_initiator
? 1 : 0);
164 tdls_cfg_cmd
.tdls_peer_count
= cnt
;
165 IWL_DEBUG_TDLS(mvm
, "send TDLS config to FW for %d peers\n", cnt
);
167 ret
= iwl_mvm_send_cmd(mvm
, &cmd
);
168 if (WARN_ON_ONCE(ret
))
172 if (pkt
->hdr
.flags
& IWL_CMD_FAILED_MSK
) {
173 IWL_ERR(mvm
, "Bad return from TDLS_CONFIG_COMMAND (0x%08X)\n",
178 if (WARN_ON_ONCE(iwl_rx_packet_payload_len(pkt
) != sizeof(*resp
)))
181 /* we don't really care about the response at this point */
187 void iwl_mvm_recalc_tdls_state(struct iwl_mvm
*mvm
, struct ieee80211_vif
*vif
,
190 int tdls_sta_cnt
= iwl_mvm_tdls_sta_count(mvm
, vif
);
192 /* when the first peer joins, send a power update first */
193 if (tdls_sta_cnt
== 1 && sta_added
)
194 iwl_mvm_power_update_mac(mvm
);
196 /* configure the FW with TDLS peer info */
197 iwl_mvm_tdls_config(mvm
, vif
);
199 /* when the last peer leaves, send a power update last */
200 if (tdls_sta_cnt
== 0 && !sta_added
)
201 iwl_mvm_power_update_mac(mvm
);
204 void iwl_mvm_mac_mgd_protect_tdls_discover(struct ieee80211_hw
*hw
,
205 struct ieee80211_vif
*vif
)
207 struct iwl_mvm
*mvm
= IWL_MAC80211_GET_MVM(hw
);
208 u32 duration
= 2 * vif
->bss_conf
.dtim_period
* vif
->bss_conf
.beacon_int
;
211 * iwl_mvm_protect_session() reads directly from the device
212 * (the system time), so make sure it is available.
214 if (iwl_mvm_ref_sync(mvm
, IWL_MVM_REF_PROTECT_TDLS
))
217 mutex_lock(&mvm
->mutex
);
218 /* Protect the session to hear the TDLS setup response on the channel */
219 iwl_mvm_protect_session(mvm
, vif
, duration
, duration
, 100, true);
220 mutex_unlock(&mvm
->mutex
);
222 iwl_mvm_unref(mvm
, IWL_MVM_REF_PROTECT_TDLS
);
226 iwl_mvm_tdls_cs_state_str(enum iwl_mvm_tdls_cs_state state
)
229 case IWL_MVM_TDLS_SW_IDLE
:
231 case IWL_MVM_TDLS_SW_REQ_SENT
:
233 case IWL_MVM_TDLS_SW_RESP_RCVD
:
234 return "RESP RECEIVED";
235 case IWL_MVM_TDLS_SW_REQ_RCVD
:
236 return "REQ RECEIVED";
237 case IWL_MVM_TDLS_SW_ACTIVE
:
244 static void iwl_mvm_tdls_update_cs_state(struct iwl_mvm
*mvm
,
245 enum iwl_mvm_tdls_cs_state state
)
247 if (mvm
->tdls_cs
.state
== state
)
250 IWL_DEBUG_TDLS(mvm
, "TDLS channel switch state: %s -> %s\n",
251 iwl_mvm_tdls_cs_state_str(mvm
->tdls_cs
.state
),
252 iwl_mvm_tdls_cs_state_str(state
));
253 mvm
->tdls_cs
.state
= state
;
255 /* we only send requests to our switching peer - update sent time */
256 if (state
== IWL_MVM_TDLS_SW_REQ_SENT
)
257 mvm
->tdls_cs
.peer
.sent_timestamp
=
258 iwl_read_prph(mvm
->trans
, DEVICE_SYSTEM_TIME_REG
);
260 if (state
== IWL_MVM_TDLS_SW_IDLE
)
261 mvm
->tdls_cs
.cur_sta_id
= IWL_MVM_STATION_COUNT
;
264 int iwl_mvm_rx_tdls_notif(struct iwl_mvm
*mvm
, struct iwl_rx_cmd_buffer
*rxb
,
265 struct iwl_device_cmd
*cmd
)
267 struct iwl_rx_packet
*pkt
= rxb_addr(rxb
);
268 struct iwl_tdls_channel_switch_notif
*notif
= (void *)pkt
->data
;
269 struct ieee80211_sta
*sta
;
271 struct iwl_mvm_sta
*mvmsta
;
272 struct ieee80211_vif
*vif
;
273 u32 sta_id
= le32_to_cpu(notif
->sta_id
);
275 lockdep_assert_held(&mvm
->mutex
);
277 /* can fail sometimes */
278 if (!le32_to_cpu(notif
->status
)) {
279 iwl_mvm_tdls_update_cs_state(mvm
, IWL_MVM_TDLS_SW_IDLE
);
283 if (WARN_ON(sta_id
>= IWL_MVM_STATION_COUNT
))
286 sta
= rcu_dereference_protected(mvm
->fw_id_to_mac_id
[sta_id
],
287 lockdep_is_held(&mvm
->mutex
));
288 /* the station may not be here, but if it is, it must be a TDLS peer */
289 if (IS_ERR_OR_NULL(sta
) || WARN_ON(!sta
->tdls
))
292 mvmsta
= iwl_mvm_sta_from_mac80211(sta
);
296 * Update state and possibly switch again after this is over (DTIM).
297 * Also convert TU to msec.
299 delay
= TU_TO_MS(vif
->bss_conf
.dtim_period
* vif
->bss_conf
.beacon_int
);
300 mod_delayed_work(system_wq
, &mvm
->tdls_cs
.dwork
,
301 msecs_to_jiffies(delay
));
303 iwl_mvm_tdls_update_cs_state(mvm
, IWL_MVM_TDLS_SW_ACTIVE
);
310 iwl_mvm_tdls_check_action(struct iwl_mvm
*mvm
,
311 enum iwl_tdls_channel_switch_type type
,
312 const u8
*peer
, bool peer_initiator
, u32 timestamp
)
314 bool same_peer
= false;
317 /* get the existing peer if it's there */
318 if (mvm
->tdls_cs
.state
!= IWL_MVM_TDLS_SW_IDLE
&&
319 mvm
->tdls_cs
.cur_sta_id
!= IWL_MVM_STATION_COUNT
) {
320 struct ieee80211_sta
*sta
= rcu_dereference_protected(
321 mvm
->fw_id_to_mac_id
[mvm
->tdls_cs
.cur_sta_id
],
322 lockdep_is_held(&mvm
->mutex
));
323 if (!IS_ERR_OR_NULL(sta
))
324 same_peer
= ether_addr_equal(peer
, sta
->addr
);
327 switch (mvm
->tdls_cs
.state
) {
328 case IWL_MVM_TDLS_SW_IDLE
:
330 * might be spurious packet from the peer after the switch is
333 if (type
== TDLS_MOVE_CH
)
336 case IWL_MVM_TDLS_SW_REQ_SENT
:
337 /* only allow requests from the same peer */
340 else if (type
== TDLS_SEND_CHAN_SW_RESP_AND_MOVE_CH
&&
343 * We received a ch-switch request while an outgoing
344 * one is pending. Allow it if the peer is the link
348 else if (type
== TDLS_SEND_CHAN_SW_REQ
)
349 /* wait for idle before sending another request */
351 else if (timestamp
<= mvm
->tdls_cs
.peer
.sent_timestamp
)
352 /* we got a stale response - ignore it */
355 case IWL_MVM_TDLS_SW_RESP_RCVD
:
357 * we are waiting for the FW to give an "active" notification,
358 * so ignore requests in the meantime
362 case IWL_MVM_TDLS_SW_REQ_RCVD
:
363 /* as above, allow the link initiator to proceed */
364 if (type
== TDLS_SEND_CHAN_SW_REQ
) {
367 else if (peer_initiator
) /* they are the initiator */
369 } else if (type
== TDLS_MOVE_CH
) {
373 case IWL_MVM_TDLS_SW_ACTIVE
:
375 * the only valid request when active is a request to return
376 * to the base channel by the current off-channel peer
378 if (type
!= TDLS_MOVE_CH
|| !same_peer
)
385 "Invalid TDLS action %d state %d peer %pM same_peer %d initiator %d\n",
386 type
, mvm
->tdls_cs
.state
, peer
, same_peer
,
393 iwl_mvm_tdls_config_channel_switch(struct iwl_mvm
*mvm
,
394 struct ieee80211_vif
*vif
,
395 enum iwl_tdls_channel_switch_type type
,
396 const u8
*peer
, bool peer_initiator
,
398 struct cfg80211_chan_def
*chandef
,
399 u32 timestamp
, u16 switch_time
,
400 u16 switch_timeout
, struct sk_buff
*skb
,
403 struct ieee80211_sta
*sta
;
404 struct iwl_mvm_sta
*mvmsta
;
405 struct ieee80211_tx_info
*info
;
406 struct ieee80211_hdr
*hdr
;
407 struct iwl_tdls_channel_switch_cmd cmd
= {0};
410 lockdep_assert_held(&mvm
->mutex
);
412 ret
= iwl_mvm_tdls_check_action(mvm
, type
, peer
, peer_initiator
,
417 if (!skb
|| WARN_ON(skb
->len
> IWL_TDLS_CH_SW_FRAME_MAX_SIZE
)) {
422 cmd
.switch_type
= type
;
423 cmd
.timing
.frame_timestamp
= cpu_to_le32(timestamp
);
424 cmd
.timing
.switch_time
= cpu_to_le32(switch_time
);
425 cmd
.timing
.switch_timeout
= cpu_to_le32(switch_timeout
);
428 sta
= ieee80211_find_sta(vif
, peer
);
434 mvmsta
= iwl_mvm_sta_from_mac80211(sta
);
435 cmd
.peer_sta_id
= cpu_to_le32(mvmsta
->sta_id
);
438 if (mvm
->tdls_cs
.state
== IWL_MVM_TDLS_SW_REQ_SENT
&&
439 mvm
->tdls_cs
.peer
.chandef
.chan
) {
440 /* actually moving to the channel */
441 chandef
= &mvm
->tdls_cs
.peer
.chandef
;
442 } else if (mvm
->tdls_cs
.state
== IWL_MVM_TDLS_SW_ACTIVE
&&
443 type
== TDLS_MOVE_CH
) {
444 /* we need to return to base channel */
445 struct ieee80211_chanctx_conf
*chanctx
=
446 rcu_dereference(vif
->chanctx_conf
);
448 if (WARN_ON_ONCE(!chanctx
)) {
453 chandef
= &chanctx
->def
;
458 cmd
.ci
.band
= (chandef
->chan
->band
== IEEE80211_BAND_2GHZ
?
459 PHY_BAND_24
: PHY_BAND_5
);
460 cmd
.ci
.channel
= chandef
->chan
->hw_value
;
461 cmd
.ci
.width
= iwl_mvm_get_channel_width(chandef
);
462 cmd
.ci
.ctrl_pos
= iwl_mvm_get_ctrl_pos(chandef
);
465 /* keep quota calculation simple for now - 50% of DTIM for TDLS */
466 cmd
.timing
.max_offchan_duration
=
467 cpu_to_le32(TU_TO_US(vif
->bss_conf
.dtim_period
*
468 vif
->bss_conf
.beacon_int
) / 2);
470 /* Switch time is the first element in the switch-timing IE. */
471 cmd
.frame
.switch_time_offset
= cpu_to_le32(ch_sw_tm_ie
+ 2);
473 info
= IEEE80211_SKB_CB(skb
);
474 if (info
->control
.hw_key
)
475 iwl_mvm_set_tx_cmd_crypto(mvm
, info
, &cmd
.frame
.tx_cmd
, skb
);
477 iwl_mvm_set_tx_cmd(mvm
, skb
, &cmd
.frame
.tx_cmd
, info
,
480 hdr
= (void *)skb
->data
;
481 iwl_mvm_set_tx_cmd_rate(mvm
, &cmd
.frame
.tx_cmd
, info
, sta
,
485 memcpy(cmd
.frame
.data
, skb
->data
, skb
->len
);
487 ret
= iwl_mvm_send_cmd_pdu(mvm
, TDLS_CHANNEL_SWITCH_CMD
, 0,
490 IWL_ERR(mvm
, "Failed to send TDLS_CHANNEL_SWITCH cmd: %d\n",
495 /* channel switch has started, update state */
496 if (type
!= TDLS_MOVE_CH
) {
497 mvm
->tdls_cs
.cur_sta_id
= mvmsta
->sta_id
;
498 iwl_mvm_tdls_update_cs_state(mvm
,
499 type
== TDLS_SEND_CHAN_SW_REQ
?
500 IWL_MVM_TDLS_SW_REQ_SENT
:
501 IWL_MVM_TDLS_SW_REQ_RCVD
);
503 iwl_mvm_tdls_update_cs_state(mvm
, IWL_MVM_TDLS_SW_RESP_RCVD
);
508 /* channel switch failed - we are idle */
510 iwl_mvm_tdls_update_cs_state(mvm
, IWL_MVM_TDLS_SW_IDLE
);
515 void iwl_mvm_tdls_ch_switch_work(struct work_struct
*work
)
518 struct ieee80211_sta
*sta
;
519 struct iwl_mvm_sta
*mvmsta
;
520 struct ieee80211_vif
*vif
;
524 mvm
= container_of(work
, struct iwl_mvm
, tdls_cs
.dwork
.work
);
525 mutex_lock(&mvm
->mutex
);
527 /* called after an active channel switch has finished or timed-out */
528 iwl_mvm_tdls_update_cs_state(mvm
, IWL_MVM_TDLS_SW_IDLE
);
530 /* station might be gone, in that case do nothing */
531 if (mvm
->tdls_cs
.peer
.sta_id
== IWL_MVM_STATION_COUNT
)
534 sta
= rcu_dereference_protected(
535 mvm
->fw_id_to_mac_id
[mvm
->tdls_cs
.peer
.sta_id
],
536 lockdep_is_held(&mvm
->mutex
));
537 /* the station may not be here, but if it is, it must be a TDLS peer */
538 if (!sta
|| IS_ERR(sta
) || WARN_ON(!sta
->tdls
))
541 mvmsta
= iwl_mvm_sta_from_mac80211(sta
);
543 ret
= iwl_mvm_tdls_config_channel_switch(mvm
, vif
,
544 TDLS_SEND_CHAN_SW_REQ
,
546 mvm
->tdls_cs
.peer
.initiator
,
547 mvm
->tdls_cs
.peer
.op_class
,
548 &mvm
->tdls_cs
.peer
.chandef
,
550 mvm
->tdls_cs
.peer
.skb
,
551 mvm
->tdls_cs
.peer
.ch_sw_tm_ie
);
553 IWL_ERR(mvm
, "Not sending TDLS channel switch: %d\n", ret
);
555 /* retry after a DTIM if we failed sending now */
556 delay
= TU_TO_MS(vif
->bss_conf
.dtim_period
* vif
->bss_conf
.beacon_int
);
557 queue_delayed_work(system_wq
, &mvm
->tdls_cs
.dwork
,
558 msecs_to_jiffies(delay
));
560 mutex_unlock(&mvm
->mutex
);
564 iwl_mvm_tdls_channel_switch(struct ieee80211_hw
*hw
,
565 struct ieee80211_vif
*vif
,
566 struct ieee80211_sta
*sta
, u8 oper_class
,
567 struct cfg80211_chan_def
*chandef
,
568 struct sk_buff
*tmpl_skb
, u32 ch_sw_tm_ie
)
570 struct iwl_mvm
*mvm
= IWL_MAC80211_GET_MVM(hw
);
571 struct iwl_mvm_sta
*mvmsta
;
575 mutex_lock(&mvm
->mutex
);
577 IWL_DEBUG_TDLS(mvm
, "TDLS channel switch with %pM ch %d width %d\n",
578 sta
->addr
, chandef
->chan
->center_freq
, chandef
->width
);
580 /* we only support a single peer for channel switching */
581 if (mvm
->tdls_cs
.peer
.sta_id
!= IWL_MVM_STATION_COUNT
) {
583 "Existing peer. Can't start switch with %pM\n",
589 ret
= iwl_mvm_tdls_config_channel_switch(mvm
, vif
,
590 TDLS_SEND_CHAN_SW_REQ
,
591 sta
->addr
, sta
->tdls_initiator
,
592 oper_class
, chandef
, 0, 0, 0,
593 tmpl_skb
, ch_sw_tm_ie
);
598 * Mark the peer as "in tdls switch" for this vif. We only allow a
599 * single such peer per vif.
601 mvm
->tdls_cs
.peer
.skb
= skb_copy(tmpl_skb
, GFP_KERNEL
);
602 if (!mvm
->tdls_cs
.peer
.skb
) {
607 mvmsta
= iwl_mvm_sta_from_mac80211(sta
);
608 mvm
->tdls_cs
.peer
.sta_id
= mvmsta
->sta_id
;
609 mvm
->tdls_cs
.peer
.chandef
= *chandef
;
610 mvm
->tdls_cs
.peer
.initiator
= sta
->tdls_initiator
;
611 mvm
->tdls_cs
.peer
.op_class
= oper_class
;
612 mvm
->tdls_cs
.peer
.ch_sw_tm_ie
= ch_sw_tm_ie
;
615 * Wait for 2 DTIM periods before attempting the next switch. The next
616 * switch will be made sooner if the current one completes before that.
618 delay
= 2 * TU_TO_MS(vif
->bss_conf
.dtim_period
*
619 vif
->bss_conf
.beacon_int
);
620 mod_delayed_work(system_wq
, &mvm
->tdls_cs
.dwork
,
621 msecs_to_jiffies(delay
));
624 mutex_unlock(&mvm
->mutex
);
628 void iwl_mvm_tdls_cancel_channel_switch(struct ieee80211_hw
*hw
,
629 struct ieee80211_vif
*vif
,
630 struct ieee80211_sta
*sta
)
632 struct iwl_mvm
*mvm
= IWL_MAC80211_GET_MVM(hw
);
633 struct ieee80211_sta
*cur_sta
;
634 bool wait_for_phy
= false;
636 mutex_lock(&mvm
->mutex
);
638 IWL_DEBUG_TDLS(mvm
, "TDLS cancel channel switch with %pM\n", sta
->addr
);
640 /* we only support a single peer for channel switching */
641 if (mvm
->tdls_cs
.peer
.sta_id
== IWL_MVM_STATION_COUNT
) {
642 IWL_DEBUG_TDLS(mvm
, "No ch switch peer - %pM\n", sta
->addr
);
646 cur_sta
= rcu_dereference_protected(
647 mvm
->fw_id_to_mac_id
[mvm
->tdls_cs
.peer
.sta_id
],
648 lockdep_is_held(&mvm
->mutex
));
649 /* make sure it's the same peer */
654 * If we're currently in a switch because of the now canceled peer,
655 * wait a DTIM here to make sure the phy is back on the base channel.
656 * We can't otherwise force it.
658 if (mvm
->tdls_cs
.cur_sta_id
== mvm
->tdls_cs
.peer
.sta_id
&&
659 mvm
->tdls_cs
.state
!= IWL_MVM_TDLS_SW_IDLE
)
662 mvm
->tdls_cs
.peer
.sta_id
= IWL_MVM_STATION_COUNT
;
663 dev_kfree_skb(mvm
->tdls_cs
.peer
.skb
);
664 mvm
->tdls_cs
.peer
.skb
= NULL
;
667 mutex_unlock(&mvm
->mutex
);
669 /* make sure the phy is on the base channel */
671 msleep(TU_TO_MS(vif
->bss_conf
.dtim_period
*
672 vif
->bss_conf
.beacon_int
));
674 /* flush the channel switch state */
675 flush_delayed_work(&mvm
->tdls_cs
.dwork
);
677 IWL_DEBUG_TDLS(mvm
, "TDLS ending channel switch with %pM\n", sta
->addr
);
681 iwl_mvm_tdls_recv_channel_switch(struct ieee80211_hw
*hw
,
682 struct ieee80211_vif
*vif
,
683 struct ieee80211_tdls_ch_sw_params
*params
)
685 struct iwl_mvm
*mvm
= IWL_MAC80211_GET_MVM(hw
);
686 enum iwl_tdls_channel_switch_type type
;
688 const char *action_str
=
689 params
->action_code
== WLAN_TDLS_CHANNEL_SWITCH_REQUEST
?
692 mutex_lock(&mvm
->mutex
);
695 "Received TDLS ch switch action %s from %pM status %d\n",
696 action_str
, params
->sta
->addr
, params
->status
);
699 * we got a non-zero status from a peer we were switching to - move to
700 * the idle state and retry again later
702 if (params
->action_code
== WLAN_TDLS_CHANNEL_SWITCH_RESPONSE
&&
703 params
->status
!= 0 &&
704 mvm
->tdls_cs
.state
== IWL_MVM_TDLS_SW_REQ_SENT
&&
705 mvm
->tdls_cs
.cur_sta_id
!= IWL_MVM_STATION_COUNT
) {
706 struct ieee80211_sta
*cur_sta
;
708 /* make sure it's the same peer */
709 cur_sta
= rcu_dereference_protected(
710 mvm
->fw_id_to_mac_id
[mvm
->tdls_cs
.cur_sta_id
],
711 lockdep_is_held(&mvm
->mutex
));
712 if (cur_sta
== params
->sta
) {
713 iwl_mvm_tdls_update_cs_state(mvm
,
714 IWL_MVM_TDLS_SW_IDLE
);
719 type
= (params
->action_code
== WLAN_TDLS_CHANNEL_SWITCH_REQUEST
) ?
720 TDLS_SEND_CHAN_SW_RESP_AND_MOVE_CH
: TDLS_MOVE_CH
;
722 iwl_mvm_tdls_config_channel_switch(mvm
, vif
, type
, params
->sta
->addr
,
723 params
->sta
->tdls_initiator
, 0,
724 params
->chandef
, params
->timestamp
,
726 params
->switch_timeout
,
728 params
->ch_sw_tm_ie
);
731 /* register a timeout in case we don't succeed in switching */
732 delay
= vif
->bss_conf
.dtim_period
* vif
->bss_conf
.beacon_int
*
734 mod_delayed_work(system_wq
, &mvm
->tdls_cs
.dwork
,
735 msecs_to_jiffies(delay
));
736 mutex_unlock(&mvm
->mutex
);