drivers/net/wireless/intel/iwlwifi/mvm/coex.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) 2013 - 2014 Intel Corporation. All rights reserved.
   9  * Copyright(c) 2013 - 2015 Intel Mobile Communications 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  * The full GNU General Public License is included in this distribution
  21  * in the file called COPYING.
  22  *
  23  * Contact Information:
  24  *  Intel Linux Wireless <linuxwifi@intel.com>
  25  * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
  26  *
  27  * BSD LICENSE
  28  *
  29  * Copyright(c) 2013 - 2014 Intel Corporation. All rights reserved.
  30  * Copyright(c) 2013 - 2015 Intel Mobile Communications GmbH
  31  * All rights reserved.
  32  *
  33  * Redistribution and use in source and binary forms, with or without
  34  * modification, are permitted provided that the following conditions
  35  * are met:
  36  *
  37  *  * Redistributions of source code must retain the above copyright
  38  *    notice, this list of conditions and the following disclaimer.
  39  *  * Redistributions in binary form must reproduce the above copyright
  40  *    notice, this list of conditions and the following disclaimer in
  41  *    the documentation and/or other materials provided with the
  42  *    distribution.
  43  *  * Neither the name Intel Corporation nor the names of its
  44  *    contributors may be used to endorse or promote products derived
  45  *    from this software without specific prior written permission.
  46  *
  47  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  48  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  49  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  50  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  51  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  52  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  53  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  54  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  55  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  56  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  57  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  58  *
  59  *****************************************************************************/
  60
  61 #include <linux/ieee80211.h>
  62 #include <linux/etherdevice.h>
  63 #include <net/mac80211.h>
  64
  65 #include "fw/api/coex.h"
  66 #include "iwl-modparams.h"
  67 #include "mvm.h"
  68 #include "iwl-debug.h"
  69
  70 /* 20MHz / 40MHz below / 40Mhz above*/
  71 static const __le64 iwl_ci_mask[][3] = {
  72         /* dummy entry for channel 0 */
  73         {cpu_to_le64(0), cpu_to_le64(0), cpu_to_le64(0)},
  74         {
  75                 cpu_to_le64(0x0000001FFFULL),
  76                 cpu_to_le64(0x0ULL),
  77                 cpu_to_le64(0x00007FFFFFULL),
  78         },
  79         {
  80                 cpu_to_le64(0x000000FFFFULL),
  81                 cpu_to_le64(0x0ULL),
  82                 cpu_to_le64(0x0003FFFFFFULL),
  83         },
  84         {
  85                 cpu_to_le64(0x000003FFFCULL),
  86                 cpu_to_le64(0x0ULL),
  87                 cpu_to_le64(0x000FFFFFFCULL),
  88         },
  89         {
  90                 cpu_to_le64(0x00001FFFE0ULL),
  91                 cpu_to_le64(0x0ULL),
  92                 cpu_to_le64(0x007FFFFFE0ULL),
  93         },
  94         {
  95                 cpu_to_le64(0x00007FFF80ULL),
  96                 cpu_to_le64(0x00007FFFFFULL),
  97                 cpu_to_le64(0x01FFFFFF80ULL),
  98         },
  99         {
 100                 cpu_to_le64(0x0003FFFC00ULL),
 101                 cpu_to_le64(0x0003FFFFFFULL),
 102                 cpu_to_le64(0x0FFFFFFC00ULL),
 103         },
 104         {
 105                 cpu_to_le64(0x000FFFF000ULL),
 106                 cpu_to_le64(0x000FFFFFFCULL),
 107                 cpu_to_le64(0x3FFFFFF000ULL),
 108         },
 109         {
 110                 cpu_to_le64(0x007FFF8000ULL),
 111                 cpu_to_le64(0x007FFFFFE0ULL),
 112                 cpu_to_le64(0xFFFFFF8000ULL),
 113         },
 114         {
 115                 cpu_to_le64(0x01FFFE0000ULL),
 116                 cpu_to_le64(0x01FFFFFF80ULL),
 117                 cpu_to_le64(0xFFFFFE0000ULL),
 118         },
 119         {
 120                 cpu_to_le64(0x0FFFF00000ULL),
 121                 cpu_to_le64(0x0FFFFFFC00ULL),
 122                 cpu_to_le64(0x0ULL),
 123         },
 124         {
 125                 cpu_to_le64(0x3FFFC00000ULL),
 126                 cpu_to_le64(0x3FFFFFF000ULL),
 127                 cpu_to_le64(0x0)
 128         },
 129         {
 130                 cpu_to_le64(0xFFFE000000ULL),
 131                 cpu_to_le64(0xFFFFFF8000ULL),
 132                 cpu_to_le64(0x0)
 133         },
 134         {
 135                 cpu_to_le64(0xFFF8000000ULL),
 136                 cpu_to_le64(0xFFFFFE0000ULL),
 137                 cpu_to_le64(0x0)
 138         },
 139         {
 140                 cpu_to_le64(0xFE00000000ULL),
 141                 cpu_to_le64(0x0ULL),
 142                 cpu_to_le64(0x0ULL)
 143         },
 144 };
 145
 146 static enum iwl_bt_coex_lut_type
 147 iwl_get_coex_type(struct iwl_mvm *mvm, const struct ieee80211_vif *vif)
 148 {
 149         struct ieee80211_chanctx_conf *chanctx_conf;
 150         enum iwl_bt_coex_lut_type ret;
 151         u16 phy_ctx_id;
 152         u32 primary_ch_phy_id, secondary_ch_phy_id;
 153
 154         /*
 155          * Checking that we hold mvm->mutex is a good idea, but the rate
 156          * control can't acquire the mutex since it runs in Tx path.
 157          * So this is racy in that case, but in the worst case, the AMPDU
 158          * size limit will be wrong for a short time which is not a big
 159          * issue.
 160          */
 161
 162         rcu_read_lock();
 163
 164         chanctx_conf = rcu_dereference(vif->chanctx_conf);
 165
 166         if (!chanctx_conf ||
 167              chanctx_conf->def.chan->band != NL80211_BAND_2GHZ) {
 168                 rcu_read_unlock();
 169                 return BT_COEX_INVALID_LUT;
 170         }
 171
 172         ret = BT_COEX_TX_DIS_LUT;
 173
 174         if (mvm->cfg->bt_shared_single_ant) {
 175                 rcu_read_unlock();
 176                 return ret;
 177         }
 178
 179         phy_ctx_id = *((u16 *)chanctx_conf->drv_priv);
 180         primary_ch_phy_id = le32_to_cpu(mvm->last_bt_ci_cmd.primary_ch_phy_id);
 181         secondary_ch_phy_id =
 182                 le32_to_cpu(mvm->last_bt_ci_cmd.secondary_ch_phy_id);
 183
 184         if (primary_ch_phy_id == phy_ctx_id)
 185                 ret = le32_to_cpu(mvm->last_bt_notif.primary_ch_lut);
 186         else if (secondary_ch_phy_id == phy_ctx_id)
 187                 ret = le32_to_cpu(mvm->last_bt_notif.secondary_ch_lut);
 188         /* else - default = TX TX disallowed */
 189
 190         rcu_read_unlock();
 191
 192         return ret;
 193 }
 194
 195 int iwl_mvm_send_bt_init_conf(struct iwl_mvm *mvm)
 196 {
 197         struct iwl_bt_coex_cmd bt_cmd = {};
 198         u32 mode;
 199
 200         lockdep_assert_held(&mvm->mutex);
 201
 202         if (unlikely(mvm->bt_force_ant_mode != BT_FORCE_ANT_DIS)) {
 203                 switch (mvm->bt_force_ant_mode) {
 204                 case BT_FORCE_ANT_BT:
 205                         mode = BT_COEX_BT;
 206                         break;
 207                 case BT_FORCE_ANT_WIFI:
 208                         mode = BT_COEX_WIFI;
 209                         break;
 210                 default:
 211                         WARN_ON(1);
 212                         mode = 0;
 213                 }
 214
 215                 bt_cmd.mode = cpu_to_le32(mode);
 216                 goto send_cmd;
 217         }
 218
 219         mode = iwlwifi_mod_params.bt_coex_active ? BT_COEX_NW : BT_COEX_DISABLE;
 220         bt_cmd.mode = cpu_to_le32(mode);
 221
 222         if (IWL_MVM_BT_COEX_SYNC2SCO)
 223                 bt_cmd.enabled_modules |=
 224                         cpu_to_le32(BT_COEX_SYNC2SCO_ENABLED);
 225
 226         if (iwl_mvm_is_mplut_supported(mvm))
 227                 bt_cmd.enabled_modules |= cpu_to_le32(BT_COEX_MPLUT_ENABLED);
 228
 229         bt_cmd.enabled_modules |= cpu_to_le32(BT_COEX_HIGH_BAND_RET);
 230
 231 send_cmd:
 232         memset(&mvm->last_bt_notif, 0, sizeof(mvm->last_bt_notif));
 233         memset(&mvm->last_bt_ci_cmd, 0, sizeof(mvm->last_bt_ci_cmd));
 234
 235         return iwl_mvm_send_cmd_pdu(mvm, BT_CONFIG, 0, sizeof(bt_cmd), &bt_cmd);
 236 }
 237
 238 static int iwl_mvm_bt_coex_reduced_txp(struct iwl_mvm *mvm, u8 sta_id,
 239                                        bool enable)
 240 {
 241         struct iwl_bt_coex_reduced_txp_update_cmd cmd = {};
 242         struct iwl_mvm_sta *mvmsta;
 243         u32 value;
 244         int ret;
 245
 246         mvmsta = iwl_mvm_sta_from_staid_protected(mvm, sta_id);
 247         if (!mvmsta)
 248                 return 0;
 249
 250         /* nothing to do */
 251         if (mvmsta->bt_reduced_txpower == enable)
 252                 return 0;
 253
 254         value = mvmsta->sta_id;
 255
 256         if (enable)
 257                 value |= BT_REDUCED_TX_POWER_BIT;
 258
 259         IWL_DEBUG_COEX(mvm, "%sable reduced Tx Power for sta %d\n",
 260                        enable ? "en" : "dis", sta_id);
 261
 262         cmd.reduced_txp = cpu_to_le32(value);
 263         mvmsta->bt_reduced_txpower = enable;
 264
 265         ret = iwl_mvm_send_cmd_pdu(mvm, BT_COEX_UPDATE_REDUCED_TXP, CMD_ASYNC,
 266                                    sizeof(cmd), &cmd);
 267
 268         return ret;
 269 }
 270
 271 struct iwl_bt_iterator_data {
 272         struct iwl_bt_coex_profile_notif *notif;
 273         struct iwl_mvm *mvm;
 274         struct ieee80211_chanctx_conf *primary;
 275         struct ieee80211_chanctx_conf *secondary;
 276         bool primary_ll;
 277         u8 primary_load;
 278         u8 secondary_load;
 279 };
 280
 281 static inline
 282 void iwl_mvm_bt_coex_enable_rssi_event(struct iwl_mvm *mvm,
 283                                        struct ieee80211_vif *vif,
 284                                        bool enable, int rssi)
 285 {
 286         struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
 287
 288         mvmvif->bf_data.last_bt_coex_event = rssi;
 289         mvmvif->bf_data.bt_coex_max_thold =
 290                 enable ? -IWL_MVM_BT_COEX_EN_RED_TXP_THRESH : 0;
 291         mvmvif->bf_data.bt_coex_min_thold =
 292                 enable ? -IWL_MVM_BT_COEX_DIS_RED_TXP_THRESH : 0;
 293 }
 294
 295 #define MVM_COEX_TCM_PERIOD (HZ * 10)
 296
 297 static void iwl_mvm_bt_coex_tcm_based_ci(struct iwl_mvm *mvm,
 298                                          struct iwl_bt_iterator_data *data)
 299 {
 300         unsigned long now = jiffies;
 301
 302         if (!time_after(now, mvm->bt_coex_last_tcm_ts + MVM_COEX_TCM_PERIOD))
 303                 return;
 304
 305         mvm->bt_coex_last_tcm_ts = now;
 306
 307         /* We assume here that we don't have more than 2 vifs on 2.4GHz */
 308
 309         /* if the primary is low latency, it will stay primary */
 310         if (data->primary_ll)
 311                 return;
 312
 313         if (data->primary_load >= data->secondary_load)
 314                 return;
 315
 316         swap(data->primary, data->secondary);
 317 }
 318
 319 /* must be called under rcu_read_lock */
 320 static void iwl_mvm_bt_notif_iterator(void *_data, u8 *mac,
 321                                       struct ieee80211_vif *vif)
 322 {
 323         struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
 324         struct iwl_bt_iterator_data *data = _data;
 325         struct iwl_mvm *mvm = data->mvm;
 326         struct ieee80211_chanctx_conf *chanctx_conf;
 327         /* default smps_mode is AUTOMATIC - only used for client modes */
 328         enum ieee80211_smps_mode smps_mode = IEEE80211_SMPS_AUTOMATIC;
 329         u32 bt_activity_grading, min_ag_for_static_smps;
 330         int ave_rssi;
 331
 332         lockdep_assert_held(&mvm->mutex);
 333
 334         switch (vif->type) {
 335         case NL80211_IFTYPE_STATION:
 336                 break;
 337         case NL80211_IFTYPE_AP:
 338                 if (!mvmvif->ap_ibss_active)
 339                         return;
 340                 break;
 341         default:
 342                 return;
 343         }
 344
 345         chanctx_conf = rcu_dereference(vif->chanctx_conf);
 346
 347         /* If channel context is invalid or not on 2.4GHz .. */
 348         if ((!chanctx_conf ||
 349              chanctx_conf->def.chan->band != NL80211_BAND_2GHZ)) {
 350                 if (vif->type == NL80211_IFTYPE_STATION) {
 351                         /* ... relax constraints and disable rssi events */
 352                         iwl_mvm_update_smps(mvm, vif, IWL_MVM_SMPS_REQ_BT_COEX,
 353                                             smps_mode);
 354                         iwl_mvm_bt_coex_reduced_txp(mvm, mvmvif->ap_sta_id,
 355                                                     false);
 356                         iwl_mvm_bt_coex_enable_rssi_event(mvm, vif, false, 0);
 357                 }
 358                 return;
 359         }
 360
 361         if (fw_has_capa(&mvm->fw->ucode_capa, IWL_UCODE_TLV_CAPA_COEX_SCHEMA_2))
 362                 min_ag_for_static_smps = BT_VERY_HIGH_TRAFFIC;
 363         else
 364                 min_ag_for_static_smps = BT_HIGH_TRAFFIC;
 365
 366         bt_activity_grading = le32_to_cpu(data->notif->bt_activity_grading);
 367         if (bt_activity_grading >= min_ag_for_static_smps)
 368                 smps_mode = IEEE80211_SMPS_STATIC;
 369         else if (bt_activity_grading >= BT_LOW_TRAFFIC)
 370                 smps_mode = IEEE80211_SMPS_DYNAMIC;
 371
 372         /* relax SMPS constraints for next association */
 373         if (!vif->bss_conf.assoc)
 374                 smps_mode = IEEE80211_SMPS_AUTOMATIC;
 375
 376         if (mvmvif->phy_ctxt &&
 377             (mvm->last_bt_notif.rrc_status & BIT(mvmvif->phy_ctxt->id)))
 378                 smps_mode = IEEE80211_SMPS_AUTOMATIC;
 379
 380         IWL_DEBUG_COEX(data->mvm,
 381                        "mac %d: bt_activity_grading %d smps_req %d\n",
 382                        mvmvif->id, bt_activity_grading, smps_mode);
 383
 384         if (vif->type == NL80211_IFTYPE_STATION)
 385                 iwl_mvm_update_smps(mvm, vif, IWL_MVM_SMPS_REQ_BT_COEX,
 386                                     smps_mode);
 387
 388         /* low latency is always primary */
 389         if (iwl_mvm_vif_low_latency(mvmvif)) {
 390                 data->primary_ll = true;
 391
 392                 data->secondary = data->primary;
 393                 data->primary = chanctx_conf;
 394         }
 395
 396         if (vif->type == NL80211_IFTYPE_AP) {
 397                 if (!mvmvif->ap_ibss_active)
 398                         return;
 399
 400                 if (chanctx_conf == data->primary)
 401                         return;
 402
 403                 if (!data->primary_ll) {
 404                         /*
 405                          * downgrade the current primary no matter what its
 406                          * type is.
 407                          */
 408                         data->secondary = data->primary;
 409                         data->primary = chanctx_conf;
 410                 } else {
 411                         /* there is low latency vif - we will be secondary */
 412                         data->secondary = chanctx_conf;
 413                 }
 414
 415                 if (data->primary == chanctx_conf)
 416                         data->primary_load = mvm->tcm.result.load[mvmvif->id];
 417                 else if (data->secondary == chanctx_conf)
 418                         data->secondary_load = mvm->tcm.result.load[mvmvif->id];
 419                 return;
 420         }
 421
 422         /*
 423          * STA / P2P Client, try to be primary if first vif. If we are in low
 424          * latency mode, we are already in primary and just don't do much
 425          */
 426         if (!data->primary || data->primary == chanctx_conf)
 427                 data->primary = chanctx_conf;
 428         else if (!data->secondary)
 429                 /* if secondary is not NULL, it might be a GO */
 430                 data->secondary = chanctx_conf;
 431
 432         if (data->primary == chanctx_conf)
 433                 data->primary_load = mvm->tcm.result.load[mvmvif->id];
 434         else if (data->secondary == chanctx_conf)
 435                 data->secondary_load = mvm->tcm.result.load[mvmvif->id];
 436         /*
 437          * don't reduce the Tx power if one of these is true:
 438          *  we are in LOOSE
 439          *  single share antenna product
 440          *  BT is inactive
 441          *  we are not associated
 442          */
 443         if (iwl_get_coex_type(mvm, vif) == BT_COEX_LOOSE_LUT ||
 444             mvm->cfg->bt_shared_single_ant || !vif->bss_conf.assoc ||
 445             le32_to_cpu(mvm->last_bt_notif.bt_activity_grading) == BT_OFF) {
 446                 iwl_mvm_bt_coex_reduced_txp(mvm, mvmvif->ap_sta_id, false);
 447                 iwl_mvm_bt_coex_enable_rssi_event(mvm, vif, false, 0);
 448                 return;
 449         }
 450
 451         /* try to get the avg rssi from fw */
 452         ave_rssi = mvmvif->bf_data.ave_beacon_signal;
 453
 454         /* if the RSSI isn't valid, fake it is very low */
 455         if (!ave_rssi)
 456                 ave_rssi = -100;
 457         if (ave_rssi > -IWL_MVM_BT_COEX_EN_RED_TXP_THRESH) {
 458                 if (iwl_mvm_bt_coex_reduced_txp(mvm, mvmvif->ap_sta_id, true))
 459                         IWL_ERR(mvm, "Couldn't send BT_CONFIG cmd\n");
 460         } else if (ave_rssi < -IWL_MVM_BT_COEX_DIS_RED_TXP_THRESH) {
 461                 if (iwl_mvm_bt_coex_reduced_txp(mvm, mvmvif->ap_sta_id, false))
 462                         IWL_ERR(mvm, "Couldn't send BT_CONFIG cmd\n");
 463         }
 464
 465         /* Begin to monitor the RSSI: it may influence the reduced Tx power */
 466         iwl_mvm_bt_coex_enable_rssi_event(mvm, vif, true, ave_rssi);
 467 }
 468
 469 static void iwl_mvm_bt_coex_notif_handle(struct iwl_mvm *mvm)
 470 {
 471         struct iwl_bt_iterator_data data = {
 472                 .mvm = mvm,
 473                 .notif = &mvm->last_bt_notif,
 474         };
 475         struct iwl_bt_coex_ci_cmd cmd = {};
 476         u8 ci_bw_idx;
 477
 478         /* Ignore updates if we are in force mode */
 479         if (unlikely(mvm->bt_force_ant_mode != BT_FORCE_ANT_DIS))
 480                 return;
 481
 482         rcu_read_lock();
 483         ieee80211_iterate_active_interfaces_atomic(
 484                                         mvm->hw, IEEE80211_IFACE_ITER_NORMAL,
 485                                         iwl_mvm_bt_notif_iterator, &data);
 486
 487         iwl_mvm_bt_coex_tcm_based_ci(mvm, &data);
 488
 489         if (data.primary) {
 490                 struct ieee80211_chanctx_conf *chan = data.primary;
 491                 if (WARN_ON(!chan->def.chan)) {
 492                         rcu_read_unlock();
 493                         return;
 494                 }
 495
 496                 if (chan->def.width < NL80211_CHAN_WIDTH_40) {
 497                         ci_bw_idx = 0;
 498                 } else {
 499                         if (chan->def.center_freq1 >
 500                             chan->def.chan->center_freq)
 501                                 ci_bw_idx = 2;
 502                         else
 503                                 ci_bw_idx = 1;
 504                 }
 505
 506                 cmd.bt_primary_ci =
 507                         iwl_ci_mask[chan->def.chan->hw_value][ci_bw_idx];
 508                 cmd.primary_ch_phy_id =
 509                         cpu_to_le32(*((u16 *)data.primary->drv_priv));
 510         }
 511
 512         if (data.secondary) {
 513                 struct ieee80211_chanctx_conf *chan = data.secondary;
 514                 if (WARN_ON(!data.secondary->def.chan)) {
 515                         rcu_read_unlock();
 516                         return;
 517                 }
 518
 519                 if (chan->def.width < NL80211_CHAN_WIDTH_40) {
 520                         ci_bw_idx = 0;
 521                 } else {
 522                         if (chan->def.center_freq1 >
 523                             chan->def.chan->center_freq)
 524                                 ci_bw_idx = 2;
 525                         else
 526                                 ci_bw_idx = 1;
 527                 }
 528
 529                 cmd.bt_secondary_ci =
 530                         iwl_ci_mask[chan->def.chan->hw_value][ci_bw_idx];
 531                 cmd.secondary_ch_phy_id =
 532                         cpu_to_le32(*((u16 *)data.secondary->drv_priv));
 533         }
 534
 535         rcu_read_unlock();
 536
 537         /* Don't spam the fw with the same command over and over */
 538         if (memcmp(&cmd, &mvm->last_bt_ci_cmd, sizeof(cmd))) {
 539                 if (iwl_mvm_send_cmd_pdu(mvm, BT_COEX_CI, 0,
 540                                          sizeof(cmd), &cmd))
 541                         IWL_ERR(mvm, "Failed to send BT_CI cmd\n");
 542                 memcpy(&mvm->last_bt_ci_cmd, &cmd, sizeof(cmd));
 543         }
 544 }
 545
 546 void iwl_mvm_rx_bt_coex_notif(struct iwl_mvm *mvm,
 547                               struct iwl_rx_cmd_buffer *rxb)
 548 {
 549         struct iwl_rx_packet *pkt = rxb_addr(rxb);
 550         struct iwl_bt_coex_profile_notif *notif = (void *)pkt->data;
 551
 552         IWL_DEBUG_COEX(mvm, "BT Coex Notification received\n");
 553         IWL_DEBUG_COEX(mvm, "\tBT ci compliance %d\n", notif->bt_ci_compliance);
 554         IWL_DEBUG_COEX(mvm, "\tBT primary_ch_lut %d\n",
 555                        le32_to_cpu(notif->primary_ch_lut));
 556         IWL_DEBUG_COEX(mvm, "\tBT secondary_ch_lut %d\n",
 557                        le32_to_cpu(notif->secondary_ch_lut));
 558         IWL_DEBUG_COEX(mvm, "\tBT activity grading %d\n",
 559                        le32_to_cpu(notif->bt_activity_grading));
 560
 561         /* remember this notification for future use: rssi fluctuations */
 562         memcpy(&mvm->last_bt_notif, notif, sizeof(mvm->last_bt_notif));
 563
 564         iwl_mvm_bt_coex_notif_handle(mvm);
 565 }
 566
 567 void iwl_mvm_bt_rssi_event(struct iwl_mvm *mvm, struct ieee80211_vif *vif,
 568                            enum ieee80211_rssi_event_data rssi_event)
 569 {
 570         struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
 571         int ret;
 572
 573         lockdep_assert_held(&mvm->mutex);
 574
 575         /* Ignore updates if we are in force mode */
 576         if (unlikely(mvm->bt_force_ant_mode != BT_FORCE_ANT_DIS))
 577                 return;
 578
 579         /*
 580          * Rssi update while not associated - can happen since the statistics
 581          * are handled asynchronously
 582          */
 583         if (mvmvif->ap_sta_id == IWL_MVM_INVALID_STA)
 584                 return;
 585
 586         /* No BT - reports should be disabled */
 587         if (le32_to_cpu(mvm->last_bt_notif.bt_activity_grading) == BT_OFF)
 588                 return;
 589
 590         IWL_DEBUG_COEX(mvm, "RSSI for %pM is now %s\n", vif->bss_conf.bssid,
 591                        rssi_event == RSSI_EVENT_HIGH ? "HIGH" : "LOW");
 592
 593         /*
 594          * Check if rssi is good enough for reduced Tx power, but not in loose
 595          * scheme.
 596          */
 597         if (rssi_event == RSSI_EVENT_LOW || mvm->cfg->bt_shared_single_ant ||
 598             iwl_get_coex_type(mvm, vif) == BT_COEX_LOOSE_LUT)
 599                 ret = iwl_mvm_bt_coex_reduced_txp(mvm, mvmvif->ap_sta_id,
 600                                                   false);
 601         else
 602                 ret = iwl_mvm_bt_coex_reduced_txp(mvm, mvmvif->ap_sta_id, true);
 603
 604         if (ret)
 605                 IWL_ERR(mvm, "couldn't send BT_CONFIG HCMD upon RSSI event\n");
 606 }
 607
 608 #define LINK_QUAL_AGG_TIME_LIMIT_DEF    (4000)
 609 #define LINK_QUAL_AGG_TIME_LIMIT_BT_ACT (1200)
 610
 611 u16 iwl_mvm_coex_agg_time_limit(struct iwl_mvm *mvm,
 612                                 struct ieee80211_sta *sta)
 613 {
 614         struct iwl_mvm_sta *mvmsta = iwl_mvm_sta_from_mac80211(sta);
 615         struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(mvmsta->vif);
 616         struct iwl_mvm_phy_ctxt *phy_ctxt = mvmvif->phy_ctxt;
 617         enum iwl_bt_coex_lut_type lut_type;
 618
 619         if (mvm->last_bt_notif.ttc_status & BIT(phy_ctxt->id))
 620                 return LINK_QUAL_AGG_TIME_LIMIT_DEF;
 621
 622         if (le32_to_cpu(mvm->last_bt_notif.bt_activity_grading) <
 623             BT_HIGH_TRAFFIC)
 624                 return LINK_QUAL_AGG_TIME_LIMIT_DEF;
 625
 626         lut_type = iwl_get_coex_type(mvm, mvmsta->vif);
 627
 628         if (lut_type == BT_COEX_LOOSE_LUT || lut_type == BT_COEX_INVALID_LUT)
 629                 return LINK_QUAL_AGG_TIME_LIMIT_DEF;
 630
 631         /* tight coex, high bt traffic, reduce AGG time limit */
 632         return LINK_QUAL_AGG_TIME_LIMIT_BT_ACT;
 633 }
 634
 635 bool iwl_mvm_bt_coex_is_mimo_allowed(struct iwl_mvm *mvm,
 636                                      struct ieee80211_sta *sta)
 637 {
 638         struct iwl_mvm_sta *mvmsta = iwl_mvm_sta_from_mac80211(sta);
 639         struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(mvmsta->vif);
 640         struct iwl_mvm_phy_ctxt *phy_ctxt = mvmvif->phy_ctxt;
 641         enum iwl_bt_coex_lut_type lut_type;
 642
 643         if (mvm->last_bt_notif.ttc_status & BIT(phy_ctxt->id))
 644                 return true;
 645
 646         if (le32_to_cpu(mvm->last_bt_notif.bt_activity_grading) <
 647             BT_HIGH_TRAFFIC)
 648                 return true;
 649
 650         /*
 651          * In Tight / TxTxDis, BT can't Rx while we Tx, so use both antennas
 652          * since BT is already killed.
 653          * In Loose, BT can Rx while we Tx, so forbid MIMO to let BT Rx while
 654          * we Tx.
 655          * When we are in 5GHz, we'll get BT_COEX_INVALID_LUT allowing MIMO.
 656          */
 657         lut_type = iwl_get_coex_type(mvm, mvmsta->vif);
 658         return lut_type != BT_COEX_LOOSE_LUT;
 659 }
 660
 661 bool iwl_mvm_bt_coex_is_ant_avail(struct iwl_mvm *mvm, u8 ant)
 662 {
 663         /* there is no other antenna, shared antenna is always available */
 664         if (mvm->cfg->bt_shared_single_ant)
 665                 return true;
 666
 667         if (ant & mvm->cfg->non_shared_ant)
 668                 return true;
 669
 670         return le32_to_cpu(mvm->last_bt_notif.bt_activity_grading) <
 671                 BT_HIGH_TRAFFIC;
 672 }
 673
 674 bool iwl_mvm_bt_coex_is_shared_ant_avail(struct iwl_mvm *mvm)
 675 {
 676         /* there is no other antenna, shared antenna is always available */
 677         if (mvm->cfg->bt_shared_single_ant)
 678                 return true;
 679
 680         return le32_to_cpu(mvm->last_bt_notif.bt_activity_grading) < BT_HIGH_TRAFFIC;
 681 }
 682
 683 bool iwl_mvm_bt_coex_is_tpc_allowed(struct iwl_mvm *mvm,
 684                                     enum nl80211_band band)
 685 {
 686         u32 bt_activity = le32_to_cpu(mvm->last_bt_notif.bt_activity_grading);
 687
 688         if (band != NL80211_BAND_2GHZ)
 689                 return false;
 690
 691         return bt_activity >= BT_LOW_TRAFFIC;
 692 }
 693
 694 u8 iwl_mvm_bt_coex_get_single_ant_msk(struct iwl_mvm *mvm, u8 enabled_ants)
 695 {
 696         if (fw_has_capa(&mvm->fw->ucode_capa, IWL_UCODE_TLV_CAPA_COEX_SCHEMA_2) &&
 697             (mvm->cfg->non_shared_ant & enabled_ants))
 698                 return mvm->cfg->non_shared_ant;
 699
 700         return first_antenna(enabled_ants);
 701 }
 702
 703 u8 iwl_mvm_bt_coex_tx_prio(struct iwl_mvm *mvm, struct ieee80211_hdr *hdr,
 704                            struct ieee80211_tx_info *info, u8 ac)
 705 {
 706         __le16 fc = hdr->frame_control;
 707         bool mplut_enabled = iwl_mvm_is_mplut_supported(mvm);
 708
 709         if (info->band != NL80211_BAND_2GHZ)
 710                 return 0;
 711
 712         if (unlikely(mvm->bt_tx_prio))
 713                 return mvm->bt_tx_prio - 1;
 714
 715         if (likely(ieee80211_is_data(fc))) {
 716                 if (likely(ieee80211_is_data_qos(fc))) {
 717                         switch (ac) {
 718                         case IEEE80211_AC_BE:
 719                                 return mplut_enabled ? 1 : 0;
 720                         case IEEE80211_AC_VI:
 721                                 return mplut_enabled ? 2 : 3;
 722                         case IEEE80211_AC_VO:
 723                                 return 3;
 724                         default:
 725                                 return 0;
 726                         }
 727                 } else if (is_multicast_ether_addr(hdr->addr1)) {
 728                         return 3;
 729                 } else
 730                         return 0;
 731         } else if (ieee80211_is_mgmt(fc)) {
 732                 return ieee80211_is_disassoc(fc) ? 0 : 3;
 733         } else if (ieee80211_is_ctl(fc)) {
 734                 /* ignore cfend and cfendack frames as we never send those */
 735                 return 3;
 736         }
 737
 738         return 0;
 739 }
 740
 741 void iwl_mvm_bt_coex_vif_change(struct iwl_mvm *mvm)
 742 {
 743         iwl_mvm_bt_coex_notif_handle(mvm);
 744 }