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 "fw-api-bt-coex.h"
  65 #include "iwl-modparams.h"
  66 #include "mvm.h"
  67 #include "iwl-debug.h"
  68
  69 #define EVENT_PRIO_ANT(_evt, _prio, _shrd_ant)                  \
  70         [(_evt)] = (((_prio) << BT_COEX_PRIO_TBL_PRIO_POS) |    \
  71                    ((_shrd_ant) << BT_COEX_PRIO_TBL_SHRD_ANT_POS))
  72
  73 static const u8 iwl_bt_prio_tbl[BT_COEX_PRIO_TBL_EVT_MAX] = {
  74         EVENT_PRIO_ANT(BT_COEX_PRIO_TBL_EVT_INIT_CALIB1,
  75                        BT_COEX_PRIO_TBL_PRIO_BYPASS, 0),
  76         EVENT_PRIO_ANT(BT_COEX_PRIO_TBL_EVT_INIT_CALIB2,
  77                        BT_COEX_PRIO_TBL_PRIO_BYPASS, 1),
  78         EVENT_PRIO_ANT(BT_COEX_PRIO_TBL_EVT_PERIODIC_CALIB_LOW1,
  79                        BT_COEX_PRIO_TBL_PRIO_LOW, 0),
  80         EVENT_PRIO_ANT(BT_COEX_PRIO_TBL_EVT_PERIODIC_CALIB_LOW2,
  81                        BT_COEX_PRIO_TBL_PRIO_LOW, 1),
  82         EVENT_PRIO_ANT(BT_COEX_PRIO_TBL_EVT_PERIODIC_CALIB_HIGH1,
  83                        BT_COEX_PRIO_TBL_PRIO_HIGH, 0),
  84         EVENT_PRIO_ANT(BT_COEX_PRIO_TBL_EVT_PERIODIC_CALIB_HIGH2,
  85                        BT_COEX_PRIO_TBL_PRIO_HIGH, 1),
  86         EVENT_PRIO_ANT(BT_COEX_PRIO_TBL_EVT_DTIM,
  87                        BT_COEX_PRIO_TBL_DISABLED, 0),
  88         EVENT_PRIO_ANT(BT_COEX_PRIO_TBL_EVT_SCAN52,
  89                        BT_COEX_PRIO_TBL_PRIO_COEX_OFF, 0),
  90         EVENT_PRIO_ANT(BT_COEX_PRIO_TBL_EVT_SCAN24,
  91                        BT_COEX_PRIO_TBL_PRIO_COEX_ON, 0),
  92         EVENT_PRIO_ANT(BT_COEX_PRIO_TBL_EVT_IDLE,
  93                        BT_COEX_PRIO_TBL_PRIO_COEX_IDLE, 0),
  94         0, 0, 0, 0, 0, 0,
  95 };
  96
  97 #undef EVENT_PRIO_ANT
  98
  99 int iwl_send_bt_prio_tbl(struct iwl_mvm *mvm)
 100 {
 101         return iwl_mvm_send_cmd_pdu(mvm, BT_COEX_PRIO_TABLE, CMD_SYNC,
 102                                     sizeof(struct iwl_bt_coex_prio_tbl_cmd),
 103                                     &iwl_bt_prio_tbl);
 104 }
 105
 106 static int iwl_send_bt_env(struct iwl_mvm *mvm, u8 action, u8 type)
 107 {
 108         struct iwl_bt_coex_prot_env_cmd env_cmd;
 109         int ret;
 110
 111         env_cmd.action = action;
 112         env_cmd.type = type;
 113         ret = iwl_mvm_send_cmd_pdu(mvm, BT_COEX_PROT_ENV, CMD_SYNC,
 114                                    sizeof(env_cmd), &env_cmd);
 115         if (ret)
 116                 IWL_ERR(mvm, "failed to send BT env command\n");
 117         return ret;
 118 }
 119
 120 enum iwl_bt_kill_msk {
 121         BT_KILL_MSK_DEFAULT,
 122         BT_KILL_MSK_SCO_HID_A2DP,
 123         BT_KILL_MSK_REDUCED_TXPOW,
 124         BT_KILL_MSK_MAX,
 125 };
 126
 127 static const u32 iwl_bt_ack_kill_msk[BT_KILL_MSK_MAX] = {
 128         [BT_KILL_MSK_DEFAULT] = 0xffff0000,
 129         [BT_KILL_MSK_SCO_HID_A2DP] = 0xffffffff,
 130         [BT_KILL_MSK_REDUCED_TXPOW] = 0,
 131 };
 132
 133 static const u32 iwl_bt_cts_kill_msk[BT_KILL_MSK_MAX] = {
 134         [BT_KILL_MSK_DEFAULT] = 0xffff0000,
 135         [BT_KILL_MSK_SCO_HID_A2DP] = 0xffffffff,
 136         [BT_KILL_MSK_REDUCED_TXPOW] = 0,
 137 };
 138
 139 #define IWL_BT_DEFAULT_BOOST (0xf0f0f0f0)
 140
 141 /* Tight Coex */
 142 static const __le32 iwl_tight_lookup[BT_COEX_LUT_SIZE] = {
 143         cpu_to_le32(0xaaaaaaaa),
 144         cpu_to_le32(0xaaaaaaaa),
 145         cpu_to_le32(0xaeaaaaaa),
 146         cpu_to_le32(0xaaaaaaaa),
 147         cpu_to_le32(0xcc00ff28),
 148         cpu_to_le32(0x0000aaaa),
 149         cpu_to_le32(0xcc00aaaa),
 150         cpu_to_le32(0x0000aaaa),
 151         cpu_to_le32(0xc0004000),
 152         cpu_to_le32(0x00000000),
 153         cpu_to_le32(0xf0005000),
 154         cpu_to_le32(0xf0005000),
 155 };
 156
 157 /* Loose Coex */
 158 static const __le32 iwl_loose_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(0x00000000),
 168         cpu_to_le32(0x00000000),
 169         cpu_to_le32(0xf0005000),
 170         cpu_to_le32(0xf0005000),
 171 };
 172
 173 /* Full concurrency */
 174 static const __le32 iwl_concurrent_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(0xaaaaaaaa),
 180         cpu_to_le32(0xaaaaaaaa),
 181         cpu_to_le32(0xaaaaaaaa),
 182         cpu_to_le32(0xaaaaaaaa),
 183         cpu_to_le32(0x00000000),
 184         cpu_to_le32(0x00000000),
 185         cpu_to_le32(0x00000000),
 186         cpu_to_le32(0x00000000),
 187 };
 188
 189 /* BT Antenna Coupling Threshold (dB) */
 190 #define IWL_BT_ANTENNA_COUPLING_THRESHOLD       (35)
 191
 192 int iwl_send_bt_init_conf(struct iwl_mvm *mvm)
 193 {
 194         struct iwl_bt_coex_cmd cmd = {
 195                 .max_kill = 5,
 196                 .bt3_time_t7_value = 1,
 197                 .bt3_prio_sample_time = 2,
 198                 .bt3_timer_t2_value = 0xc,
 199         };
 200         int ret;
 201
 202         cmd.flags = iwlwifi_mod_params.bt_coex_active ?
 203                         BT_COEX_NW : BT_COEX_DISABLE;
 204         cmd.flags |= iwlwifi_mod_params.bt_ch_announce ? BT_CH_PRIMARY_EN : 0;
 205         cmd.flags |= BT_SYNC_2_BT_DISABLE;
 206
 207         cmd.valid_bit_msk = cpu_to_le16(BT_VALID_ENABLE |
 208                                         BT_VALID_BT_PRIO_BOOST |
 209                                         BT_VALID_MAX_KILL |
 210                                         BT_VALID_3W_TMRS |
 211                                         BT_VALID_KILL_ACK |
 212                                         BT_VALID_KILL_CTS |
 213                                         BT_VALID_REDUCED_TX_POWER |
 214                                         BT_VALID_LUT);
 215
 216         if (iwlwifi_mod_params.ant_coupling > IWL_BT_ANTENNA_COUPLING_THRESHOLD)
 217                 memcpy(&cmd.decision_lut, iwl_loose_lookup,
 218                        sizeof(iwl_tight_lookup));
 219         else
 220                 memcpy(&cmd.decision_lut, iwl_tight_lookup,
 221                        sizeof(iwl_tight_lookup));
 222
 223         cmd.bt_prio_boost = cpu_to_le32(IWL_BT_DEFAULT_BOOST);
 224         cmd.kill_ack_msk =
 225                 cpu_to_le32(iwl_bt_ack_kill_msk[BT_KILL_MSK_DEFAULT]);
 226         cmd.kill_cts_msk =
 227                 cpu_to_le32(iwl_bt_cts_kill_msk[BT_KILL_MSK_DEFAULT]);
 228
 229         /* go to CALIB state in internal BT-Coex state machine */
 230         ret = iwl_send_bt_env(mvm, BT_COEX_ENV_OPEN,
 231                               BT_COEX_PRIO_TBL_EVT_INIT_CALIB2);
 232         if (ret)
 233                 return ret;
 234
 235         ret  = iwl_send_bt_env(mvm, BT_COEX_ENV_CLOSE,
 236                                BT_COEX_PRIO_TBL_EVT_INIT_CALIB2);
 237         if (ret)
 238                 return ret;
 239
 240         return iwl_mvm_send_cmd_pdu(mvm, BT_CONFIG, CMD_SYNC,
 241                                     sizeof(cmd), &cmd);
 242 }
 243
 244 struct iwl_bt_notif_iterator_data {
 245         struct iwl_mvm *mvm;
 246         struct iwl_bt_coex_profile_notif *notif;
 247 };
 248
 249 static void iwl_mvm_bt_notif_iterator(void *_data, u8 *mac,
 250                                       struct ieee80211_vif *vif)
 251 {
 252         struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
 253         struct iwl_bt_notif_iterator_data *data = _data;
 254         struct ieee80211_chanctx_conf *chanctx_conf;
 255         enum ieee80211_smps_mode smps_mode;
 256         enum ieee80211_band band;
 257
 258         if (vif->type != NL80211_IFTYPE_STATION)
 259                 return;
 260
 261         rcu_read_lock();
 262         chanctx_conf = rcu_dereference(vif->chanctx_conf);
 263         if (chanctx_conf && chanctx_conf->def.chan)
 264                 band = chanctx_conf->def.chan->band;
 265         else
 266                 band = -1;
 267         rcu_read_unlock();
 268
 269         if (band != IEEE80211_BAND_2GHZ)
 270                 return;
 271
 272         smps_mode = IEEE80211_SMPS_AUTOMATIC;
 273
 274         if (data->notif->bt_status)
 275                 smps_mode = IEEE80211_SMPS_DYNAMIC;
 276
 277         if (data->notif->bt_traffic_load)
 278                 smps_mode = IEEE80211_SMPS_STATIC;
 279
 280         IWL_DEBUG_COEX(data->mvm,
 281                        "mac %d: bt_status %d traffic_load %d smps_req %d\n",
 282                        mvmvif->id,  data->notif->bt_status,
 283                        data->notif->bt_traffic_load, smps_mode);
 284
 285         ieee80211_request_smps(vif, smps_mode);
 286 }
 287
 288 int iwl_mvm_rx_bt_coex_notif(struct iwl_mvm *mvm,
 289                              struct iwl_rx_cmd_buffer *rxb,
 290                              struct iwl_device_cmd *dev_cmd)
 291 {
 292         struct iwl_rx_packet *pkt = rxb_addr(rxb);
 293         struct iwl_bt_coex_profile_notif *notif = (void *)pkt->data;
 294         struct iwl_bt_notif_iterator_data data = {
 295                 .mvm = mvm,
 296                 .notif = notif,
 297         };
 298         struct iwl_bt_coex_cmd cmd = {};
 299         enum iwl_bt_kill_msk bt_kill_msk;
 300
 301         IWL_DEBUG_COEX(mvm, "BT Coex Notification received\n");
 302         IWL_DEBUG_COEX(mvm, "\tBT %salive\n", notif->bt_status ? "" : "not ");
 303         IWL_DEBUG_COEX(mvm, "\tBT open conn %d\n", notif->bt_open_conn);
 304         IWL_DEBUG_COEX(mvm, "\tBT traffic load %d\n", notif->bt_traffic_load);
 305         IWL_DEBUG_COEX(mvm, "\tBT agg traffic load %d\n",
 306                        notif->bt_agg_traffic_load);
 307         IWL_DEBUG_COEX(mvm, "\tBT ci compliance %d\n", notif->bt_ci_compliance);
 308
 309         /* remember this notification for future use: rssi fluctuations */
 310         memcpy(&mvm->last_bt_notif, notif, sizeof(mvm->last_bt_notif));
 311
 312         ieee80211_iterate_active_interfaces_atomic(
 313                                         mvm->hw, IEEE80211_IFACE_ITER_NORMAL,
 314                                         iwl_mvm_bt_notif_iterator, &data);
 315
 316         /* Low latency BT profile is active: give higher prio to BT */
 317         if (BT_MBOX_MSG(notif, 3, SCO_STATE)  ||
 318             BT_MBOX_MSG(notif, 3, A2DP_STATE) ||
 319             BT_MBOX_MSG(notif, 3, SNIFF_STATE))
 320                 bt_kill_msk = BT_KILL_MSK_SCO_HID_A2DP;
 321         else
 322                 bt_kill_msk = BT_KILL_MSK_DEFAULT;
 323
 324         /* Don't send HCMD if there is no update */
 325         if (bt_kill_msk == mvm->bt_kill_msk)
 326                 return 0;
 327
 328         IWL_DEBUG_COEX(mvm,
 329                        "Update kill_msk: %d - SCO %sactive A2DP %sactive SNIFF %sactive\n",
 330                        bt_kill_msk,
 331                        BT_MBOX_MSG(notif, 3, SCO_STATE) ? "" : "in",
 332                        BT_MBOX_MSG(notif, 3, A2DP_STATE) ? "" : "in",
 333                        BT_MBOX_MSG(notif, 3, SNIFF_STATE) ? "" : "in");
 334
 335         mvm->bt_kill_msk = bt_kill_msk;
 336         cmd.kill_ack_msk = cpu_to_le32(iwl_bt_ack_kill_msk[bt_kill_msk]);
 337         cmd.kill_cts_msk = cpu_to_le32(iwl_bt_cts_kill_msk[bt_kill_msk]);
 338
 339         cmd.valid_bit_msk = cpu_to_le16(BT_VALID_KILL_ACK | BT_VALID_KILL_CTS);
 340
 341         if (iwl_mvm_send_cmd_pdu(mvm, BT_CONFIG, CMD_SYNC, sizeof(cmd), &cmd))
 342                 IWL_ERR(mvm, "Failed to sent BT Coex CMD\n");
 343
 344         /* This handler is ASYNC */
 345         return 0;
 346 }