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
9 * Copyright(c) 2017 Intel Deutschland GmbH
10 * Copyright(C) 2018 Intel Corporation
12 * This program is free software; you can redistribute it and/or modify
13 * it under the terms of version 2 of the GNU General Public License as
14 * published by the Free Software Foundation.
16 * This program is distributed in the hope that it will be useful, but
17 * WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19 * General Public License for more details.
21 * The full GNU General Public License is included in this distribution
22 * in the file called COPYING.
24 * Contact Information:
25 * Intel Linux Wireless <linuxwifi@intel.com>
26 * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
30 * Copyright(c) 2014 Intel Mobile Communications GmbH
31 * Copyright(c) 2017 Intel Deutschland GmbH
32 * Copyright(C) 2018 Intel Corporation
33 * All rights reserved.
35 * Redistribution and use in source and binary forms, with or without
36 * modification, are permitted provided that the following conditions
39 * * Redistributions of source code must retain the above copyright
40 * notice, this list of conditions and the following disclaimer.
41 * * Redistributions in binary form must reproduce the above copyright
42 * notice, this list of conditions and the following disclaimer in
43 * the documentation and/or other materials provided with the
45 * * Neither the name Intel Corporation nor the names of its
46 * contributors may be used to endorse or promote products derived
47 * from this software without specific prior written permission.
49 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
50 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
51 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
52 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
53 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
54 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
55 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
56 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
57 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
58 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
59 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
61 *****************************************************************************/
63 #include <linux/etherdevice.h>
65 #include "time-event.h"
69 #define TU_TO_US(x) (x * 1024)
70 #define TU_TO_MS(x) (TU_TO_US(x) / 1000)
72 void iwl_mvm_teardown_tdls_peers(struct iwl_mvm *mvm)
74 struct ieee80211_sta *sta;
75 struct iwl_mvm_sta *mvmsta;
78 lockdep_assert_held(&mvm->mutex);
80 for (i = 0; i < ARRAY_SIZE(mvm->fw_id_to_mac_id); i++) {
81 sta = rcu_dereference_protected(mvm->fw_id_to_mac_id[i],
82 lockdep_is_held(&mvm->mutex));
83 if (!sta || IS_ERR(sta) || !sta->tdls)
86 mvmsta = iwl_mvm_sta_from_mac80211(sta);
87 ieee80211_tdls_oper_request(mvmsta->vif, sta->addr,
88 NL80211_TDLS_TEARDOWN,
89 WLAN_REASON_TDLS_TEARDOWN_UNSPECIFIED,
94 int iwl_mvm_tdls_sta_count(struct iwl_mvm *mvm, struct ieee80211_vif *vif)
96 struct ieee80211_sta *sta;
97 struct iwl_mvm_sta *mvmsta;
101 lockdep_assert_held(&mvm->mutex);
103 for (i = 0; i < ARRAY_SIZE(mvm->fw_id_to_mac_id); i++) {
104 sta = rcu_dereference_protected(mvm->fw_id_to_mac_id[i],
105 lockdep_is_held(&mvm->mutex));
106 if (!sta || IS_ERR(sta) || !sta->tdls)
110 mvmsta = iwl_mvm_sta_from_mac80211(sta);
111 if (mvmsta->vif != vif)
121 static void iwl_mvm_tdls_config(struct iwl_mvm *mvm, struct ieee80211_vif *vif)
123 struct iwl_rx_packet *pkt;
124 struct iwl_tdls_config_res *resp;
125 struct iwl_tdls_config_cmd tdls_cfg_cmd = {};
126 struct iwl_host_cmd cmd = {
127 .id = TDLS_CONFIG_CMD,
128 .flags = CMD_WANT_SKB,
129 .data = { &tdls_cfg_cmd, },
130 .len = { sizeof(struct iwl_tdls_config_cmd), },
132 struct ieee80211_sta *sta;
134 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
136 lockdep_assert_held(&mvm->mutex);
138 tdls_cfg_cmd.id_and_color =
139 cpu_to_le32(FW_CMD_ID_AND_COLOR(mvmvif->id, mvmvif->color));
140 tdls_cfg_cmd.tx_to_ap_tid = IWL_MVM_TDLS_FW_TID;
141 tdls_cfg_cmd.tx_to_ap_ssn = cpu_to_le16(0); /* not used for now */
143 /* for now the Tx cmd is empty and unused */
145 /* populate TDLS peer data */
147 for (i = 0; i < ARRAY_SIZE(mvm->fw_id_to_mac_id); i++) {
148 sta = rcu_dereference_protected(mvm->fw_id_to_mac_id[i],
149 lockdep_is_held(&mvm->mutex));
150 if (IS_ERR_OR_NULL(sta) || !sta->tdls)
153 tdls_cfg_cmd.sta_info[cnt].sta_id = i;
154 tdls_cfg_cmd.sta_info[cnt].tx_to_peer_tid =
156 tdls_cfg_cmd.sta_info[cnt].tx_to_peer_ssn = cpu_to_le16(0);
157 tdls_cfg_cmd.sta_info[cnt].is_initiator =
158 cpu_to_le32(sta->tdls_initiator ? 1 : 0);
163 tdls_cfg_cmd.tdls_peer_count = cnt;
164 IWL_DEBUG_TDLS(mvm, "send TDLS config to FW for %d peers\n", cnt);
166 ret = iwl_mvm_send_cmd(mvm, &cmd);
167 if (WARN_ON_ONCE(ret))
172 WARN_ON_ONCE(iwl_rx_packet_payload_len(pkt) != sizeof(*resp));
174 /* we don't really care about the response at this point */
179 void iwl_mvm_recalc_tdls_state(struct iwl_mvm *mvm, struct ieee80211_vif *vif,
182 int tdls_sta_cnt = iwl_mvm_tdls_sta_count(mvm, vif);
184 /* when the first peer joins, send a power update first */
185 if (tdls_sta_cnt == 1 && sta_added)
186 iwl_mvm_power_update_mac(mvm);
188 /* Configure the FW with TDLS peer info only if TDLS channel switch
190 * TDLS config data is used currently only in TDLS channel switch code.
191 * Supposed to serve also TDLS buffer station which is not implemneted
193 if (fw_has_capa(&mvm->fw->ucode_capa,
194 IWL_UCODE_TLV_CAPA_TDLS_CHANNEL_SWITCH))
195 iwl_mvm_tdls_config(mvm, vif);
197 /* when the last peer leaves, send a power update last */
198 if (tdls_sta_cnt == 0 && !sta_added)
199 iwl_mvm_power_update_mac(mvm);
202 void iwl_mvm_mac_mgd_protect_tdls_discover(struct ieee80211_hw *hw,
203 struct ieee80211_vif *vif)
205 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
206 u32 duration = 2 * vif->bss_conf.dtim_period * vif->bss_conf.beacon_int;
209 * iwl_mvm_protect_session() reads directly from the device
210 * (the system time), so make sure it is available.
212 if (iwl_mvm_ref_sync(mvm, IWL_MVM_REF_PROTECT_TDLS))
215 mutex_lock(&mvm->mutex);
216 /* Protect the session to hear the TDLS setup response on the channel */
217 iwl_mvm_protect_session(mvm, vif, duration, duration, 100, true);
218 mutex_unlock(&mvm->mutex);
220 iwl_mvm_unref(mvm, IWL_MVM_REF_PROTECT_TDLS);
224 iwl_mvm_tdls_cs_state_str(enum iwl_mvm_tdls_cs_state state)
227 case IWL_MVM_TDLS_SW_IDLE:
229 case IWL_MVM_TDLS_SW_REQ_SENT:
231 case IWL_MVM_TDLS_SW_RESP_RCVD:
232 return "RESP RECEIVED";
233 case IWL_MVM_TDLS_SW_REQ_RCVD:
234 return "REQ RECEIVED";
235 case IWL_MVM_TDLS_SW_ACTIVE:
242 static void iwl_mvm_tdls_update_cs_state(struct iwl_mvm *mvm,
243 enum iwl_mvm_tdls_cs_state state)
245 if (mvm->tdls_cs.state == state)
248 IWL_DEBUG_TDLS(mvm, "TDLS channel switch state: %s -> %s\n",
249 iwl_mvm_tdls_cs_state_str(mvm->tdls_cs.state),
250 iwl_mvm_tdls_cs_state_str(state));
251 mvm->tdls_cs.state = state;
253 /* we only send requests to our switching peer - update sent time */
254 if (state == IWL_MVM_TDLS_SW_REQ_SENT)
255 mvm->tdls_cs.peer.sent_timestamp =
256 iwl_read_prph(mvm->trans, DEVICE_SYSTEM_TIME_REG);
258 if (state == IWL_MVM_TDLS_SW_IDLE)
259 mvm->tdls_cs.cur_sta_id = IWL_MVM_INVALID_STA;
262 void iwl_mvm_rx_tdls_notif(struct iwl_mvm *mvm, struct iwl_rx_cmd_buffer *rxb)
264 struct iwl_rx_packet *pkt = rxb_addr(rxb);
265 struct iwl_tdls_channel_switch_notif *notif = (void *)pkt->data;
266 struct ieee80211_sta *sta;
268 struct iwl_mvm_sta *mvmsta;
269 struct ieee80211_vif *vif;
270 u32 sta_id = le32_to_cpu(notif->sta_id);
272 lockdep_assert_held(&mvm->mutex);
274 /* can fail sometimes */
275 if (!le32_to_cpu(notif->status)) {
276 iwl_mvm_tdls_update_cs_state(mvm, IWL_MVM_TDLS_SW_IDLE);
280 if (WARN_ON(sta_id >= IWL_MVM_STATION_COUNT))
283 sta = rcu_dereference_protected(mvm->fw_id_to_mac_id[sta_id],
284 lockdep_is_held(&mvm->mutex));
285 /* the station may not be here, but if it is, it must be a TDLS peer */
286 if (IS_ERR_OR_NULL(sta) || WARN_ON(!sta->tdls))
289 mvmsta = iwl_mvm_sta_from_mac80211(sta);
293 * Update state and possibly switch again after this is over (DTIM).
294 * Also convert TU to msec.
296 delay = TU_TO_MS(vif->bss_conf.dtim_period * vif->bss_conf.beacon_int);
297 mod_delayed_work(system_wq, &mvm->tdls_cs.dwork,
298 msecs_to_jiffies(delay));
300 iwl_mvm_tdls_update_cs_state(mvm, IWL_MVM_TDLS_SW_ACTIVE);
304 iwl_mvm_tdls_check_action(struct iwl_mvm *mvm,
305 enum iwl_tdls_channel_switch_type type,
306 const u8 *peer, bool peer_initiator, u32 timestamp)
308 bool same_peer = false;
311 /* get the existing peer if it's there */
312 if (mvm->tdls_cs.state != IWL_MVM_TDLS_SW_IDLE &&
313 mvm->tdls_cs.cur_sta_id != IWL_MVM_INVALID_STA) {
314 struct ieee80211_sta *sta = rcu_dereference_protected(
315 mvm->fw_id_to_mac_id[mvm->tdls_cs.cur_sta_id],
316 lockdep_is_held(&mvm->mutex));
317 if (!IS_ERR_OR_NULL(sta))
318 same_peer = ether_addr_equal(peer, sta->addr);
321 switch (mvm->tdls_cs.state) {
322 case IWL_MVM_TDLS_SW_IDLE:
324 * might be spurious packet from the peer after the switch is
327 if (type == TDLS_MOVE_CH)
330 case IWL_MVM_TDLS_SW_REQ_SENT:
331 /* only allow requests from the same peer */
334 else if (type == TDLS_SEND_CHAN_SW_RESP_AND_MOVE_CH &&
337 * We received a ch-switch request while an outgoing
338 * one is pending. Allow it if the peer is the link
342 else if (type == TDLS_SEND_CHAN_SW_REQ)
343 /* wait for idle before sending another request */
345 else if (timestamp <= mvm->tdls_cs.peer.sent_timestamp)
346 /* we got a stale response - ignore it */
349 case IWL_MVM_TDLS_SW_RESP_RCVD:
351 * we are waiting for the FW to give an "active" notification,
352 * so ignore requests in the meantime
356 case IWL_MVM_TDLS_SW_REQ_RCVD:
357 /* as above, allow the link initiator to proceed */
358 if (type == TDLS_SEND_CHAN_SW_REQ) {
361 else if (peer_initiator) /* they are the initiator */
363 } else if (type == TDLS_MOVE_CH) {
367 case IWL_MVM_TDLS_SW_ACTIVE:
369 * the only valid request when active is a request to return
370 * to the base channel by the current off-channel peer
372 if (type != TDLS_MOVE_CH || !same_peer)
379 "Invalid TDLS action %d state %d peer %pM same_peer %d initiator %d\n",
380 type, mvm->tdls_cs.state, peer, same_peer,
387 iwl_mvm_tdls_config_channel_switch(struct iwl_mvm *mvm,
388 struct ieee80211_vif *vif,
389 enum iwl_tdls_channel_switch_type type,
390 const u8 *peer, bool peer_initiator,
392 struct cfg80211_chan_def *chandef,
393 u32 timestamp, u16 switch_time,
394 u16 switch_timeout, struct sk_buff *skb,
397 struct ieee80211_sta *sta;
398 struct iwl_mvm_sta *mvmsta;
399 struct ieee80211_tx_info *info;
400 struct ieee80211_hdr *hdr;
401 struct iwl_tdls_channel_switch_cmd cmd = {0};
404 lockdep_assert_held(&mvm->mutex);
406 ret = iwl_mvm_tdls_check_action(mvm, type, peer, peer_initiator,
411 if (!skb || WARN_ON(skb->len > IWL_TDLS_CH_SW_FRAME_MAX_SIZE)) {
416 cmd.switch_type = type;
417 cmd.timing.frame_timestamp = cpu_to_le32(timestamp);
418 cmd.timing.switch_time = cpu_to_le32(switch_time);
419 cmd.timing.switch_timeout = cpu_to_le32(switch_timeout);
422 sta = ieee80211_find_sta(vif, peer);
428 mvmsta = iwl_mvm_sta_from_mac80211(sta);
429 cmd.peer_sta_id = cpu_to_le32(mvmsta->sta_id);
432 if (mvm->tdls_cs.state == IWL_MVM_TDLS_SW_REQ_SENT &&
433 mvm->tdls_cs.peer.chandef.chan) {
434 /* actually moving to the channel */
435 chandef = &mvm->tdls_cs.peer.chandef;
436 } else if (mvm->tdls_cs.state == IWL_MVM_TDLS_SW_ACTIVE &&
437 type == TDLS_MOVE_CH) {
438 /* we need to return to base channel */
439 struct ieee80211_chanctx_conf *chanctx =
440 rcu_dereference(vif->chanctx_conf);
442 if (WARN_ON_ONCE(!chanctx)) {
447 chandef = &chanctx->def;
452 cmd.ci.band = (chandef->chan->band == NL80211_BAND_2GHZ ?
453 PHY_BAND_24 : PHY_BAND_5);
454 cmd.ci.channel = chandef->chan->hw_value;
455 cmd.ci.width = iwl_mvm_get_channel_width(chandef);
456 cmd.ci.ctrl_pos = iwl_mvm_get_ctrl_pos(chandef);
459 /* keep quota calculation simple for now - 50% of DTIM for TDLS */
460 cmd.timing.max_offchan_duration =
461 cpu_to_le32(TU_TO_US(vif->bss_conf.dtim_period *
462 vif->bss_conf.beacon_int) / 2);
464 /* Switch time is the first element in the switch-timing IE. */
465 cmd.frame.switch_time_offset = cpu_to_le32(ch_sw_tm_ie + 2);
467 info = IEEE80211_SKB_CB(skb);
468 hdr = (void *)skb->data;
469 if (info->control.hw_key) {
470 if (info->control.hw_key->cipher != WLAN_CIPHER_SUITE_CCMP) {
475 iwl_mvm_set_tx_cmd_ccmp(info, &cmd.frame.tx_cmd);
478 iwl_mvm_set_tx_cmd(mvm, skb, &cmd.frame.tx_cmd, info,
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_INVALID_STA)
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 schedule_delayed_work(&mvm->tdls_cs.dwork, msecs_to_jiffies(delay));
559 mutex_unlock(&mvm->mutex);
563 iwl_mvm_tdls_channel_switch(struct ieee80211_hw *hw,
564 struct ieee80211_vif *vif,
565 struct ieee80211_sta *sta, u8 oper_class,
566 struct cfg80211_chan_def *chandef,
567 struct sk_buff *tmpl_skb, u32 ch_sw_tm_ie)
569 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
570 struct iwl_mvm_sta *mvmsta;
574 mutex_lock(&mvm->mutex);
576 IWL_DEBUG_TDLS(mvm, "TDLS channel switch with %pM ch %d width %d\n",
577 sta->addr, chandef->chan->center_freq, chandef->width);
579 /* we only support a single peer for channel switching */
580 if (mvm->tdls_cs.peer.sta_id != IWL_MVM_INVALID_STA) {
582 "Existing peer. Can't start switch with %pM\n",
588 ret = iwl_mvm_tdls_config_channel_switch(mvm, vif,
589 TDLS_SEND_CHAN_SW_REQ,
590 sta->addr, sta->tdls_initiator,
591 oper_class, chandef, 0, 0, 0,
592 tmpl_skb, ch_sw_tm_ie);
597 * Mark the peer as "in tdls switch" for this vif. We only allow a
598 * single such peer per vif.
600 mvm->tdls_cs.peer.skb = skb_copy(tmpl_skb, GFP_KERNEL);
601 if (!mvm->tdls_cs.peer.skb) {
606 mvmsta = iwl_mvm_sta_from_mac80211(sta);
607 mvm->tdls_cs.peer.sta_id = mvmsta->sta_id;
608 mvm->tdls_cs.peer.chandef = *chandef;
609 mvm->tdls_cs.peer.initiator = sta->tdls_initiator;
610 mvm->tdls_cs.peer.op_class = oper_class;
611 mvm->tdls_cs.peer.ch_sw_tm_ie = ch_sw_tm_ie;
614 * Wait for 2 DTIM periods before attempting the next switch. The next
615 * switch will be made sooner if the current one completes before that.
617 delay = 2 * TU_TO_MS(vif->bss_conf.dtim_period *
618 vif->bss_conf.beacon_int);
619 mod_delayed_work(system_wq, &mvm->tdls_cs.dwork,
620 msecs_to_jiffies(delay));
623 mutex_unlock(&mvm->mutex);
627 void iwl_mvm_tdls_cancel_channel_switch(struct ieee80211_hw *hw,
628 struct ieee80211_vif *vif,
629 struct ieee80211_sta *sta)
631 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
632 struct ieee80211_sta *cur_sta;
633 bool wait_for_phy = false;
635 mutex_lock(&mvm->mutex);
637 IWL_DEBUG_TDLS(mvm, "TDLS cancel channel switch with %pM\n", sta->addr);
639 /* we only support a single peer for channel switching */
640 if (mvm->tdls_cs.peer.sta_id == IWL_MVM_INVALID_STA) {
641 IWL_DEBUG_TDLS(mvm, "No ch switch peer - %pM\n", sta->addr);
645 cur_sta = rcu_dereference_protected(
646 mvm->fw_id_to_mac_id[mvm->tdls_cs.peer.sta_id],
647 lockdep_is_held(&mvm->mutex));
648 /* make sure it's the same peer */
653 * If we're currently in a switch because of the now canceled peer,
654 * wait a DTIM here to make sure the phy is back on the base channel.
655 * We can't otherwise force it.
657 if (mvm->tdls_cs.cur_sta_id == mvm->tdls_cs.peer.sta_id &&
658 mvm->tdls_cs.state != IWL_MVM_TDLS_SW_IDLE)
661 mvm->tdls_cs.peer.sta_id = IWL_MVM_INVALID_STA;
662 dev_kfree_skb(mvm->tdls_cs.peer.skb);
663 mvm->tdls_cs.peer.skb = NULL;
666 mutex_unlock(&mvm->mutex);
668 /* make sure the phy is on the base channel */
670 msleep(TU_TO_MS(vif->bss_conf.dtim_period *
671 vif->bss_conf.beacon_int));
673 /* flush the channel switch state */
674 flush_delayed_work(&mvm->tdls_cs.dwork);
676 IWL_DEBUG_TDLS(mvm, "TDLS ending channel switch with %pM\n", sta->addr);
680 iwl_mvm_tdls_recv_channel_switch(struct ieee80211_hw *hw,
681 struct ieee80211_vif *vif,
682 struct ieee80211_tdls_ch_sw_params *params)
684 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
685 enum iwl_tdls_channel_switch_type type;
687 const char *action_str =
688 params->action_code == WLAN_TDLS_CHANNEL_SWITCH_REQUEST ?
691 mutex_lock(&mvm->mutex);
694 "Received TDLS ch switch action %s from %pM status %d\n",
695 action_str, params->sta->addr, params->status);
698 * we got a non-zero status from a peer we were switching to - move to
699 * the idle state and retry again later
701 if (params->action_code == WLAN_TDLS_CHANNEL_SWITCH_RESPONSE &&
702 params->status != 0 &&
703 mvm->tdls_cs.state == IWL_MVM_TDLS_SW_REQ_SENT &&
704 mvm->tdls_cs.cur_sta_id != IWL_MVM_INVALID_STA) {
705 struct ieee80211_sta *cur_sta;
707 /* make sure it's the same peer */
708 cur_sta = rcu_dereference_protected(
709 mvm->fw_id_to_mac_id[mvm->tdls_cs.cur_sta_id],
710 lockdep_is_held(&mvm->mutex));
711 if (cur_sta == params->sta) {
712 iwl_mvm_tdls_update_cs_state(mvm,
713 IWL_MVM_TDLS_SW_IDLE);
718 type = (params->action_code == WLAN_TDLS_CHANNEL_SWITCH_REQUEST) ?
719 TDLS_SEND_CHAN_SW_RESP_AND_MOVE_CH : TDLS_MOVE_CH;
721 iwl_mvm_tdls_config_channel_switch(mvm, vif, type, params->sta->addr,
722 params->sta->tdls_initiator, 0,
723 params->chandef, params->timestamp,
725 params->switch_timeout,
727 params->ch_sw_tm_ie);
730 /* register a timeout in case we don't succeed in switching */
731 delay = vif->bss_conf.dtim_period * vif->bss_conf.beacon_int *
733 mod_delayed_work(system_wq, &mvm->tdls_cs.dwork,
734 msecs_to_jiffies(delay));
735 mutex_unlock(&mvm->mutex);