1 /******************************************************************************
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.
8 * Copyright(c) 2013 Intel Corporation. All rights reserved.
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.
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.
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,
24 * The full GNU General Public License is included in this distribution
25 * in the file called COPYING.
27 * Contact Information:
28 * Intel Linux Wireless <ilw@linux.intel.com>
29 * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
33 * Copyright(c) 2013 Intel Corporation. All rights reserved.
34 * All rights reserved.
36 * Redistribution and use in source and binary forms, with or without
37 * modification, are permitted provided that the following conditions
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
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.
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.
62 *****************************************************************************/
64 #include <net/mac80211.h>
66 #include "fw-api-bt-coex.h"
67 #include "iwl-modparams.h"
69 #include "iwl-debug.h"
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))
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),
101 #define BT_ENABLE_REDUCED_TXPOWER_THRESHOLD (-62)
102 #define BT_DISABLE_REDUCED_TXPOWER_THRESHOLD (-65)
103 #define BT_ANTENNA_COUPLING_THRESHOLD (30)
105 int iwl_send_bt_prio_tbl(struct iwl_mvm *mvm)
107 if (!(mvm->fw->ucode_capa.flags & IWL_UCODE_TLV_FLAGS_NEWBT_COEX))
110 return iwl_mvm_send_cmd_pdu(mvm, BT_COEX_PRIO_TABLE, CMD_SYNC,
111 sizeof(struct iwl_bt_coex_prio_tbl_cmd),
115 const u32 iwl_bt_ack_kill_msk[BT_KILL_MSK_MAX] = {
116 [BT_KILL_MSK_DEFAULT] = 0xffff0000,
117 [BT_KILL_MSK_SCO_HID_A2DP] = 0xffffffff,
118 [BT_KILL_MSK_REDUCED_TXPOW] = 0,
121 const u32 iwl_bt_cts_kill_msk[BT_KILL_MSK_MAX] = {
122 [BT_KILL_MSK_DEFAULT] = 0xffff0000,
123 [BT_KILL_MSK_SCO_HID_A2DP] = 0xffffffff,
124 [BT_KILL_MSK_REDUCED_TXPOW] = 0,
127 static const __le32 iwl_bt_prio_boost[BT_COEX_BOOST_SIZE] = {
128 cpu_to_le32(0xf0f0f0f0),
129 cpu_to_le32(0xc0c0c0c0),
130 cpu_to_le32(0xfcfcfcfc),
131 cpu_to_le32(0xff00ff00),
134 static const __le32 iwl_combined_lookup[BT_COEX_MAX_LUT][BT_COEX_LUT_SIZE] = {
137 cpu_to_le32(0xaaaaaaaa),
138 cpu_to_le32(0xaaaaaaaa),
139 cpu_to_le32(0xaeaaaaaa),
140 cpu_to_le32(0xaaaaaaaa),
141 cpu_to_le32(0xcc00ff28),
142 cpu_to_le32(0x0000aaaa),
143 cpu_to_le32(0xcc00aaaa),
144 cpu_to_le32(0x0000aaaa),
145 cpu_to_le32(0xc0004000),
146 cpu_to_le32(0x00000000),
147 cpu_to_le32(0xf0005000),
148 cpu_to_le32(0xf0005000),
152 cpu_to_le32(0xaaaaaaaa),
153 cpu_to_le32(0xaaaaaaaa),
154 cpu_to_le32(0xaaaaaaaa),
155 cpu_to_le32(0xaaaaaaaa),
156 cpu_to_le32(0xcc00ff28),
157 cpu_to_le32(0x0000aaaa),
158 cpu_to_le32(0xcc00aaaa),
159 cpu_to_le32(0x0000aaaa),
160 cpu_to_le32(0x00000000),
161 cpu_to_le32(0x00000000),
162 cpu_to_le32(0xf0005000),
163 cpu_to_le32(0xf0005000),
167 cpu_to_le32(0xaaaaaaaa),
168 cpu_to_le32(0xaaaaaaaa),
169 cpu_to_le32(0xaaaaaaaa),
170 cpu_to_le32(0xaaaaaaaa),
171 cpu_to_le32(0xcc00ff28),
172 cpu_to_le32(0x0000aaaa),
173 cpu_to_le32(0xcc00aaaa),
174 cpu_to_le32(0x0000aaaa),
175 cpu_to_le32(0xC0004000),
176 cpu_to_le32(0xC0004000),
177 cpu_to_le32(0xF0005000),
178 cpu_to_le32(0xF0005000),
182 /* 20MHz / 40MHz below / 40Mhz above*/
183 static const __le64 iwl_ci_mask[][3] = {
184 /* dummy entry for channel 0 */
185 {cpu_to_le64(0), cpu_to_le64(0), cpu_to_le64(0)},
187 cpu_to_le64(0x0000001FFFULL),
189 cpu_to_le64(0x00007FFFFFULL),
192 cpu_to_le64(0x000000FFFFULL),
194 cpu_to_le64(0x0003FFFFFFULL),
197 cpu_to_le64(0x000003FFFCULL),
199 cpu_to_le64(0x000FFFFFFCULL),
202 cpu_to_le64(0x00001FFFE0ULL),
204 cpu_to_le64(0x007FFFFFE0ULL),
207 cpu_to_le64(0x00007FFF80ULL),
208 cpu_to_le64(0x00007FFFFFULL),
209 cpu_to_le64(0x01FFFFFF80ULL),
212 cpu_to_le64(0x0003FFFC00ULL),
213 cpu_to_le64(0x0003FFFFFFULL),
214 cpu_to_le64(0x0FFFFFFC00ULL),
217 cpu_to_le64(0x000FFFF000ULL),
218 cpu_to_le64(0x000FFFFFFCULL),
219 cpu_to_le64(0x3FFFFFF000ULL),
222 cpu_to_le64(0x007FFF8000ULL),
223 cpu_to_le64(0x007FFFFFE0ULL),
224 cpu_to_le64(0xFFFFFF8000ULL),
227 cpu_to_le64(0x01FFFE0000ULL),
228 cpu_to_le64(0x01FFFFFF80ULL),
229 cpu_to_le64(0xFFFFFE0000ULL),
232 cpu_to_le64(0x0FFFF00000ULL),
233 cpu_to_le64(0x0FFFFFFC00ULL),
237 cpu_to_le64(0x3FFFC00000ULL),
238 cpu_to_le64(0x3FFFFFF000ULL),
242 cpu_to_le64(0xFFFE000000ULL),
243 cpu_to_le64(0xFFFFFF8000ULL),
247 cpu_to_le64(0xFFF8000000ULL),
248 cpu_to_le64(0xFFFFFE0000ULL),
252 cpu_to_le64(0xFE00000000ULL),
258 static const __le32 iwl_bt_mprio_lut[BT_COEX_MULTI_PRIO_LUT_SIZE] = {
259 cpu_to_le32(0x22002200),
260 cpu_to_le32(0x33113311),
263 static enum iwl_bt_coex_lut_type
264 iwl_get_coex_type(struct iwl_mvm *mvm, const struct ieee80211_vif *vif)
266 struct ieee80211_chanctx_conf *chanctx_conf;
267 enum iwl_bt_coex_lut_type ret;
270 lockdep_assert_held(&mvm->mutex);
274 chanctx_conf = rcu_dereference(vif->chanctx_conf);
277 chanctx_conf->def.chan->band != IEEE80211_BAND_2GHZ) {
279 return BT_COEX_LOOSE_LUT;
282 ret = BT_COEX_TX_DIS_LUT;
284 if (mvm->cfg->bt_shared_single_ant) {
289 phy_ctx_id = *((u16 *)chanctx_conf->drv_priv);
291 if (mvm->last_bt_ci_cmd.primary_ch_phy_id == phy_ctx_id)
292 ret = le32_to_cpu(mvm->last_bt_notif.primary_ch_lut);
293 else if (mvm->last_bt_ci_cmd.secondary_ch_phy_id == phy_ctx_id)
294 ret = le32_to_cpu(mvm->last_bt_notif.secondary_ch_lut);
295 /* else - default = TX TX disallowed */
302 int iwl_send_bt_init_conf(struct iwl_mvm *mvm)
304 struct iwl_bt_coex_cmd *bt_cmd;
305 struct iwl_host_cmd cmd = {
307 .len = { sizeof(*bt_cmd), },
308 .dataflags = { IWL_HCMD_DFL_NOCOPY, },
314 if (!(mvm->fw->ucode_capa.flags & IWL_UCODE_TLV_FLAGS_NEWBT_COEX))
317 bt_cmd = kzalloc(sizeof(*bt_cmd), GFP_KERNEL);
320 cmd.data[0] = bt_cmd;
322 bt_cmd->max_kill = 5;
323 bt_cmd->bt4_antenna_isolation_thr = BT_ANTENNA_COUPLING_THRESHOLD,
324 bt_cmd->bt4_antenna_isolation = iwlwifi_mod_params.ant_coupling,
325 bt_cmd->bt4_tx_tx_delta_freq_thr = 15,
326 bt_cmd->bt4_tx_rx_max_freq0 = 15,
328 flags = iwlwifi_mod_params.bt_coex_active ?
329 BT_COEX_NW : BT_COEX_DISABLE;
330 flags |= BT_CH_PRIMARY_EN | BT_CH_SECONDARY_EN | BT_SYNC_2_BT_DISABLE;
331 bt_cmd->flags = cpu_to_le32(flags);
333 bt_cmd->valid_bit_msk = cpu_to_le32(BT_VALID_ENABLE |
334 BT_VALID_BT_PRIO_BOOST |
339 BT_VALID_REDUCED_TX_POWER |
341 BT_VALID_WIFI_RX_SW_PRIO_BOOST |
342 BT_VALID_WIFI_TX_SW_PRIO_BOOST |
343 BT_VALID_MULTI_PRIO_LUT |
344 BT_VALID_CORUN_LUT_20 |
345 BT_VALID_CORUN_LUT_40 |
346 BT_VALID_ANT_ISOLATION |
347 BT_VALID_ANT_ISOLATION_THRS |
348 BT_VALID_TXTX_DELTA_FREQ_THRS |
349 BT_VALID_TXRX_MAX_FREQ_0);
351 memcpy(&bt_cmd->decision_lut, iwl_combined_lookup,
352 sizeof(iwl_combined_lookup));
353 memcpy(&bt_cmd->bt_prio_boost, iwl_bt_prio_boost,
354 sizeof(iwl_bt_prio_boost));
355 memcpy(&bt_cmd->bt4_multiprio_lut, iwl_bt_mprio_lut,
356 sizeof(iwl_bt_mprio_lut));
357 bt_cmd->kill_ack_msk =
358 cpu_to_le32(iwl_bt_ack_kill_msk[BT_KILL_MSK_DEFAULT]);
359 bt_cmd->kill_cts_msk =
360 cpu_to_le32(iwl_bt_cts_kill_msk[BT_KILL_MSK_DEFAULT]);
362 memset(&mvm->last_bt_notif, 0, sizeof(mvm->last_bt_notif));
363 memset(&mvm->last_bt_ci_cmd, 0, sizeof(mvm->last_bt_ci_cmd));
365 ret = iwl_mvm_send_cmd(mvm, &cmd);
371 static int iwl_mvm_bt_udpate_ctrl_kill_msk(struct iwl_mvm *mvm,
372 bool reduced_tx_power)
374 enum iwl_bt_kill_msk bt_kill_msk;
375 struct iwl_bt_coex_cmd *bt_cmd;
376 struct iwl_bt_coex_profile_notif *notif = &mvm->last_bt_notif;
377 struct iwl_host_cmd cmd = {
380 .len = { sizeof(*bt_cmd), },
381 .dataflags = { IWL_HCMD_DFL_NOCOPY, },
386 lockdep_assert_held(&mvm->mutex);
388 if (reduced_tx_power) {
389 /* Reduced Tx power has precedence on the type of the profile */
390 bt_kill_msk = BT_KILL_MSK_REDUCED_TXPOW;
392 /* Low latency BT profile is active: give higher prio to BT */
393 if (BT_MBOX_MSG(notif, 3, SCO_STATE) ||
394 BT_MBOX_MSG(notif, 3, A2DP_STATE) ||
395 BT_MBOX_MSG(notif, 3, SNIFF_STATE))
396 bt_kill_msk = BT_KILL_MSK_SCO_HID_A2DP;
398 bt_kill_msk = BT_KILL_MSK_DEFAULT;
402 "Update kill_msk: %d - SCO %sactive A2DP %sactive SNIFF %sactive\n",
404 BT_MBOX_MSG(notif, 3, SCO_STATE) ? "" : "in",
405 BT_MBOX_MSG(notif, 3, A2DP_STATE) ? "" : "in",
406 BT_MBOX_MSG(notif, 3, SNIFF_STATE) ? "" : "in");
408 /* Don't send HCMD if there is no update */
409 if (bt_kill_msk == mvm->bt_kill_msk)
412 mvm->bt_kill_msk = bt_kill_msk;
414 bt_cmd = kzalloc(sizeof(*bt_cmd), GFP_KERNEL);
417 cmd.data[0] = bt_cmd;
419 bt_cmd->kill_ack_msk = cpu_to_le32(iwl_bt_ack_kill_msk[bt_kill_msk]);
420 bt_cmd->kill_cts_msk = cpu_to_le32(iwl_bt_cts_kill_msk[bt_kill_msk]);
421 bt_cmd->valid_bit_msk =
422 cpu_to_le32(BT_VALID_KILL_ACK | BT_VALID_KILL_CTS);
424 IWL_DEBUG_COEX(mvm, "ACK Kill msk = 0x%08x, CTS Kill msk = 0x%08x\n",
425 iwl_bt_ack_kill_msk[bt_kill_msk],
426 iwl_bt_cts_kill_msk[bt_kill_msk]);
428 ret = iwl_mvm_send_cmd(mvm, &cmd);
434 static int iwl_mvm_bt_coex_reduced_txp(struct iwl_mvm *mvm, u8 sta_id,
437 struct iwl_bt_coex_cmd *bt_cmd;
438 /* Send ASYNC since this can be sent from an atomic context */
439 struct iwl_host_cmd cmd = {
441 .len = { sizeof(*bt_cmd), },
442 .dataflags = { IWL_HCMD_DFL_DUP, },
446 struct ieee80211_sta *sta;
447 struct iwl_mvm_sta *mvmsta;
450 /* This can happen if the station has been removed right now */
451 if (sta_id == IWL_MVM_STATION_COUNT)
454 sta = rcu_dereference_protected(mvm->fw_id_to_mac_id[sta_id],
455 lockdep_is_held(&mvm->mutex));
456 mvmsta = (void *)sta->drv_priv;
459 if (mvmsta->bt_reduced_txpower == enable)
462 bt_cmd = kzalloc(sizeof(*bt_cmd), GFP_ATOMIC);
465 cmd.data[0] = bt_cmd;
467 bt_cmd->valid_bit_msk = cpu_to_le32(BT_VALID_REDUCED_TX_POWER),
468 bt_cmd->bt_reduced_tx_power = sta_id;
471 bt_cmd->bt_reduced_tx_power |= BT_REDUCED_TX_POWER_BIT;
473 IWL_DEBUG_COEX(mvm, "%sable reduced Tx Power for sta %d\n",
474 enable ? "en" : "dis", sta_id);
476 mvmsta->bt_reduced_txpower = enable;
478 ret = iwl_mvm_send_cmd(mvm, &cmd);
484 struct iwl_bt_iterator_data {
485 struct iwl_bt_coex_profile_notif *notif;
488 bool reduced_tx_power;
489 struct ieee80211_chanctx_conf *primary;
490 struct ieee80211_chanctx_conf *secondary;
493 /* must be called under rcu_read_lock */
494 static void iwl_mvm_bt_notif_iterator(void *_data, u8 *mac,
495 struct ieee80211_vif *vif)
497 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
498 struct iwl_bt_iterator_data *data = _data;
499 struct iwl_mvm *mvm = data->mvm;
500 struct ieee80211_chanctx_conf *chanctx_conf;
501 enum ieee80211_smps_mode smps_mode;
504 lockdep_assert_held(&mvm->mutex);
506 if (vif->type != NL80211_IFTYPE_STATION &&
507 vif->type != NL80211_IFTYPE_AP)
510 smps_mode = IEEE80211_SMPS_AUTOMATIC;
512 chanctx_conf = rcu_dereference(vif->chanctx_conf);
514 /* If channel context is invalid or not on 2.4GHz .. */
515 if ((!chanctx_conf ||
516 chanctx_conf->def.chan->band != IEEE80211_BAND_2GHZ)) {
517 /* ... and it is an associated STATION, relax constraints */
518 if (vif->type == NL80211_IFTYPE_STATION && vif->bss_conf.assoc)
519 iwl_mvm_update_smps(mvm, vif, IWL_MVM_SMPS_REQ_BT_COEX,
524 /* SoftAP / GO will always be primary */
525 if (vif->type == NL80211_IFTYPE_AP) {
526 if (!mvmvif->ap_active)
529 /* the Ack / Cts kill mask must be default if AP / GO */
530 data->reduced_tx_power = false;
532 if (chanctx_conf == data->primary)
535 /* downgrade the current primary no matter what its type is */
536 data->secondary = data->primary;
537 data->primary = chanctx_conf;
541 data->num_bss_ifaces++;
543 /* we are now a STA / P2P Client, and take associated ones only */
544 if (!vif->bss_conf.assoc)
547 /* STA / P2P Client, try to be primary if first vif */
548 if (!data->primary || data->primary == chanctx_conf)
549 data->primary = chanctx_conf;
550 else if (!data->secondary)
551 /* if secondary is not NULL, it might be a GO */
552 data->secondary = chanctx_conf;
554 if (data->notif->bt_status)
555 smps_mode = IEEE80211_SMPS_DYNAMIC;
557 if (le32_to_cpu(data->notif->bt_activity_grading) >= BT_LOW_TRAFFIC)
558 smps_mode = IEEE80211_SMPS_STATIC;
560 IWL_DEBUG_COEX(data->mvm,
561 "mac %d: bt_status %d bt_activity_grading %d smps_req %d\n",
562 mvmvif->id, data->notif->bt_status,
563 data->notif->bt_activity_grading, smps_mode);
565 iwl_mvm_update_smps(mvm, vif, IWL_MVM_SMPS_REQ_BT_COEX, smps_mode);
567 /* don't reduce the Tx power if in loose scheme */
568 if (iwl_get_coex_type(mvm, vif) == BT_COEX_LOOSE_LUT ||
569 mvm->cfg->bt_shared_single_ant) {
570 data->reduced_tx_power = false;
574 /* reduced Txpower only if BT is on, so ...*/
575 if (le32_to_cpu(data->notif->bt_activity_grading) == BT_OFF) {
576 /* ... cancel reduced Tx power ... */
577 if (iwl_mvm_bt_coex_reduced_txp(mvm, mvmvif->ap_sta_id, false))
578 IWL_ERR(mvm, "Couldn't send BT_CONFIG cmd\n");
579 data->reduced_tx_power = false;
581 /* ... and there is no need to get reports on RSSI any more. */
582 mvmvif->bf_data.last_bt_coex_event = 0;
583 mvmvif->bf_data.bt_coex_max_thold = 0;
584 mvmvif->bf_data.bt_coex_min_thold = 0;
588 /* try to get the avg rssi from fw */
589 ave_rssi = mvmvif->bf_data.ave_beacon_signal;
591 /* if the RSSI isn't valid, fake it is very low */
594 if (ave_rssi > BT_ENABLE_REDUCED_TXPOWER_THRESHOLD) {
595 if (iwl_mvm_bt_coex_reduced_txp(mvm, mvmvif->ap_sta_id, true))
596 IWL_ERR(mvm, "Couldn't send BT_CONFIG cmd\n");
599 * bt_kill_msk can be BT_KILL_MSK_REDUCED_TXPOW only if all the
600 * BSS / P2P clients have rssi above threshold.
601 * We set the bt_kill_msk to BT_KILL_MSK_REDUCED_TXPOW before
602 * the iteration, if one interface's rssi isn't good enough,
603 * bt_kill_msk will be set to default values.
605 } else if (ave_rssi < BT_DISABLE_REDUCED_TXPOWER_THRESHOLD) {
606 if (iwl_mvm_bt_coex_reduced_txp(mvm, mvmvif->ap_sta_id, false))
607 IWL_ERR(mvm, "Couldn't send BT_CONFIG cmd\n");
610 * One interface hasn't rssi above threshold, bt_kill_msk must
611 * be set to default values.
613 data->reduced_tx_power = false;
616 /* Begin to monitor the RSSI: it may influence the reduced Tx power */
618 /* reset previous bt coex event tracking */
619 mvmvif->bf_data.last_bt_coex_event = 0;
620 mvmvif->bf_data.bt_coex_max_thold =
621 BT_ENABLE_REDUCED_TXPOWER_THRESHOLD;
622 mvmvif->bf_data.bt_coex_min_thold =
623 BT_DISABLE_REDUCED_TXPOWER_THRESHOLD;
626 static void iwl_mvm_bt_coex_notif_handle(struct iwl_mvm *mvm)
628 struct iwl_bt_iterator_data data = {
630 .notif = &mvm->last_bt_notif,
631 .reduced_tx_power = true,
633 struct iwl_bt_coex_ci_cmd cmd = {};
637 ieee80211_iterate_active_interfaces_atomic(
638 mvm->hw, IEEE80211_IFACE_ITER_NORMAL,
639 iwl_mvm_bt_notif_iterator, &data);
642 struct ieee80211_chanctx_conf *chan = data.primary;
643 if (WARN_ON(!chan->def.chan)) {
648 if (chan->def.width < NL80211_CHAN_WIDTH_40) {
650 cmd.co_run_bw_primary = 0;
652 cmd.co_run_bw_primary = 1;
653 if (chan->def.center_freq1 >
654 chan->def.chan->center_freq)
661 iwl_ci_mask[chan->def.chan->hw_value][ci_bw_idx];
662 cmd.primary_ch_phy_id = *((u16 *)data.primary->drv_priv);
665 if (data.secondary) {
666 struct ieee80211_chanctx_conf *chan = data.secondary;
667 if (WARN_ON(!data.secondary->def.chan)) {
672 if (chan->def.width < NL80211_CHAN_WIDTH_40) {
674 cmd.co_run_bw_secondary = 0;
676 cmd.co_run_bw_secondary = 1;
677 if (chan->def.center_freq1 >
678 chan->def.chan->center_freq)
684 cmd.bt_secondary_ci =
685 iwl_ci_mask[chan->def.chan->hw_value][ci_bw_idx];
686 cmd.secondary_ch_phy_id = *((u16 *)data.primary->drv_priv);
691 /* Don't spam the fw with the same command over and over */
692 if (memcmp(&cmd, &mvm->last_bt_ci_cmd, sizeof(cmd))) {
693 if (iwl_mvm_send_cmd_pdu(mvm, BT_COEX_CI, CMD_SYNC,
695 IWL_ERR(mvm, "Failed to send BT_CI cmd");
696 memcpy(&mvm->last_bt_ci_cmd, &cmd, sizeof(cmd));
700 * If there are no BSS / P2P client interfaces, reduced Tx Power is
701 * irrelevant since it is based on the RSSI coming from the beacon.
702 * Use BT_KILL_MSK_DEFAULT in that case.
704 data.reduced_tx_power = data.reduced_tx_power && data.num_bss_ifaces;
706 if (iwl_mvm_bt_udpate_ctrl_kill_msk(mvm, data.reduced_tx_power))
707 IWL_ERR(mvm, "Failed to update the ctrl_kill_msk\n");
710 /* upon association, the fw will send in BT Coex notification */
711 int iwl_mvm_rx_bt_coex_notif(struct iwl_mvm *mvm,
712 struct iwl_rx_cmd_buffer *rxb,
713 struct iwl_device_cmd *dev_cmd)
715 struct iwl_rx_packet *pkt = rxb_addr(rxb);
716 struct iwl_bt_coex_profile_notif *notif = (void *)pkt->data;
719 IWL_DEBUG_COEX(mvm, "BT Coex Notification received\n");
720 IWL_DEBUG_COEX(mvm, "\tBT status: %s\n",
721 notif->bt_status ? "ON" : "OFF");
722 IWL_DEBUG_COEX(mvm, "\tBT open conn %d\n", notif->bt_open_conn);
723 IWL_DEBUG_COEX(mvm, "\tBT ci compliance %d\n", notif->bt_ci_compliance);
724 IWL_DEBUG_COEX(mvm, "\tBT primary_ch_lut %d\n",
725 le32_to_cpu(notif->primary_ch_lut));
726 IWL_DEBUG_COEX(mvm, "\tBT secondary_ch_lut %d\n",
727 le32_to_cpu(notif->secondary_ch_lut));
728 IWL_DEBUG_COEX(mvm, "\tBT activity grading %d\n",
729 le32_to_cpu(notif->bt_activity_grading));
730 IWL_DEBUG_COEX(mvm, "\tBT agg traffic load %d\n",
731 notif->bt_agg_traffic_load);
733 /* remember this notification for future use: rssi fluctuations */
734 memcpy(&mvm->last_bt_notif, notif, sizeof(mvm->last_bt_notif));
736 iwl_mvm_bt_coex_notif_handle(mvm);
739 * This is an async handler for a notification, returning anything other
740 * than 0 doesn't make sense even if HCMD failed.
745 static void iwl_mvm_bt_rssi_iterator(void *_data, u8 *mac,
746 struct ieee80211_vif *vif)
748 struct iwl_mvm_vif *mvmvif = (void *)vif->drv_priv;
749 struct iwl_bt_iterator_data *data = _data;
750 struct iwl_mvm *mvm = data->mvm;
752 struct ieee80211_sta *sta;
753 struct iwl_mvm_sta *mvmsta;
755 if (vif->type != NL80211_IFTYPE_STATION ||
756 mvmvif->ap_sta_id == IWL_MVM_STATION_COUNT)
759 sta = rcu_dereference_protected(mvm->fw_id_to_mac_id[mvmvif->ap_sta_id],
760 lockdep_is_held(&mvm->mutex));
761 mvmsta = (void *)sta->drv_priv;
763 data->num_bss_ifaces++;
766 * This interface doesn't support reduced Tx power (because of low
767 * RSSI probably), then set bt_kill_msk to default values.
769 if (!mvmsta->bt_reduced_txpower)
770 data->reduced_tx_power = false;
771 /* else - possibly leave it to BT_KILL_MSK_REDUCED_TXPOW */
774 void iwl_mvm_bt_rssi_event(struct iwl_mvm *mvm, struct ieee80211_vif *vif,
775 enum ieee80211_rssi_event rssi_event)
777 struct iwl_mvm_vif *mvmvif = (void *)vif->drv_priv;
778 struct iwl_bt_iterator_data data = {
780 .reduced_tx_power = true,
784 lockdep_assert_held(&mvm->mutex);
786 /* Rssi update while not associated ?! */
787 if (WARN_ON_ONCE(mvmvif->ap_sta_id == IWL_MVM_STATION_COUNT))
790 /* No BT - reports should be disabled */
791 if (le32_to_cpu(mvm->last_bt_notif.bt_activity_grading) == BT_OFF)
794 IWL_DEBUG_COEX(mvm, "RSSI for %pM is now %s\n", vif->bss_conf.bssid,
795 rssi_event == RSSI_EVENT_HIGH ? "HIGH" : "LOW");
798 * Check if rssi is good enough for reduced Tx power, but not in loose
801 if (rssi_event == RSSI_EVENT_LOW || mvm->cfg->bt_shared_single_ant ||
802 iwl_get_coex_type(mvm, vif) == BT_COEX_LOOSE_LUT)
803 ret = iwl_mvm_bt_coex_reduced_txp(mvm, mvmvif->ap_sta_id,
806 ret = iwl_mvm_bt_coex_reduced_txp(mvm, mvmvif->ap_sta_id, true);
809 IWL_ERR(mvm, "couldn't send BT_CONFIG HCMD upon RSSI event\n");
811 ieee80211_iterate_active_interfaces_atomic(
812 mvm->hw, IEEE80211_IFACE_ITER_NORMAL,
813 iwl_mvm_bt_rssi_iterator, &data);
816 * If there are no BSS / P2P client interfaces, reduced Tx Power is
817 * irrelevant since it is based on the RSSI coming from the beacon.
818 * Use BT_KILL_MSK_DEFAULT in that case.
820 data.reduced_tx_power = data.reduced_tx_power && data.num_bss_ifaces;
822 if (iwl_mvm_bt_udpate_ctrl_kill_msk(mvm, data.reduced_tx_power))
823 IWL_ERR(mvm, "Failed to update the ctrl_kill_msk\n");
826 void iwl_mvm_bt_coex_vif_change(struct iwl_mvm *mvm, struct ieee80211_vif *vif)
828 if (!(mvm->fw->ucode_capa.flags & IWL_UCODE_TLV_FLAGS_NEWBT_COEX))
831 iwl_mvm_bt_coex_notif_handle(mvm);