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"
68 #define TU_TO_US(x) (x * 1024)
69 #define TU_TO_MS(x) (TU_TO_US(x) / 1000)
71 void iwl_mvm_teardown_tdls_peers(struct iwl_mvm *mvm)
73 struct ieee80211_sta *sta;
74 struct iwl_mvm_sta *mvmsta;
77 lockdep_assert_held(&mvm->mutex);
79 for (i = 0; i < IWL_MVM_STATION_COUNT; i++) {
80 sta = rcu_dereference_protected(mvm->fw_id_to_mac_id[i],
81 lockdep_is_held(&mvm->mutex));
82 if (!sta || IS_ERR(sta) || !sta->tdls)
85 mvmsta = iwl_mvm_sta_from_mac80211(sta);
86 ieee80211_tdls_oper_request(mvmsta->vif, sta->addr,
87 NL80211_TDLS_TEARDOWN,
88 WLAN_REASON_TDLS_TEARDOWN_UNSPECIFIED,
93 int iwl_mvm_tdls_sta_count(struct iwl_mvm *mvm, struct ieee80211_vif *vif)
95 struct ieee80211_sta *sta;
96 struct iwl_mvm_sta *mvmsta;
100 lockdep_assert_held(&mvm->mutex);
102 for (i = 0; i < IWL_MVM_STATION_COUNT; i++) {
103 sta = rcu_dereference_protected(mvm->fw_id_to_mac_id[i],
104 lockdep_is_held(&mvm->mutex));
105 if (!sta || IS_ERR(sta) || !sta->tdls)
109 mvmsta = iwl_mvm_sta_from_mac80211(sta);
110 if (mvmsta->vif != vif)
120 static void iwl_mvm_tdls_config(struct iwl_mvm *mvm, struct ieee80211_vif *vif)
122 struct iwl_rx_packet *pkt;
123 struct iwl_tdls_config_res *resp;
124 struct iwl_tdls_config_cmd tdls_cfg_cmd = {};
125 struct iwl_host_cmd cmd = {
126 .id = TDLS_CONFIG_CMD,
127 .flags = CMD_WANT_SKB,
128 .data = { &tdls_cfg_cmd, },
129 .len = { sizeof(struct iwl_tdls_config_cmd), },
131 struct ieee80211_sta *sta;
133 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
135 lockdep_assert_held(&mvm->mutex);
137 tdls_cfg_cmd.id_and_color =
138 cpu_to_le32(FW_CMD_ID_AND_COLOR(mvmvif->id, mvmvif->color));
139 tdls_cfg_cmd.tx_to_ap_tid = IWL_MVM_TDLS_FW_TID;
140 tdls_cfg_cmd.tx_to_ap_ssn = cpu_to_le16(0); /* not used for now */
142 /* for now the Tx cmd is empty and unused */
144 /* populate TDLS peer data */
146 for (i = 0; i < IWL_MVM_STATION_COUNT; i++) {
147 sta = rcu_dereference_protected(mvm->fw_id_to_mac_id[i],
148 lockdep_is_held(&mvm->mutex));
149 if (IS_ERR_OR_NULL(sta) || !sta->tdls)
152 tdls_cfg_cmd.sta_info[cnt].sta_id = i;
153 tdls_cfg_cmd.sta_info[cnt].tx_to_peer_tid =
155 tdls_cfg_cmd.sta_info[cnt].tx_to_peer_ssn = cpu_to_le16(0);
156 tdls_cfg_cmd.sta_info[cnt].is_initiator =
157 cpu_to_le32(sta->tdls_initiator ? 1 : 0);
162 tdls_cfg_cmd.tdls_peer_count = cnt;
163 IWL_DEBUG_TDLS(mvm, "send TDLS config to FW for %d peers\n", cnt);
165 ret = iwl_mvm_send_cmd(mvm, &cmd);
166 if (WARN_ON_ONCE(ret))
170 if (pkt->hdr.flags & IWL_CMD_FAILED_MSK) {
171 IWL_ERR(mvm, "Bad return from TDLS_CONFIG_COMMAND (0x%08X)\n",
176 if (WARN_ON_ONCE(iwl_rx_packet_payload_len(pkt) != sizeof(*resp)))
179 /* we don't really care about the response at this point */
185 void iwl_mvm_recalc_tdls_state(struct iwl_mvm *mvm, struct ieee80211_vif *vif,
188 int tdls_sta_cnt = iwl_mvm_tdls_sta_count(mvm, vif);
190 /* when the first peer joins, send a power update first */
191 if (tdls_sta_cnt == 1 && sta_added)
192 iwl_mvm_power_update_mac(mvm);
194 /* configure the FW with TDLS peer info */
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_REQ_RCVD:
232 return "REQ RECEIVED";
233 case IWL_MVM_TDLS_SW_ACTIVE:
240 static void iwl_mvm_tdls_update_cs_state(struct iwl_mvm *mvm,
241 enum iwl_mvm_tdls_cs_state state)
243 if (mvm->tdls_cs.state == state)
246 IWL_DEBUG_TDLS(mvm, "TDLS channel switch state: %s -> %s\n",
247 iwl_mvm_tdls_cs_state_str(mvm->tdls_cs.state),
248 iwl_mvm_tdls_cs_state_str(state));
249 mvm->tdls_cs.state = state;
251 if (state == IWL_MVM_TDLS_SW_IDLE)
252 mvm->tdls_cs.cur_sta_id = IWL_MVM_STATION_COUNT;
255 int iwl_mvm_rx_tdls_notif(struct iwl_mvm *mvm, struct iwl_rx_cmd_buffer *rxb,
256 struct iwl_device_cmd *cmd)
258 struct iwl_rx_packet *pkt = rxb_addr(rxb);
259 struct iwl_tdls_channel_switch_notif *notif = (void *)pkt->data;
260 struct ieee80211_sta *sta;
262 struct iwl_mvm_sta *mvmsta;
263 struct ieee80211_vif *vif;
264 u32 sta_id = le32_to_cpu(notif->sta_id);
266 lockdep_assert_held(&mvm->mutex);
268 /* can fail sometimes */
269 if (!le32_to_cpu(notif->status)) {
270 iwl_mvm_tdls_update_cs_state(mvm, IWL_MVM_TDLS_SW_IDLE);
274 if (WARN_ON(sta_id >= IWL_MVM_STATION_COUNT))
277 sta = rcu_dereference_protected(mvm->fw_id_to_mac_id[sta_id],
278 lockdep_is_held(&mvm->mutex));
279 /* the station may not be here, but if it is, it must be a TDLS peer */
280 if (IS_ERR_OR_NULL(sta) || WARN_ON(!sta->tdls))
283 mvmsta = iwl_mvm_sta_from_mac80211(sta);
287 * Update state and possibly switch again after this is over (DTIM).
288 * Also convert TU to msec.
290 delay = TU_TO_MS(vif->bss_conf.dtim_period * vif->bss_conf.beacon_int);
291 mod_delayed_work(system_wq, &mvm->tdls_cs.dwork,
292 msecs_to_jiffies(delay));
294 iwl_mvm_tdls_update_cs_state(mvm, IWL_MVM_TDLS_SW_ACTIVE);
301 iwl_mvm_tdls_check_action(struct iwl_mvm *mvm,
302 enum iwl_tdls_channel_switch_type type,
303 const u8 *peer, bool peer_initiator)
305 bool same_peer = false;
308 /* get the existing peer if it's there */
309 if (mvm->tdls_cs.state != IWL_MVM_TDLS_SW_IDLE &&
310 mvm->tdls_cs.cur_sta_id != IWL_MVM_STATION_COUNT) {
311 struct ieee80211_sta *sta = rcu_dereference_protected(
312 mvm->fw_id_to_mac_id[mvm->tdls_cs.cur_sta_id],
313 lockdep_is_held(&mvm->mutex));
314 if (!IS_ERR_OR_NULL(sta))
315 same_peer = ether_addr_equal(peer, sta->addr);
318 switch (mvm->tdls_cs.state) {
319 case IWL_MVM_TDLS_SW_IDLE:
321 * might be spurious packet from the peer after the switch is
324 if (type == TDLS_MOVE_CH)
327 case IWL_MVM_TDLS_SW_REQ_SENT:
329 * We received a ch-switch request while an outgoing one is
330 * pending. Allow it to proceed if the other peer is the same
331 * one we sent to, and we are not the link initiator.
333 if (type == TDLS_SEND_CHAN_SW_RESP_AND_MOVE_CH) {
336 else if (!peer_initiator) /* we are the initiator */
340 case IWL_MVM_TDLS_SW_REQ_RCVD:
341 /* as above, allow the link initiator to proceed */
342 if (type == TDLS_SEND_CHAN_SW_REQ) {
345 else if (peer_initiator) /* they are the initiator */
347 } else if (type == TDLS_MOVE_CH) {
351 case IWL_MVM_TDLS_SW_ACTIVE:
352 /* we don't allow initiations during active channel switch */
353 if (type == TDLS_SEND_CHAN_SW_REQ)
360 "Invalid TDLS action %d state %d peer %pM same_peer %d initiator %d\n",
361 type, mvm->tdls_cs.state, peer, same_peer,
368 iwl_mvm_tdls_config_channel_switch(struct iwl_mvm *mvm,
369 struct ieee80211_vif *vif,
370 enum iwl_tdls_channel_switch_type type,
371 const u8 *peer, bool peer_initiator,
373 struct cfg80211_chan_def *chandef,
374 u32 timestamp, u16 switch_time,
375 u16 switch_timeout, struct sk_buff *skb,
378 struct ieee80211_sta *sta;
379 struct iwl_mvm_sta *mvmsta;
380 struct ieee80211_tx_info *info;
381 struct ieee80211_hdr *hdr;
382 struct iwl_tdls_channel_switch_cmd cmd = {0};
385 lockdep_assert_held(&mvm->mutex);
387 ret = iwl_mvm_tdls_check_action(mvm, type, peer, peer_initiator);
391 if (!skb || WARN_ON(skb->len > IWL_TDLS_CH_SW_FRAME_MAX_SIZE)) {
396 cmd.switch_type = type;
397 cmd.timing.frame_timestamp = cpu_to_le32(timestamp);
398 cmd.timing.switch_time = cpu_to_le32(switch_time);
399 cmd.timing.switch_timeout = cpu_to_le32(switch_timeout);
402 sta = ieee80211_find_sta(vif, peer);
408 mvmsta = iwl_mvm_sta_from_mac80211(sta);
409 cmd.peer_sta_id = cpu_to_le32(mvmsta->sta_id);
412 if (mvm->tdls_cs.state == IWL_MVM_TDLS_SW_REQ_SENT &&
413 mvm->tdls_cs.peer.chandef.chan) {
414 /* actually moving to the channel */
415 chandef = &mvm->tdls_cs.peer.chandef;
416 } else if (mvm->tdls_cs.state == IWL_MVM_TDLS_SW_ACTIVE &&
417 type == TDLS_MOVE_CH) {
418 /* we need to return to base channel */
419 struct ieee80211_chanctx_conf *chanctx =
420 rcu_dereference(vif->chanctx_conf);
422 if (WARN_ON_ONCE(!chanctx)) {
427 chandef = &chanctx->def;
432 cmd.ci.band = (chandef->chan->band == IEEE80211_BAND_2GHZ ?
433 PHY_BAND_24 : PHY_BAND_5);
434 cmd.ci.channel = chandef->chan->hw_value;
435 cmd.ci.width = iwl_mvm_get_channel_width(chandef);
436 cmd.ci.ctrl_pos = iwl_mvm_get_ctrl_pos(chandef);
439 /* keep quota calculation simple for now - 50% of DTIM for TDLS */
440 cmd.timing.max_offchan_duration =
441 cpu_to_le32(TU_TO_US(vif->bss_conf.dtim_period *
442 vif->bss_conf.beacon_int) / 2);
444 /* Switch time is the first element in the switch-timing IE. */
445 cmd.frame.switch_time_offset = cpu_to_le32(ch_sw_tm_ie + 2);
447 info = IEEE80211_SKB_CB(skb);
448 if (info->control.hw_key)
449 iwl_mvm_set_tx_cmd_crypto(mvm, info, &cmd.frame.tx_cmd, skb);
451 iwl_mvm_set_tx_cmd(mvm, skb, &cmd.frame.tx_cmd, info,
454 hdr = (void *)skb->data;
455 iwl_mvm_set_tx_cmd_rate(mvm, &cmd.frame.tx_cmd, info, sta,
459 memcpy(cmd.frame.data, skb->data, skb->len);
461 ret = iwl_mvm_send_cmd_pdu(mvm, TDLS_CHANNEL_SWITCH_CMD, 0,
464 IWL_ERR(mvm, "Failed to send TDLS_CHANNEL_SWITCH cmd: %d\n",
469 /* channel switch has started, update state */
470 if (type != TDLS_MOVE_CH) {
471 mvm->tdls_cs.cur_sta_id = mvmsta->sta_id;
472 iwl_mvm_tdls_update_cs_state(mvm,
473 type == TDLS_SEND_CHAN_SW_REQ ?
474 IWL_MVM_TDLS_SW_REQ_SENT :
475 IWL_MVM_TDLS_SW_REQ_RCVD);
480 /* channel switch failed - we are idle */
482 iwl_mvm_tdls_update_cs_state(mvm, IWL_MVM_TDLS_SW_IDLE);
487 void iwl_mvm_tdls_ch_switch_work(struct work_struct *work)
490 struct ieee80211_sta *sta;
491 struct iwl_mvm_sta *mvmsta;
492 struct ieee80211_vif *vif;
496 mvm = container_of(work, struct iwl_mvm, tdls_cs.dwork.work);
497 mutex_lock(&mvm->mutex);
499 /* called after an active channel switch has finished or timed-out */
500 iwl_mvm_tdls_update_cs_state(mvm, IWL_MVM_TDLS_SW_IDLE);
502 /* station might be gone, in that case do nothing */
503 if (mvm->tdls_cs.peer.sta_id == IWL_MVM_STATION_COUNT)
506 sta = rcu_dereference_protected(
507 mvm->fw_id_to_mac_id[mvm->tdls_cs.peer.sta_id],
508 lockdep_is_held(&mvm->mutex));
509 /* the station may not be here, but if it is, it must be a TDLS peer */
510 if (!sta || IS_ERR(sta) || WARN_ON(!sta->tdls))
513 mvmsta = iwl_mvm_sta_from_mac80211(sta);
515 ret = iwl_mvm_tdls_config_channel_switch(mvm, vif,
516 TDLS_SEND_CHAN_SW_REQ,
518 mvm->tdls_cs.peer.initiator,
519 mvm->tdls_cs.peer.op_class,
520 &mvm->tdls_cs.peer.chandef,
522 mvm->tdls_cs.peer.skb,
523 mvm->tdls_cs.peer.ch_sw_tm_ie);
525 IWL_ERR(mvm, "Not sending TDLS channel switch: %d\n", ret);
527 /* retry after a DTIM if we failed sending now */
528 delay = TU_TO_MS(vif->bss_conf.dtim_period * vif->bss_conf.beacon_int);
529 queue_delayed_work(system_wq, &mvm->tdls_cs.dwork,
530 msecs_to_jiffies(delay));
532 mutex_unlock(&mvm->mutex);
536 iwl_mvm_tdls_channel_switch(struct ieee80211_hw *hw,
537 struct ieee80211_vif *vif,
538 struct ieee80211_sta *sta, u8 oper_class,
539 struct cfg80211_chan_def *chandef,
540 struct sk_buff *tmpl_skb, u32 ch_sw_tm_ie)
542 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
543 struct iwl_mvm_sta *mvmsta;
547 mutex_lock(&mvm->mutex);
549 IWL_DEBUG_TDLS(mvm, "TDLS channel switch with %pM ch %d width %d\n",
550 sta->addr, chandef->chan->center_freq, chandef->width);
552 /* we only support a single peer for channel switching */
553 if (mvm->tdls_cs.peer.sta_id != IWL_MVM_STATION_COUNT) {
555 "Existing peer. Can't start switch with %pM\n",
561 ret = iwl_mvm_tdls_config_channel_switch(mvm, vif,
562 TDLS_SEND_CHAN_SW_REQ,
563 sta->addr, sta->tdls_initiator,
564 oper_class, chandef, 0, 0, 0,
565 tmpl_skb, ch_sw_tm_ie);
570 * Mark the peer as "in tdls switch" for this vif. We only allow a
571 * single such peer per vif.
573 mvm->tdls_cs.peer.skb = skb_copy(tmpl_skb, GFP_KERNEL);
574 if (!mvm->tdls_cs.peer.skb) {
579 mvmsta = iwl_mvm_sta_from_mac80211(sta);
580 mvm->tdls_cs.peer.sta_id = mvmsta->sta_id;
581 mvm->tdls_cs.peer.chandef = *chandef;
582 mvm->tdls_cs.peer.initiator = sta->tdls_initiator;
583 mvm->tdls_cs.peer.op_class = oper_class;
584 mvm->tdls_cs.peer.ch_sw_tm_ie = ch_sw_tm_ie;
587 * Wait for 2 DTIM periods before attempting the next switch. The next
588 * switch will be made sooner if the current one completes before that.
590 delay = 2 * TU_TO_MS(vif->bss_conf.dtim_period *
591 vif->bss_conf.beacon_int);
592 mod_delayed_work(system_wq, &mvm->tdls_cs.dwork,
593 msecs_to_jiffies(delay));
596 mutex_unlock(&mvm->mutex);
600 void iwl_mvm_tdls_cancel_channel_switch(struct ieee80211_hw *hw,
601 struct ieee80211_vif *vif,
602 struct ieee80211_sta *sta)
604 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
605 struct ieee80211_sta *cur_sta;
606 bool wait_for_phy = false;
608 mutex_lock(&mvm->mutex);
610 IWL_DEBUG_TDLS(mvm, "TDLS cancel channel switch with %pM\n", sta->addr);
612 /* we only support a single peer for channel switching */
613 if (mvm->tdls_cs.peer.sta_id == IWL_MVM_STATION_COUNT) {
614 IWL_DEBUG_TDLS(mvm, "No ch switch peer - %pM\n", sta->addr);
618 cur_sta = rcu_dereference_protected(
619 mvm->fw_id_to_mac_id[mvm->tdls_cs.peer.sta_id],
620 lockdep_is_held(&mvm->mutex));
621 /* make sure it's the same peer */
626 * If we're currently in a switch because of the now canceled peer,
627 * wait a DTIM here to make sure the phy is back on the base channel.
628 * We can't otherwise force it.
630 if (mvm->tdls_cs.cur_sta_id == mvm->tdls_cs.peer.sta_id &&
631 mvm->tdls_cs.state != IWL_MVM_TDLS_SW_IDLE)
634 mvm->tdls_cs.peer.sta_id = IWL_MVM_STATION_COUNT;
635 dev_kfree_skb(mvm->tdls_cs.peer.skb);
636 mvm->tdls_cs.peer.skb = NULL;
639 mutex_unlock(&mvm->mutex);
641 /* make sure the phy is on the base channel */
643 msleep(TU_TO_MS(vif->bss_conf.dtim_period *
644 vif->bss_conf.beacon_int));
646 /* flush the channel switch state */
647 flush_delayed_work(&mvm->tdls_cs.dwork);
649 IWL_DEBUG_TDLS(mvm, "TDLS ending channel switch with %pM\n", sta->addr);
653 iwl_mvm_tdls_recv_channel_switch(struct ieee80211_hw *hw,
654 struct ieee80211_vif *vif,
655 struct ieee80211_tdls_ch_sw_params *params)
657 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
658 enum iwl_tdls_channel_switch_type type;
661 mutex_lock(&mvm->mutex);
664 "Received TDLS ch switch action %d from %pM status %d\n",
665 params->action_code, params->sta->addr, params->status);
668 * we got a non-zero status from a peer we were switching to - move to
669 * the idle state and retry again later
671 if (params->action_code == WLAN_TDLS_CHANNEL_SWITCH_RESPONSE &&
672 params->status != 0 &&
673 mvm->tdls_cs.state == IWL_MVM_TDLS_SW_REQ_SENT &&
674 mvm->tdls_cs.cur_sta_id != IWL_MVM_STATION_COUNT) {
675 struct ieee80211_sta *cur_sta;
677 /* make sure it's the same peer */
678 cur_sta = rcu_dereference_protected(
679 mvm->fw_id_to_mac_id[mvm->tdls_cs.cur_sta_id],
680 lockdep_is_held(&mvm->mutex));
681 if (cur_sta == params->sta) {
682 iwl_mvm_tdls_update_cs_state(mvm,
683 IWL_MVM_TDLS_SW_IDLE);
688 type = (params->action_code == WLAN_TDLS_CHANNEL_SWITCH_REQUEST) ?
689 TDLS_SEND_CHAN_SW_RESP_AND_MOVE_CH : TDLS_MOVE_CH;
691 iwl_mvm_tdls_config_channel_switch(mvm, vif, type, params->sta->addr,
692 params->sta->tdls_initiator, 0,
693 params->chandef, params->timestamp,
695 params->switch_timeout,
697 params->ch_sw_tm_ie);
700 /* register a timeout in case we don't succeed in switching */
701 delay = vif->bss_conf.dtim_period * vif->bss_conf.beacon_int *
703 mod_delayed_work(system_wq, &mvm->tdls_cs.dwork,
704 msecs_to_jiffies(delay));
705 mutex_unlock(&mvm->mutex);