coex.c

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