* [PATCH v3 1/3] wifi: mac80211: add ieee80211_tx_peek API
2026-07-20 7:08 [PATCH v3 0/3] wifi: ath11k/ath12k: implement TX flow control Jose Ignacio Tornos Martinez
@ 2026-07-20 7:08 ` Jose Ignacio Tornos Martinez
2026-07-21 16:28 ` Johannes Berg
2026-07-20 7:08 ` [PATCH v3 2/3] wifi: ath11k: implement custom wake_tx_queue with flow control Jose Ignacio Tornos Martinez
2026-07-20 7:08 ` [PATCH v3 3/3] wifi: ath12k: " Jose Ignacio Tornos Martinez
2 siblings, 1 reply; 5+ messages in thread
From: Jose Ignacio Tornos Martinez @ 2026-07-20 7:08 UTC (permalink / raw)
To: jjohnson
Cc: ath11k, ath12k, linux-wireless, linux-kernel,
Jose Ignacio Tornos Martinez
Add ieee80211_tx_peek() to allow drivers to inspect the next frame
in a TXQ without removing it.
Drivers implementing custom wake_tx_queue operations may need to
determine which hardware TX ring to use before dequeuing a packet,
using properties like the skb hash or queue mapping that are only
available from the skb itself.
The function checks pending fragments first, then iterates through
all fair-queue flows (new_flows and old_flows) to find the first
queued frame, matching the iteration behavior of fq_tin_dequeue.
It also pre-caches the skb hash via skb_get_hash() so that
hash-based ring selectors see a stable value through the subsequent
dequeue and TX path.
Signed-off-by: Jose Ignacio Tornos Martinez <jtornosm@redhat.com>
---
v3: no modification
v2: https://lore.kernel.org/all/20260715125017.277242-2-jtornosm@redhat.com/
include/net/mac80211.h | 20 ++++++++++++++++++++
net/mac80211/tx.c | 39 +++++++++++++++++++++++++++++++++++++++
2 files changed, 59 insertions(+)
diff --git a/include/net/mac80211.h b/include/net/mac80211.h
index 4f95da023746..9289b8dca972 100644
--- a/include/net/mac80211.h
+++ b/include/net/mac80211.h
@@ -7742,6 +7742,26 @@ void ieee80211_unreserve_tid(struct ieee80211_sta *sta, u8 tid);
struct sk_buff *ieee80211_tx_dequeue(struct ieee80211_hw *hw,
struct ieee80211_txq *txq);
+/**
+ * ieee80211_tx_peek - peek at the next packet in a software tx queue
+ *
+ * @hw: pointer as obtained from ieee80211_alloc_hw()
+ * @txq: pointer obtained from station or virtual interface, or from
+ * ieee80211_next_txq()
+ *
+ * Return: the next skb without dequeuing it, or %NULL if the queue is empty.
+ * The returned pointer is const — the caller must not modify or free the skb.
+ * The skb remains queued and will be returned by a subsequent
+ * ieee80211_tx_dequeue() call.
+ *
+ * This is useful for drivers that need to inspect the next frame (e.g. to
+ * determine the target TX ring) before deciding whether to dequeue.
+ *
+ * Must be called in the same context as ieee80211_tx_dequeue().
+ */
+const struct sk_buff *ieee80211_tx_peek(struct ieee80211_hw *hw,
+ struct ieee80211_txq *txq);
+
/**
* ieee80211_tx_dequeue_ni - dequeue a packet from a software tx queue
* (in process context)
diff --git a/net/mac80211/tx.c b/net/mac80211/tx.c
index c13b209fad47..91bfd8ef9428 100644
--- a/net/mac80211/tx.c
+++ b/net/mac80211/tx.c
@@ -3857,6 +3857,45 @@ static bool ieee80211_xmit_fast(struct ieee80211_sub_if_data *sdata,
return true;
}
+const struct sk_buff *ieee80211_tx_peek(struct ieee80211_hw *hw,
+ struct ieee80211_txq *txq)
+{
+ struct txq_info *txqi = container_of(txq, struct txq_info, txq);
+ struct ieee80211_local *local = hw_to_local(hw);
+ struct fq_tin *tin = &txqi->tin;
+ struct fq *fq = &local->fq;
+ struct sk_buff *skb = NULL;
+ struct fq_flow *flow;
+
+ WARN_ON_ONCE(softirq_count() == 0);
+
+ spin_lock_bh(&fq->lock);
+
+ skb = skb_peek(&txqi->frags);
+ if (skb)
+ goto out;
+
+ list_for_each_entry(flow, &tin->new_flows, flowchain) {
+ skb = skb_peek(&flow->queue);
+ if (skb)
+ goto out;
+ }
+
+ list_for_each_entry(flow, &tin->old_flows, flowchain) {
+ skb = skb_peek(&flow->queue);
+ if (skb)
+ goto out;
+ }
+
+out:
+ if (skb)
+ skb_get_hash(skb);
+
+ spin_unlock_bh(&fq->lock);
+ return skb;
+}
+EXPORT_SYMBOL_GPL(ieee80211_tx_peek);
+
struct sk_buff *ieee80211_tx_dequeue(struct ieee80211_hw *hw,
struct ieee80211_txq *txq)
{
--
2.54.0
^ permalink raw reply related [flat|nested] 5+ messages in thread* Re: [PATCH v3 1/3] wifi: mac80211: add ieee80211_tx_peek API
2026-07-20 7:08 ` [PATCH v3 1/3] wifi: mac80211: add ieee80211_tx_peek API Jose Ignacio Tornos Martinez
@ 2026-07-21 16:28 ` Johannes Berg
0 siblings, 0 replies; 5+ messages in thread
From: Johannes Berg @ 2026-07-21 16:28 UTC (permalink / raw)
To: Jose Ignacio Tornos Martinez, jjohnson
Cc: ath11k, ath12k, linux-wireless, linux-kernel
On Mon, 2026-07-20 at 09:08 +0200, Jose Ignacio Tornos Martinez wrote:
>
> +const struct sk_buff *ieee80211_tx_peek(struct ieee80211_hw *hw,
> + struct ieee80211_txq *txq)
While it makes some sense, I don't think I like the way you've
implemented this.
First, it basically does a lot of the work twice, say if it has to walk
a lot of flows to find the SKB.
Second, the work that it does is almost entirely disjoint from
ieee80211_tx_dequeue(). The latter doesn't even fill the hash (and not
all drivers might care), although I'm not even sure it's _needed_ to do
skb_get_hash() there, seems like this fairly obviously happens *after*
ieee80211_select_queue() or ieee80211_select_queue_80211(). So maybe
this isn't strictly more work than what dequeue() would do, because it's
a nop anyway.
Also though it does a LOT less work, although it pretends that the SKB
is fully formed, at least it makes no representations otherwise, and
that's obviously not true. Most things in the ieee80211_tx_info are not
filled in, kind of randomly by where and when mac80211 decided to do
that (which isn't really random, of course, but might as well be random
to the driver). As such, it seems only useful in a very limited subset
of cases.
Third, it documents that the skb will be returned by a subsequent
ieee80211_tx_dequeue() call, but that's obviously not true - the next
such call might not return anything at all, even for quite a while if
queues are stopped etc. which isn't considered in peek(), and I'm not
even convinced that it must ever be returned, if something else happened
in the meantime while such a situation occurred (queues stopped). Even
ieee80211_tx_dequeue() itself can drop SKBs entirely.
As such I'm not even convinced that there's a guarantee that after the
skb peek you even have done the work you claim to have done, if a
different skb is returned from dequeue() instead of this one.
I think I sort of understand the motivation, but it feels like you need
to go back to the drawing board. Maybe even further back, and perhaps
ath11k/ath12k just shouldn't use the hash of the SKB itself, but
something else that can be derived without the SKB hash?
If that's not feasible then this probably needs to be turned upside
down; perhaps there's some way to dequeue it anyway and hold it
somewhere for later (though that has issues with all the pointers in the
skb->cb), I don't have a good idea though.
johannes
^ permalink raw reply [flat|nested] 5+ messages in thread
* [PATCH v3 2/3] wifi: ath11k: implement custom wake_tx_queue with flow control
2026-07-20 7:08 [PATCH v3 0/3] wifi: ath11k/ath12k: implement TX flow control Jose Ignacio Tornos Martinez
2026-07-20 7:08 ` [PATCH v3 1/3] wifi: mac80211: add ieee80211_tx_peek API Jose Ignacio Tornos Martinez
@ 2026-07-20 7:08 ` Jose Ignacio Tornos Martinez
2026-07-20 7:08 ` [PATCH v3 3/3] wifi: ath12k: " Jose Ignacio Tornos Martinez
2 siblings, 0 replies; 5+ messages in thread
From: Jose Ignacio Tornos Martinez @ 2026-07-20 7:08 UTC (permalink / raw)
To: jjohnson
Cc: ath11k, ath12k, linux-wireless, linux-kernel,
Jose Ignacio Tornos Martinez
Under heavy traffic, ath11k experiences frequent -ENOMEM errors
("failed to transmit frame -12") when the hardware TCL ring fills up.
This issue is more commonly observed in VMs with PCIe passthrough but
also occurs on bare metal systems. It is particularly problematic on
devices with a single shared TCL ring where all traffic classes
compete for the same 512 descriptor slots.
Implement a custom wake_tx_queue operation that:
1. Checks hardware ring space before dequeuing packets from mac80211
2. Uses per-txq locking via txq->drv_priv to serialize peek and
dequeue operations for the same txq, preventing use-after-free
races between ieee80211_tx_peek() and ieee80211_tx_dequeue() when
multiple CPUs process the same txq concurrently, while keeping
different txqs fully parallel
3. Syncs with hardware state to get accurate free slot count
4. Uses ieee80211_tx_peek() to determine the exact target ring via
get_ring_selector(), matching dp_tx on all platforms
5. Returns early during firmware crash in the same way as other
tx paths
This approach follows the pattern used in the iwlwifi driver, adapted
for ath11k's hardware ring architecture.
This eliminates -ENOMEM errors and improves throughput by optimizing
resource usage and preventing unnecessary packet drops.
Signed-off-by: Jose Ignacio Tornos Martinez <jtornosm@redhat.com>
---
v3: Address the review comments from Tamizh Raja:
- Replace per-ring wake_tx_lock with per-txq spinlock via
txq->drv_priv to fix race condition between ieee80211_tx_peek() and
ieee80211_tx_dequeue() when multiple CPUs process the same txq
v2: https://lore.kernel.org/all/20260715125017.277242-3-jtornosm@redhat.com/
drivers/net/wireless/ath/ath11k/mac.c | 80 ++++++++++++++++++++++++++-
drivers/net/wireless/ath/ath11k/mac.h | 5 ++
2 files changed, 84 insertions(+), 1 deletion(-)
diff --git a/drivers/net/wireless/ath/ath11k/mac.c b/drivers/net/wireless/ath/ath11k/mac.c
index 2d55cdc4d165..1eb5edca4ee6 100644
--- a/drivers/net/wireless/ath/ath11k/mac.c
+++ b/drivers/net/wireless/ath/ath11k/mac.c
@@ -7079,6 +7079,7 @@ static int ath11k_mac_op_add_interface(struct ieee80211_hw *hw,
struct vdev_create_params vdev_param = {};
struct peer_create_params peer_param;
u32 param_id, param_value;
+ struct ath11k_txq *atxq;
u16 nss;
int i;
int ret, fbret;
@@ -7112,6 +7113,11 @@ static int ath11k_mac_op_add_interface(struct ieee80211_hw *hw,
INIT_DELAYED_WORK(&arvif->connection_loss_work,
ath11k_mac_vif_sta_connection_loss_work);
+ if (vif->txq) {
+ atxq = (void *)vif->txq->drv_priv;
+ spin_lock_init(&atxq->lock);
+ }
+
for (i = 0; i < ARRAY_SIZE(arvif->bitrate_mask.control); i++) {
arvif->bitrate_mask.control[i].legacy = 0xffffffff;
arvif->bitrate_mask.control[i].gi = NL80211_TXRATE_FORCE_SGI;
@@ -9938,7 +9944,9 @@ static int ath11k_mac_op_sta_state(struct ieee80211_hw *hw,
enum ieee80211_ap_reg_power power_type;
struct cur_regulatory_info *reg_info;
struct ath11k_peer *peer;
+ struct ath11k_txq *atxq;
int ret = 0;
+ int tid;
/* cancel must be done outside the mutex to avoid deadlock */
if ((old_state == IEEE80211_STA_NONE &&
@@ -9957,6 +9965,14 @@ static int ath11k_mac_op_sta_state(struct ieee80211_hw *hw,
INIT_WORK(&arsta->update_wk, ath11k_sta_rc_update_wk);
INIT_WORK(&arsta->set_4addr_wk, ath11k_sta_set_4addr_wk);
+ for (tid = 0; tid < ARRAY_SIZE(sta->txq); tid++) {
+ if (!sta->txq[tid])
+ continue;
+
+ atxq = (void *)sta->txq[tid]->drv_priv;
+ spin_lock_init(&atxq->lock);
+ }
+
ret = ath11k_mac_station_add(ar, vif, sta);
if (ret)
ath11k_warn(ar->ab, "Failed to add station: %pM for VDEV: %d\n",
@@ -10065,9 +10081,70 @@ static int ath11k_mac_op_sta_state(struct ieee80211_hw *hw,
return ret;
}
+static void ath11k_mac_op_wake_tx_queue(struct ieee80211_hw *hw,
+ struct ieee80211_txq *txq)
+{
+ struct ath11k_txq *atxq = (void *)txq->drv_priv;
+ struct ieee80211_tx_control control = {
+ .sta = txq->sta,
+ };
+ const struct ath11k_hw_ops *ops;
+ const struct sk_buff *peek_skb;
+ struct ath11k *ar = hw->priv;
+ struct dp_tx_ring *tx_ring;
+ struct hal_srng *tcl_ring;
+ struct sk_buff *skb;
+ u32 ring_selector;
+ int num_free;
+ u8 ring_id;
+
+ if (!ar)
+ return;
+
+ while (1) {
+ if (unlikely(test_bit(ATH11K_FLAG_CRASH_FLUSH,
+ &ar->ab->dev_flags)))
+ break;
+
+ spin_lock_bh(&atxq->lock);
+
+ peek_skb = ieee80211_tx_peek(hw, txq);
+ if (!peek_skb) {
+ spin_unlock_bh(&atxq->lock);
+ break;
+ }
+
+ ops = ar->ab->hw_params.hw_ops;
+ ring_selector = ops->get_ring_selector((struct sk_buff *)peek_skb);
+ ring_id = ring_selector %
+ ar->ab->hw_params.hal_params->num_tx_rings;
+
+ tx_ring = &ar->ab->dp.tx_ring[ring_id];
+ tcl_ring = &ar->ab->hal.srng_list[tx_ring->tcl_data_ring.ring_id];
+
+ spin_lock(&tcl_ring->lock);
+ num_free = ath11k_hal_srng_src_num_free(ar->ab, tcl_ring, true);
+ spin_unlock(&tcl_ring->lock);
+
+ if (num_free == 0) {
+ spin_unlock_bh(&atxq->lock);
+ break;
+ }
+
+ skb = ieee80211_tx_dequeue(hw, txq);
+
+ spin_unlock_bh(&atxq->lock);
+
+ if (!skb)
+ break;
+
+ ath11k_mac_op_tx(hw, &control, skb);
+ }
+}
+
static const struct ieee80211_ops ath11k_ops = {
.tx = ath11k_mac_op_tx,
- .wake_tx_queue = ieee80211_handle_wake_tx_queue,
+ .wake_tx_queue = ath11k_mac_op_wake_tx_queue,
.start = ath11k_mac_op_start,
.stop = ath11k_mac_op_stop,
.reconfig_complete = ath11k_mac_op_reconfig_complete,
@@ -10590,6 +10667,7 @@ static int __ath11k_mac_register(struct ath11k *ar)
ar->hw->vif_data_size = sizeof(struct ath11k_vif);
ar->hw->sta_data_size = sizeof(struct ath11k_sta);
+ ar->hw->txq_data_size = sizeof(struct ath11k_txq);
wiphy_ext_feature_set(ar->hw->wiphy, NL80211_EXT_FEATURE_CQM_RSSI_LIST);
wiphy_ext_feature_set(ar->hw->wiphy, NL80211_EXT_FEATURE_STA_TX_PWR);
diff --git a/drivers/net/wireless/ath/ath11k/mac.h b/drivers/net/wireless/ath/ath11k/mac.h
index 59f83c7175fd..b0116ced9c67 100644
--- a/drivers/net/wireless/ath/ath11k/mac.h
+++ b/drivers/net/wireless/ath/ath11k/mac.h
@@ -14,6 +14,11 @@
struct ath11k;
struct ath11k_base;
+struct ath11k_txq {
+ /* protects ieee80211_tx_peek/dequeue serialization per txq */
+ spinlock_t lock;
+};
+
struct ath11k_generic_iter {
struct ath11k *ar;
int ret;
--
2.54.0
^ permalink raw reply related [flat|nested] 5+ messages in thread* [PATCH v3 3/3] wifi: ath12k: implement custom wake_tx_queue with flow control
2026-07-20 7:08 [PATCH v3 0/3] wifi: ath11k/ath12k: implement TX flow control Jose Ignacio Tornos Martinez
2026-07-20 7:08 ` [PATCH v3 1/3] wifi: mac80211: add ieee80211_tx_peek API Jose Ignacio Tornos Martinez
2026-07-20 7:08 ` [PATCH v3 2/3] wifi: ath11k: implement custom wake_tx_queue with flow control Jose Ignacio Tornos Martinez
@ 2026-07-20 7:08 ` Jose Ignacio Tornos Martinez
2 siblings, 0 replies; 5+ messages in thread
From: Jose Ignacio Tornos Martinez @ 2026-07-20 7:08 UTC (permalink / raw)
To: jjohnson
Cc: ath11k, ath12k, linux-wireless, linux-kernel,
Jose Ignacio Tornos Martinez
Under heavy traffic, ath12k can hang and experiences -ENOMEM errors
("failed to transmit frame -12") when the hardware TCL ring fills up.
This issue is more commonly observed in VMs with PCIe passthrough but
also occurs on bare metal systems.
Implement a custom wake_tx_queue operation that:
1. Checks hardware ring space before dequeuing packets from mac80211
2. Uses per-txq locking via txq->drv_priv to serialize peek and
dequeue operations for the same txq, preventing use-after-free
races between ieee80211_tx_peek() and ieee80211_tx_dequeue() when
multiple CPUs process the same txq concurrently, while keeping
different txqs fully parallel
3. Syncs with hardware state to get accurate free slot count
4. Uses ieee80211_tx_peek() to determine the exact target ring via
get_ring_selector(), matching dp_tx on all platforms
5. Returns early during firmware crash in the same way as other
tx paths
This approach follows the pattern used in the iwlwifi driver, adapted
for ath12k's hardware ring architecture.
This prevents hangs, eliminates -ENOMEM errors, and improves throughput
by optimizing resource usage and preventing unnecessary packet drops.
Signed-off-by: Jose Ignacio Tornos Martinez <jtornosm@redhat.com>
---
v3: Address the review comments from Tamizh Raja:
- Replace per-ring wake_tx_lock with per-txq spinlock via
txq->drv_priv to fix race condition between ieee80211_tx_peek() and
ieee80211_tx_dequeue() when multiple CPUs process the same txq
- Fix MLO link selection in wake_tx_queue to use
rcu_dereference(ahvif->link[link_id]) instead of deflink, matching
the link selection logic in op_tx
v2: https://lore.kernel.org/all/20260715125017.277242-4-jtornosm@redhat.com/
drivers/net/wireless/ath/ath12k/hal.c | 1 +
drivers/net/wireless/ath/ath12k/mac.c | 17 +++++
drivers/net/wireless/ath/ath12k/mac.h | 5 ++
drivers/net/wireless/ath/ath12k/wifi7/hw.c | 87 +++++++++++++++++++++-
4 files changed, 109 insertions(+), 1 deletion(-)
diff --git a/drivers/net/wireless/ath/ath12k/hal.c b/drivers/net/wireless/ath/ath12k/hal.c
index a164563fff28..c1c656e4550b 100644
--- a/drivers/net/wireless/ath/ath12k/hal.c
+++ b/drivers/net/wireless/ath/ath12k/hal.c
@@ -390,6 +390,7 @@ int ath12k_hal_srng_src_num_free(struct ath12k_base *ab, struct hal_srng *srng,
else
return ((srng->ring_size - hp + tp) / srng->entry_size) - 1;
}
+EXPORT_SYMBOL_GPL(ath12k_hal_srng_src_num_free);
void *ath12k_hal_srng_src_next_peek(struct ath12k_base *ab,
struct hal_srng *srng)
diff --git a/drivers/net/wireless/ath/ath12k/mac.c b/drivers/net/wireless/ath/ath12k/mac.c
index 51c4df32e716..03618a8d3e65 100644
--- a/drivers/net/wireless/ath/ath12k/mac.c
+++ b/drivers/net/wireless/ath/ath12k/mac.c
@@ -7705,10 +7705,12 @@ int ath12k_mac_op_sta_state(struct ieee80211_hw *hw,
struct ath12k_link_vif *arvif;
struct ath12k_link_sta *arsta;
unsigned long valid_links;
+ struct ath12k_txq *atxq;
u16 selected_links = 0;
u8 link_id = 0, i;
struct ath12k *ar;
int ret = -EINVAL;
+ int tid;
struct ath12k_dp_peer_create_params dp_params = {};
lockdep_assert_wiphy(hw->wiphy);
@@ -7728,6 +7730,14 @@ int ath12k_mac_op_sta_state(struct ieee80211_hw *hw,
memset(ahsta, 0, sizeof(*ahsta));
ahsta->free_logical_link_idx_map = U16_MAX;
+ for (tid = 0; tid < ARRAY_SIZE(sta->txq); tid++) {
+ if (!sta->txq[tid])
+ continue;
+
+ atxq = (void *)sta->txq[tid]->drv_priv;
+ spin_lock_init(&atxq->lock);
+ }
+
arsta = &ahsta->deflink;
/* ML sta */
@@ -10790,6 +10800,7 @@ int ath12k_mac_op_add_interface(struct ieee80211_hw *hw,
struct ath12k_vif *ahvif = ath12k_vif_to_ahvif(vif);
struct ath12k_reg_info *reg_info;
struct ath12k_link_vif *arvif;
+ struct ath12k_txq *atxq;
struct ath12k_base *ab;
struct ath12k *ar;
int i;
@@ -10802,6 +10813,11 @@ int ath12k_mac_op_add_interface(struct ieee80211_hw *hw,
ahvif->vif = vif;
arvif = &ahvif->deflink;
+ if (vif->txq) {
+ atxq = (void *)vif->txq->drv_priv;
+ spin_lock_init(&atxq->lock);
+ }
+
ath12k_mac_init_arvif(ahvif, arvif, -1);
/* Allocate Default Queue now and reassign during actual vdev create */
@@ -14899,6 +14915,7 @@ static int ath12k_mac_hw_register(struct ath12k_hw *ah)
hw->vif_data_size = sizeof(struct ath12k_vif);
hw->sta_data_size = sizeof(struct ath12k_sta);
+ hw->txq_data_size = sizeof(struct ath12k_txq);
hw->extra_tx_headroom = ab->hw_params->iova_mask;
wiphy_ext_feature_set(wiphy, NL80211_EXT_FEATURE_CQM_RSSI_LIST);
diff --git a/drivers/net/wireless/ath/ath12k/mac.h b/drivers/net/wireless/ath/ath12k/mac.h
index aba98afd4365..2855d8fdb99d 100644
--- a/drivers/net/wireless/ath/ath12k/mac.h
+++ b/drivers/net/wireless/ath/ath12k/mac.h
@@ -17,6 +17,11 @@ struct ath12k_hw;
struct ath12k_hw_group;
struct ath12k_pdev_map;
+struct ath12k_txq {
+ /* protects ieee80211_tx_peek/dequeue serialization per txq */
+ spinlock_t lock;
+};
+
struct ath12k_generic_iter {
struct ath12k *ar;
int ret;
diff --git a/drivers/net/wireless/ath/ath12k/wifi7/hw.c b/drivers/net/wireless/ath/ath12k/wifi7/hw.c
index d9fdd2fc8298..86c3e9a8b87c 100644
--- a/drivers/net/wireless/ath/ath12k/wifi7/hw.c
+++ b/drivers/net/wireless/ath/ath12k/wifi7/hw.c
@@ -1100,9 +1100,94 @@ static void ath12k_wifi7_mac_op_tx(struct ieee80211_hw *hw,
}
}
+static void ath12k_wifi7_mac_op_wake_tx_queue(struct ieee80211_hw *hw,
+ struct ieee80211_txq *txq)
+{
+ struct ath12k_vif *ahvif = ath12k_vif_to_ahvif(txq->vif);
+ struct ath12k_txq *atxq = (void *)txq->drv_priv;
+ struct ath12k_hw *ah = ath12k_hw_to_ah(hw);
+ struct ieee80211_tx_control control = {
+ .sta = txq->sta,
+ };
+ struct ieee80211_vif *vif = txq->vif;
+ const struct ath12k_hw_ops *ops;
+ const struct sk_buff *peek_skb;
+ struct ath12k_link_vif *arvif;
+ struct dp_tx_ring *tx_ring;
+ struct hal_srng *tcl_ring;
+ struct ath12k_sta *ahsta;
+ struct ath12k_dp *dp;
+ struct sk_buff *skb;
+ struct ath12k *ar;
+ u32 ring_selector;
+ int num_free;
+ u8 ring_id;
+ u8 link_id;
+
+ while (1) {
+ if (unlikely(test_bit(ATH12K_FLAG_CRASH_FLUSH,
+ &ah->radio[0].ab->dev_flags)))
+ break;
+
+ spin_lock_bh(&atxq->lock);
+
+ peek_skb = ieee80211_tx_peek(hw, txq);
+ if (!peek_skb) {
+ spin_unlock_bh(&atxq->lock);
+ break;
+ }
+
+ if (ieee80211_vif_is_mld(vif) && txq->sta) {
+ ahsta = ath12k_sta_to_ahsta(txq->sta);
+ link_id = ahsta->assoc_link_id;
+ } else {
+ link_id = ahvif->deflink.link_id;
+ }
+
+ rcu_read_lock();
+
+ arvif = rcu_dereference(ahvif->link[link_id]);
+ if (!arvif || !arvif->ar) {
+ rcu_read_unlock();
+ spin_unlock_bh(&atxq->lock);
+ break;
+ }
+
+ ar = arvif->ar;
+ dp = ar->ab->dp;
+
+ ops = dp->hw_params->hw_ops;
+ ring_selector = ops->get_ring_selector((struct sk_buff *)peek_skb);
+ ring_id = ring_selector % dp->hw_params->max_tx_ring;
+
+ tx_ring = &dp->tx_ring[ring_id];
+ tcl_ring = &dp->hal->srng_list[tx_ring->tcl_data_ring.ring_id];
+
+ spin_lock(&tcl_ring->lock);
+ num_free = ath12k_hal_srng_src_num_free(ar->ab, tcl_ring, true);
+ spin_unlock(&tcl_ring->lock);
+
+ if (num_free == 0) {
+ rcu_read_unlock();
+ spin_unlock_bh(&atxq->lock);
+ break;
+ }
+
+ skb = ieee80211_tx_dequeue(hw, txq);
+
+ rcu_read_unlock();
+ spin_unlock_bh(&atxq->lock);
+
+ if (!skb)
+ break;
+
+ ath12k_wifi7_mac_op_tx(hw, &control, skb);
+ }
+}
+
static const struct ieee80211_ops ath12k_ops_wifi7 = {
.tx = ath12k_wifi7_mac_op_tx,
- .wake_tx_queue = ieee80211_handle_wake_tx_queue,
+ .wake_tx_queue = ath12k_wifi7_mac_op_wake_tx_queue,
.start = ath12k_mac_op_start,
.stop = ath12k_mac_op_stop,
.reconfig_complete = ath12k_mac_op_reconfig_complete,
--
2.54.0
^ permalink raw reply related [flat|nested] 5+ messages in thread