drivers/net/wireless/iwlwifi/mvm/bt-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 Intel Corporation. All rights reserved.
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of version 2 of the GNU General Public License as
  12  * published by the Free Software Foundation.
  13  *
  14  * This program is distributed in the hope that it will be useful, but
  15  * WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110,
  22  * USA
  23  *
  24  * The full GNU General Public License is included in this distribution
  25  * in the file called COPYING.
  26  *
  27  * Contact Information:
  28  *  Intel Linux Wireless <ilw@linux.intel.com>
  29  * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
  30  *
  31  * BSD LICENSE
  32  *
  33  * Copyright(c) 2013 Intel Corporation. All rights reserved.
  34  * All rights reserved.
  35  *
  36  * Redistribution and use in source and binary forms, with or without
  37  * modification, are permitted provided that the following conditions
  38  * are met:
  39  *
  40  *  * Redistributions of source code must retain the above copyright
  41  *    notice, this list of conditions and the following disclaimer.
  42  *  * Redistributions in binary form must reproduce the above copyright
  43  *    notice, this list of conditions and the following disclaimer in
  44  *    the documentation and/or other materials provided with the
  45  *    distribution.
  46  *  * Neither the name Intel Corporation nor the names of its
  47  *    contributors may be used to endorse or promote products derived
  48  *    from this software without specific prior written permission.
  49  *
  50  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  51  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  52  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  53  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  54  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  55  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  56  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  57  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  58  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  59  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  60  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  61  *
  62  *****************************************************************************/
  63
  64 #include <net/mac80211.h>
  65
  66 #include "fw-api-bt-coex.h"
  67 #include "iwl-modparams.h"
  68 #include "mvm.h"
  69 #include "iwl-debug.h"
  70
  71 #define EVENT_PRIO_ANT(_evt, _prio, _shrd_ant)                  \
  72         [(_evt)] = (((_prio) << BT_COEX_PRIO_TBL_PRIO_POS) |    \
  73                    ((_shrd_ant) << BT_COEX_PRIO_TBL_SHRD_ANT_POS))
  74
  75 static const u8 iwl_bt_prio_tbl[BT_COEX_PRIO_TBL_EVT_MAX] = {
  76         EVENT_PRIO_ANT(BT_COEX_PRIO_TBL_EVT_INIT_CALIB1,
  77                        BT_COEX_PRIO_TBL_PRIO_BYPASS, 0),
  78         EVENT_PRIO_ANT(BT_COEX_PRIO_TBL_EVT_INIT_CALIB2,
  79                        BT_COEX_PRIO_TBL_PRIO_BYPASS, 1),
  80         EVENT_PRIO_ANT(BT_COEX_PRIO_TBL_EVT_PERIODIC_CALIB_LOW1,
  81                        BT_COEX_PRIO_TBL_PRIO_LOW, 0),
  82         EVENT_PRIO_ANT(BT_COEX_PRIO_TBL_EVT_PERIODIC_CALIB_LOW2,
  83                        BT_COEX_PRIO_TBL_PRIO_LOW, 1),
  84         EVENT_PRIO_ANT(BT_COEX_PRIO_TBL_EVT_PERIODIC_CALIB_HIGH1,
  85                        BT_COEX_PRIO_TBL_PRIO_HIGH, 0),
  86         EVENT_PRIO_ANT(BT_COEX_PRIO_TBL_EVT_PERIODIC_CALIB_HIGH2,
  87                        BT_COEX_PRIO_TBL_PRIO_HIGH, 1),
  88         EVENT_PRIO_ANT(BT_COEX_PRIO_TBL_EVT_DTIM,
  89                        BT_COEX_PRIO_TBL_DISABLED, 0),
  90         EVENT_PRIO_ANT(BT_COEX_PRIO_TBL_EVT_SCAN52,
  91                        BT_COEX_PRIO_TBL_PRIO_COEX_OFF, 0),
  92         EVENT_PRIO_ANT(BT_COEX_PRIO_TBL_EVT_SCAN24,
  93                        BT_COEX_PRIO_TBL_PRIO_COEX_ON, 0),
  94         EVENT_PRIO_ANT(BT_COEX_PRIO_TBL_EVT_IDLE,
  95                        BT_COEX_PRIO_TBL_PRIO_COEX_IDLE, 0),
  96         0, 0, 0, 0, 0, 0,
  97 };
  98
  99 #undef EVENT_PRIO_ANT
 100
 101 /* BT Antenna Coupling Threshold (dB) */
 102 #define IWL_BT_ANTENNA_COUPLING_THRESHOLD       (35)
 103 #define IWL_BT_LOAD_FORCE_SISO_THRESHOLD        (3)
 104
 105 #define BT_ENABLE_REDUCED_TXPOWER_THRESHOLD     (-62)
 106 #define BT_DISABLE_REDUCED_TXPOWER_THRESHOLD    (-65)
 107 #define BT_REDUCED_TX_POWER_BIT                 BIT(7)
 108
 109 static inline bool is_loose_coex(void)
 110 {
 111         return iwlwifi_mod_params.ant_coupling >
 112                 IWL_BT_ANTENNA_COUPLING_THRESHOLD;
 113 }
 114
 115 int iwl_send_bt_prio_tbl(struct iwl_mvm *mvm)
 116 {
 117         return iwl_mvm_send_cmd_pdu(mvm, BT_COEX_PRIO_TABLE, CMD_SYNC,
 118                                     sizeof(struct iwl_bt_coex_prio_tbl_cmd),
 119                                     &iwl_bt_prio_tbl);
 120 }
 121
 122 static int iwl_send_bt_env(struct iwl_mvm *mvm, u8 action, u8 type)
 123 {
 124         struct iwl_bt_coex_prot_env_cmd env_cmd;
 125         int ret;
 126
 127         env_cmd.action = action;
 128         env_cmd.type = type;
 129         ret = iwl_mvm_send_cmd_pdu(mvm, BT_COEX_PROT_ENV, CMD_SYNC,
 130                                    sizeof(env_cmd), &env_cmd);
 131         if (ret)
 132                 IWL_ERR(mvm, "failed to send BT env command\n");
 133         return ret;
 134 }
 135
 136 enum iwl_bt_kill_msk {
 137         BT_KILL_MSK_DEFAULT,
 138         BT_KILL_MSK_SCO_HID_A2DP,
 139         BT_KILL_MSK_REDUCED_TXPOW,
 140         BT_KILL_MSK_MAX,
 141 };
 142
 143 static const u32 iwl_bt_ack_kill_msk[BT_KILL_MSK_MAX] = {
 144         [BT_KILL_MSK_DEFAULT] = 0xffff0000,
 145         [BT_KILL_MSK_SCO_HID_A2DP] = 0xffffffff,
 146         [BT_KILL_MSK_REDUCED_TXPOW] = 0,
 147 };
 148
 149 static const u32 iwl_bt_cts_kill_msk[BT_KILL_MSK_MAX] = {
 150         [BT_KILL_MSK_DEFAULT] = 0xffff0000,
 151         [BT_KILL_MSK_SCO_HID_A2DP] = 0xffffffff,
 152         [BT_KILL_MSK_REDUCED_TXPOW] = 0,
 153 };
 154
 155 #define IWL_BT_DEFAULT_BOOST (0xf0f0f0f0)
 156
 157 /* Tight Coex */
 158 static const __le32 iwl_tight_lookup[BT_COEX_LUT_SIZE] = {
 159         cpu_to_le32(0xaaaaaaaa),
 160         cpu_to_le32(0xaaaaaaaa),
 161         cpu_to_le32(0xaeaaaaaa),
 162         cpu_to_le32(0xaaaaaaaa),
 163         cpu_to_le32(0xcc00ff28),
 164         cpu_to_le32(0x0000aaaa),
 165         cpu_to_le32(0xcc00aaaa),
 166         cpu_to_le32(0x0000aaaa),
 167         cpu_to_le32(0xc0004000),
 168         cpu_to_le32(0x00000000),
 169         cpu_to_le32(0xf0005000),
 170         cpu_to_le32(0xf0005000),
 171 };
 172
 173 /* Loose Coex */
 174 static const __le32 iwl_loose_lookup[BT_COEX_LUT_SIZE] = {
 175         cpu_to_le32(0xaaaaaaaa),
 176         cpu_to_le32(0xaaaaaaaa),
 177         cpu_to_le32(0xaaaaaaaa),
 178         cpu_to_le32(0xaaaaaaaa),
 179         cpu_to_le32(0xcc00ff28),
 180         cpu_to_le32(0x0000aaaa),
 181         cpu_to_le32(0xcc00aaaa),
 182         cpu_to_le32(0x0000aaaa),
 183         cpu_to_le32(0x00000000),
 184         cpu_to_le32(0x00000000),
 185         cpu_to_le32(0xf0005000),
 186         cpu_to_le32(0xf0005000),
 187 };
 188
 189 /* Full concurrency */
 190 static const __le32 iwl_concurrent_lookup[BT_COEX_LUT_SIZE] = {
 191         cpu_to_le32(0xaaaaaaaa),
 192         cpu_to_le32(0xaaaaaaaa),
 193         cpu_to_le32(0xaaaaaaaa),
 194         cpu_to_le32(0xaaaaaaaa),
 195         cpu_to_le32(0xaaaaaaaa),
 196         cpu_to_le32(0xaaaaaaaa),
 197         cpu_to_le32(0xaaaaaaaa),
 198         cpu_to_le32(0xaaaaaaaa),
 199         cpu_to_le32(0x00000000),
 200         cpu_to_le32(0x00000000),
 201         cpu_to_le32(0x00000000),
 202         cpu_to_le32(0x00000000),
 203 };
 204
 205 /* single shared antenna */
 206 static const __le32 iwl_single_shared_ant_lookup[BT_COEX_LUT_SIZE] = {
 207         cpu_to_le32(0x40000000),
 208         cpu_to_le32(0x00000000),
 209         cpu_to_le32(0x44000000),
 210         cpu_to_le32(0x00000000),
 211         cpu_to_le32(0x40000000),
 212         cpu_to_le32(0x00000000),
 213         cpu_to_le32(0x44000000),
 214         cpu_to_le32(0x00000000),
 215         cpu_to_le32(0xC0004000),
 216         cpu_to_le32(0xF0005000),
 217         cpu_to_le32(0xC0004000),
 218         cpu_to_le32(0xF0005000),
 219 };
 220
 221 int iwl_send_bt_init_conf(struct iwl_mvm *mvm)
 222 {
 223         struct iwl_bt_coex_cmd *bt_cmd;
 224         struct iwl_host_cmd cmd = {
 225                 .id = BT_CONFIG,
 226                 .len = { sizeof(*bt_cmd), },
 227                 .dataflags = { IWL_HCMD_DFL_NOCOPY, },
 228                 .flags = CMD_SYNC,
 229         };
 230         int ret;
 231
 232         /* go to CALIB state in internal BT-Coex state machine */
 233         ret = iwl_send_bt_env(mvm, BT_COEX_ENV_OPEN,
 234                               BT_COEX_PRIO_TBL_EVT_INIT_CALIB2);
 235         if (ret)
 236                 return ret;
 237
 238         ret  = iwl_send_bt_env(mvm, BT_COEX_ENV_CLOSE,
 239                                BT_COEX_PRIO_TBL_EVT_INIT_CALIB2);
 240         if (ret)
 241                 return ret;
 242
 243         bt_cmd = kzalloc(sizeof(*bt_cmd), GFP_KERNEL);
 244         if (!bt_cmd)
 245                 return -ENOMEM;
 246         cmd.data[0] = bt_cmd;
 247
 248         bt_cmd->max_kill = 5;
 249         bt_cmd->bt3_time_t7_value = 1;
 250         bt_cmd->bt3_prio_sample_time = 2;
 251         bt_cmd->bt3_timer_t2_value = 0xc;
 252
 253         bt_cmd->flags = iwlwifi_mod_params.bt_coex_active ?
 254                         BT_COEX_NW : BT_COEX_DISABLE;
 255         bt_cmd->flags |= BT_CH_PRIMARY_EN | BT_SYNC_2_BT_DISABLE;
 256
 257         bt_cmd->valid_bit_msk = cpu_to_le16(BT_VALID_ENABLE |
 258                                             BT_VALID_BT_PRIO_BOOST |
 259                                             BT_VALID_MAX_KILL |
 260                                             BT_VALID_3W_TMRS |
 261                                             BT_VALID_KILL_ACK |
 262                                             BT_VALID_KILL_CTS |
 263                                             BT_VALID_REDUCED_TX_POWER |
 264                                             BT_VALID_LUT);
 265
 266         if (mvm->cfg->bt_shared_single_ant)
 267                 memcpy(&bt_cmd->decision_lut, iwl_single_shared_ant_lookup,
 268                        sizeof(iwl_single_shared_ant_lookup));
 269         else if (is_loose_coex())
 270                 memcpy(&bt_cmd->decision_lut, iwl_loose_lookup,
 271                        sizeof(iwl_tight_lookup));
 272         else
 273                 memcpy(&bt_cmd->decision_lut, iwl_tight_lookup,
 274                        sizeof(iwl_tight_lookup));
 275
 276         bt_cmd->bt_prio_boost = cpu_to_le32(IWL_BT_DEFAULT_BOOST);
 277         bt_cmd->kill_ack_msk =
 278                 cpu_to_le32(iwl_bt_ack_kill_msk[BT_KILL_MSK_DEFAULT]);
 279         bt_cmd->kill_cts_msk =
 280                 cpu_to_le32(iwl_bt_cts_kill_msk[BT_KILL_MSK_DEFAULT]);
 281
 282         memset(&mvm->last_bt_notif, 0, sizeof(mvm->last_bt_notif));
 283
 284         ret = iwl_mvm_send_cmd(mvm, &cmd);
 285
 286         kfree(bt_cmd);
 287         return ret;
 288 }
 289
 290 static int iwl_mvm_bt_udpate_ctrl_kill_msk(struct iwl_mvm *mvm,
 291                                            bool reduced_tx_power)
 292 {
 293         enum iwl_bt_kill_msk bt_kill_msk;
 294         struct iwl_bt_coex_cmd *bt_cmd;
 295         struct iwl_bt_coex_profile_notif *notif = &mvm->last_bt_notif;
 296         struct iwl_host_cmd cmd = {
 297                 .id = BT_CONFIG,
 298                 .data[0] = &bt_cmd,
 299                 .len = { sizeof(*bt_cmd), },
 300                 .dataflags = { IWL_HCMD_DFL_NOCOPY, },
 301                 .flags = CMD_SYNC,
 302         };
 303         int ret = 0;
 304
 305         lockdep_assert_held(&mvm->mutex);
 306
 307         if (reduced_tx_power) {
 308                 /* Reduced Tx power has precedence on the type of the profile */
 309                 bt_kill_msk = BT_KILL_MSK_REDUCED_TXPOW;
 310         } else {
 311                 /* Low latency BT profile is active: give higher prio to BT */
 312                 if (BT_MBOX_MSG(notif, 3, SCO_STATE)  ||
 313                     BT_MBOX_MSG(notif, 3, A2DP_STATE) ||
 314                     BT_MBOX_MSG(notif, 3, SNIFF_STATE))
 315                         bt_kill_msk = BT_KILL_MSK_SCO_HID_A2DP;
 316                 else
 317                         bt_kill_msk = BT_KILL_MSK_DEFAULT;
 318         }
 319
 320         IWL_DEBUG_COEX(mvm,
 321                        "Update kill_msk: %d - SCO %sactive A2DP %sactive SNIFF %sactive\n",
 322                        bt_kill_msk,
 323                        BT_MBOX_MSG(notif, 3, SCO_STATE) ? "" : "in",
 324                        BT_MBOX_MSG(notif, 3, A2DP_STATE) ? "" : "in",
 325                        BT_MBOX_MSG(notif, 3, SNIFF_STATE) ? "" : "in");
 326
 327         /* Don't send HCMD if there is no update */
 328         if (bt_kill_msk == mvm->bt_kill_msk)
 329                 return 0;
 330
 331         mvm->bt_kill_msk = bt_kill_msk;
 332
 333         bt_cmd = kzalloc(sizeof(*bt_cmd), GFP_KERNEL);
 334         if (!bt_cmd)
 335                 return -ENOMEM;
 336         cmd.data[0] = bt_cmd;
 337
 338         bt_cmd->kill_ack_msk = cpu_to_le32(iwl_bt_ack_kill_msk[bt_kill_msk]);
 339         bt_cmd->kill_cts_msk = cpu_to_le32(iwl_bt_cts_kill_msk[bt_kill_msk]);
 340         bt_cmd->valid_bit_msk =
 341                 cpu_to_le16(BT_VALID_KILL_ACK | BT_VALID_KILL_CTS);
 342
 343         IWL_DEBUG_COEX(mvm, "bt_kill_msk = %d\n", bt_kill_msk);
 344
 345         ret = iwl_mvm_send_cmd(mvm, &cmd);
 346
 347         kfree(bt_cmd);
 348         return ret;
 349 }
 350
 351 static int iwl_mvm_bt_coex_reduced_txp(struct iwl_mvm *mvm, u8 sta_id,
 352                                        bool enable)
 353 {
 354         struct iwl_bt_coex_cmd *bt_cmd;
 355         /* Send ASYNC since this can be sent from an atomic context */
 356         struct iwl_host_cmd cmd = {
 357                 .id = BT_CONFIG,
 358                 .len = { sizeof(*bt_cmd), },
 359                 .dataflags = { IWL_HCMD_DFL_DUP, },
 360                 .flags = CMD_ASYNC,
 361         };
 362
 363         struct ieee80211_sta *sta;
 364         struct iwl_mvm_sta *mvmsta;
 365         int ret;
 366
 367         /* This can happen if the station has been removed right now */
 368         if (sta_id == IWL_MVM_STATION_COUNT)
 369                 return 0;
 370
 371         sta = rcu_dereference_protected(mvm->fw_id_to_mac_id[sta_id],
 372                                         lockdep_is_held(&mvm->mutex));
 373         mvmsta = (void *)sta->drv_priv;
 374
 375         /* nothing to do */
 376         if (mvmsta->bt_reduced_txpower == enable)
 377                 return 0;
 378
 379         bt_cmd = kzalloc(sizeof(*bt_cmd), GFP_ATOMIC);
 380         if (!bt_cmd)
 381                 return -ENOMEM;
 382         cmd.data[0] = bt_cmd;
 383
 384         bt_cmd->valid_bit_msk = cpu_to_le16(BT_VALID_REDUCED_TX_POWER),
 385         bt_cmd->bt_reduced_tx_power = sta_id;
 386
 387         if (enable)
 388                 bt_cmd->bt_reduced_tx_power |= BT_REDUCED_TX_POWER_BIT;
 389
 390         IWL_DEBUG_COEX(mvm, "%sable reduced Tx Power for sta %d\n",
 391                        enable ? "en" : "dis", sta_id);
 392
 393         mvmsta->bt_reduced_txpower = enable;
 394
 395         ret = iwl_mvm_send_cmd(mvm, &cmd);
 396
 397         kfree(bt_cmd);
 398         return ret;
 399 }
 400
 401 struct iwl_bt_iterator_data {
 402         struct iwl_bt_coex_profile_notif *notif;
 403         struct iwl_mvm *mvm;
 404         u32 num_bss_ifaces;
 405         bool reduced_tx_power;
 406 };
 407
 408 static void iwl_mvm_bt_notif_iterator(void *_data, u8 *mac,
 409                                       struct ieee80211_vif *vif)
 410 {
 411         struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
 412         struct iwl_bt_iterator_data *data = _data;
 413         struct iwl_mvm *mvm = data->mvm;
 414         struct ieee80211_chanctx_conf *chanctx_conf;
 415         enum ieee80211_smps_mode smps_mode;
 416         enum ieee80211_band band;
 417         int ave_rssi;
 418
 419         lockdep_assert_held(&mvm->mutex);
 420         if (vif->type != NL80211_IFTYPE_STATION)
 421                 return;
 422
 423         rcu_read_lock();
 424         chanctx_conf = rcu_dereference(vif->chanctx_conf);
 425         if (chanctx_conf && chanctx_conf->def.chan)
 426                 band = chanctx_conf->def.chan->band;
 427         else
 428                 band = -1;
 429         rcu_read_unlock();
 430
 431         smps_mode = IEEE80211_SMPS_AUTOMATIC;
 432
 433         /* non associated BSSes aren't to be considered */
 434         if (!vif->bss_conf.assoc)
 435                 return;
 436
 437         if (band != IEEE80211_BAND_2GHZ) {
 438                 iwl_mvm_update_smps(mvm, vif, IWL_MVM_SMPS_REQ_BT_COEX,
 439                                     smps_mode);
 440                 return;
 441         }
 442
 443         if (data->notif->bt_status)
 444                 smps_mode = IEEE80211_SMPS_DYNAMIC;
 445
 446         if (data->notif->bt_traffic_load >= IWL_BT_LOAD_FORCE_SISO_THRESHOLD)
 447                 smps_mode = IEEE80211_SMPS_STATIC;
 448
 449         IWL_DEBUG_COEX(data->mvm,
 450                        "mac %d: bt_status %d traffic_load %d smps_req %d\n",
 451                        mvmvif->id,  data->notif->bt_status,
 452                        data->notif->bt_traffic_load, smps_mode);
 453
 454         iwl_mvm_update_smps(mvm, vif, IWL_MVM_SMPS_REQ_BT_COEX, smps_mode);
 455
 456         /* don't reduce the Tx power if in loose scheme */
 457         if (is_loose_coex())
 458                 return;
 459
 460         data->num_bss_ifaces++;
 461
 462         /* reduced Txpower only if there are open BT connections, so ...*/
 463         if (!BT_MBOX_MSG(data->notif, 3, OPEN_CON_2)) {
 464                 /* ... cancel reduced Tx power ... */
 465                 if (iwl_mvm_bt_coex_reduced_txp(mvm, mvmvif->ap_sta_id, false))
 466                         IWL_ERR(mvm, "Couldn't send BT_CONFIG cmd\n");
 467                 data->reduced_tx_power = false;
 468
 469                 /* ... and there is no need to get reports on RSSI any more. */
 470                 ieee80211_disable_rssi_reports(vif);
 471                 return;
 472         }
 473
 474         ave_rssi = ieee80211_ave_rssi(vif);
 475
 476         /* if the RSSI isn't valid, fake it is very low */
 477         if (!ave_rssi)
 478                 ave_rssi = -100;
 479         if (ave_rssi > BT_ENABLE_REDUCED_TXPOWER_THRESHOLD) {
 480                 if (iwl_mvm_bt_coex_reduced_txp(mvm, mvmvif->ap_sta_id, true))
 481                         IWL_ERR(mvm, "Couldn't send BT_CONFIG cmd\n");
 482
 483                 /*
 484                  * bt_kill_msk can be BT_KILL_MSK_REDUCED_TXPOW only if all the
 485                  * BSS / P2P clients have rssi above threshold.
 486                  * We set the bt_kill_msk to BT_KILL_MSK_REDUCED_TXPOW before
 487                  * the iteration, if one interface's rssi isn't good enough,
 488                  * bt_kill_msk will be set to default values.
 489                  */
 490         } else if (ave_rssi < BT_DISABLE_REDUCED_TXPOWER_THRESHOLD) {
 491                 if (iwl_mvm_bt_coex_reduced_txp(mvm, mvmvif->ap_sta_id, false))
 492                         IWL_ERR(mvm, "Couldn't send BT_CONFIG cmd\n");
 493
 494                 /*
 495                  * One interface hasn't rssi above threshold, bt_kill_msk must
 496                  * be set to default values.
 497                  */
 498                 data->reduced_tx_power = false;
 499         }
 500
 501         /* Begin to monitor the RSSI: it may influence the reduced Tx power */
 502         ieee80211_enable_rssi_reports(vif, BT_DISABLE_REDUCED_TXPOWER_THRESHOLD,
 503                                       BT_ENABLE_REDUCED_TXPOWER_THRESHOLD);
 504 }
 505
 506 static void iwl_mvm_bt_coex_notif_handle(struct iwl_mvm *mvm)
 507 {
 508         struct iwl_bt_iterator_data data = {
 509                 .mvm = mvm,
 510                 .notif = &mvm->last_bt_notif,
 511                 .reduced_tx_power = true,
 512         };
 513
 514         ieee80211_iterate_active_interfaces_atomic(
 515                                         mvm->hw, IEEE80211_IFACE_ITER_NORMAL,
 516                                         iwl_mvm_bt_notif_iterator, &data);
 517
 518         /*
 519          * If there are no BSS / P2P client interfaces, reduced Tx Power is
 520          * irrelevant since it is based on the RSSI coming from the beacon.
 521          * Use BT_KILL_MSK_DEFAULT in that case.
 522          */
 523         data.reduced_tx_power = data.reduced_tx_power && data.num_bss_ifaces;
 524
 525         if (iwl_mvm_bt_udpate_ctrl_kill_msk(mvm, data.reduced_tx_power))
 526                 IWL_ERR(mvm, "Failed to update the ctrl_kill_msk\n");
 527 }
 528
 529 /* upon association, the fw will send in BT Coex notification */
 530 int iwl_mvm_rx_bt_coex_notif(struct iwl_mvm *mvm,
 531                              struct iwl_rx_cmd_buffer *rxb,
 532                              struct iwl_device_cmd *dev_cmd)
 533 {
 534         struct iwl_rx_packet *pkt = rxb_addr(rxb);
 535         struct iwl_bt_coex_profile_notif *notif = (void *)pkt->data;
 536
 537
 538         IWL_DEBUG_COEX(mvm, "BT Coex Notification received\n");
 539         IWL_DEBUG_COEX(mvm, "\tBT %salive\n", notif->bt_status ? "" : "not ");
 540         IWL_DEBUG_COEX(mvm, "\tBT open conn %d\n", notif->bt_open_conn);
 541         IWL_DEBUG_COEX(mvm, "\tBT traffic load %d\n", notif->bt_traffic_load);
 542         IWL_DEBUG_COEX(mvm, "\tBT agg traffic load %d\n",
 543                        notif->bt_agg_traffic_load);
 544         IWL_DEBUG_COEX(mvm, "\tBT ci compliance %d\n", notif->bt_ci_compliance);
 545
 546         /* remember this notification for future use: rssi fluctuations */
 547         memcpy(&mvm->last_bt_notif, notif, sizeof(mvm->last_bt_notif));
 548
 549         iwl_mvm_bt_coex_notif_handle(mvm);
 550
 551         /*
 552          * This is an async handler for a notification, returning anything other
 553          * than 0 doesn't make sense even if HCMD failed.
 554          */
 555         return 0;
 556 }
 557
 558 static void iwl_mvm_bt_rssi_iterator(void *_data, u8 *mac,
 559                                    struct ieee80211_vif *vif)
 560 {
 561         struct iwl_mvm_vif *mvmvif = (void *)vif->drv_priv;
 562         struct iwl_bt_iterator_data *data = _data;
 563         struct iwl_mvm *mvm = data->mvm;
 564
 565         struct ieee80211_sta *sta;
 566         struct iwl_mvm_sta *mvmsta;
 567
 568         if (vif->type != NL80211_IFTYPE_STATION ||
 569             mvmvif->ap_sta_id == IWL_MVM_STATION_COUNT)
 570                 return;
 571
 572         sta = rcu_dereference_protected(mvm->fw_id_to_mac_id[mvmvif->ap_sta_id],
 573                                         lockdep_is_held(&mvm->mutex));
 574         mvmsta = (void *)sta->drv_priv;
 575
 576         data->num_bss_ifaces++;
 577
 578         /*
 579          * This interface doesn't support reduced Tx power (because of low
 580          * RSSI probably), then set bt_kill_msk to default values.
 581          */
 582         if (!mvmsta->bt_reduced_txpower)
 583                 data->reduced_tx_power = false;
 584         /* else - possibly leave it to BT_KILL_MSK_REDUCED_TXPOW */
 585 }
 586
 587 void iwl_mvm_bt_rssi_event(struct iwl_mvm *mvm, struct ieee80211_vif *vif,
 588                            enum ieee80211_rssi_event rssi_event)
 589 {
 590         struct iwl_mvm_vif *mvmvif = (void *)vif->drv_priv;
 591         struct iwl_bt_iterator_data data = {
 592                 .mvm = mvm,
 593                 .reduced_tx_power = true,
 594         };
 595         int ret;
 596
 597         mutex_lock(&mvm->mutex);
 598
 599         /*
 600          * Rssi update while not associated - can happen since the statistics
 601          * are handled asynchronously
 602          */
 603         if (mvmvif->ap_sta_id == IWL_MVM_STATION_COUNT)
 604                 goto out_unlock;
 605
 606         /* No open connection - reports should be disabled */
 607         if (!BT_MBOX_MSG(&mvm->last_bt_notif, 3, OPEN_CON_2))
 608                 goto out_unlock;
 609
 610         IWL_DEBUG_COEX(mvm, "RSSI for %pM is now %s\n", vif->bss_conf.bssid,
 611                        rssi_event == RSSI_EVENT_HIGH ? "HIGH" : "LOW");
 612
 613         /*
 614          * Check if rssi is good enough for reduced Tx power, but not in loose
 615          * scheme.
 616          */
 617         if (rssi_event == RSSI_EVENT_LOW || is_loose_coex())
 618                 ret = iwl_mvm_bt_coex_reduced_txp(mvm, mvmvif->ap_sta_id,
 619                                                   false);
 620         else
 621                 ret = iwl_mvm_bt_coex_reduced_txp(mvm, mvmvif->ap_sta_id, true);
 622
 623         if (ret)
 624                 IWL_ERR(mvm, "couldn't send BT_CONFIG HCMD upon RSSI event\n");
 625
 626         ieee80211_iterate_active_interfaces_atomic(
 627                 mvm->hw, IEEE80211_IFACE_ITER_NORMAL,
 628                 iwl_mvm_bt_rssi_iterator, &data);
 629
 630         /*
 631          * If there are no BSS / P2P client interfaces, reduced Tx Power is
 632          * irrelevant since it is based on the RSSI coming from the beacon.
 633          * Use BT_KILL_MSK_DEFAULT in that case.
 634          */
 635         data.reduced_tx_power = data.reduced_tx_power && data.num_bss_ifaces;
 636
 637         if (iwl_mvm_bt_udpate_ctrl_kill_msk(mvm, data.reduced_tx_power))
 638                 IWL_ERR(mvm, "Failed to update the ctrl_kill_msk\n");
 639
 640  out_unlock:
 641         mutex_unlock(&mvm->mutex);
 642 }
 643
 644 void iwl_mvm_bt_coex_vif_assoc(struct iwl_mvm *mvm, struct ieee80211_vif *vif)
 645 {
 646         iwl_mvm_bt_coex_notif_handle(mvm);
 647 }