From fd89017061fc9e11c32ba2bada6fb175d5894417 Mon Sep 17 00:00:00 2001

From: Eugene Syromiatnikov <esyr@redhat.com>

Date: Wed, 31 Jul 2019 18:48:56 +0200

Subject: [PATCH 7/7] Revert "iwlwifi: mvm: support mac80211 TXQs model"

This reverts commit cfbc6c4c5b91c7725ef14465b98ac347d31f2334.

---

 drivers/net/wireless/intel/iwlwifi/mvm/d3.c       |   8 +-

 drivers/net/wireless/intel/iwlwifi/mvm/fw.c       |   5 +-

 drivers/net/wireless/intel/iwlwifi/mvm/mac-ctxt.c |  72 ++++-

 drivers/net/wireless/intel/iwlwifi/mvm/mac80211.c | 143 ++-------

 drivers/net/wireless/intel/iwlwifi/mvm/mvm.h      |  53 +---

 drivers/net/wireless/intel/iwlwifi/mvm/ops.c      |  87 +++---

 drivers/net/wireless/intel/iwlwifi/mvm/sta.c      | 360 +++++++++++++---------

 drivers/net/wireless/intel/iwlwifi/mvm/sta.h      |   4 +

 drivers/net/wireless/intel/iwlwifi/mvm/tx.c       |  69 ++++-

 9 files changed, 442 insertions(+), 359 deletions(-)

Index: src/drivers/net/wireless/intel/iwlwifi/mvm/d3.c

===================================================================

--- src.orig/drivers/net/wireless/intel/iwlwifi/mvm/d3.c	2019-06-27 14:54:04.132678349 +0200

+++ src/drivers/net/wireless/intel/iwlwifi/mvm/d3.c	2019-07-31 18:51:11.751815280 +0200

@@ -2231,6 +2231,7 @@

 	file->private_data = inode->i_private;

+	ieee80211_stop_queues(mvm->hw);

 	synchronize_net();

 	mvm->trans->system_pm_mode = IWL_PLAT_PM_MODE_D3;

@@ -2245,9 +2246,10 @@

 	rtnl_unlock();

 	if (err > 0)

 		err = -EINVAL;

-	if (err)

+	if (err) {

+		ieee80211_wake_queues(mvm->hw);

 		return err;

-

+	}

 	mvm->d3_test_active = true;

 	mvm->keep_vif = NULL;

 	return 0;

@@ -2327,6 +2329,8 @@

 		mvm->hw, IEEE80211_IFACE_ITER_NORMAL,

 		iwl_mvm_d3_test_disconn_work_iter, mvm->keep_vif);

+	ieee80211_wake_queues(mvm->hw);

+

 	return 0;

 }

Index: src/drivers/net/wireless/intel/iwlwifi/mvm/fw.c

===================================================================

--- src.orig/drivers/net/wireless/intel/iwlwifi/mvm/fw.c	2019-06-27 14:54:04.134678325 +0200

+++ src/drivers/net/wireless/intel/iwlwifi/mvm/fw.c	2019-07-31 18:51:11.752815267 +0200

@@ -308,7 +308,7 @@

 	struct iwl_notification_wait alive_wait;

 	struct iwl_mvm_alive_data alive_data = {};

 	const struct fw_img *fw;

-	int ret;

+	int ret, i;

 	enum iwl_ucode_type old_type = mvm->fwrt.cur_fw_img;

 	static const u16 alive_cmd[] = { MVM_ALIVE };

@@ -390,6 +390,9 @@

 	mvm->queue_info[IWL_MVM_DQA_CMD_QUEUE].tid_bitmap =

 		BIT(IWL_MAX_TID_COUNT + 2);

+	for (i = 0; i < IEEE80211_MAX_QUEUES; i++)

+		atomic_set(&mvm->mac80211_queue_stop_count[i], 0);

+

 	set_bit(IWL_MVM_STATUS_FIRMWARE_RUNNING, &mvm->status);

 #ifdef CONFIG_IWLWIFI_DEBUGFS

 	iwl_fw_set_dbg_rec_on(&mvm->fwrt);

Index: src/drivers/net/wireless/intel/iwlwifi/mvm/mac-ctxt.c

===================================================================

--- src.orig/drivers/net/wireless/intel/iwlwifi/mvm/mac-ctxt.c	2019-07-31 18:51:06.045891463 +0200

+++ src/drivers/net/wireless/intel/iwlwifi/mvm/mac-ctxt.c	2019-07-31 18:51:11.752815267 +0200

@@ -97,6 +97,11 @@

 	bool found_vif;

 };

+struct iwl_mvm_hw_queues_iface_iterator_data {

+	struct ieee80211_vif *exclude_vif;

+	unsigned long used_hw_queues;

+};

+

 static void iwl_mvm_mac_tsf_id_iter(void *_data, u8 *mac,

 				    struct ieee80211_vif *vif)

 {

@@ -203,6 +208,61 @@

 		data->preferred_tsf = NUM_TSF_IDS;

 }

+/*

+ * Get the mask of the queues used by the vif

+ */

+u32 iwl_mvm_mac_get_queues_mask(struct ieee80211_vif *vif)

+{

+	u32 qmask = 0, ac;

+

+	if (vif->type == NL80211_IFTYPE_P2P_DEVICE)

+		return BIT(IWL_MVM_OFFCHANNEL_QUEUE);

+

+	for (ac = 0; ac < IEEE80211_NUM_ACS; ac++) {

+		if (vif->hw_queue[ac] != IEEE80211_INVAL_HW_QUEUE)

+			qmask |= BIT(vif->hw_queue[ac]);

+	}

+

+	if (vif->type == NL80211_IFTYPE_AP ||

+	    vif->type == NL80211_IFTYPE_ADHOC)

+		qmask |= BIT(vif->cab_queue);

+

+	return qmask;

+}

+

+static void iwl_mvm_iface_hw_queues_iter(void *_data, u8 *mac,

+					 struct ieee80211_vif *vif)

+{

+	struct iwl_mvm_hw_queues_iface_iterator_data *data = _data;

+

+	/* exclude the given vif */

+	if (vif == data->exclude_vif)

+		return;

+

+	data->used_hw_queues |= iwl_mvm_mac_get_queues_mask(vif);

+}

+

+unsigned long iwl_mvm_get_used_hw_queues(struct iwl_mvm *mvm,

+					 struct ieee80211_vif *exclude_vif)

+{

+	struct iwl_mvm_hw_queues_iface_iterator_data data = {

+		.exclude_vif = exclude_vif,

+		.used_hw_queues =

+			BIT(IWL_MVM_OFFCHANNEL_QUEUE) |

+			BIT(mvm->aux_queue) |

+			BIT(IWL_MVM_DQA_GCAST_QUEUE),

+	};

+

+	lockdep_assert_held(&mvm->mutex);

+

+	/* mark all VIF used hw queues */

+	ieee80211_iterate_active_interfaces_atomic(

+		mvm->hw, IEEE80211_IFACE_ITER_RESUME_ALL,

+		iwl_mvm_iface_hw_queues_iter, &data);

+

+	return data.used_hw_queues;

+}

+

 static void iwl_mvm_mac_iface_iterator(void *_data, u8 *mac,

 				       struct ieee80211_vif *vif)

 {

@@ -300,6 +360,8 @@

 		mvm->hw, IEEE80211_IFACE_ITER_RESUME_ALL,

 		iwl_mvm_mac_iface_iterator, &data);

+	used_hw_queues = iwl_mvm_get_used_hw_queues(mvm, vif);

+

 	/*

 	 * In the case we're getting here during resume, it's similar to

 	 * firmware restart, and with RESUME_ALL the iterator will find

@@ -354,6 +416,9 @@

 	 * the ones here - no real limit

 	 */

 	queue_limit = IEEE80211_MAX_QUEUES;

+	BUILD_BUG_ON(IEEE80211_MAX_QUEUES >

+		     BITS_PER_BYTE *

+		     sizeof(mvm->hw_queue_to_mac80211[0]));

 	/*

 	 * Find available queues, and allocate them to the ACs. When in

@@ -381,6 +446,9 @@

 		 * queue value (when queue is enabled).

 		 */

 		mvmvif->cab_queue = IWL_MVM_DQA_GCAST_QUEUE;

+		vif->cab_queue = IWL_MVM_DQA_GCAST_QUEUE;

+	} else {

+		vif->cab_queue = IEEE80211_INVAL_HW_QUEUE;

 	}

 	mvmvif->bcast_sta.sta_id = IWL_MVM_INVALID_STA;

@@ -394,6 +462,8 @@

 exit_fail:

 	memset(mvmvif, 0, sizeof(struct iwl_mvm_vif));

+	memset(vif->hw_queue, IEEE80211_INVAL_HW_QUEUE, sizeof(vif->hw_queue));

+	vif->cab_queue = IEEE80211_INVAL_HW_QUEUE;

 	return ret;

 }

@@ -1120,7 +1190,7 @@

 	if (!fw_has_api(&mvm->fw->ucode_capa,

 			IWL_UCODE_TLV_API_STA_TYPE))

-		ctxt_ap->mcast_qid = cpu_to_le32(mvmvif->cab_queue);

+		ctxt_ap->mcast_qid = cpu_to_le32(vif->cab_queue);

 	/*

 	 * Only set the beacon time when the MAC is being added, when we

Index: src/drivers/net/wireless/intel/iwlwifi/mvm/mac80211.c

===================================================================

--- src.orig/drivers/net/wireless/intel/iwlwifi/mvm/mac80211.c	2019-07-31 18:50:40.636230724 +0200

+++ src/drivers/net/wireless/intel/iwlwifi/mvm/mac80211.c	2019-07-31 18:51:11.753815253 +0200

@@ -414,6 +414,7 @@

 	ieee80211_hw_set(hw, SIGNAL_DBM);

 	ieee80211_hw_set(hw, SPECTRUM_MGMT);

 	ieee80211_hw_set(hw, REPORTS_TX_ACK_STATUS);

+	ieee80211_hw_set(hw, QUEUE_CONTROL);

 	ieee80211_hw_set(hw, WANT_MONITOR_VIF);

 	ieee80211_hw_set(hw, SUPPORTS_PS);

 	ieee80211_hw_set(hw, SUPPORTS_DYNAMIC_PS);

@@ -427,8 +428,6 @@

 	ieee80211_hw_set(hw, NEEDS_UNIQUE_STA_ADDR);

 	ieee80211_hw_set(hw, DEAUTH_NEED_MGD_TX_PREP);

 	ieee80211_hw_set(hw, SUPPORTS_VHT_EXT_NSS_BW);

-	ieee80211_hw_set(hw, BUFF_MMPDU_TXQ);

-	ieee80211_hw_set(hw, STA_MMPDU_TXQ);

 	if (iwl_mvm_has_tlc_offload(mvm)) {

 		ieee80211_hw_set(hw, TX_AMPDU_SETUP_IN_HW);

@@ -539,7 +538,6 @@

 	hw->sta_data_size = sizeof(struct iwl_mvm_sta);

 	hw->vif_data_size = sizeof(struct iwl_mvm_vif);

 	hw->chanctx_data_size = sizeof(u16);

-	hw->txq_data_size = sizeof(struct iwl_mvm_txq);

 	hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |

 		BIT(NL80211_IFTYPE_P2P_CLIENT) |

@@ -785,6 +783,7 @@

 		goto out;

 	__skb_queue_tail(&mvm->d0i3_tx, skb);

+	ieee80211_stop_queues(mvm->hw);

 	/* trigger wakeup */

 	iwl_mvm_ref(mvm, IWL_MVM_REF_TX);

@@ -804,15 +803,13 @@

 	struct ieee80211_sta *sta = control->sta;

 	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);

 	struct ieee80211_hdr *hdr = (void *)skb->data;

-	bool offchannel = IEEE80211_SKB_CB(skb)->flags &

-		IEEE80211_TX_CTL_TX_OFFCHAN;

 	if (iwl_mvm_is_radio_killed(mvm)) {

 		IWL_DEBUG_DROP(mvm, "Dropping - RF/CT KILL\n");

 		goto drop;

 	}

-	if (offchannel &&

+	if (info->hw_queue == IWL_MVM_OFFCHANNEL_QUEUE &&

 	    !test_bit(IWL_MVM_STATUS_ROC_RUNNING, &mvm->status) &&

 	    !test_bit(IWL_MVM_STATUS_ROC_AUX_RUNNING, &mvm->status))

 		goto drop;

@@ -825,8 +822,8 @@

 		sta = NULL;

 	/* If there is no sta, and it's not offchannel - send through AP */

-	if (!sta && info->control.vif->type == NL80211_IFTYPE_STATION &&

-	    !offchannel) {

+	if (info->control.vif->type == NL80211_IFTYPE_STATION &&

+	    info->hw_queue != IWL_MVM_OFFCHANNEL_QUEUE && !sta) {

 		struct iwl_mvm_vif *mvmvif =

 			iwl_mvm_vif_from_mac80211(info->control.vif);

 		u8 ap_sta_id = READ_ONCE(mvmvif->ap_sta_id);

@@ -854,107 +851,6 @@

 	ieee80211_free_txskb(hw, skb);

 }

-void iwl_mvm_mac_itxq_xmit(struct ieee80211_hw *hw, struct ieee80211_txq *txq)

-{

-	struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);

-	struct iwl_mvm_txq *mvmtxq = iwl_mvm_txq_from_mac80211(txq);

-	struct sk_buff *skb = NULL;

-

-	/*

-	 * No need for threads to be pending here, they can leave the first

-	 * taker all the work.

-	 *

-	 * mvmtxq->tx_request logic:

-	 *

-	 * If 0, no one is currently TXing, set to 1 to indicate current thread

-	 * will now start TX and other threads should quit.

-	 *

-	 * If 1, another thread is currently TXing, set to 2 to indicate to

-	 * that thread that there was another request. Since that request may

-	 * have raced with the check whether the queue is empty, the TXing

-	 * thread should check the queue's status one more time before leaving.

-	 * This check is done in order to not leave any TX hanging in the queue

-	 * until the next TX invocation (which may not even happen).

-	 *

-	 * If 2, another thread is currently TXing, and it will already double

-	 * check the queue, so do nothing.

-	 */

-#if 0 /* Not in RHEL */

-	if (atomic_fetch_add_unless(&mvmtxq->tx_request, 1, 2))

-#else

-	if (__atomic_add_unless(&mvmtxq->tx_request, 1, 2))

-#endif

-		return;

-

-

-	rcu_read_lock();

-	do {

-		while (likely(!mvmtxq->stopped &&

-			      (mvm->trans->system_pm_mode ==

-			       IWL_PLAT_PM_MODE_DISABLED))) {

-			skb = ieee80211_tx_dequeue(hw, txq);

-

-			if (!skb) {

-				if (txq->sta)

-					IWL_DEBUG_TX(mvm,

-						     "TXQ of sta %pM tid %d is now empty\n",

-						     txq->sta->addr,

-						     txq->tid);

-				break;

-			}

-

-			if (!txq->sta)

-				iwl_mvm_tx_skb_non_sta(mvm, skb);

-			else

-				iwl_mvm_tx_skb(mvm, skb, txq->sta);

-		}

-	} while (atomic_dec_return(&mvmtxq->tx_request));

-	rcu_read_unlock();

-}

-

-static void iwl_mvm_mac_wake_tx_queue(struct ieee80211_hw *hw,

-				      struct ieee80211_txq *txq)

-{

-	struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);

-	struct iwl_mvm_txq *mvmtxq = iwl_mvm_txq_from_mac80211(txq);

-

-	/*

-	 * Please note that racing is handled very carefully here:

-	 * mvmtxq->txq_id is updated during allocation, and mvmtxq->list is

-	 * deleted afterwards.

-	 * This means that if:

-	 * mvmtxq->txq_id != INVALID_QUEUE && list_empty(&mvmtxq->list):

-	 *	queue is allocated and we can TX.

-	 * mvmtxq->txq_id != INVALID_QUEUE && !list_empty(&mvmtxq->list):

-	 *	a race, should defer the frame.

-	 * mvmtxq->txq_id == INVALID_QUEUE && list_empty(&mvmtxq->list):

-	 *	need to allocate the queue and defer the frame.

-	 * mvmtxq->txq_id == INVALID_QUEUE && !list_empty(&mvmtxq->list):

-	 *	queue is already scheduled for allocation, no need to allocate,

-	 *	should defer the frame.

-	 */

-

-	/* If the queue is allocated TX and return. */

-	if (!txq->sta || mvmtxq->txq_id != IWL_MVM_INVALID_QUEUE) {

-		/*

-		 * Check that list is empty to avoid a race where txq_id is

-		 * already updated, but the queue allocation work wasn't

-		 * finished

-		 */

-		if (unlikely(txq->sta && !list_empty(&mvmtxq->list)))

-			return;

-

-		iwl_mvm_mac_itxq_xmit(hw, txq);

-		return;

-	}

-

-	/* The list is being deleted only after the queue is fully allocated. */

-	if (!list_empty(&mvmtxq->list))

-		return;

-

-	list_add_tail(&mvmtxq->list, &mvm->add_stream_txqs);

-	schedule_work(&mvm->add_stream_wk);

-}

 #define CHECK_BA_TRIGGER(_mvm, _trig, _tid_bm, _tid, _fmt...)		\

 	do {								\

@@ -1172,6 +1068,7 @@

 	iwl_mvm_reset_phy_ctxts(mvm);

 	memset(mvm->fw_key_table, 0, sizeof(mvm->fw_key_table));

+	memset(mvm->sta_deferred_frames, 0, sizeof(mvm->sta_deferred_frames));

 	memset(&mvm->last_bt_notif, 0, sizeof(mvm->last_bt_notif));

 	memset(&mvm->last_bt_ci_cmd, 0, sizeof(mvm->last_bt_ci_cmd));

@@ -3086,6 +2983,32 @@

 				peer_addr, action);

 }

+static void iwl_mvm_purge_deferred_tx_frames(struct iwl_mvm *mvm,

+					     struct iwl_mvm_sta *mvm_sta)

+{

+	struct iwl_mvm_tid_data *tid_data;

+	struct sk_buff *skb;

+	int i;

+

+	spin_lock_bh(&mvm_sta->lock);

+	for (i = 0; i <= IWL_MAX_TID_COUNT; i++) {

+		tid_data = &mvm_sta->tid_data[i];

+

+		while ((skb = __skb_dequeue(&tid_data->deferred_tx_frames))) {

+			struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);

+

+			/*

+			 * The first deferred frame should've stopped the MAC

+			 * queues, so we should never get a second deferred

+			 * frame for the RA/TID.

+			 */

+			iwl_mvm_start_mac_queues(mvm, BIT(info->hw_queue));

+			ieee80211_free_txskb(mvm->hw, skb);

+		}

+	}

+	spin_unlock_bh(&mvm_sta->lock);

+}

+

 static int iwl_mvm_mac_sta_state(struct ieee80211_hw *hw,

 				 struct ieee80211_vif *vif,

 				 struct ieee80211_sta *sta,

@@ -3119,6 +3042,7 @@

 	 */

 	if (old_state == IEEE80211_STA_NONE &&

 	    new_state == IEEE80211_STA_NOTEXIST) {

+		iwl_mvm_purge_deferred_tx_frames(mvm, mvm_sta);

 		flush_work(&mvm->add_stream_wk);

 		/*

@@ -4914,7 +4838,6 @@

 const struct ieee80211_ops iwl_mvm_hw_ops = {

 	.tx = iwl_mvm_mac_tx,

-	.wake_tx_queue = iwl_mvm_mac_wake_tx_queue,

 	.ampdu_action = iwl_mvm_mac_ampdu_action,

 	.start = iwl_mvm_mac_start,

 	.reconfig_complete = iwl_mvm_mac_reconfig_complete,

Index: src/drivers/net/wireless/intel/iwlwifi/mvm/mvm.h

===================================================================

--- src.orig/drivers/net/wireless/intel/iwlwifi/mvm/mvm.h	2019-07-31 18:50:40.637230710 +0200

+++ src/drivers/net/wireless/intel/iwlwifi/mvm/mvm.h	2019-07-31 18:51:11.753815253 +0200

@@ -805,39 +805,6 @@

 	u8 values[ACPI_GEO_TABLE_SIZE];

 };

-struct iwl_mvm_txq {

-	struct list_head list;

-	u16 txq_id;

-	atomic_t tx_request;

-	bool stopped;

-};

-

-static inline struct iwl_mvm_txq *

-iwl_mvm_txq_from_mac80211(struct ieee80211_txq *txq)

-{

-	return (void *)txq->drv_priv;

-}

-

-static inline struct iwl_mvm_txq *

-iwl_mvm_txq_from_tid(struct ieee80211_sta *sta, u8 tid)

-{

-	if (tid == IWL_MAX_TID_COUNT)

-		tid = IEEE80211_NUM_TIDS;

-

-	return (void *)sta->txq[tid]->drv_priv;

-}

-

-/**

- * struct iwl_mvm_tvqm_txq_info - maps TVQM hw queue to tid

- *

- * @sta_id: sta id

- * @txq_tid: txq tid

- */

-struct iwl_mvm_tvqm_txq_info {

-	u8 sta_id;

-	u8 txq_tid;

-};

-

 struct iwl_mvm_dqa_txq_info {

 	u8 ra_sta_id; /* The RA this queue is mapped to, if exists */

 	bool reserved; /* Is this the TXQ reserved for a STA */

@@ -900,13 +867,13 @@

 		u64 on_time_scan;

 	} radio_stats, accu_radio_stats;

-	struct list_head add_stream_txqs;

-	union {

-		struct iwl_mvm_dqa_txq_info queue_info[IWL_MAX_HW_QUEUES];

-		struct iwl_mvm_tvqm_txq_info tvqm_info[IWL_MAX_TVQM_QUEUES];

-	};

+	u16 hw_queue_to_mac80211[IWL_MAX_TVQM_QUEUES];

+

+	struct iwl_mvm_dqa_txq_info queue_info[IWL_MAX_HW_QUEUES];

 	struct work_struct add_stream_wk; /* To add streams to queues */

+	atomic_t mac80211_queue_stop_count[IEEE80211_MAX_QUEUES];

+

 	const char *nvm_file_name;

 	struct iwl_nvm_data *nvm_data;

 	/* NVM sections */

@@ -920,6 +887,7 @@

 	/* data related to data path */

 	struct iwl_rx_phy_info last_phy_info;

 	struct ieee80211_sta __rcu *fw_id_to_mac_id[IWL_MVM_STATION_COUNT];

+	unsigned long sta_deferred_frames[BITS_TO_LONGS(IWL_MVM_STATION_COUNT)];

 	u8 rx_ba_sessions;

 	/* configured by mac80211 */

@@ -1552,8 +1520,6 @@

 void iwl_mvm_set_tx_cmd_rate(struct iwl_mvm *mvm, struct iwl_tx_cmd *tx_cmd,

 			    struct ieee80211_tx_info *info,

 			    struct ieee80211_sta *sta, __le16 fc);

-void iwl_mvm_mac_itxq_xmit(struct ieee80211_hw *hw, struct ieee80211_txq *txq);

-

 #ifdef CONFIG_IWLWIFI_DEBUG

 const char *iwl_mvm_get_tx_fail_reason(u32 status);

 #else

@@ -1684,6 +1650,7 @@

 int iwl_mvm_mac_ctxt_changed(struct iwl_mvm *mvm, struct ieee80211_vif *vif,

 			     bool force_assoc_off, const u8 *bssid_override);

 int iwl_mvm_mac_ctxt_remove(struct iwl_mvm *mvm, struct ieee80211_vif *vif);

+u32 iwl_mvm_mac_get_queues_mask(struct ieee80211_vif *vif);

 int iwl_mvm_mac_ctxt_beacon_changed(struct iwl_mvm *mvm,

 				    struct ieee80211_vif *vif);

 int iwl_mvm_mac_ctxt_send_beacon(struct iwl_mvm *mvm,

@@ -1710,6 +1677,8 @@

 				 struct iwl_rx_cmd_buffer *rxb);

 void iwl_mvm_mac_ctxt_recalc_tsf_id(struct iwl_mvm *mvm,

 				    struct ieee80211_vif *vif);

+unsigned long iwl_mvm_get_used_hw_queues(struct iwl_mvm *mvm,

+					 struct ieee80211_vif *exclude_vif);

 void iwl_mvm_probe_resp_data_notif(struct iwl_mvm *mvm,

 				   struct iwl_rx_cmd_buffer *rxb);

 void iwl_mvm_channel_switch_noa_notif(struct iwl_mvm *mvm,

@@ -2020,6 +1989,10 @@

 	iwl_fw_dump_conf_clear(&mvm->fwrt);

 }

+/* Stop/start all mac queues in a given bitmap */

+void iwl_mvm_start_mac_queues(struct iwl_mvm *mvm, unsigned long mq);

+void iwl_mvm_stop_mac_queues(struct iwl_mvm *mvm, unsigned long mq);

+

 /* Re-configure the SCD for a queue that has already been configured */

 int iwl_mvm_reconfig_scd(struct iwl_mvm *mvm, int queue, int fifo, int sta_id,

 			 int tid, int frame_limit, u16 ssn);

Index: src/drivers/net/wireless/intel/iwlwifi/mvm/ops.c

===================================================================

--- src.orig/drivers/net/wireless/intel/iwlwifi/mvm/ops.c	2019-07-31 18:50:59.172983228 +0200

+++ src/drivers/net/wireless/intel/iwlwifi/mvm/ops.c	2019-07-31 18:51:11.754815240 +0200

@@ -707,7 +707,6 @@

 	INIT_DELAYED_WORK(&mvm->tdls_cs.dwork, iwl_mvm_tdls_ch_switch_work);

 	INIT_DELAYED_WORK(&mvm->scan_timeout_dwork, iwl_mvm_scan_timeout_wk);

 	INIT_WORK(&mvm->add_stream_wk, iwl_mvm_add_new_dqa_stream_wk);

-	INIT_LIST_HEAD(&mvm->add_stream_txqs);

 	spin_lock_init(&mvm->d0i3_tx_lock);

 	spin_lock_init(&mvm->refs_lock);

@@ -1091,6 +1090,24 @@

 		iwl_mvm_rx_common(mvm, rxb, pkt);

 }

+void iwl_mvm_stop_mac_queues(struct iwl_mvm *mvm, unsigned long mq)

+{

+	int q;

+

+	if (WARN_ON_ONCE(!mq))

+		return;

+

+	for_each_set_bit(q, &mq, IEEE80211_MAX_QUEUES) {

+		if (atomic_inc_return(&mvm->mac80211_queue_stop_count[q]) > 1) {

+			IWL_DEBUG_TX_QUEUES(mvm,

+					    "mac80211 %d already stopped\n", q);

+			continue;

+		}

+

+		ieee80211_stop_queue(mvm->hw, q);

+	}

+}

+

 static void iwl_mvm_async_cb(struct iwl_op_mode *op_mode,

 			     const struct iwl_device_cmd *cmd)

 {

@@ -1103,66 +1120,38 @@

 	iwl_trans_block_txq_ptrs(mvm->trans, false);

 }

-static void iwl_mvm_queue_state_change(struct iwl_op_mode *op_mode,

-				       int hw_queue, bool start)

+static void iwl_mvm_stop_sw_queue(struct iwl_op_mode *op_mode, int hw_queue)

 {

 	struct iwl_mvm *mvm = IWL_OP_MODE_GET_MVM(op_mode);

-	struct ieee80211_sta *sta;

-	struct ieee80211_txq *txq;

-	struct iwl_mvm_txq *mvmtxq;

-	int i;

-	unsigned long tid_bitmap;

-	struct iwl_mvm_sta *mvmsta;

-	u8 sta_id;

-

-	sta_id = iwl_mvm_has_new_tx_api(mvm) ?

-		mvm->tvqm_info[hw_queue].sta_id :

-		mvm->queue_info[hw_queue].ra_sta_id;

-

-	if (WARN_ON_ONCE(sta_id >= ARRAY_SIZE(mvm->fw_id_to_mac_id)))

-		return;

+	unsigned long mq = mvm->hw_queue_to_mac80211[hw_queue];

-	rcu_read_lock();

-

-	sta = rcu_dereference(mvm->fw_id_to_mac_id[sta_id]);

-	if (IS_ERR_OR_NULL(sta))

-		goto out;

-	mvmsta = iwl_mvm_sta_from_mac80211(sta);

-

-	if (iwl_mvm_has_new_tx_api(mvm)) {

-		int tid = mvm->tvqm_info[hw_queue].txq_tid;

-

-		tid_bitmap = BIT(tid);

-	} else {

-		tid_bitmap = mvm->queue_info[hw_queue].tid_bitmap;

-	}

+	iwl_mvm_stop_mac_queues(mvm, mq);

+}

-	for_each_set_bit(i, &tid_bitmap, IWL_MAX_TID_COUNT + 1) {

-		int tid = i;

+void iwl_mvm_start_mac_queues(struct iwl_mvm *mvm, unsigned long mq)

+{

+	int q;

-		if (tid == IWL_MAX_TID_COUNT)

-			tid = IEEE80211_NUM_TIDS;

+	if (WARN_ON_ONCE(!mq))

+		return;

-		txq = sta->txq[tid];

-		mvmtxq = iwl_mvm_txq_from_mac80211(txq);

-		mvmtxq->stopped = !start;

+	for_each_set_bit(q, &mq, IEEE80211_MAX_QUEUES) {

+		if (atomic_dec_return(&mvm->mac80211_queue_stop_count[q]) > 0) {

+			IWL_DEBUG_TX_QUEUES(mvm,

+					    "mac80211 %d still stopped\n", q);

+			continue;

+		}

-		if (start && mvmsta->sta_state != IEEE80211_STA_NOTEXIST)

-			iwl_mvm_mac_itxq_xmit(mvm->hw, txq);

+		ieee80211_wake_queue(mvm->hw, q);

 	}

-

-out:

-	rcu_read_unlock();

-}

-

-static void iwl_mvm_stop_sw_queue(struct iwl_op_mode *op_mode, int hw_queue)

-{

-	iwl_mvm_queue_state_change(op_mode, hw_queue, false);

 }

 static void iwl_mvm_wake_sw_queue(struct iwl_op_mode *op_mode, int hw_queue)

 {

-	iwl_mvm_queue_state_change(op_mode, hw_queue, true);

+	struct iwl_mvm *mvm = IWL_OP_MODE_GET_MVM(op_mode);

+	unsigned long mq = mvm->hw_queue_to_mac80211[hw_queue];

+

+	iwl_mvm_start_mac_queues(mvm, mq);

 }

 static void iwl_mvm_set_rfkill_state(struct iwl_mvm *mvm)

Index: src/drivers/net/wireless/intel/iwlwifi/mvm/sta.c

===================================================================

--- src.orig/drivers/net/wireless/intel/iwlwifi/mvm/sta.c	2019-07-31 18:50:53.312061481 +0200

+++ src/drivers/net/wireless/intel/iwlwifi/mvm/sta.c	2019-07-31 18:51:11.755815227 +0200

@@ -353,16 +353,24 @@

 					   &cmd, &status);

 }

-static int iwl_mvm_disable_txq(struct iwl_mvm *mvm, struct ieee80211_sta *sta,

-			       int queue, u8 tid, u8 flags)

+static int iwl_mvm_disable_txq(struct iwl_mvm *mvm, int queue,

+			       int mac80211_queue, u8 tid, u8 flags)

 {

 	struct iwl_scd_txq_cfg_cmd cmd = {

 		.scd_queue = queue,

 		.action = SCD_CFG_DISABLE_QUEUE,

 	};

+	bool remove_mac_queue = mac80211_queue != IEEE80211_INVAL_HW_QUEUE;

 	int ret;

+	if (WARN_ON(remove_mac_queue && mac80211_queue >= IEEE80211_MAX_QUEUES))

+		return -EINVAL;

+

 	if (iwl_mvm_has_new_tx_api(mvm)) {

+		if (remove_mac_queue)

+			mvm->hw_queue_to_mac80211[queue] &=

+				~BIT(mac80211_queue);

+

 		iwl_trans_txq_free(mvm->trans, queue);

 		return 0;

@@ -373,15 +381,36 @@

 	mvm->queue_info[queue].tid_bitmap &= ~BIT(tid);

+	/*

+	 * If there is another TID with the same AC - don't remove the MAC queue

+	 * from the mapping

+	 */

+	if (tid < IWL_MAX_TID_COUNT) {

+		unsigned long tid_bitmap =

+			mvm->queue_info[queue].tid_bitmap;

+		int ac = tid_to_mac80211_ac[tid];

+		int i;

+

+		for_each_set_bit(i, &tid_bitmap, IWL_MAX_TID_COUNT) {

+			if (tid_to_mac80211_ac[i] == ac)

+				remove_mac_queue = false;

+		}

+	}

+

+	if (remove_mac_queue)

+		mvm->hw_queue_to_mac80211[queue] &=

+			~BIT(mac80211_queue);

+

 	cmd.action = mvm->queue_info[queue].tid_bitmap ?

 		SCD_CFG_ENABLE_QUEUE : SCD_CFG_DISABLE_QUEUE;

 	if (cmd.action == SCD_CFG_DISABLE_QUEUE)