drivers/net/wireless/intel/iwlwifi/mvm/tdls.c

   1 /******************************************************************************
   2  *
   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.
   5  *
   6  * GPL LICENSE SUMMARY
   7  *
   8  * Copyright(c) 2014 Intel Mobile Communications GmbH
   9  * Copyright(c) 2017 Intel Deutschland GmbH
  10  *
  11  * This program is free software; you can redistribute it and/or modify
  12  * it under the terms of version 2 of the GNU General Public License as
  13  * published by the Free Software Foundation.
  14  *
  15  * This program is distributed in the hope that it will be useful, but
  16  * WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18  * General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110,
  23  * USA
  24  *
  25  * The full GNU General Public License is included in this distribution
  26  * in the file called COPYING.
  27  *
  28  * Contact Information:
  29  *  Intel Linux Wireless <linuxwifi@intel.com>
  30  * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
  31  *
  32  * BSD LICENSE
  33  *
  34  * Copyright(c) 2014 Intel Mobile Communications GmbH
  35  * Copyright(c) 2017 Intel Deutschland GmbH
  36  * All rights reserved.
  37  *
  38  * Redistribution and use in source and binary forms, with or without
  39  * modification, are permitted provided that the following conditions
  40  * are met:
  41  *
  42  *  * Redistributions of source code must retain the above copyright
  43  *    notice, this list of conditions and the following disclaimer.
  44  *  * Redistributions in binary form must reproduce the above copyright
  45  *    notice, this list of conditions and the following disclaimer in
  46  *    the documentation and/or other materials provided with the
  47  *    distribution.
  48  *  * Neither the name Intel Corporation nor the names of its
  49  *    contributors may be used to endorse or promote products derived
  50  *    from this software without specific prior written permission.
  51  *
  52  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  53  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  54  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  55  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  56  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  57  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  58  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  59  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  60  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  61  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  62  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  63  *
  64  *****************************************************************************/
  65
  66 #include <linux/etherdevice.h>
  67 #include "mvm.h"
  68 #include "time-event.h"
  69 #include "iwl-io.h"
  70 #include "iwl-prph.h"
  71
  72 #define TU_TO_US(x) (x * 1024)
  73 #define TU_TO_MS(x) (TU_TO_US(x) / 1000)
  74
  75 void iwl_mvm_teardown_tdls_peers(struct iwl_mvm *mvm)
  76 {
  77         struct ieee80211_sta *sta;
  78         struct iwl_mvm_sta *mvmsta;
  79         int i;
  80
  81         lockdep_assert_held(&mvm->mutex);
  82
  83         for (i = 0; i < ARRAY_SIZE(mvm->fw_id_to_mac_id); i++) {
  84                 sta = rcu_dereference_protected(mvm->fw_id_to_mac_id[i],
  85                                                 lockdep_is_held(&mvm->mutex));
  86                 if (!sta || IS_ERR(sta) || !sta->tdls)
  87                         continue;
  88
  89                 mvmsta = iwl_mvm_sta_from_mac80211(sta);
  90                 ieee80211_tdls_oper_request(mvmsta->vif, sta->addr,
  91                                 NL80211_TDLS_TEARDOWN,
  92                                 WLAN_REASON_TDLS_TEARDOWN_UNSPECIFIED,
  93                                 GFP_KERNEL);
  94         }
  95 }
  96
  97 int iwl_mvm_tdls_sta_count(struct iwl_mvm *mvm, struct ieee80211_vif *vif)
  98 {
  99         struct ieee80211_sta *sta;
 100         struct iwl_mvm_sta *mvmsta;
 101         int count = 0;
 102         int i;
 103
 104         lockdep_assert_held(&mvm->mutex);
 105
 106         for (i = 0; i < ARRAY_SIZE(mvm->fw_id_to_mac_id); i++) {
 107                 sta = rcu_dereference_protected(mvm->fw_id_to_mac_id[i],
 108                                                 lockdep_is_held(&mvm->mutex));
 109                 if (!sta || IS_ERR(sta) || !sta->tdls)
 110                         continue;
 111
 112                 if (vif) {
 113                         mvmsta = iwl_mvm_sta_from_mac80211(sta);
 114                         if (mvmsta->vif != vif)
 115                                 continue;
 116                 }
 117
 118                 count++;
 119         }
 120
 121         return count;
 122 }
 123
 124 static void iwl_mvm_tdls_config(struct iwl_mvm *mvm, struct ieee80211_vif *vif)
 125 {
 126         struct iwl_rx_packet *pkt;
 127         struct iwl_tdls_config_res *resp;
 128         struct iwl_tdls_config_cmd tdls_cfg_cmd = {};
 129         struct iwl_host_cmd cmd = {
 130                 .id = TDLS_CONFIG_CMD,
 131                 .flags = CMD_WANT_SKB,
 132                 .data = { &tdls_cfg_cmd, },
 133                 .len = { sizeof(struct iwl_tdls_config_cmd), },
 134         };
 135         struct ieee80211_sta *sta;
 136         int ret, i, cnt;
 137         struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
 138
 139         lockdep_assert_held(&mvm->mutex);
 140
 141         tdls_cfg_cmd.id_and_color =
 142                 cpu_to_le32(FW_CMD_ID_AND_COLOR(mvmvif->id, mvmvif->color));
 143         tdls_cfg_cmd.tx_to_ap_tid = IWL_MVM_TDLS_FW_TID;
 144         tdls_cfg_cmd.tx_to_ap_ssn = cpu_to_le16(0); /* not used for now */
 145
 146         /* for now the Tx cmd is empty and unused */
 147
 148         /* populate TDLS peer data */
 149         cnt = 0;
 150         for (i = 0; i < ARRAY_SIZE(mvm->fw_id_to_mac_id); i++) {
 151                 sta = rcu_dereference_protected(mvm->fw_id_to_mac_id[i],
 152                                                 lockdep_is_held(&mvm->mutex));
 153                 if (IS_ERR_OR_NULL(sta) || !sta->tdls)
 154                         continue;
 155
 156                 tdls_cfg_cmd.sta_info[cnt].sta_id = i;
 157                 tdls_cfg_cmd.sta_info[cnt].tx_to_peer_tid =
 158                                                         IWL_MVM_TDLS_FW_TID;
 159                 tdls_cfg_cmd.sta_info[cnt].tx_to_peer_ssn = cpu_to_le16(0);
 160                 tdls_cfg_cmd.sta_info[cnt].is_initiator =
 161                                 cpu_to_le32(sta->tdls_initiator ? 1 : 0);
 162
 163                 cnt++;
 164         }
 165
 166         tdls_cfg_cmd.tdls_peer_count = cnt;
 167         IWL_DEBUG_TDLS(mvm, "send TDLS config to FW for %d peers\n", cnt);
 168
 169         ret = iwl_mvm_send_cmd(mvm, &cmd);
 170         if (WARN_ON_ONCE(ret))
 171                 return;
 172
 173         pkt = cmd.resp_pkt;
 174
 175         WARN_ON_ONCE(iwl_rx_packet_payload_len(pkt) != sizeof(*resp));
 176
 177         /* we don't really care about the response at this point */
 178
 179         iwl_free_resp(&cmd);
 180 }
 181
 182 void iwl_mvm_recalc_tdls_state(struct iwl_mvm *mvm, struct ieee80211_vif *vif,
 183                                bool sta_added)
 184 {
 185         int tdls_sta_cnt = iwl_mvm_tdls_sta_count(mvm, vif);
 186
 187         /* when the first peer joins, send a power update first */
 188         if (tdls_sta_cnt == 1 && sta_added)
 189                 iwl_mvm_power_update_mac(mvm);
 190
 191         /* configure the FW with TDLS peer info */
 192         iwl_mvm_tdls_config(mvm, vif);
 193
 194         /* when the last peer leaves, send a power update last */
 195         if (tdls_sta_cnt == 0 && !sta_added)
 196                 iwl_mvm_power_update_mac(mvm);
 197 }
 198
 199 void iwl_mvm_mac_mgd_protect_tdls_discover(struct ieee80211_hw *hw,
 200                                            struct ieee80211_vif *vif)
 201 {
 202         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
 203         u32 duration = 2 * vif->bss_conf.dtim_period * vif->bss_conf.beacon_int;
 204
 205         /*
 206          * iwl_mvm_protect_session() reads directly from the device
 207          * (the system time), so make sure it is available.
 208          */
 209         if (iwl_mvm_ref_sync(mvm, IWL_MVM_REF_PROTECT_TDLS))
 210                 return;
 211
 212         mutex_lock(&mvm->mutex);
 213         /* Protect the session to hear the TDLS setup response on the channel */
 214         iwl_mvm_protect_session(mvm, vif, duration, duration, 100, true);
 215         mutex_unlock(&mvm->mutex);
 216
 217         iwl_mvm_unref(mvm, IWL_MVM_REF_PROTECT_TDLS);
 218 }
 219
 220 static const char *
 221 iwl_mvm_tdls_cs_state_str(enum iwl_mvm_tdls_cs_state state)
 222 {
 223         switch (state) {
 224         case IWL_MVM_TDLS_SW_IDLE:
 225                 return "IDLE";
 226         case IWL_MVM_TDLS_SW_REQ_SENT:
 227                 return "REQ SENT";
 228         case IWL_MVM_TDLS_SW_RESP_RCVD:
 229                 return "RESP RECEIVED";
 230         case IWL_MVM_TDLS_SW_REQ_RCVD:
 231                 return "REQ RECEIVED";
 232         case IWL_MVM_TDLS_SW_ACTIVE:
 233                 return "ACTIVE";
 234         }
 235
 236         return NULL;
 237 }
 238
 239 static void iwl_mvm_tdls_update_cs_state(struct iwl_mvm *mvm,
 240                                          enum iwl_mvm_tdls_cs_state state)
 241 {
 242         if (mvm->tdls_cs.state == state)
 243                 return;
 244
 245         IWL_DEBUG_TDLS(mvm, "TDLS channel switch state: %s -> %s\n",
 246                        iwl_mvm_tdls_cs_state_str(mvm->tdls_cs.state),
 247                        iwl_mvm_tdls_cs_state_str(state));
 248         mvm->tdls_cs.state = state;
 249
 250         /* we only send requests to our switching peer - update sent time */
 251         if (state == IWL_MVM_TDLS_SW_REQ_SENT)
 252                 mvm->tdls_cs.peer.sent_timestamp =
 253                         iwl_read_prph(mvm->trans, DEVICE_SYSTEM_TIME_REG);
 254
 255         if (state == IWL_MVM_TDLS_SW_IDLE)
 256                 mvm->tdls_cs.cur_sta_id = IWL_MVM_INVALID_STA;
 257 }
 258
 259 void iwl_mvm_rx_tdls_notif(struct iwl_mvm *mvm, struct iwl_rx_cmd_buffer *rxb)
 260 {
 261         struct iwl_rx_packet *pkt = rxb_addr(rxb);
 262         struct iwl_tdls_channel_switch_notif *notif = (void *)pkt->data;
 263         struct ieee80211_sta *sta;
 264         unsigned int delay;
 265         struct iwl_mvm_sta *mvmsta;
 266         struct ieee80211_vif *vif;
 267         u32 sta_id = le32_to_cpu(notif->sta_id);
 268
 269         lockdep_assert_held(&mvm->mutex);
 270
 271         /* can fail sometimes */
 272         if (!le32_to_cpu(notif->status)) {
 273                 iwl_mvm_tdls_update_cs_state(mvm, IWL_MVM_TDLS_SW_IDLE);
 274                 return;
 275         }
 276
 277         if (WARN_ON(sta_id >= IWL_MVM_STATION_COUNT))
 278                 return;
 279
 280         sta = rcu_dereference_protected(mvm->fw_id_to_mac_id[sta_id],
 281                                         lockdep_is_held(&mvm->mutex));
 282         /* the station may not be here, but if it is, it must be a TDLS peer */
 283         if (IS_ERR_OR_NULL(sta) || WARN_ON(!sta->tdls))
 284                 return;
 285
 286         mvmsta = iwl_mvm_sta_from_mac80211(sta);
 287         vif = mvmsta->vif;
 288
 289         /*
 290          * Update state and possibly switch again after this is over (DTIM).
 291          * Also convert TU to msec.
 292          */
 293         delay = TU_TO_MS(vif->bss_conf.dtim_period * vif->bss_conf.beacon_int);
 294         mod_delayed_work(system_wq, &mvm->tdls_cs.dwork,
 295                          msecs_to_jiffies(delay));
 296
 297         iwl_mvm_tdls_update_cs_state(mvm, IWL_MVM_TDLS_SW_ACTIVE);
 298 }
 299
 300 static int
 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, u32 timestamp)
 304 {
 305         bool same_peer = false;
 306         int ret = 0;
 307
 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_INVALID_STA) {
 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);
 316         }
 317
 318         switch (mvm->tdls_cs.state) {
 319         case IWL_MVM_TDLS_SW_IDLE:
 320                 /*
 321                  * might be spurious packet from the peer after the switch is
 322                  * already done
 323                  */
 324                 if (type == TDLS_MOVE_CH)
 325                         ret = -EINVAL;
 326                 break;
 327         case IWL_MVM_TDLS_SW_REQ_SENT:
 328                 /* only allow requests from the same peer */
 329                 if (!same_peer)
 330                         ret = -EBUSY;
 331                 else if (type == TDLS_SEND_CHAN_SW_RESP_AND_MOVE_CH &&
 332                          !peer_initiator)
 333                         /*
 334                          * We received a ch-switch request while an outgoing
 335                          * one is pending. Allow it if the peer is the link
 336                          * initiator.
 337                          */
 338                         ret = -EBUSY;
 339                 else if (type == TDLS_SEND_CHAN_SW_REQ)
 340                         /* wait for idle before sending another request */
 341                         ret = -EBUSY;
 342                 else if (timestamp <= mvm->tdls_cs.peer.sent_timestamp)
 343                         /* we got a stale response - ignore it */
 344                         ret = -EINVAL;
 345                 break;
 346         case IWL_MVM_TDLS_SW_RESP_RCVD:
 347                 /*
 348                  * we are waiting for the FW to give an "active" notification,
 349                  * so ignore requests in the meantime
 350                  */
 351                 ret = -EBUSY;
 352                 break;
 353         case IWL_MVM_TDLS_SW_REQ_RCVD:
 354                 /* as above, allow the link initiator to proceed */
 355                 if (type == TDLS_SEND_CHAN_SW_REQ) {
 356                         if (!same_peer)
 357                                 ret = -EBUSY;
 358                         else if (peer_initiator) /* they are the initiator */
 359                                 ret = -EBUSY;
 360                 } else if (type == TDLS_MOVE_CH) {
 361                         ret = -EINVAL;
 362                 }
 363                 break;
 364         case IWL_MVM_TDLS_SW_ACTIVE:
 365                 /*
 366                  * the only valid request when active is a request to return
 367                  * to the base channel by the current off-channel peer
 368                  */
 369                 if (type != TDLS_MOVE_CH || !same_peer)
 370                         ret = -EBUSY;
 371                 break;
 372         }
 373
 374         if (ret)
 375                 IWL_DEBUG_TDLS(mvm,
 376                                "Invalid TDLS action %d state %d peer %pM same_peer %d initiator %d\n",
 377                                type, mvm->tdls_cs.state, peer, same_peer,
 378                                peer_initiator);
 379
 380         return ret;
 381 }
 382
 383 static int
 384 iwl_mvm_tdls_config_channel_switch(struct iwl_mvm *mvm,
 385                                    struct ieee80211_vif *vif,
 386                                    enum iwl_tdls_channel_switch_type type,
 387                                    const u8 *peer, bool peer_initiator,
 388                                    u8 oper_class,
 389                                    struct cfg80211_chan_def *chandef,
 390                                    u32 timestamp, u16 switch_time,
 391                                    u16 switch_timeout, struct sk_buff *skb,
 392                                    u32 ch_sw_tm_ie)
 393 {
 394         struct ieee80211_sta *sta;
 395         struct iwl_mvm_sta *mvmsta;
 396         struct ieee80211_tx_info *info;
 397         struct ieee80211_hdr *hdr;
 398         struct iwl_tdls_channel_switch_cmd cmd = {0};
 399         int ret;
 400
 401         lockdep_assert_held(&mvm->mutex);
 402
 403         ret = iwl_mvm_tdls_check_action(mvm, type, peer, peer_initiator,
 404                                         timestamp);
 405         if (ret)
 406                 return ret;
 407
 408         if (!skb || WARN_ON(skb->len > IWL_TDLS_CH_SW_FRAME_MAX_SIZE)) {
 409                 ret = -EINVAL;
 410                 goto out;
 411         }
 412
 413         cmd.switch_type = type;
 414         cmd.timing.frame_timestamp = cpu_to_le32(timestamp);
 415         cmd.timing.switch_time = cpu_to_le32(switch_time);
 416         cmd.timing.switch_timeout = cpu_to_le32(switch_timeout);
 417
 418         rcu_read_lock();
 419         sta = ieee80211_find_sta(vif, peer);
 420         if (!sta) {
 421                 rcu_read_unlock();
 422                 ret = -ENOENT;
 423                 goto out;
 424         }
 425         mvmsta = iwl_mvm_sta_from_mac80211(sta);
 426         cmd.peer_sta_id = cpu_to_le32(mvmsta->sta_id);
 427
 428         if (!chandef) {
 429                 if (mvm->tdls_cs.state == IWL_MVM_TDLS_SW_REQ_SENT &&
 430                     mvm->tdls_cs.peer.chandef.chan) {
 431                         /* actually moving to the channel */
 432                         chandef = &mvm->tdls_cs.peer.chandef;
 433                 } else if (mvm->tdls_cs.state == IWL_MVM_TDLS_SW_ACTIVE &&
 434                            type == TDLS_MOVE_CH) {
 435                         /* we need to return to base channel */
 436                         struct ieee80211_chanctx_conf *chanctx =
 437                                         rcu_dereference(vif->chanctx_conf);
 438
 439                         if (WARN_ON_ONCE(!chanctx)) {
 440                                 rcu_read_unlock();
 441                                 goto out;
 442                         }
 443
 444                         chandef = &chanctx->def;
 445                 }
 446         }
 447
 448         if (chandef) {
 449                 cmd.ci.band = (chandef->chan->band == NL80211_BAND_2GHZ ?
 450                                PHY_BAND_24 : PHY_BAND_5);
 451                 cmd.ci.channel = chandef->chan->hw_value;
 452                 cmd.ci.width = iwl_mvm_get_channel_width(chandef);
 453                 cmd.ci.ctrl_pos = iwl_mvm_get_ctrl_pos(chandef);
 454         }
 455
 456         /* keep quota calculation simple for now - 50% of DTIM for TDLS */
 457         cmd.timing.max_offchan_duration =
 458                         cpu_to_le32(TU_TO_US(vif->bss_conf.dtim_period *
 459                                              vif->bss_conf.beacon_int) / 2);
 460
 461         /* Switch time is the first element in the switch-timing IE. */
 462         cmd.frame.switch_time_offset = cpu_to_le32(ch_sw_tm_ie + 2);
 463
 464         info = IEEE80211_SKB_CB(skb);
 465         hdr = (void *)skb->data;
 466         if (info->control.hw_key) {
 467                 if (info->control.hw_key->cipher != WLAN_CIPHER_SUITE_CCMP) {
 468                         rcu_read_unlock();
 469                         ret = -EINVAL;
 470                         goto out;
 471                 }
 472                 iwl_mvm_set_tx_cmd_ccmp(info, &cmd.frame.tx_cmd);
 473         }
 474
 475         iwl_mvm_set_tx_cmd(mvm, skb, &cmd.frame.tx_cmd, info,
 476                            mvmsta->sta_id);
 477
 478         iwl_mvm_set_tx_cmd_rate(mvm, &cmd.frame.tx_cmd, info, sta,
 479                                 hdr->frame_control);
 480         rcu_read_unlock();
 481
 482         memcpy(cmd.frame.data, skb->data, skb->len);
 483
 484         ret = iwl_mvm_send_cmd_pdu(mvm, TDLS_CHANNEL_SWITCH_CMD, 0,
 485                                    sizeof(cmd), &cmd);
 486         if (ret) {
 487                 IWL_ERR(mvm, "Failed to send TDLS_CHANNEL_SWITCH cmd: %d\n",
 488                         ret);
 489                 goto out;
 490         }
 491
 492         /* channel switch has started, update state */
 493         if (type != TDLS_MOVE_CH) {
 494                 mvm->tdls_cs.cur_sta_id = mvmsta->sta_id;
 495                 iwl_mvm_tdls_update_cs_state(mvm,
 496                                              type == TDLS_SEND_CHAN_SW_REQ ?
 497                                              IWL_MVM_TDLS_SW_REQ_SENT :
 498                                              IWL_MVM_TDLS_SW_REQ_RCVD);
 499         } else {
 500                 iwl_mvm_tdls_update_cs_state(mvm, IWL_MVM_TDLS_SW_RESP_RCVD);
 501         }
 502
 503 out:
 504
 505         /* channel switch failed - we are idle */
 506         if (ret)
 507                 iwl_mvm_tdls_update_cs_state(mvm, IWL_MVM_TDLS_SW_IDLE);
 508
 509         return ret;
 510 }
 511
 512 void iwl_mvm_tdls_ch_switch_work(struct work_struct *work)
 513 {
 514         struct iwl_mvm *mvm;
 515         struct ieee80211_sta *sta;
 516         struct iwl_mvm_sta *mvmsta;
 517         struct ieee80211_vif *vif;
 518         unsigned int delay;
 519         int ret;
 520
 521         mvm = container_of(work, struct iwl_mvm, tdls_cs.dwork.work);
 522         mutex_lock(&mvm->mutex);
 523
 524         /* called after an active channel switch has finished or timed-out */
 525         iwl_mvm_tdls_update_cs_state(mvm, IWL_MVM_TDLS_SW_IDLE);
 526
 527         /* station might be gone, in that case do nothing */
 528         if (mvm->tdls_cs.peer.sta_id == IWL_MVM_INVALID_STA)
 529                 goto out;
 530
 531         sta = rcu_dereference_protected(
 532                                 mvm->fw_id_to_mac_id[mvm->tdls_cs.peer.sta_id],
 533                                 lockdep_is_held(&mvm->mutex));
 534         /* the station may not be here, but if it is, it must be a TDLS peer */
 535         if (!sta || IS_ERR(sta) || WARN_ON(!sta->tdls))
 536                 goto out;
 537
 538         mvmsta = iwl_mvm_sta_from_mac80211(sta);
 539         vif = mvmsta->vif;
 540         ret = iwl_mvm_tdls_config_channel_switch(mvm, vif,
 541                                                  TDLS_SEND_CHAN_SW_REQ,
 542                                                  sta->addr,
 543                                                  mvm->tdls_cs.peer.initiator,
 544                                                  mvm->tdls_cs.peer.op_class,
 545                                                  &mvm->tdls_cs.peer.chandef,
 546                                                  0, 0, 0,
 547                                                  mvm->tdls_cs.peer.skb,
 548                                                  mvm->tdls_cs.peer.ch_sw_tm_ie);
 549         if (ret)
 550                 IWL_ERR(mvm, "Not sending TDLS channel switch: %d\n", ret);
 551
 552         /* retry after a DTIM if we failed sending now */
 553         delay = TU_TO_MS(vif->bss_conf.dtim_period * vif->bss_conf.beacon_int);
 554         schedule_delayed_work(&mvm->tdls_cs.dwork, msecs_to_jiffies(delay));
 555 out:
 556         mutex_unlock(&mvm->mutex);
 557 }
 558
 559 int
 560 iwl_mvm_tdls_channel_switch(struct ieee80211_hw *hw,
 561                             struct ieee80211_vif *vif,
 562                             struct ieee80211_sta *sta, u8 oper_class,
 563                             struct cfg80211_chan_def *chandef,
 564                             struct sk_buff *tmpl_skb, u32 ch_sw_tm_ie)
 565 {
 566         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
 567         struct iwl_mvm_sta *mvmsta;
 568         unsigned int delay;
 569         int ret;
 570
 571         mutex_lock(&mvm->mutex);
 572
 573         IWL_DEBUG_TDLS(mvm, "TDLS channel switch with %pM ch %d width %d\n",
 574                        sta->addr, chandef->chan->center_freq, chandef->width);
 575
 576         /* we only support a single peer for channel switching */
 577         if (mvm->tdls_cs.peer.sta_id != IWL_MVM_INVALID_STA) {
 578                 IWL_DEBUG_TDLS(mvm,
 579                                "Existing peer. Can't start switch with %pM\n",
 580                                sta->addr);
 581                 ret = -EBUSY;
 582                 goto out;
 583         }
 584
 585         ret = iwl_mvm_tdls_config_channel_switch(mvm, vif,
 586                                                  TDLS_SEND_CHAN_SW_REQ,
 587                                                  sta->addr, sta->tdls_initiator,
 588                                                  oper_class, chandef, 0, 0, 0,
 589                                                  tmpl_skb, ch_sw_tm_ie);
 590         if (ret)
 591                 goto out;
 592
 593         /*
 594          * Mark the peer as "in tdls switch" for this vif. We only allow a
 595          * single such peer per vif.
 596          */
 597         mvm->tdls_cs.peer.skb = skb_copy(tmpl_skb, GFP_KERNEL);
 598         if (!mvm->tdls_cs.peer.skb) {
 599                 ret = -ENOMEM;
 600                 goto out;
 601         }
 602
 603         mvmsta = iwl_mvm_sta_from_mac80211(sta);
 604         mvm->tdls_cs.peer.sta_id = mvmsta->sta_id;
 605         mvm->tdls_cs.peer.chandef = *chandef;
 606         mvm->tdls_cs.peer.initiator = sta->tdls_initiator;
 607         mvm->tdls_cs.peer.op_class = oper_class;
 608         mvm->tdls_cs.peer.ch_sw_tm_ie = ch_sw_tm_ie;
 609
 610         /*
 611          * Wait for 2 DTIM periods before attempting the next switch. The next
 612          * switch will be made sooner if the current one completes before that.
 613          */
 614         delay = 2 * TU_TO_MS(vif->bss_conf.dtim_period *
 615                              vif->bss_conf.beacon_int);
 616         mod_delayed_work(system_wq, &mvm->tdls_cs.dwork,
 617                          msecs_to_jiffies(delay));
 618
 619 out:
 620         mutex_unlock(&mvm->mutex);
 621         return ret;
 622 }
 623
 624 void iwl_mvm_tdls_cancel_channel_switch(struct ieee80211_hw *hw,
 625                                         struct ieee80211_vif *vif,
 626                                         struct ieee80211_sta *sta)
 627 {
 628         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
 629         struct ieee80211_sta *cur_sta;
 630         bool wait_for_phy = false;
 631
 632         mutex_lock(&mvm->mutex);
 633
 634         IWL_DEBUG_TDLS(mvm, "TDLS cancel channel switch with %pM\n", sta->addr);
 635
 636         /* we only support a single peer for channel switching */
 637         if (mvm->tdls_cs.peer.sta_id == IWL_MVM_INVALID_STA) {
 638                 IWL_DEBUG_TDLS(mvm, "No ch switch peer - %pM\n", sta->addr);
 639                 goto out;
 640         }
 641
 642         cur_sta = rcu_dereference_protected(
 643                                 mvm->fw_id_to_mac_id[mvm->tdls_cs.peer.sta_id],
 644                                 lockdep_is_held(&mvm->mutex));
 645         /* make sure it's the same peer */
 646         if (cur_sta != sta)
 647                 goto out;
 648
 649         /*
 650          * If we're currently in a switch because of the now canceled peer,
 651          * wait a DTIM here to make sure the phy is back on the base channel.
 652          * We can't otherwise force it.
 653          */
 654         if (mvm->tdls_cs.cur_sta_id == mvm->tdls_cs.peer.sta_id &&
 655             mvm->tdls_cs.state != IWL_MVM_TDLS_SW_IDLE)
 656                 wait_for_phy = true;
 657
 658         mvm->tdls_cs.peer.sta_id = IWL_MVM_INVALID_STA;
 659         dev_kfree_skb(mvm->tdls_cs.peer.skb);
 660         mvm->tdls_cs.peer.skb = NULL;
 661
 662 out:
 663         mutex_unlock(&mvm->mutex);
 664
 665         /* make sure the phy is on the base channel */
 666         if (wait_for_phy)
 667                 msleep(TU_TO_MS(vif->bss_conf.dtim_period *
 668                                 vif->bss_conf.beacon_int));
 669
 670         /* flush the channel switch state */
 671         flush_delayed_work(&mvm->tdls_cs.dwork);
 672
 673         IWL_DEBUG_TDLS(mvm, "TDLS ending channel switch with %pM\n", sta->addr);
 674 }
 675
 676 void
 677 iwl_mvm_tdls_recv_channel_switch(struct ieee80211_hw *hw,
 678                                  struct ieee80211_vif *vif,
 679                                  struct ieee80211_tdls_ch_sw_params *params)
 680 {
 681         struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
 682         enum iwl_tdls_channel_switch_type type;
 683         unsigned int delay;
 684         const char *action_str =
 685                 params->action_code == WLAN_TDLS_CHANNEL_SWITCH_REQUEST ?
 686                 "REQ" : "RESP";
 687
 688         mutex_lock(&mvm->mutex);
 689
 690         IWL_DEBUG_TDLS(mvm,
 691                        "Received TDLS ch switch action %s from %pM status %d\n",
 692                        action_str, params->sta->addr, params->status);
 693
 694         /*
 695          * we got a non-zero status from a peer we were switching to - move to
 696          * the idle state and retry again later
 697          */
 698         if (params->action_code == WLAN_TDLS_CHANNEL_SWITCH_RESPONSE &&
 699             params->status != 0 &&
 700             mvm->tdls_cs.state == IWL_MVM_TDLS_SW_REQ_SENT &&
 701             mvm->tdls_cs.cur_sta_id != IWL_MVM_INVALID_STA) {
 702                 struct ieee80211_sta *cur_sta;
 703
 704                 /* make sure it's the same peer */
 705                 cur_sta = rcu_dereference_protected(
 706                                 mvm->fw_id_to_mac_id[mvm->tdls_cs.cur_sta_id],
 707                                 lockdep_is_held(&mvm->mutex));
 708                 if (cur_sta == params->sta) {
 709                         iwl_mvm_tdls_update_cs_state(mvm,
 710                                                      IWL_MVM_TDLS_SW_IDLE);
 711                         goto retry;
 712                 }
 713         }
 714
 715         type = (params->action_code == WLAN_TDLS_CHANNEL_SWITCH_REQUEST) ?
 716                TDLS_SEND_CHAN_SW_RESP_AND_MOVE_CH : TDLS_MOVE_CH;
 717
 718         iwl_mvm_tdls_config_channel_switch(mvm, vif, type, params->sta->addr,
 719                                            params->sta->tdls_initiator, 0,
 720                                            params->chandef, params->timestamp,
 721                                            params->switch_time,
 722                                            params->switch_timeout,
 723                                            params->tmpl_skb,
 724                                            params->ch_sw_tm_ie);
 725
 726 retry:
 727         /* register a timeout in case we don't succeed in switching */
 728         delay = vif->bss_conf.dtim_period * vif->bss_conf.beacon_int *
 729                 1024 / 1000;
 730         mod_delayed_work(system_wq, &mvm->tdls_cs.dwork,
 731                          msecs_to_jiffies(delay));
 732         mutex_unlock(&mvm->mutex);
 733 }