drivers/net/wireless/intel/iwlwifi/mvm/time-event.c

   1 // SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause
   2 /*
   3  * Copyright (C) 2012-2014, 2018-2024 Intel Corporation
   4  * Copyright (C) 2013-2015 Intel Mobile Communications GmbH
   5  * Copyright (C) 2017 Intel Deutschland GmbH
   6  */
   7 #include <linux/jiffies.h>
   8 #include <net/mac80211.h>
   9
  10 #include "fw/notif-wait.h"
  11 #include "iwl-trans.h"
  12 #include "fw-api.h"
  13 #include "time-event.h"
  14 #include "mvm.h"
  15 #include "iwl-io.h"
  16 #include "iwl-prph.h"
  17
  18 /*
  19  * For the high priority TE use a time event type that has similar priority to
  20  * the FW's action scan priority.
  21  */
  22 #define IWL_MVM_ROC_TE_TYPE_NORMAL TE_P2P_DEVICE_DISCOVERABLE
  23 #define IWL_MVM_ROC_TE_TYPE_MGMT_TX TE_P2P_CLIENT_ASSOC
  24
  25 void iwl_mvm_te_clear_data(struct iwl_mvm *mvm,
  26                            struct iwl_mvm_time_event_data *te_data)
  27 {
  28         lockdep_assert_held(&mvm->time_event_lock);
  29
  30         if (!te_data || !te_data->vif)
  31                 return;
  32
  33         list_del(&te_data->list);
  34
  35         /*
  36          * the list is only used for AUX ROC events so make sure it is always
  37          * initialized
  38          */
  39         INIT_LIST_HEAD(&te_data->list);
  40
  41         te_data->running = false;
  42         te_data->uid = 0;
  43         te_data->id = TE_MAX;
  44         te_data->vif = NULL;
  45         te_data->link_id = -1;
  46 }
  47
  48 static void iwl_mvm_cleanup_roc(struct iwl_mvm *mvm)
  49 {
  50         /*
  51          * Clear the ROC_RUNNING status bit.
  52          * This will cause the TX path to drop offchannel transmissions.
  53          * That would also be done by mac80211, but it is racy, in particular
  54          * in the case that the time event actually completed in the firmware.
  55          *
  56          * Also flush the offchannel queue -- this is called when the time
  57          * event finishes or is canceled, so that frames queued for it
  58          * won't get stuck on the queue and be transmitted in the next
  59          * time event.
  60          */
  61         if (test_and_clear_bit(IWL_MVM_STATUS_ROC_RUNNING, &mvm->status)) {
  62                 struct iwl_mvm_vif *mvmvif;
  63
  64                 synchronize_net();
  65
  66                 /*
  67                  * NB: access to this pointer would be racy, but the flush bit
  68                  * can only be set when we had a P2P-Device VIF, and we have a
  69                  * flush of this work in iwl_mvm_prepare_mac_removal() so it's
  70                  * not really racy.
  71                  */
  72
  73                 if (!WARN_ON(!mvm->p2p_device_vif)) {
  74                         struct ieee80211_vif *vif = mvm->p2p_device_vif;
  75
  76                         mvmvif = iwl_mvm_vif_from_mac80211(vif);
  77                         iwl_mvm_flush_sta(mvm, mvmvif->deflink.bcast_sta.sta_id,
  78                                           mvmvif->deflink.bcast_sta.tfd_queue_msk);
  79
  80                         if (mvm->mld_api_is_used) {
  81                                 iwl_mvm_mld_rm_bcast_sta(mvm, vif,
  82                                                          &vif->bss_conf);
  83
  84                                 iwl_mvm_link_changed(mvm, vif, &vif->bss_conf,
  85                                                      LINK_CONTEXT_MODIFY_ACTIVE,
  86                                                      false);
  87                         } else {
  88                                 iwl_mvm_rm_p2p_bcast_sta(mvm, vif);
  89                                 iwl_mvm_binding_remove_vif(mvm, vif);
  90                         }
  91
  92                         /* Do not remove the PHY context as removing and adding
  93                          * a PHY context has timing overheads. Leaving it
  94                          * configured in FW would be useful in case the next ROC
  95                          * is with the same channel.
  96                          */
  97                 }
  98         }
  99
 100         /* Do the same for AUX ROC */
 101         if (test_and_clear_bit(IWL_MVM_STATUS_ROC_AUX_RUNNING, &mvm->status)) {
 102                 synchronize_net();
 103
 104                 iwl_mvm_flush_sta(mvm, mvm->aux_sta.sta_id,
 105                                   mvm->aux_sta.tfd_queue_msk);
 106
 107                 if (mvm->mld_api_is_used) {
 108                         iwl_mvm_mld_rm_aux_sta(mvm);
 109                         return;
 110                 }
 111
 112                 /* In newer version of this command an aux station is added only
 113                  * in cases of dedicated tx queue and need to be removed in end
 114                  * of use */
 115                 if (iwl_mvm_has_new_station_api(mvm->fw))
 116                         iwl_mvm_rm_aux_sta(mvm);
 117         }
 118 }
 119
 120 void iwl_mvm_roc_done_wk(struct work_struct *wk)
 121 {
 122         struct iwl_mvm *mvm = container_of(wk, struct iwl_mvm, roc_done_wk);
 123
 124         mutex_lock(&mvm->mutex);
 125         iwl_mvm_cleanup_roc(mvm);
 126         mutex_unlock(&mvm->mutex);
 127 }
 128
 129 static void iwl_mvm_roc_finished(struct iwl_mvm *mvm)
 130 {
 131         /*
 132          * Of course, our status bit is just as racy as mac80211, so in
 133          * addition, fire off the work struct which will drop all frames
 134          * from the hardware queues that made it through the race. First
 135          * it will of course synchronize the TX path to make sure that
 136          * any *new* TX will be rejected.
 137          */
 138         schedule_work(&mvm->roc_done_wk);
 139 }
 140
 141 static void iwl_mvm_csa_noa_start(struct iwl_mvm *mvm)
 142 {
 143         struct ieee80211_vif *csa_vif;
 144
 145         rcu_read_lock();
 146
 147         csa_vif = rcu_dereference(mvm->csa_vif);
 148         if (!csa_vif || !csa_vif->bss_conf.csa_active)
 149                 goto out_unlock;
 150
 151         IWL_DEBUG_TE(mvm, "CSA NOA started\n");
 152
 153         /*
 154          * CSA NoA is started but we still have beacons to
 155          * transmit on the current channel.
 156          * So we just do nothing here and the switch
 157          * will be performed on the last TBTT.
 158          */
 159         if (!ieee80211_beacon_cntdwn_is_complete(csa_vif, 0)) {
 160                 IWL_WARN(mvm, "CSA NOA started too early\n");
 161                 goto out_unlock;
 162         }
 163
 164         ieee80211_csa_finish(csa_vif, 0);
 165
 166         rcu_read_unlock();
 167
 168         RCU_INIT_POINTER(mvm->csa_vif, NULL);
 169
 170         return;
 171
 172 out_unlock:
 173         rcu_read_unlock();
 174 }
 175
 176 static bool iwl_mvm_te_check_disconnect(struct iwl_mvm *mvm,
 177                                         struct ieee80211_vif *vif,
 178                                         const char *errmsg)
 179 {
 180         struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
 181
 182         if (vif->type != NL80211_IFTYPE_STATION)
 183                 return false;
 184
 185         if (!mvmvif->csa_bcn_pending && vif->cfg.assoc &&
 186             vif->bss_conf.dtim_period)
 187                 return false;
 188         if (errmsg)
 189                 IWL_ERR(mvm, "%s\n", errmsg);
 190
 191         if (mvmvif->csa_bcn_pending) {
 192                 struct iwl_mvm_sta *mvmsta;
 193
 194                 rcu_read_lock();
 195                 mvmsta = iwl_mvm_sta_from_staid_rcu(mvm,
 196                                                     mvmvif->deflink.ap_sta_id);
 197                 if (!WARN_ON(!mvmsta))
 198                         iwl_mvm_sta_modify_disable_tx(mvm, mvmsta, false);
 199                 rcu_read_unlock();
 200         }
 201
 202         if (vif->cfg.assoc) {
 203                 /*
 204                  * When not associated, this will be called from
 205                  * iwl_mvm_event_mlme_callback_ini()
 206                  */
 207                 iwl_dbg_tlv_time_point(&mvm->fwrt,
 208                                        IWL_FW_INI_TIME_POINT_ASSOC_FAILED,
 209                                        NULL);
 210         }
 211
 212         iwl_mvm_connection_loss(mvm, vif, errmsg);
 213         return true;
 214 }
 215
 216 static void
 217 iwl_mvm_te_handle_notify_csa(struct iwl_mvm *mvm,
 218                              struct iwl_mvm_time_event_data *te_data,
 219                              struct iwl_time_event_notif *notif)
 220 {
 221         struct ieee80211_vif *vif = te_data->vif;
 222         struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
 223
 224         if (!notif->status)
 225                 IWL_DEBUG_TE(mvm, "CSA time event failed to start\n");
 226
 227         switch (te_data->vif->type) {
 228         case NL80211_IFTYPE_AP:
 229                 if (!notif->status)
 230                         mvmvif->csa_failed = true;
 231                 iwl_mvm_csa_noa_start(mvm);
 232                 break;
 233         case NL80211_IFTYPE_STATION:
 234                 if (!notif->status) {
 235                         iwl_mvm_connection_loss(mvm, vif,
 236                                                 "CSA TE failed to start");
 237                         break;
 238                 }
 239                 iwl_mvm_csa_client_absent(mvm, te_data->vif);
 240                 cancel_delayed_work(&mvmvif->csa_work);
 241                 ieee80211_chswitch_done(te_data->vif, true, 0);
 242                 break;
 243         default:
 244                 /* should never happen */
 245                 WARN_ON_ONCE(1);
 246                 break;
 247         }
 248
 249         /* we don't need it anymore */
 250         iwl_mvm_te_clear_data(mvm, te_data);
 251 }
 252
 253 static void iwl_mvm_te_check_trigger(struct iwl_mvm *mvm,
 254                                      struct iwl_time_event_notif *notif,
 255                                      struct iwl_mvm_time_event_data *te_data)
 256 {
 257         struct iwl_fw_dbg_trigger_tlv *trig;
 258         struct iwl_fw_dbg_trigger_time_event *te_trig;
 259         int i;
 260
 261         trig = iwl_fw_dbg_trigger_on(&mvm->fwrt,
 262                                      ieee80211_vif_to_wdev(te_data->vif),
 263                                      FW_DBG_TRIGGER_TIME_EVENT);
 264         if (!trig)
 265                 return;
 266
 267         te_trig = (void *)trig->data;
 268
 269         for (i = 0; i < ARRAY_SIZE(te_trig->time_events); i++) {
 270                 u32 trig_te_id = le32_to_cpu(te_trig->time_events[i].id);
 271                 u32 trig_action_bitmap =
 272                         le32_to_cpu(te_trig->time_events[i].action_bitmap);
 273                 u32 trig_status_bitmap =
 274                         le32_to_cpu(te_trig->time_events[i].status_bitmap);
 275
 276                 if (trig_te_id != te_data->id ||
 277                     !(trig_action_bitmap & le32_to_cpu(notif->action)) ||
 278                     !(trig_status_bitmap & BIT(le32_to_cpu(notif->status))))
 279                         continue;
 280
 281                 iwl_fw_dbg_collect_trig(&mvm->fwrt, trig,
 282                                         "Time event %d Action 0x%x received status: %d",
 283                                         te_data->id,
 284                                         le32_to_cpu(notif->action),
 285                                         le32_to_cpu(notif->status));
 286                 break;
 287         }
 288 }
 289
 290 /*
 291  * Handles a FW notification for an event that is known to the driver.
 292  *
 293  * @mvm: the mvm component
 294  * @te_data: the time event data
 295  * @notif: the notification data corresponding the time event data.
 296  */
 297 static void iwl_mvm_te_handle_notif(struct iwl_mvm *mvm,
 298                                     struct iwl_mvm_time_event_data *te_data,
 299                                     struct iwl_time_event_notif *notif)
 300 {
 301         lockdep_assert_held(&mvm->time_event_lock);
 302
 303         IWL_DEBUG_TE(mvm, "Handle time event notif - UID = 0x%x action %d\n",
 304                      le32_to_cpu(notif->unique_id),
 305                      le32_to_cpu(notif->action));
 306
 307         iwl_mvm_te_check_trigger(mvm, notif, te_data);
 308
 309         /*
 310          * The FW sends the start/end time event notifications even for events
 311          * that it fails to schedule. This is indicated in the status field of
 312          * the notification. This happens in cases that the scheduler cannot
 313          * find a schedule that can handle the event (for example requesting a
 314          * P2P Device discoveribility, while there are other higher priority
 315          * events in the system).
 316          */
 317         if (!le32_to_cpu(notif->status)) {
 318                 const char *msg;
 319
 320                 if (notif->action & cpu_to_le32(TE_V2_NOTIF_HOST_EVENT_START))
 321                         msg = "Time Event start notification failure";
 322                 else
 323                         msg = "Time Event end notification failure";
 324
 325                 IWL_DEBUG_TE(mvm, "%s\n", msg);
 326
 327                 if (iwl_mvm_te_check_disconnect(mvm, te_data->vif, msg)) {
 328                         iwl_mvm_te_clear_data(mvm, te_data);
 329                         return;
 330                 }
 331         }
 332
 333         if (le32_to_cpu(notif->action) & TE_V2_NOTIF_HOST_EVENT_END) {
 334                 IWL_DEBUG_TE(mvm,
 335                              "TE ended - current time %lu, estimated end %lu\n",
 336                              jiffies, te_data->end_jiffies);
 337
 338                 switch (te_data->vif->type) {
 339                 case NL80211_IFTYPE_P2P_DEVICE:
 340                         ieee80211_remain_on_channel_expired(mvm->hw);
 341                         iwl_mvm_roc_finished(mvm);
 342                         break;
 343                 case NL80211_IFTYPE_STATION:
 344                         /*
 345                          * If we are switching channel, don't disconnect
 346                          * if the time event is already done. Beacons can
 347                          * be delayed a bit after the switch.
 348                          */
 349                         if (te_data->id == TE_CHANNEL_SWITCH_PERIOD) {
 350                                 IWL_DEBUG_TE(mvm,
 351                                              "No beacon heard and the CS time event is over, don't disconnect\n");
 352                                 break;
 353                         }
 354
 355                         /*
 356                          * By now, we should have finished association
 357                          * and know the dtim period.
 358                          */
 359                         iwl_mvm_te_check_disconnect(mvm, te_data->vif,
 360                                 !te_data->vif->cfg.assoc ?
 361                                 "Not associated and the time event is over already..." :
 362                                 "No beacon heard and the time event is over already...");
 363                         break;
 364                 default:
 365                         break;
 366                 }
 367
 368                 iwl_mvm_te_clear_data(mvm, te_data);
 369         } else if (le32_to_cpu(notif->action) & TE_V2_NOTIF_HOST_EVENT_START) {
 370                 te_data->running = true;
 371                 te_data->end_jiffies = TU_TO_EXP_TIME(te_data->duration);
 372
 373                 if (te_data->vif->type == NL80211_IFTYPE_P2P_DEVICE) {
 374                         set_bit(IWL_MVM_STATUS_ROC_RUNNING, &mvm->status);
 375                         ieee80211_ready_on_channel(mvm->hw);
 376                 } else if (te_data->id == TE_CHANNEL_SWITCH_PERIOD) {
 377                         iwl_mvm_te_handle_notify_csa(mvm, te_data, notif);
 378                 }
 379         } else {
 380                 IWL_WARN(mvm, "Got TE with unknown action\n");
 381         }
 382 }
 383
 384 void iwl_mvm_rx_roc_notif(struct iwl_mvm *mvm,
 385                           struct iwl_rx_cmd_buffer *rxb)
 386 {
 387         struct iwl_rx_packet *pkt = rxb_addr(rxb);
 388         struct iwl_roc_notif *notif = (void *)pkt->data;
 389
 390         if (le32_to_cpu(notif->success) && le32_to_cpu(notif->started) &&
 391             le32_to_cpu(notif->activity) == ROC_ACTIVITY_HOTSPOT) {
 392                 set_bit(IWL_MVM_STATUS_ROC_AUX_RUNNING, &mvm->status);
 393                 ieee80211_ready_on_channel(mvm->hw);
 394         } else {
 395                 iwl_mvm_roc_finished(mvm);
 396                 ieee80211_remain_on_channel_expired(mvm->hw);
 397         }
 398 }
 399
 400 /*
 401  * Handle A Aux ROC time event
 402  */
 403 static int iwl_mvm_aux_roc_te_handle_notif(struct iwl_mvm *mvm,
 404                                            struct iwl_time_event_notif *notif)
 405 {
 406         struct iwl_mvm_time_event_data *aux_roc_te = NULL, *te_data;
 407
 408         list_for_each_entry(te_data, &mvm->aux_roc_te_list, list) {
 409                 if (le32_to_cpu(notif->unique_id) == te_data->uid) {
 410                         aux_roc_te = te_data;
 411                         break;
 412                 }
 413         }
 414         if (!aux_roc_te) /* Not a Aux ROC time event */
 415                 return -EINVAL;
 416
 417         iwl_mvm_te_check_trigger(mvm, notif, te_data);
 418
 419         IWL_DEBUG_TE(mvm,
 420                      "Aux ROC time event notification  - UID = 0x%x action %d (error = %d)\n",
 421                      le32_to_cpu(notif->unique_id),
 422                      le32_to_cpu(notif->action), le32_to_cpu(notif->status));
 423
 424         if (!le32_to_cpu(notif->status) ||
 425             le32_to_cpu(notif->action) == TE_V2_NOTIF_HOST_EVENT_END) {
 426                 /* End TE, notify mac80211 */
 427                 ieee80211_remain_on_channel_expired(mvm->hw);
 428                 iwl_mvm_roc_finished(mvm); /* flush aux queue */
 429                 list_del(&te_data->list); /* remove from list */
 430                 te_data->running = false;
 431                 te_data->vif = NULL;
 432                 te_data->uid = 0;
 433                 te_data->id = TE_MAX;
 434         } else if (le32_to_cpu(notif->action) == TE_V2_NOTIF_HOST_EVENT_START) {
 435                 set_bit(IWL_MVM_STATUS_ROC_AUX_RUNNING, &mvm->status);
 436                 te_data->running = true;
 437                 ieee80211_ready_on_channel(mvm->hw); /* Start TE */
 438         } else {
 439                 IWL_DEBUG_TE(mvm,
 440                              "ERROR: Unknown Aux ROC Time Event (action = %d)\n",
 441                              le32_to_cpu(notif->action));
 442                 return -EINVAL;
 443         }
 444
 445         return 0;
 446 }
 447
 448 /*
 449  * The Rx handler for time event notifications
 450  */
 451 void iwl_mvm_rx_time_event_notif(struct iwl_mvm *mvm,
 452                                  struct iwl_rx_cmd_buffer *rxb)
 453 {
 454         struct iwl_rx_packet *pkt = rxb_addr(rxb);
 455         struct iwl_time_event_notif *notif = (void *)pkt->data;
 456         struct iwl_mvm_time_event_data *te_data, *tmp;
 457
 458         IWL_DEBUG_TE(mvm, "Time event notification - UID = 0x%x action %d\n",
 459                      le32_to_cpu(notif->unique_id),
 460                      le32_to_cpu(notif->action));
 461
 462         spin_lock_bh(&mvm->time_event_lock);
 463         /* This time event is triggered for Aux ROC request */
 464         if (!iwl_mvm_aux_roc_te_handle_notif(mvm, notif))
 465                 goto unlock;
 466
 467         list_for_each_entry_safe(te_data, tmp, &mvm->time_event_list, list) {
 468                 if (le32_to_cpu(notif->unique_id) == te_data->uid)
 469                         iwl_mvm_te_handle_notif(mvm, te_data, notif);
 470         }
 471 unlock:
 472         spin_unlock_bh(&mvm->time_event_lock);
 473 }
 474
 475 static bool iwl_mvm_te_notif(struct iwl_notif_wait_data *notif_wait,
 476                              struct iwl_rx_packet *pkt, void *data)
 477 {
 478         struct iwl_mvm *mvm =
 479                 container_of(notif_wait, struct iwl_mvm, notif_wait);
 480         struct iwl_mvm_time_event_data *te_data = data;
 481         struct iwl_time_event_notif *resp;
 482         int resp_len = iwl_rx_packet_payload_len(pkt);
 483
 484         if (WARN_ON(pkt->hdr.cmd != TIME_EVENT_NOTIFICATION))
 485                 return true;
 486
 487         if (WARN_ON_ONCE(resp_len != sizeof(*resp))) {
 488                 IWL_ERR(mvm, "Invalid TIME_EVENT_NOTIFICATION response\n");
 489                 return true;
 490         }
 491
 492         resp = (void *)pkt->data;
 493
 494         /* te_data->uid is already set in the TIME_EVENT_CMD response */
 495         if (le32_to_cpu(resp->unique_id) != te_data->uid)
 496                 return false;
 497
 498         IWL_DEBUG_TE(mvm, "TIME_EVENT_NOTIFICATION response - UID = 0x%x\n",
 499                      te_data->uid);
 500         if (!resp->status)
 501                 IWL_ERR(mvm,
 502                         "TIME_EVENT_NOTIFICATION received but not executed\n");
 503
 504         return true;
 505 }
 506
 507 static bool iwl_mvm_time_event_response(struct iwl_notif_wait_data *notif_wait,
 508                                         struct iwl_rx_packet *pkt, void *data)
 509 {
 510         struct iwl_mvm *mvm =
 511                 container_of(notif_wait, struct iwl_mvm, notif_wait);
 512         struct iwl_mvm_time_event_data *te_data = data;
 513         struct iwl_time_event_resp *resp;
 514         int resp_len = iwl_rx_packet_payload_len(pkt);
 515
 516         if (WARN_ON(pkt->hdr.cmd != TIME_EVENT_CMD))
 517                 return true;
 518
 519         if (WARN_ON_ONCE(resp_len != sizeof(*resp))) {
 520                 IWL_ERR(mvm, "Invalid TIME_EVENT_CMD response\n");
 521                 return true;
 522         }
 523
 524         resp = (void *)pkt->data;
 525
 526         /* we should never get a response to another TIME_EVENT_CMD here */
 527         if (WARN_ON_ONCE(le32_to_cpu(resp->id) != te_data->id))
 528                 return false;
 529
 530         te_data->uid = le32_to_cpu(resp->unique_id);
 531         IWL_DEBUG_TE(mvm, "TIME_EVENT_CMD response - UID = 0x%x\n",
 532                      te_data->uid);
 533         return true;
 534 }
 535
 536 static int iwl_mvm_time_event_send_add(struct iwl_mvm *mvm,
 537                                        struct ieee80211_vif *vif,
 538                                        struct iwl_mvm_time_event_data *te_data,
 539                                        struct iwl_time_event_cmd *te_cmd)
 540 {
 541         static const u16 time_event_response[] = { TIME_EVENT_CMD };
 542         struct iwl_notification_wait wait_time_event;
 543         int ret;
 544
 545         lockdep_assert_held(&mvm->mutex);
 546
 547         IWL_DEBUG_TE(mvm, "Add new TE, duration %d TU\n",
 548                      le32_to_cpu(te_cmd->duration));
 549
 550         spin_lock_bh(&mvm->time_event_lock);
 551         if (WARN_ON(te_data->id != TE_MAX)) {
 552                 spin_unlock_bh(&mvm->time_event_lock);
 553                 return -EIO;
 554         }
 555         te_data->vif = vif;
 556         te_data->duration = le32_to_cpu(te_cmd->duration);
 557         te_data->id = le32_to_cpu(te_cmd->id);
 558         list_add_tail(&te_data->list, &mvm->time_event_list);
 559         spin_unlock_bh(&mvm->time_event_lock);
 560
 561         /*
 562          * Use a notification wait, which really just processes the
 563          * command response and doesn't wait for anything, in order
 564          * to be able to process the response and get the UID inside
 565          * the RX path. Using CMD_WANT_SKB doesn't work because it
 566          * stores the buffer and then wakes up this thread, by which
 567          * time another notification (that the time event started)
 568          * might already be processed unsuccessfully.
 569          */
 570         iwl_init_notification_wait(&mvm->notif_wait, &wait_time_event,
 571                                    time_event_response,
 572                                    ARRAY_SIZE(time_event_response),
 573                                    iwl_mvm_time_event_response, te_data);
 574
 575         ret = iwl_mvm_send_cmd_pdu(mvm, TIME_EVENT_CMD, 0,
 576                                             sizeof(*te_cmd), te_cmd);
 577         if (ret) {
 578                 IWL_ERR(mvm, "Couldn't send TIME_EVENT_CMD: %d\n", ret);
 579                 iwl_remove_notification(&mvm->notif_wait, &wait_time_event);
 580                 goto out_clear_te;
 581         }
 582
 583         /* No need to wait for anything, so just pass 1 (0 isn't valid) */
 584         ret = iwl_wait_notification(&mvm->notif_wait, &wait_time_event, 1);
 585         /* should never fail */
 586         WARN_ON_ONCE(ret);
 587
 588         if (ret) {
 589  out_clear_te:
 590                 spin_lock_bh(&mvm->time_event_lock);
 591                 iwl_mvm_te_clear_data(mvm, te_data);
 592                 spin_unlock_bh(&mvm->time_event_lock);
 593         }
 594         return ret;
 595 }
 596
 597 void iwl_mvm_protect_session(struct iwl_mvm *mvm,
 598                              struct ieee80211_vif *vif,
 599                              u32 duration, u32 min_duration,
 600                              u32 max_delay, bool wait_for_notif)
 601 {
 602         struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
 603         struct iwl_mvm_time_event_data *te_data = &mvmvif->time_event_data;
 604         const u16 te_notif_response[] = { TIME_EVENT_NOTIFICATION };
 605         struct iwl_notification_wait wait_te_notif;
 606         struct iwl_time_event_cmd time_cmd = {};
 607
 608         lockdep_assert_held(&mvm->mutex);
 609
 610         if (te_data->running &&
 611             time_after(te_data->end_jiffies, TU_TO_EXP_TIME(min_duration))) {
 612                 IWL_DEBUG_TE(mvm, "We have enough time in the current TE: %u\n",
 613                              jiffies_to_msecs(te_data->end_jiffies - jiffies));
 614                 return;
 615         }
 616
 617         if (te_data->running) {
 618                 IWL_DEBUG_TE(mvm, "extend 0x%x: only %u ms left\n",
 619                              te_data->uid,
 620                              jiffies_to_msecs(te_data->end_jiffies - jiffies));
 621                 /*
 622                  * we don't have enough time
 623                  * cancel the current TE and issue a new one
 624                  * Of course it would be better to remove the old one only
 625                  * when the new one is added, but we don't care if we are off
 626                  * channel for a bit. All we need to do, is not to return
 627                  * before we actually begin to be on the channel.
 628                  */
 629                 iwl_mvm_stop_session_protection(mvm, vif);
 630         }
 631
 632         time_cmd.action = cpu_to_le32(FW_CTXT_ACTION_ADD);
 633         time_cmd.id_and_color =
 634                 cpu_to_le32(FW_CMD_ID_AND_COLOR(mvmvif->id, mvmvif->color));
 635         time_cmd.id = cpu_to_le32(TE_BSS_STA_AGGRESSIVE_ASSOC);
 636
 637         time_cmd.apply_time = cpu_to_le32(0);
 638
 639         time_cmd.max_frags = TE_V2_FRAG_NONE;
 640         time_cmd.max_delay = cpu_to_le32(max_delay);
 641         /* TODO: why do we need to interval = bi if it is not periodic? */
 642         time_cmd.interval = cpu_to_le32(1);
 643         time_cmd.duration = cpu_to_le32(duration);
 644         time_cmd.repeat = 1;
 645         time_cmd.policy = cpu_to_le16(TE_V2_NOTIF_HOST_EVENT_START |
 646                                       TE_V2_NOTIF_HOST_EVENT_END |
 647                                       TE_V2_START_IMMEDIATELY);
 648
 649         if (!wait_for_notif) {
 650                 iwl_mvm_time_event_send_add(mvm, vif, te_data, &time_cmd);
 651                 return;
 652         }
 653
 654         /*
 655          * Create notification_wait for the TIME_EVENT_NOTIFICATION to use
 656          * right after we send the time event
 657          */
 658         iwl_init_notification_wait(&mvm->notif_wait, &wait_te_notif,
 659                                    te_notif_response,
 660                                    ARRAY_SIZE(te_notif_response),
 661                                    iwl_mvm_te_notif, te_data);
 662
 663         /* If TE was sent OK - wait for the notification that started */
 664         if (iwl_mvm_time_event_send_add(mvm, vif, te_data, &time_cmd)) {
 665                 IWL_ERR(mvm, "Failed to add TE to protect session\n");
 666                 iwl_remove_notification(&mvm->notif_wait, &wait_te_notif);
 667         } else if (iwl_wait_notification(&mvm->notif_wait, &wait_te_notif,
 668                                          TU_TO_JIFFIES(max_delay))) {
 669                 IWL_ERR(mvm, "Failed to protect session until TE\n");
 670         }
 671 }
 672
 673 /* Determine whether mac or link id should be used, and validate the link id */
 674 static int iwl_mvm_get_session_prot_id(struct iwl_mvm *mvm,
 675                                        struct ieee80211_vif *vif,
 676                                        s8 link_id)
 677 {
 678         struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
 679         int ver = iwl_fw_lookup_cmd_ver(mvm->fw,
 680                                         WIDE_ID(MAC_CONF_GROUP,
 681                                                 SESSION_PROTECTION_CMD), 1);
 682
 683         if (ver < 2)
 684                 return mvmvif->id;
 685
 686         if (WARN(link_id < 0 || !mvmvif->link[link_id],
 687                  "Invalid link ID for session protection: %u\n", link_id))
 688                 return -EINVAL;
 689
 690         if (WARN(!mvmvif->link[link_id]->active,
 691                  "Session Protection on an inactive link: %u\n", link_id))
 692                 return -EINVAL;
 693
 694         return mvmvif->link[link_id]->fw_link_id;
 695 }
 696
 697 static void iwl_mvm_cancel_session_protection(struct iwl_mvm *mvm,
 698                                               struct ieee80211_vif *vif,
 699                                               u32 id, s8 link_id)
 700 {
 701         int mac_link_id = iwl_mvm_get_session_prot_id(mvm, vif, link_id);
 702         struct iwl_mvm_session_prot_cmd cmd = {
 703                 .id_and_color = cpu_to_le32(mac_link_id),
 704                 .action = cpu_to_le32(FW_CTXT_ACTION_REMOVE),
 705                 .conf_id = cpu_to_le32(id),
 706         };
 707         int ret;
 708
 709         if (mac_link_id < 0)
 710                 return;
 711
 712         ret = iwl_mvm_send_cmd_pdu(mvm,
 713                                    WIDE_ID(MAC_CONF_GROUP, SESSION_PROTECTION_CMD),
 714                                    0, sizeof(cmd), &cmd);
 715         if (ret)
 716                 IWL_ERR(mvm,
 717                         "Couldn't send the SESSION_PROTECTION_CMD: %d\n", ret);
 718 }
 719
 720 static bool __iwl_mvm_remove_time_event(struct iwl_mvm *mvm,
 721                                         struct iwl_mvm_time_event_data *te_data,
 722                                         u32 *uid)
 723 {
 724         u32 id;
 725         struct ieee80211_vif *vif = te_data->vif;
 726         struct iwl_mvm_vif *mvmvif;
 727         enum nl80211_iftype iftype;
 728         s8 link_id;
 729
 730         if (!vif)
 731                 return false;
 732
 733         mvmvif = iwl_mvm_vif_from_mac80211(te_data->vif);
 734         iftype = te_data->vif->type;
 735
 736         /*
 737          * It is possible that by the time we got to this point the time
 738          * event was already removed.
 739          */
 740         spin_lock_bh(&mvm->time_event_lock);
 741
 742         /* Save time event uid before clearing its data */
 743         *uid = te_data->uid;
 744         id = te_data->id;
 745         link_id = te_data->link_id;
 746
 747         /*
 748          * The clear_data function handles time events that were already removed
 749          */
 750         iwl_mvm_te_clear_data(mvm, te_data);
 751         spin_unlock_bh(&mvm->time_event_lock);
 752
 753         /* When session protection is used, the te_data->id field
 754          * is reused to save session protection's configuration.
 755          * For AUX ROC, HOT_SPOT_CMD is used and the te_data->id field is set
 756          * to HOT_SPOT_CMD.
 757          */
 758         if (fw_has_capa(&mvm->fw->ucode_capa,
 759                         IWL_UCODE_TLV_CAPA_SESSION_PROT_CMD) &&
 760             id != HOT_SPOT_CMD) {
 761                 if (mvmvif && id < SESSION_PROTECT_CONF_MAX_ID) {
 762                         /* Session protection is still ongoing. Cancel it */
 763                         iwl_mvm_cancel_session_protection(mvm, vif, id,
 764                                                           link_id);
 765                         if (iftype == NL80211_IFTYPE_P2P_DEVICE) {
 766                                 iwl_mvm_roc_finished(mvm);
 767                         }
 768                 }
 769                 return false;
 770         } else {
 771                 /* It is possible that by the time we try to remove it, the
 772                  * time event has already ended and removed. In such a case
 773                  * there is no need to send a removal command.
 774                  */
 775                 if (id == TE_MAX) {
 776                         IWL_DEBUG_TE(mvm, "TE 0x%x has already ended\n", *uid);
 777                         return false;
 778                 }
 779         }
 780
 781         return true;
 782 }
 783
 784 /*
 785  * Explicit request to remove a aux roc time event. The removal of a time
 786  * event needs to be synchronized with the flow of a time event's end
 787  * notification, which also removes the time event from the op mode
 788  * data structures.
 789  */
 790 static void iwl_mvm_remove_aux_roc_te(struct iwl_mvm *mvm,
 791                                       struct iwl_mvm_vif *mvmvif,
 792                                       struct iwl_mvm_time_event_data *te_data)
 793 {
 794         struct iwl_hs20_roc_req aux_cmd = {};
 795         u16 len = sizeof(aux_cmd) - iwl_mvm_chan_info_padding(mvm);
 796
 797         u32 uid;
 798         int ret;
 799
 800         if (!__iwl_mvm_remove_time_event(mvm, te_data, &uid))
 801                 return;
 802
 803         aux_cmd.event_unique_id = cpu_to_le32(uid);
 804         aux_cmd.action = cpu_to_le32(FW_CTXT_ACTION_REMOVE);
 805         aux_cmd.id_and_color =
 806                 cpu_to_le32(FW_CMD_ID_AND_COLOR(mvmvif->id, mvmvif->color));
 807         IWL_DEBUG_TE(mvm, "Removing BSS AUX ROC TE 0x%x\n",
 808                      le32_to_cpu(aux_cmd.event_unique_id));
 809         ret = iwl_mvm_send_cmd_pdu(mvm, HOT_SPOT_CMD, 0,
 810                                    len, &aux_cmd);
 811
 812         if (WARN_ON(ret))
 813                 return;
 814 }
 815
 816 /*
 817  * Explicit request to remove a time event. The removal of a time event needs to
 818  * be synchronized with the flow of a time event's end notification, which also
 819  * removes the time event from the op mode data structures.
 820  */
 821 void iwl_mvm_remove_time_event(struct iwl_mvm *mvm,
 822                                struct iwl_mvm_vif *mvmvif,
 823                                struct iwl_mvm_time_event_data *te_data)
 824 {
 825         struct iwl_time_event_cmd time_cmd = {};
 826         u32 uid;
 827         int ret;
 828
 829         if (!__iwl_mvm_remove_time_event(mvm, te_data, &uid))
 830                 return;
 831
 832         /* When we remove a TE, the UID is to be set in the id field */
 833         time_cmd.id = cpu_to_le32(uid);
 834         time_cmd.action = cpu_to_le32(FW_CTXT_ACTION_REMOVE);
 835         time_cmd.id_and_color =
 836                 cpu_to_le32(FW_CMD_ID_AND_COLOR(mvmvif->id, mvmvif->color));
 837
 838         IWL_DEBUG_TE(mvm, "Removing TE 0x%x\n", le32_to_cpu(time_cmd.id));
 839         ret = iwl_mvm_send_cmd_pdu(mvm, TIME_EVENT_CMD, 0,
 840                                    sizeof(time_cmd), &time_cmd);
 841         if (ret)
 842                 IWL_ERR(mvm, "Couldn't remove the time event\n");
 843 }
 844
 845 void iwl_mvm_stop_session_protection(struct iwl_mvm *mvm,
 846                                      struct ieee80211_vif *vif)
 847 {
 848         struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
 849         struct iwl_mvm_time_event_data *te_data = &mvmvif->time_event_data;
 850         u32 id;
 851
 852         lockdep_assert_held(&mvm->mutex);
 853
 854         spin_lock_bh(&mvm->time_event_lock);
 855         id = te_data->id;
 856         spin_unlock_bh(&mvm->time_event_lock);
 857
 858         if (fw_has_capa(&mvm->fw->ucode_capa,
 859                         IWL_UCODE_TLV_CAPA_SESSION_PROT_CMD)) {
 860                 if (id != SESSION_PROTECT_CONF_ASSOC) {
 861                         IWL_DEBUG_TE(mvm,
 862                                      "don't remove session protection id=%u\n",
 863                                      id);
 864                         return;
 865                 }
 866         } else if (id != TE_BSS_STA_AGGRESSIVE_ASSOC) {
 867                 IWL_DEBUG_TE(mvm,
 868                              "don't remove TE with id=%u (not session protection)\n",
 869                              id);
 870                 return;
 871         }
 872
 873         iwl_mvm_remove_time_event(mvm, mvmvif, te_data);
 874 }
 875
 876 void iwl_mvm_rx_session_protect_notif(struct iwl_mvm *mvm,
 877                                       struct iwl_rx_cmd_buffer *rxb)
 878 {
 879         struct iwl_rx_packet *pkt = rxb_addr(rxb);
 880         struct iwl_mvm_session_prot_notif *notif = (void *)pkt->data;
 881         unsigned int ver =
 882                 iwl_fw_lookup_cmd_ver(mvm->fw,
 883                                       WIDE_ID(MAC_CONF_GROUP,
 884                                               SESSION_PROTECTION_CMD), 2);
 885         int id = le32_to_cpu(notif->mac_link_id);
 886         struct ieee80211_vif *vif;
 887         struct iwl_mvm_vif *mvmvif;
 888         unsigned int notif_link_id;
 889
 890         rcu_read_lock();
 891
 892         if (ver <= 2) {
 893                 vif = iwl_mvm_rcu_dereference_vif_id(mvm, id, true);
 894         } else {
 895                 struct ieee80211_bss_conf *link_conf =
 896                         iwl_mvm_rcu_fw_link_id_to_link_conf(mvm, id, true);
 897
 898                 if (!link_conf)
 899                         goto out_unlock;
 900
 901                 notif_link_id = link_conf->link_id;
 902                 vif = link_conf->vif;
 903         }
 904
 905         if (!vif)
 906                 goto out_unlock;
 907
 908         mvmvif = iwl_mvm_vif_from_mac80211(vif);
 909
 910         if (WARN(ver > 2 && mvmvif->time_event_data.link_id >= 0 &&
 911                  mvmvif->time_event_data.link_id != notif_link_id,
 912                  "SESSION_PROTECTION_NOTIF was received for link %u, while the current time event is on link %u\n",
 913                  notif_link_id, mvmvif->time_event_data.link_id))
 914                 goto out_unlock;
 915
 916         /* The vif is not a P2P_DEVICE, maintain its time_event_data */
 917         if (vif->type != NL80211_IFTYPE_P2P_DEVICE) {
 918                 struct iwl_mvm_time_event_data *te_data =
 919                         &mvmvif->time_event_data;
 920
 921                 if (!le32_to_cpu(notif->status)) {
 922                         iwl_mvm_te_check_disconnect(mvm, vif,
 923                                                     "Session protection failure");
 924                         spin_lock_bh(&mvm->time_event_lock);
 925                         iwl_mvm_te_clear_data(mvm, te_data);
 926                         spin_unlock_bh(&mvm->time_event_lock);
 927                 }
 928
 929                 if (le32_to_cpu(notif->start)) {
 930                         spin_lock_bh(&mvm->time_event_lock);
 931                         te_data->running = le32_to_cpu(notif->start);
 932                         te_data->end_jiffies =
 933                                 TU_TO_EXP_TIME(te_data->duration);
 934                         spin_unlock_bh(&mvm->time_event_lock);
 935                 } else {
 936                         /*
 937                          * By now, we should have finished association
 938                          * and know the dtim period.
 939                          */
 940                         iwl_mvm_te_check_disconnect(mvm, vif,
 941                                                     !vif->cfg.assoc ?
 942                                                     "Not associated and the session protection is over already..." :
 943                                                     "No beacon heard and the session protection is over already...");
 944                         spin_lock_bh(&mvm->time_event_lock);
 945                         iwl_mvm_te_clear_data(mvm, te_data);
 946                         spin_unlock_bh(&mvm->time_event_lock);
 947                 }
 948
 949                 goto out_unlock;
 950         }
 951
 952         if (!le32_to_cpu(notif->status) || !le32_to_cpu(notif->start)) {
 953                 /* End TE, notify mac80211 */
 954                 mvmvif->time_event_data.id = SESSION_PROTECT_CONF_MAX_ID;
 955                 mvmvif->time_event_data.link_id = -1;
 956                 iwl_mvm_roc_finished(mvm);
 957                 ieee80211_remain_on_channel_expired(mvm->hw);
 958         } else if (le32_to_cpu(notif->start)) {
 959                 if (WARN_ON(mvmvif->time_event_data.id !=
 960                                 le32_to_cpu(notif->conf_id)))
 961                         goto out_unlock;
 962                 set_bit(IWL_MVM_STATUS_ROC_RUNNING, &mvm->status);
 963                 ieee80211_ready_on_channel(mvm->hw); /* Start TE */
 964         }
 965
 966  out_unlock:
 967         rcu_read_unlock();
 968 }
 969
 970 #define AUX_ROC_MIN_DURATION MSEC_TO_TU(100)
 971 #define AUX_ROC_MIN_DELAY MSEC_TO_TU(200)
 972 #define AUX_ROC_MAX_DELAY MSEC_TO_TU(600)
 973 #define AUX_ROC_SAFETY_BUFFER MSEC_TO_TU(20)
 974 #define AUX_ROC_MIN_SAFETY_BUFFER MSEC_TO_TU(10)
 975
 976 void iwl_mvm_roc_duration_and_delay(struct ieee80211_vif *vif,
 977                                     u32 duration_ms,
 978                                     u32 *duration_tu,
 979                                     u32 *delay)
 980 {
 981         u32 dtim_interval = vif->bss_conf.dtim_period *
 982                 vif->bss_conf.beacon_int;
 983
 984         *delay = AUX_ROC_MIN_DELAY;
 985         *duration_tu = MSEC_TO_TU(duration_ms);
 986
 987         /*
 988          * If we are associated we want the delay time to be at least one
 989          * dtim interval so that the FW can wait until after the DTIM and
 990          * then start the time event, this will potentially allow us to
 991          * remain off-channel for the max duration.
 992          * Since we want to use almost a whole dtim interval we would also
 993          * like the delay to be for 2-3 dtim intervals, in case there are
 994          * other time events with higher priority.
 995          */
 996         if (vif->cfg.assoc) {
 997                 *delay = min_t(u32, dtim_interval * 3, AUX_ROC_MAX_DELAY);
 998                 /* We cannot remain off-channel longer than the DTIM interval */
 999                 if (dtim_interval <= *duration_tu) {
1000                         *duration_tu = dtim_interval - AUX_ROC_SAFETY_BUFFER;
1001                         if (*duration_tu <= AUX_ROC_MIN_DURATION)
1002                                 *duration_tu = dtim_interval -
1003                                         AUX_ROC_MIN_SAFETY_BUFFER;
1004                 }
1005         }
1006 }
1007
1008 int iwl_mvm_roc_add_cmd(struct iwl_mvm *mvm,
1009                         struct ieee80211_channel *channel,
1010                         struct ieee80211_vif *vif,
1011                         int duration, u32 activity)
1012 {
1013         int res;
1014         u32 duration_tu, delay;
1015         struct iwl_roc_req roc_req = {
1016                 .action = cpu_to_le32(FW_CTXT_ACTION_ADD),
1017                 .activity = cpu_to_le32(activity),
1018                 .sta_id = cpu_to_le32(mvm->aux_sta.sta_id),
1019         };
1020
1021         lockdep_assert_held(&mvm->mutex);
1022
1023         /* Set the channel info data */
1024         iwl_mvm_set_chan_info(mvm, &roc_req.channel_info,
1025                               channel->hw_value,
1026                               iwl_mvm_phy_band_from_nl80211(channel->band),
1027                               IWL_PHY_CHANNEL_MODE20, 0);
1028
1029         iwl_mvm_roc_duration_and_delay(vif, duration, &duration_tu,
1030                                        &delay);
1031         roc_req.duration = cpu_to_le32(duration_tu);
1032         roc_req.max_delay = cpu_to_le32(delay);
1033
1034         IWL_DEBUG_TE(mvm,
1035                      "\t(requested = %ums, max_delay = %ums)\n",
1036                      duration, delay);
1037         IWL_DEBUG_TE(mvm,
1038                      "Requesting to remain on channel %u for %utu\n",
1039                      channel->hw_value, duration_tu);
1040
1041         /* Set the node address */
1042         memcpy(roc_req.node_addr, vif->addr, ETH_ALEN);
1043
1044         res = iwl_mvm_send_cmd_pdu(mvm, WIDE_ID(MAC_CONF_GROUP, ROC_CMD),
1045                                    0, sizeof(roc_req), &roc_req);
1046
1047         return res;
1048 }
1049
1050 static int
1051 iwl_mvm_start_p2p_roc_session_protection(struct iwl_mvm *mvm,
1052                                          struct ieee80211_vif *vif,
1053                                          int duration,
1054                                          enum ieee80211_roc_type type)
1055 {
1056         struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
1057         struct iwl_mvm_session_prot_cmd cmd = {
1058                 .id_and_color =
1059                         cpu_to_le32(iwl_mvm_get_session_prot_id(mvm, vif, 0)),
1060                 .action = cpu_to_le32(FW_CTXT_ACTION_ADD),
1061                 .duration_tu = cpu_to_le32(MSEC_TO_TU(duration)),
1062         };
1063
1064         lockdep_assert_held(&mvm->mutex);
1065
1066         /* The time_event_data.id field is reused to save session
1067          * protection's configuration.
1068          */
1069
1070         mvmvif->time_event_data.link_id = 0;
1071
1072         switch (type) {
1073         case IEEE80211_ROC_TYPE_NORMAL:
1074                 mvmvif->time_event_data.id =
1075                         SESSION_PROTECT_CONF_P2P_DEVICE_DISCOV;
1076                 break;
1077         case IEEE80211_ROC_TYPE_MGMT_TX:
1078                 mvmvif->time_event_data.id =
1079                         SESSION_PROTECT_CONF_P2P_GO_NEGOTIATION;
1080                 break;
1081         default:
1082                 WARN_ONCE(1, "Got an invalid ROC type\n");
1083                 return -EINVAL;
1084         }
1085
1086         cmd.conf_id = cpu_to_le32(mvmvif->time_event_data.id);
1087         return iwl_mvm_send_cmd_pdu(mvm,
1088                                     WIDE_ID(MAC_CONF_GROUP, SESSION_PROTECTION_CMD),
1089                                     0, sizeof(cmd), &cmd);
1090 }
1091
1092 int iwl_mvm_start_p2p_roc(struct iwl_mvm *mvm, struct ieee80211_vif *vif,
1093                           int duration, enum ieee80211_roc_type type)
1094 {
1095         struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
1096         struct iwl_mvm_time_event_data *te_data = &mvmvif->time_event_data;
1097         struct iwl_time_event_cmd time_cmd = {};
1098
1099         lockdep_assert_held(&mvm->mutex);
1100         if (te_data->running) {
1101                 IWL_WARN(mvm, "P2P_DEVICE remain on channel already running\n");
1102                 return -EBUSY;
1103         }
1104
1105         if (fw_has_capa(&mvm->fw->ucode_capa,
1106                         IWL_UCODE_TLV_CAPA_SESSION_PROT_CMD))
1107                 return iwl_mvm_start_p2p_roc_session_protection(mvm, vif,
1108                                                                 duration,
1109                                                                 type);
1110
1111         time_cmd.action = cpu_to_le32(FW_CTXT_ACTION_ADD);
1112         time_cmd.id_and_color =
1113                 cpu_to_le32(FW_CMD_ID_AND_COLOR(mvmvif->id, mvmvif->color));
1114
1115         switch (type) {
1116         case IEEE80211_ROC_TYPE_NORMAL:
1117                 time_cmd.id = cpu_to_le32(IWL_MVM_ROC_TE_TYPE_NORMAL);
1118                 break;
1119         case IEEE80211_ROC_TYPE_MGMT_TX:
1120                 time_cmd.id = cpu_to_le32(IWL_MVM_ROC_TE_TYPE_MGMT_TX);
1121                 break;
1122         default:
1123                 WARN_ONCE(1, "Got an invalid ROC type\n");
1124                 return -EINVAL;
1125         }
1126
1127         time_cmd.apply_time = cpu_to_le32(0);
1128         time_cmd.interval = cpu_to_le32(1);
1129
1130         /*
1131          * The P2P Device TEs can have lower priority than other events
1132          * that are being scheduled by the driver/fw, and thus it might not be
1133          * scheduled. To improve the chances of it being scheduled, allow them
1134          * to be fragmented, and in addition allow them to be delayed.
1135          */
1136         time_cmd.max_frags = min(MSEC_TO_TU(duration)/50, TE_V2_FRAG_ENDLESS);
1137         time_cmd.max_delay = cpu_to_le32(MSEC_TO_TU(duration/2));
1138         time_cmd.duration = cpu_to_le32(MSEC_TO_TU(duration));
1139         time_cmd.repeat = 1;
1140         time_cmd.policy = cpu_to_le16(TE_V2_NOTIF_HOST_EVENT_START |
1141                                       TE_V2_NOTIF_HOST_EVENT_END |
1142                                       TE_V2_START_IMMEDIATELY);
1143
1144         return iwl_mvm_time_event_send_add(mvm, vif, te_data, &time_cmd);
1145 }
1146
1147 static struct iwl_mvm_time_event_data *iwl_mvm_get_roc_te(struct iwl_mvm *mvm)
1148 {
1149         struct iwl_mvm_time_event_data *te_data;
1150
1151         lockdep_assert_held(&mvm->mutex);
1152
1153         spin_lock_bh(&mvm->time_event_lock);
1154
1155         /*
1156          * Iterate over the list of time events and find the time event that is
1157          * associated with a P2P_DEVICE interface.
1158          * This assumes that a P2P_DEVICE interface can have only a single time
1159          * event at any given time and this time event coresponds to a ROC
1160          * request
1161          */
1162         list_for_each_entry(te_data, &mvm->time_event_list, list) {
1163                 if (te_data->vif->type == NL80211_IFTYPE_P2P_DEVICE)
1164                         goto out;
1165         }
1166
1167         /* There can only be at most one AUX ROC time event, we just use the
1168          * list to simplify/unify code. Remove it if it exists.
1169          */
1170         te_data = list_first_entry_or_null(&mvm->aux_roc_te_list,
1171                                            struct iwl_mvm_time_event_data,
1172                                            list);
1173 out:
1174         spin_unlock_bh(&mvm->time_event_lock);
1175         return te_data;
1176 }
1177
1178 void iwl_mvm_cleanup_roc_te(struct iwl_mvm *mvm)
1179 {
1180         struct iwl_mvm_time_event_data *te_data;
1181         u32 uid;
1182
1183         te_data = iwl_mvm_get_roc_te(mvm);
1184         if (te_data)
1185                 __iwl_mvm_remove_time_event(mvm, te_data, &uid);
1186 }
1187
1188 static void iwl_mvm_roc_rm_cmd(struct iwl_mvm *mvm, u32 activity)
1189 {
1190         int ret;
1191         struct iwl_roc_req roc_cmd = {
1192                 .action = cpu_to_le32(FW_CTXT_ACTION_REMOVE),
1193                 .activity = cpu_to_le32(activity),
1194         };
1195
1196         lockdep_assert_held(&mvm->mutex);
1197         ret = iwl_mvm_send_cmd_pdu(mvm,
1198                                    WIDE_ID(MAC_CONF_GROUP, ROC_CMD),
1199                                    0, sizeof(roc_cmd), &roc_cmd);
1200         WARN_ON(ret);
1201 }
1202
1203 static void iwl_mvm_roc_station_remove(struct iwl_mvm *mvm,
1204                                        struct iwl_mvm_vif *mvmvif)
1205 {
1206         u32 cmd_id = WIDE_ID(MAC_CONF_GROUP, ROC_CMD);
1207         u8 fw_ver = iwl_fw_lookup_cmd_ver(mvm->fw, cmd_id,
1208                                           IWL_FW_CMD_VER_UNKNOWN);
1209
1210         if (fw_ver == IWL_FW_CMD_VER_UNKNOWN)
1211                 iwl_mvm_remove_aux_roc_te(mvm, mvmvif,
1212                                           &mvmvif->hs_time_event_data);
1213         else if (fw_ver == 3)
1214                 iwl_mvm_roc_rm_cmd(mvm, ROC_ACTIVITY_HOTSPOT);
1215         else
1216                 IWL_ERR(mvm, "ROC command version %d mismatch!\n", fw_ver);
1217 }
1218
1219 void iwl_mvm_stop_roc(struct iwl_mvm *mvm, struct ieee80211_vif *vif)
1220 {
1221         struct iwl_mvm_vif *mvmvif;
1222         struct iwl_mvm_time_event_data *te_data;
1223
1224         if (fw_has_capa(&mvm->fw->ucode_capa,
1225                         IWL_UCODE_TLV_CAPA_SESSION_PROT_CMD)) {
1226                 mvmvif = iwl_mvm_vif_from_mac80211(vif);
1227                 te_data = &mvmvif->time_event_data;
1228
1229                 if (vif->type == NL80211_IFTYPE_P2P_DEVICE) {
1230                         if (te_data->id >= SESSION_PROTECT_CONF_MAX_ID) {
1231                                 IWL_DEBUG_TE(mvm,
1232                                              "No remain on channel event\n");
1233                                 return;
1234                         }
1235
1236                         iwl_mvm_cancel_session_protection(mvm, vif,
1237                                                           te_data->id,
1238                                                           te_data->link_id);
1239                 } else {
1240                         iwl_mvm_roc_station_remove(mvm, mvmvif);
1241                 }
1242                 goto cleanup_roc;
1243         }
1244
1245         te_data = iwl_mvm_get_roc_te(mvm);
1246         if (!te_data) {
1247                 IWL_WARN(mvm, "No remain on channel event\n");
1248                 return;
1249         }
1250
1251         mvmvif = iwl_mvm_vif_from_mac80211(te_data->vif);
1252
1253         if (te_data->vif->type == NL80211_IFTYPE_P2P_DEVICE)
1254                 iwl_mvm_remove_time_event(mvm, mvmvif, te_data);
1255         else
1256                 iwl_mvm_remove_aux_roc_te(mvm, mvmvif, te_data);
1257
1258 cleanup_roc:
1259         /*
1260          * In case we get here before the ROC event started,
1261          * (so the status bit isn't set) set it here so iwl_mvm_cleanup_roc will
1262          * cleanup things properly
1263          */
1264         set_bit(vif->type == NL80211_IFTYPE_P2P_DEVICE ?
1265                 IWL_MVM_STATUS_ROC_RUNNING : IWL_MVM_STATUS_ROC_AUX_RUNNING,
1266                 &mvm->status);
1267         iwl_mvm_cleanup_roc(mvm);
1268 }
1269
1270 void iwl_mvm_remove_csa_period(struct iwl_mvm *mvm,
1271                                struct ieee80211_vif *vif)
1272 {
1273         struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
1274         struct iwl_mvm_time_event_data *te_data = &mvmvif->time_event_data;
1275         u32 id;
1276
1277         lockdep_assert_held(&mvm->mutex);
1278
1279         spin_lock_bh(&mvm->time_event_lock);
1280         id = te_data->id;
1281         spin_unlock_bh(&mvm->time_event_lock);
1282
1283         if (id != TE_CHANNEL_SWITCH_PERIOD)
1284                 return;
1285
1286         iwl_mvm_remove_time_event(mvm, mvmvif, te_data);
1287 }
1288
1289 int iwl_mvm_schedule_csa_period(struct iwl_mvm *mvm,
1290                                 struct ieee80211_vif *vif,
1291                                 u32 duration, u32 apply_time)
1292 {
1293         struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
1294         struct iwl_mvm_time_event_data *te_data = &mvmvif->time_event_data;
1295         struct iwl_time_event_cmd time_cmd = {};
1296
1297         lockdep_assert_held(&mvm->mutex);
1298
1299         if (te_data->running) {
1300                 u32 id;
1301
1302                 spin_lock_bh(&mvm->time_event_lock);
1303                 id = te_data->id;
1304                 spin_unlock_bh(&mvm->time_event_lock);
1305
1306                 if (id == TE_CHANNEL_SWITCH_PERIOD) {
1307                         IWL_DEBUG_TE(mvm, "CS period is already scheduled\n");
1308                         return -EBUSY;
1309                 }
1310
1311                 /*
1312                  * Remove the session protection time event to allow the
1313                  * channel switch. If we got here, we just heard a beacon so
1314                  * the session protection is not needed anymore anyway.
1315                  */
1316                 iwl_mvm_remove_time_event(mvm, mvmvif, te_data);
1317         }
1318
1319         time_cmd.action = cpu_to_le32(FW_CTXT_ACTION_ADD);
1320         time_cmd.id_and_color =
1321                 cpu_to_le32(FW_CMD_ID_AND_COLOR(mvmvif->id, mvmvif->color));
1322         time_cmd.id = cpu_to_le32(TE_CHANNEL_SWITCH_PERIOD);
1323         time_cmd.apply_time = cpu_to_le32(apply_time);
1324         time_cmd.max_frags = TE_V2_FRAG_NONE;
1325         time_cmd.duration = cpu_to_le32(duration);
1326         time_cmd.repeat = 1;
1327         time_cmd.interval = cpu_to_le32(1);
1328         time_cmd.policy = cpu_to_le16(TE_V2_NOTIF_HOST_EVENT_START |
1329                                       TE_V2_ABSENCE);
1330         if (!apply_time)
1331                 time_cmd.policy |= cpu_to_le16(TE_V2_START_IMMEDIATELY);
1332
1333         return iwl_mvm_time_event_send_add(mvm, vif, te_data, &time_cmd);
1334 }
1335
1336 static bool iwl_mvm_session_prot_notif(struct iwl_notif_wait_data *notif_wait,
1337                                        struct iwl_rx_packet *pkt, void *data)
1338 {
1339         struct iwl_mvm *mvm =
1340                 container_of(notif_wait, struct iwl_mvm, notif_wait);
1341         struct iwl_mvm_session_prot_notif *resp;
1342         int resp_len = iwl_rx_packet_payload_len(pkt);
1343
1344         if (WARN_ON(pkt->hdr.cmd != SESSION_PROTECTION_NOTIF ||
1345                     pkt->hdr.group_id != MAC_CONF_GROUP))
1346                 return true;
1347
1348         if (WARN_ON_ONCE(resp_len != sizeof(*resp))) {
1349                 IWL_ERR(mvm, "Invalid SESSION_PROTECTION_NOTIF response\n");
1350                 return true;
1351         }
1352
1353         resp = (void *)pkt->data;
1354
1355         if (!resp->status)
1356                 IWL_ERR(mvm,
1357                         "TIME_EVENT_NOTIFICATION received but not executed\n");
1358
1359         return true;
1360 }
1361
1362 void iwl_mvm_schedule_session_protection(struct iwl_mvm *mvm,
1363                                          struct ieee80211_vif *vif,
1364                                          u32 duration, u32 min_duration,
1365                                          bool wait_for_notif,
1366                                          unsigned int link_id)
1367 {
1368         struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
1369         struct iwl_mvm_time_event_data *te_data = &mvmvif->time_event_data;
1370         const u16 notif[] = { WIDE_ID(MAC_CONF_GROUP, SESSION_PROTECTION_NOTIF) };
1371         struct iwl_notification_wait wait_notif;
1372         int mac_link_id = iwl_mvm_get_session_prot_id(mvm, vif, (s8)link_id);
1373         struct iwl_mvm_session_prot_cmd cmd = {
1374                 .id_and_color = cpu_to_le32(mac_link_id),
1375                 .action = cpu_to_le32(FW_CTXT_ACTION_ADD),
1376                 .conf_id = cpu_to_le32(SESSION_PROTECT_CONF_ASSOC),
1377                 .duration_tu = cpu_to_le32(MSEC_TO_TU(duration)),
1378         };
1379
1380         if (mac_link_id < 0)
1381                 return;
1382
1383         lockdep_assert_held(&mvm->mutex);
1384
1385         spin_lock_bh(&mvm->time_event_lock);
1386         if (te_data->running && te_data->link_id == link_id &&
1387             time_after(te_data->end_jiffies, TU_TO_EXP_TIME(min_duration))) {
1388                 IWL_DEBUG_TE(mvm, "We have enough time in the current TE: %u\n",
1389                              jiffies_to_msecs(te_data->end_jiffies - jiffies));
1390                 spin_unlock_bh(&mvm->time_event_lock);
1391
1392                 return;
1393         }
1394
1395         iwl_mvm_te_clear_data(mvm, te_data);
1396         /*
1397          * The time_event_data.id field is reused to save session
1398          * protection's configuration.
1399          */
1400         te_data->id = le32_to_cpu(cmd.conf_id);
1401         te_data->duration = le32_to_cpu(cmd.duration_tu);
1402         te_data->vif = vif;
1403         te_data->link_id = link_id;
1404         spin_unlock_bh(&mvm->time_event_lock);
1405
1406         IWL_DEBUG_TE(mvm, "Add new session protection, duration %d TU\n",
1407                      le32_to_cpu(cmd.duration_tu));
1408
1409         if (!wait_for_notif) {
1410                 if (iwl_mvm_send_cmd_pdu(mvm,
1411                                          WIDE_ID(MAC_CONF_GROUP, SESSION_PROTECTION_CMD),
1412                                          0, sizeof(cmd), &cmd)) {
1413                         goto send_cmd_err;
1414                 }
1415
1416                 return;
1417         }
1418
1419         iwl_init_notification_wait(&mvm->notif_wait, &wait_notif,
1420                                    notif, ARRAY_SIZE(notif),
1421                                    iwl_mvm_session_prot_notif, NULL);
1422
1423         if (iwl_mvm_send_cmd_pdu(mvm,
1424                                  WIDE_ID(MAC_CONF_GROUP, SESSION_PROTECTION_CMD),
1425                                  0, sizeof(cmd), &cmd)) {
1426                 iwl_remove_notification(&mvm->notif_wait, &wait_notif);
1427                 goto send_cmd_err;
1428         } else if (iwl_wait_notification(&mvm->notif_wait, &wait_notif,
1429                                          TU_TO_JIFFIES(100))) {
1430                 IWL_ERR(mvm,
1431                         "Failed to protect session until session protection\n");
1432         }
1433         return;
1434
1435 send_cmd_err:
1436         IWL_ERR(mvm,
1437                 "Couldn't send the SESSION_PROTECTION_CMD\n");
1438         spin_lock_bh(&mvm->time_event_lock);
1439         iwl_mvm_te_clear_data(mvm, te_data);
1440         spin_unlock_bh(&mvm->time_event_lock);
1441 }