2019-06-04 11:11:33 +03:00
|
|
|
// SPDX-License-Identifier: GPL-2.0-only
|
2009-11-18 20:42:47 +03:00
|
|
|
/*
|
|
|
|
* Copyright 2002-2005, Instant802 Networks, Inc.
|
|
|
|
* Copyright 2005-2006, Devicescape Software, Inc.
|
|
|
|
* Copyright 2006-2007 Jiri Benc <jbenc@suse.cz>
|
2010-02-15 13:53:10 +03:00
|
|
|
* Copyright 2008-2010 Johannes Berg <johannes@sipsolutions.net>
|
2014-09-03 16:24:57 +04:00
|
|
|
* Copyright 2013-2014 Intel Mobile Communications GmbH
|
2022-02-02 11:49:47 +03:00
|
|
|
* Copyright 2021-2022 Intel Corporation
|
2009-11-18 20:42:47 +03:00
|
|
|
*/
|
|
|
|
|
2011-07-15 19:47:34 +04:00
|
|
|
#include <linux/export.h>
|
2012-03-01 18:22:09 +04:00
|
|
|
#include <linux/etherdevice.h>
|
2009-11-18 20:42:47 +03:00
|
|
|
#include <net/mac80211.h>
|
2012-02-20 14:38:41 +04:00
|
|
|
#include <asm/unaligned.h>
|
2009-11-18 20:42:47 +03:00
|
|
|
#include "ieee80211_i.h"
|
|
|
|
#include "rate.h"
|
|
|
|
#include "mesh.h"
|
|
|
|
#include "led.h"
|
2011-09-29 18:04:29 +04:00
|
|
|
#include "wme.h"
|
2009-11-18 20:42:47 +03:00
|
|
|
|
|
|
|
|
|
|
|
void ieee80211_tx_status_irqsafe(struct ieee80211_hw *hw,
|
|
|
|
struct sk_buff *skb)
|
|
|
|
{
|
|
|
|
struct ieee80211_local *local = hw_to_local(hw);
|
|
|
|
struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
|
|
|
|
int tmp;
|
|
|
|
|
|
|
|
skb->pkt_type = IEEE80211_TX_STATUS_MSG;
|
|
|
|
skb_queue_tail(info->flags & IEEE80211_TX_CTL_REQ_TX_STATUS ?
|
|
|
|
&local->skb_queue : &local->skb_queue_unreliable, skb);
|
|
|
|
tmp = skb_queue_len(&local->skb_queue) +
|
|
|
|
skb_queue_len(&local->skb_queue_unreliable);
|
|
|
|
while (tmp > IEEE80211_IRQSAFE_QUEUE_LIMIT &&
|
|
|
|
(skb = skb_dequeue(&local->skb_queue_unreliable))) {
|
2012-10-08 16:39:33 +04:00
|
|
|
ieee80211_free_txskb(hw, skb);
|
2009-11-18 20:42:47 +03:00
|
|
|
tmp--;
|
|
|
|
I802_DEBUG_INC(local->tx_status_drop);
|
|
|
|
}
|
|
|
|
tasklet_schedule(&local->tasklet);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ieee80211_tx_status_irqsafe);
|
|
|
|
|
|
|
|
static void ieee80211_handle_filtered_frame(struct ieee80211_local *local,
|
|
|
|
struct sta_info *sta,
|
|
|
|
struct sk_buff *skb)
|
|
|
|
{
|
|
|
|
struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
|
2011-09-29 18:04:29 +04:00
|
|
|
struct ieee80211_hdr *hdr = (void *)skb->data;
|
|
|
|
int ac;
|
2009-11-18 20:42:47 +03:00
|
|
|
|
2017-02-22 18:16:07 +03:00
|
|
|
if (info->flags & (IEEE80211_TX_CTL_NO_PS_BUFFER |
|
2020-11-11 21:33:57 +03:00
|
|
|
IEEE80211_TX_CTL_AMPDU |
|
|
|
|
IEEE80211_TX_CTL_HW_80211_ENCAP)) {
|
2016-01-05 19:42:13 +03:00
|
|
|
ieee80211_free_txskb(&local->hw, skb);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2010-01-17 03:47:56 +03:00
|
|
|
/*
|
|
|
|
* This skb 'survived' a round-trip through the driver, and
|
|
|
|
* hopefully the driver didn't mangle it too badly. However,
|
2010-05-18 15:44:54 +04:00
|
|
|
* we can definitely not rely on the control information
|
2010-01-17 03:47:59 +03:00
|
|
|
* being correct. Clear it so we don't get junk there, and
|
|
|
|
* indicate that it needs new processing, but must not be
|
|
|
|
* modified/encrypted again.
|
2010-01-17 03:47:56 +03:00
|
|
|
*/
|
|
|
|
memset(&info->control, 0, sizeof(info->control));
|
2010-01-25 21:07:39 +03:00
|
|
|
|
|
|
|
info->control.jiffies = jiffies;
|
|
|
|
info->control.vif = &sta->sdata->vif;
|
2020-09-08 15:36:57 +03:00
|
|
|
info->control.flags |= IEEE80211_TX_INTCFL_NEED_TXPROCESSING;
|
|
|
|
info->flags |= IEEE80211_TX_INTFL_RETRANSMISSION;
|
2010-09-21 23:36:18 +04:00
|
|
|
info->flags &= ~IEEE80211_TX_TEMPORARY_FLAGS;
|
2010-01-17 03:47:56 +03:00
|
|
|
|
mac80211: prepare sta handling for MLO support
Currently in mac80211 each STA object is represented
using sta_info datastructure with the associated
STA specific information and drivers access ieee80211_sta
part of it.
With MLO (Multi Link Operation) support being added
in 802.11be standard, though the association is logically
with a single Multi Link capable STA, at the physical level
communication can happen via different advertised
links (uniquely identified by Channel, operating class,
BSSID) and hence the need to handle multiple link
STA parameters within a composite sta_info object
called the MLD STA. The different link STA part of
MLD STA are identified using the link address which can
be same or different as the MLD STA address and unique
link id based on the link vif.
To support extension of such a model, the sta_info
datastructure is modified to hold multiple link STA
objects with link specific params currently within
sta_info moved to this new structure. Similarly this is
done for ieee80211_sta as well which will be accessed
within mac80211 as well as by drivers, hence trivial
driver changes are expected to support this.
For current non MLO supported drivers, only one link STA
is present and link information is accessed via 'deflink'
member.
For MLO drivers, we still need to define the APIs etc. to
get the correct link ID and access the correct part of
the station info.
Currently in mac80211, all link STA info are accessed directly
via deflink. These will be updated to access via link pointers
indexed by link id with MLO support patches, with link id
being 0 for non MLO supported cases.
Except for couple of macro related changes, below spatch takes
care of updating mac80211 and driver code to access to the
link STA info via deflink.
@ieee80211_sta@
struct ieee80211_sta *s;
struct sta_info *si;
identifier var = {supp_rates, ht_cap, vht_cap, he_cap, he_6ghz_capa, eht_cap, rx_nss, bandwidth, txpwr};
@@
(
s->
- var
+ deflink.var
|
si->sta.
- var
+ deflink.var
)
@sta_info@
struct sta_info *si;
identifier var = {gtk, pcpu_rx_stats, rx_stats, rx_stats_avg, status_stats, tx_stats, cur_max_bandwidth};
@@
(
si->
- var
+ deflink.var
)
Signed-off-by: Sriram R <quic_srirrama@quicinc.com>
Link: https://lore.kernel.org/r/1649086883-13246-1-git-send-email-quic_srirrama@quicinc.com
[remove MLO-drivers notes from commit message, not clear yet; run spatch]
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
2022-04-04 18:41:23 +03:00
|
|
|
sta->deflink.status_stats.filtered++;
|
2009-11-18 20:42:47 +03:00
|
|
|
|
2011-09-29 18:04:31 +04:00
|
|
|
/*
|
|
|
|
* Clear more-data bit on filtered frames, it might be set
|
|
|
|
* but later frames might time out so it might have to be
|
|
|
|
* clear again ... It's all rather unlikely (this frame
|
|
|
|
* should time out first, right?) but let's not confuse
|
|
|
|
* peers unnecessarily.
|
|
|
|
*/
|
|
|
|
if (hdr->frame_control & cpu_to_le16(IEEE80211_FCTL_MOREDATA))
|
|
|
|
hdr->frame_control &= ~cpu_to_le16(IEEE80211_FCTL_MOREDATA);
|
|
|
|
|
2011-09-29 18:04:29 +04:00
|
|
|
if (ieee80211_is_data_qos(hdr->frame_control)) {
|
2011-09-29 18:04:33 +04:00
|
|
|
u8 *p = ieee80211_get_qos_ctl(hdr);
|
|
|
|
int tid = *p & IEEE80211_QOS_CTL_TID_MASK;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Clear EOSP if set, this could happen e.g.
|
|
|
|
* if an absence period (us being a P2P GO)
|
|
|
|
* shortens the SP.
|
|
|
|
*/
|
|
|
|
if (*p & IEEE80211_QOS_CTL_EOSP)
|
|
|
|
*p &= ~IEEE80211_QOS_CTL_EOSP;
|
2017-01-24 18:42:10 +03:00
|
|
|
ac = ieee80211_ac_from_tid(tid);
|
2011-09-29 18:04:29 +04:00
|
|
|
} else {
|
|
|
|
ac = IEEE80211_AC_BE;
|
|
|
|
}
|
|
|
|
|
2009-11-18 20:42:47 +03:00
|
|
|
/*
|
|
|
|
* Clear the TX filter mask for this STA when sending the next
|
|
|
|
* packet. If the STA went to power save mode, this will happen
|
|
|
|
* when it wakes up for the next time.
|
|
|
|
*/
|
2011-09-29 18:04:36 +04:00
|
|
|
set_sta_flag(sta, WLAN_STA_CLEAR_PS_FILT);
|
2015-09-24 15:59:49 +03:00
|
|
|
ieee80211_clear_fast_xmit(sta);
|
2009-11-18 20:42:47 +03:00
|
|
|
|
|
|
|
/*
|
|
|
|
* This code races in the following way:
|
|
|
|
*
|
|
|
|
* (1) STA sends frame indicating it will go to sleep and does so
|
|
|
|
* (2) hardware/firmware adds STA to filter list, passes frame up
|
|
|
|
* (3) hardware/firmware processes TX fifo and suppresses a frame
|
|
|
|
* (4) we get TX status before having processed the frame and
|
|
|
|
* knowing that the STA has gone to sleep.
|
|
|
|
*
|
|
|
|
* This is actually quite unlikely even when both those events are
|
|
|
|
* processed from interrupts coming in quickly after one another or
|
|
|
|
* even at the same time because we queue both TX status events and
|
|
|
|
* RX frames to be processed by a tasklet and process them in the
|
|
|
|
* same order that they were received or TX status last. Hence, there
|
|
|
|
* is no race as long as the frame RX is processed before the next TX
|
|
|
|
* status, which drivers can ensure, see below.
|
|
|
|
*
|
|
|
|
* Note that this can only happen if the hardware or firmware can
|
|
|
|
* actually add STAs to the filter list, if this is done by the
|
|
|
|
* driver in response to set_tim() (which will only reduce the race
|
|
|
|
* this whole filtering tries to solve, not completely solve it)
|
|
|
|
* this situation cannot happen.
|
|
|
|
*
|
|
|
|
* To completely solve this race drivers need to make sure that they
|
|
|
|
* (a) don't mix the irq-safe/not irq-safe TX status/RX processing
|
|
|
|
* functions and
|
|
|
|
* (b) always process RX events before TX status events if ordering
|
|
|
|
* can be unknown, for example with different interrupt status
|
|
|
|
* bits.
|
2011-01-31 23:29:13 +03:00
|
|
|
* (c) if PS mode transitions are manual (i.e. the flag
|
|
|
|
* %IEEE80211_HW_AP_LINK_PS is set), always process PS state
|
|
|
|
* changes before calling TX status events if ordering can be
|
|
|
|
* unknown.
|
2009-11-18 20:42:47 +03:00
|
|
|
*/
|
2011-09-29 18:04:36 +04:00
|
|
|
if (test_sta_flag(sta, WLAN_STA_PS_STA) &&
|
2011-09-29 18:04:29 +04:00
|
|
|
skb_queue_len(&sta->tx_filtered[ac]) < STA_MAX_TX_BUFFER) {
|
|
|
|
skb_queue_tail(&sta->tx_filtered[ac], skb);
|
2011-09-29 18:04:27 +04:00
|
|
|
sta_info_recalc_tim(sta);
|
2011-09-29 18:04:28 +04:00
|
|
|
|
|
|
|
if (!timer_pending(&local->sta_cleanup))
|
|
|
|
mod_timer(&local->sta_cleanup,
|
|
|
|
round_jiffies(jiffies +
|
|
|
|
STA_INFO_CLEANUP_INTERVAL));
|
2009-11-18 20:42:47 +03:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2011-09-29 18:04:36 +04:00
|
|
|
if (!test_sta_flag(sta, WLAN_STA_PS_STA) &&
|
2009-11-18 20:42:47 +03:00
|
|
|
!(info->flags & IEEE80211_TX_INTFL_RETRIED)) {
|
|
|
|
/* Software retry the packet once */
|
|
|
|
info->flags |= IEEE80211_TX_INTFL_RETRIED;
|
|
|
|
ieee80211_add_pending_skb(local, skb);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2012-06-22 13:29:50 +04:00
|
|
|
ps_dbg_ratelimited(sta->sdata,
|
|
|
|
"dropped TX filtered frame, queue_len=%d PS=%d @%lu\n",
|
|
|
|
skb_queue_len(&sta->tx_filtered[ac]),
|
|
|
|
!!test_sta_flag(sta, WLAN_STA_PS_STA), jiffies);
|
2012-10-08 16:39:33 +04:00
|
|
|
ieee80211_free_txskb(&local->hw, skb);
|
2009-11-18 20:42:47 +03:00
|
|
|
}
|
|
|
|
|
2011-08-28 23:11:01 +04:00
|
|
|
static void ieee80211_check_pending_bar(struct sta_info *sta, u8 *addr, u8 tid)
|
|
|
|
{
|
|
|
|
struct tid_ampdu_tx *tid_tx;
|
|
|
|
|
|
|
|
tid_tx = rcu_dereference(sta->ampdu_mlme.tid_tx[tid]);
|
|
|
|
if (!tid_tx || !tid_tx->bar_pending)
|
|
|
|
return;
|
|
|
|
|
|
|
|
tid_tx->bar_pending = false;
|
2011-08-20 17:53:55 +04:00
|
|
|
ieee80211_send_bar(&sta->sdata->vif, addr, tid, tid_tx->failed_bar_ssn);
|
2011-08-28 23:11:01 +04:00
|
|
|
}
|
|
|
|
|
2009-12-01 15:37:02 +03:00
|
|
|
static void ieee80211_frame_acked(struct sta_info *sta, struct sk_buff *skb)
|
|
|
|
{
|
|
|
|
struct ieee80211_mgmt *mgmt = (void *) skb->data;
|
|
|
|
struct ieee80211_local *local = sta->local;
|
|
|
|
struct ieee80211_sub_if_data *sdata = sta->sdata;
|
2013-09-29 23:39:34 +04:00
|
|
|
|
2011-08-28 23:11:01 +04:00
|
|
|
if (ieee80211_is_data_qos(mgmt->frame_control)) {
|
|
|
|
struct ieee80211_hdr *hdr = (void *) skb->data;
|
|
|
|
u8 *qc = ieee80211_get_qos_ctl(hdr);
|
|
|
|
u16 tid = qc[0] & 0xf;
|
|
|
|
|
|
|
|
ieee80211_check_pending_bar(sta, hdr->addr1, tid);
|
|
|
|
}
|
|
|
|
|
2009-12-01 15:37:02 +03:00
|
|
|
if (ieee80211_is_action(mgmt->frame_control) &&
|
2017-04-26 10:58:51 +03:00
|
|
|
!ieee80211_has_protected(mgmt->frame_control) &&
|
2009-12-01 15:37:02 +03:00
|
|
|
mgmt->u.action.category == WLAN_CATEGORY_HT &&
|
2012-09-11 16:34:12 +04:00
|
|
|
mgmt->u.action.u.ht_smps.action == WLAN_HT_ACTION_SMPS &&
|
|
|
|
ieee80211_sdata_running(sdata)) {
|
2013-10-01 17:45:43 +04:00
|
|
|
enum ieee80211_smps_mode smps_mode;
|
|
|
|
|
2009-12-01 15:37:02 +03:00
|
|
|
switch (mgmt->u.action.u.ht_smps.smps_control) {
|
|
|
|
case WLAN_HT_SMPS_CONTROL_DYNAMIC:
|
2013-10-01 17:45:43 +04:00
|
|
|
smps_mode = IEEE80211_SMPS_DYNAMIC;
|
2009-12-01 15:37:02 +03:00
|
|
|
break;
|
|
|
|
case WLAN_HT_SMPS_CONTROL_STATIC:
|
2013-10-01 17:45:43 +04:00
|
|
|
smps_mode = IEEE80211_SMPS_STATIC;
|
2009-12-01 15:37:02 +03:00
|
|
|
break;
|
|
|
|
case WLAN_HT_SMPS_CONTROL_DISABLED:
|
|
|
|
default: /* shouldn't happen since we don't send that */
|
2013-10-01 17:45:43 +04:00
|
|
|
smps_mode = IEEE80211_SMPS_OFF;
|
2009-12-01 15:37:02 +03:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2013-10-01 17:45:43 +04:00
|
|
|
if (sdata->vif.type == NL80211_IFTYPE_STATION) {
|
|
|
|
/*
|
|
|
|
* This update looks racy, but isn't -- if we come
|
|
|
|
* here we've definitely got a station that we're
|
|
|
|
* talking to, and on a managed interface that can
|
|
|
|
* only be the AP. And the only other place updating
|
|
|
|
* this variable in managed mode is before association.
|
|
|
|
*/
|
2022-05-16 16:00:15 +03:00
|
|
|
sdata->deflink.smps_mode = smps_mode;
|
2013-10-01 17:45:43 +04:00
|
|
|
ieee80211_queue_work(&local->hw, &sdata->recalc_smps);
|
|
|
|
}
|
2009-12-01 15:37:02 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-08-28 23:11:01 +04:00
|
|
|
static void ieee80211_set_bar_pending(struct sta_info *sta, u8 tid, u16 ssn)
|
|
|
|
{
|
|
|
|
struct tid_ampdu_tx *tid_tx;
|
|
|
|
|
|
|
|
tid_tx = rcu_dereference(sta->ampdu_mlme.tid_tx[tid]);
|
|
|
|
if (!tid_tx)
|
|
|
|
return;
|
|
|
|
|
|
|
|
tid_tx->failed_bar_ssn = ssn;
|
|
|
|
tid_tx->bar_pending = true;
|
|
|
|
}
|
|
|
|
|
2019-07-14 18:44:16 +03:00
|
|
|
static int ieee80211_tx_radiotap_len(struct ieee80211_tx_info *info,
|
|
|
|
struct ieee80211_tx_status *status)
|
2011-10-11 20:08:54 +04:00
|
|
|
{
|
2022-05-09 20:39:57 +03:00
|
|
|
struct ieee80211_rate_status *status_rate = NULL;
|
2011-10-11 20:08:54 +04:00
|
|
|
int len = sizeof(struct ieee80211_radiotap_header);
|
|
|
|
|
2022-05-09 20:39:57 +03:00
|
|
|
if (status && status->n_rates)
|
|
|
|
status_rate = &status->rates[status->n_rates - 1];
|
|
|
|
|
2011-10-11 20:08:54 +04:00
|
|
|
/* IEEE80211_RADIOTAP_RATE rate */
|
2022-05-09 20:39:57 +03:00
|
|
|
if (status_rate && !(status_rate->rate_idx.flags &
|
|
|
|
(RATE_INFO_FLAGS_MCS |
|
|
|
|
RATE_INFO_FLAGS_DMG |
|
|
|
|
RATE_INFO_FLAGS_EDMG |
|
|
|
|
RATE_INFO_FLAGS_VHT_MCS |
|
|
|
|
RATE_INFO_FLAGS_HE_MCS)))
|
2019-08-07 10:59:46 +03:00
|
|
|
len += 2;
|
|
|
|
else if (info->status.rates[0].idx >= 0 &&
|
|
|
|
!(info->status.rates[0].flags &
|
|
|
|
(IEEE80211_TX_RC_MCS | IEEE80211_TX_RC_VHT_MCS)))
|
2011-10-11 20:08:54 +04:00
|
|
|
len += 2;
|
|
|
|
|
|
|
|
/* IEEE80211_RADIOTAP_TX_FLAGS */
|
|
|
|
len += 2;
|
|
|
|
|
|
|
|
/* IEEE80211_RADIOTAP_DATA_RETRIES */
|
|
|
|
len += 1;
|
|
|
|
|
2013-07-27 13:47:04 +04:00
|
|
|
/* IEEE80211_RADIOTAP_MCS
|
|
|
|
* IEEE80211_RADIOTAP_VHT */
|
2022-05-09 20:39:57 +03:00
|
|
|
if (status_rate) {
|
|
|
|
if (status_rate->rate_idx.flags & RATE_INFO_FLAGS_MCS)
|
2019-07-14 18:44:16 +03:00
|
|
|
len += 3;
|
2022-05-09 20:39:57 +03:00
|
|
|
else if (status_rate->rate_idx.flags & RATE_INFO_FLAGS_VHT_MCS)
|
2019-07-14 18:44:16 +03:00
|
|
|
len = ALIGN(len, 2) + 12;
|
2022-05-09 20:39:57 +03:00
|
|
|
else if (status_rate->rate_idx.flags & RATE_INFO_FLAGS_HE_MCS)
|
2019-07-14 18:44:16 +03:00
|
|
|
len = ALIGN(len, 2) + 12;
|
|
|
|
} else if (info->status.rates[0].idx >= 0) {
|
2013-07-27 13:47:04 +04:00
|
|
|
if (info->status.rates[0].flags & IEEE80211_TX_RC_MCS)
|
|
|
|
len += 3;
|
|
|
|
else if (info->status.rates[0].flags & IEEE80211_TX_RC_VHT_MCS)
|
|
|
|
len = ALIGN(len, 2) + 12;
|
|
|
|
}
|
2011-10-11 20:08:55 +04:00
|
|
|
|
2011-10-11 20:08:54 +04:00
|
|
|
return len;
|
|
|
|
}
|
|
|
|
|
2013-07-08 18:55:53 +04:00
|
|
|
static void
|
2013-07-27 13:47:04 +04:00
|
|
|
ieee80211_add_tx_radiotap_header(struct ieee80211_local *local,
|
2013-07-08 18:55:53 +04:00
|
|
|
struct sk_buff *skb, int retry_count,
|
2019-07-14 18:44:16 +03:00
|
|
|
int rtap_len, int shift,
|
|
|
|
struct ieee80211_tx_status *status)
|
2011-10-11 20:08:54 +04:00
|
|
|
{
|
|
|
|
struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
|
|
|
|
struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
|
|
|
|
struct ieee80211_radiotap_header *rthdr;
|
2022-05-09 20:39:57 +03:00
|
|
|
struct ieee80211_rate_status *status_rate = NULL;
|
2011-10-11 20:08:54 +04:00
|
|
|
unsigned char *pos;
|
2019-07-14 18:44:16 +03:00
|
|
|
u16 legacy_rate = 0;
|
2011-11-18 20:02:16 +04:00
|
|
|
u16 txflags;
|
2011-10-11 20:08:54 +04:00
|
|
|
|
2022-05-09 20:39:57 +03:00
|
|
|
if (status && status->n_rates)
|
|
|
|
status_rate = &status->rates[status->n_rates - 1];
|
|
|
|
|
networking: make skb_push & __skb_push return void pointers
It seems like a historic accident that these return unsigned char *,
and in many places that means casts are required, more often than not.
Make these functions return void * and remove all the casts across
the tree, adding a (u8 *) cast only where the unsigned char pointer
was used directly, all done with the following spatch:
@@
expression SKB, LEN;
typedef u8;
identifier fn = { skb_push, __skb_push, skb_push_rcsum };
@@
- *(fn(SKB, LEN))
+ *(u8 *)fn(SKB, LEN)
@@
expression E, SKB, LEN;
identifier fn = { skb_push, __skb_push, skb_push_rcsum };
type T;
@@
- E = ((T *)(fn(SKB, LEN)))
+ E = fn(SKB, LEN)
@@
expression SKB, LEN;
identifier fn = { skb_push, __skb_push, skb_push_rcsum };
@@
- fn(SKB, LEN)[0]
+ *(u8 *)fn(SKB, LEN)
Note that the last part there converts from push(...)[0] to the
more idiomatic *(u8 *)push(...).
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-06-16 15:29:23 +03:00
|
|
|
rthdr = skb_push(skb, rtap_len);
|
2011-10-11 20:08:54 +04:00
|
|
|
|
|
|
|
memset(rthdr, 0, rtap_len);
|
|
|
|
rthdr->it_len = cpu_to_le16(rtap_len);
|
|
|
|
rthdr->it_present =
|
2021-08-07 00:51:12 +03:00
|
|
|
cpu_to_le32(BIT(IEEE80211_RADIOTAP_TX_FLAGS) |
|
|
|
|
BIT(IEEE80211_RADIOTAP_DATA_RETRIES));
|
2011-10-11 20:08:54 +04:00
|
|
|
pos = (unsigned char *)(rthdr + 1);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* XXX: Once radiotap gets the bitmap reset thing the vendor
|
|
|
|
* extensions proposal contains, we can actually report
|
|
|
|
* the whole set of tries we did.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* IEEE80211_RADIOTAP_RATE */
|
2013-07-08 18:55:53 +04:00
|
|
|
|
2022-05-09 20:39:57 +03:00
|
|
|
if (status_rate) {
|
|
|
|
if (!(status_rate->rate_idx.flags &
|
|
|
|
(RATE_INFO_FLAGS_MCS |
|
|
|
|
RATE_INFO_FLAGS_DMG |
|
|
|
|
RATE_INFO_FLAGS_EDMG |
|
|
|
|
RATE_INFO_FLAGS_VHT_MCS |
|
|
|
|
RATE_INFO_FLAGS_HE_MCS)))
|
|
|
|
legacy_rate = status_rate->rate_idx.legacy;
|
2019-08-07 10:59:47 +03:00
|
|
|
} else if (info->status.rates[0].idx >= 0 &&
|
2019-07-14 18:44:16 +03:00
|
|
|
!(info->status.rates[0].flags & (IEEE80211_TX_RC_MCS |
|
2022-06-01 15:16:00 +03:00
|
|
|
IEEE80211_TX_RC_VHT_MCS))) {
|
|
|
|
struct ieee80211_supported_band *sband;
|
|
|
|
|
|
|
|
sband = local->hw.wiphy->bands[info->band];
|
2019-07-14 18:44:16 +03:00
|
|
|
legacy_rate =
|
|
|
|
sband->bitrates[info->status.rates[0].idx].bitrate;
|
2022-06-01 15:16:00 +03:00
|
|
|
}
|
2019-07-14 18:44:16 +03:00
|
|
|
|
|
|
|
if (legacy_rate) {
|
2021-08-07 00:51:12 +03:00
|
|
|
rthdr->it_present |= cpu_to_le32(BIT(IEEE80211_RADIOTAP_RATE));
|
2019-07-14 18:44:16 +03:00
|
|
|
*pos = DIV_ROUND_UP(legacy_rate, 5 * (1 << shift));
|
2011-10-11 20:08:54 +04:00
|
|
|
/* padding for tx flags */
|
|
|
|
pos += 2;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* IEEE80211_RADIOTAP_TX_FLAGS */
|
|
|
|
txflags = 0;
|
|
|
|
if (!(info->flags & IEEE80211_TX_STAT_ACK) &&
|
|
|
|
!is_multicast_ether_addr(hdr->addr1))
|
2011-11-18 20:02:16 +04:00
|
|
|
txflags |= IEEE80211_RADIOTAP_F_TX_FAIL;
|
2011-10-11 20:08:54 +04:00
|
|
|
|
2014-04-16 16:32:41 +04:00
|
|
|
if (info->status.rates[0].flags & IEEE80211_TX_RC_USE_CTS_PROTECT)
|
2011-11-18 20:02:16 +04:00
|
|
|
txflags |= IEEE80211_RADIOTAP_F_TX_CTS;
|
2014-04-16 16:32:41 +04:00
|
|
|
if (info->status.rates[0].flags & IEEE80211_TX_RC_USE_RTS_CTS)
|
2011-11-18 20:02:16 +04:00
|
|
|
txflags |= IEEE80211_RADIOTAP_F_TX_RTS;
|
2011-10-11 20:08:54 +04:00
|
|
|
|
|
|
|
put_unaligned_le16(txflags, pos);
|
|
|
|
pos += 2;
|
|
|
|
|
|
|
|
/* IEEE80211_RADIOTAP_DATA_RETRIES */
|
|
|
|
/* for now report the total retry_count */
|
|
|
|
*pos = retry_count;
|
|
|
|
pos++;
|
2011-10-11 20:08:55 +04:00
|
|
|
|
2022-05-09 20:39:57 +03:00
|
|
|
if (status_rate && (status_rate->rate_idx.flags & RATE_INFO_FLAGS_MCS))
|
|
|
|
{
|
2021-08-07 00:51:12 +03:00
|
|
|
rthdr->it_present |= cpu_to_le32(BIT(IEEE80211_RADIOTAP_MCS));
|
2019-07-14 18:44:16 +03:00
|
|
|
pos[0] = IEEE80211_RADIOTAP_MCS_HAVE_MCS |
|
|
|
|
IEEE80211_RADIOTAP_MCS_HAVE_GI |
|
|
|
|
IEEE80211_RADIOTAP_MCS_HAVE_BW;
|
2022-05-09 20:39:57 +03:00
|
|
|
if (status_rate->rate_idx.flags & RATE_INFO_FLAGS_SHORT_GI)
|
2019-07-14 18:44:16 +03:00
|
|
|
pos[1] |= IEEE80211_RADIOTAP_MCS_SGI;
|
2022-05-09 20:39:57 +03:00
|
|
|
if (status_rate->rate_idx.bw == RATE_INFO_BW_40)
|
2019-07-14 18:44:16 +03:00
|
|
|
pos[1] |= IEEE80211_RADIOTAP_MCS_BW_40;
|
2022-05-09 20:39:57 +03:00
|
|
|
pos[2] = status_rate->rate_idx.mcs;
|
2019-07-14 18:44:16 +03:00
|
|
|
pos += 3;
|
2022-05-09 20:39:57 +03:00
|
|
|
} else if (status_rate && (status_rate->rate_idx.flags &
|
|
|
|
RATE_INFO_FLAGS_VHT_MCS))
|
|
|
|
{
|
2019-07-14 18:44:16 +03:00
|
|
|
u16 known = local->hw.radiotap_vht_details &
|
|
|
|
(IEEE80211_RADIOTAP_VHT_KNOWN_GI |
|
|
|
|
IEEE80211_RADIOTAP_VHT_KNOWN_BANDWIDTH);
|
|
|
|
|
2021-08-07 00:51:12 +03:00
|
|
|
rthdr->it_present |= cpu_to_le32(BIT(IEEE80211_RADIOTAP_VHT));
|
2019-07-14 18:44:16 +03:00
|
|
|
|
|
|
|
/* required alignment from rthdr */
|
|
|
|
pos = (u8 *)rthdr + ALIGN(pos - (u8 *)rthdr, 2);
|
|
|
|
|
|
|
|
/* u16 known - IEEE80211_RADIOTAP_VHT_KNOWN_* */
|
|
|
|
put_unaligned_le16(known, pos);
|
|
|
|
pos += 2;
|
|
|
|
|
|
|
|
/* u8 flags - IEEE80211_RADIOTAP_VHT_FLAG_* */
|
2022-05-09 20:39:57 +03:00
|
|
|
if (status_rate->rate_idx.flags & RATE_INFO_FLAGS_SHORT_GI)
|
2019-07-14 18:44:16 +03:00
|
|
|
*pos |= IEEE80211_RADIOTAP_VHT_FLAG_SGI;
|
|
|
|
pos++;
|
|
|
|
|
|
|
|
/* u8 bandwidth */
|
2022-05-09 20:39:57 +03:00
|
|
|
switch (status_rate->rate_idx.bw) {
|
2019-07-14 18:44:16 +03:00
|
|
|
case RATE_INFO_BW_160:
|
|
|
|
*pos = 11;
|
|
|
|
break;
|
|
|
|
case RATE_INFO_BW_80:
|
2019-08-07 10:59:48 +03:00
|
|
|
*pos = 4;
|
2019-07-14 18:44:16 +03:00
|
|
|
break;
|
|
|
|
case RATE_INFO_BW_40:
|
|
|
|
*pos = 1;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
*pos = 0;
|
|
|
|
break;
|
|
|
|
}
|
2019-08-07 10:59:49 +03:00
|
|
|
pos++;
|
2019-07-14 18:44:16 +03:00
|
|
|
|
|
|
|
/* u8 mcs_nss[4] */
|
2022-05-09 20:39:57 +03:00
|
|
|
*pos = (status_rate->rate_idx.mcs << 4) |
|
|
|
|
status_rate->rate_idx.nss;
|
2019-07-14 18:44:16 +03:00
|
|
|
pos += 4;
|
|
|
|
|
|
|
|
/* u8 coding */
|
|
|
|
pos++;
|
|
|
|
/* u8 group_id */
|
|
|
|
pos++;
|
|
|
|
/* u16 partial_aid */
|
|
|
|
pos += 2;
|
2022-05-09 20:39:57 +03:00
|
|
|
} else if (status_rate && (status_rate->rate_idx.flags &
|
|
|
|
RATE_INFO_FLAGS_HE_MCS))
|
|
|
|
{
|
2019-07-14 18:44:16 +03:00
|
|
|
struct ieee80211_radiotap_he *he;
|
|
|
|
|
2021-08-07 00:51:12 +03:00
|
|
|
rthdr->it_present |= cpu_to_le32(BIT(IEEE80211_RADIOTAP_HE));
|
2019-07-14 18:44:16 +03:00
|
|
|
|
|
|
|
/* required alignment from rthdr */
|
|
|
|
pos = (u8 *)rthdr + ALIGN(pos - (u8 *)rthdr, 2);
|
|
|
|
he = (struct ieee80211_radiotap_he *)pos;
|
|
|
|
|
|
|
|
he->data1 = cpu_to_le16(IEEE80211_RADIOTAP_HE_DATA1_FORMAT_SU |
|
|
|
|
IEEE80211_RADIOTAP_HE_DATA1_DATA_MCS_KNOWN |
|
|
|
|
IEEE80211_RADIOTAP_HE_DATA1_DATA_DCM_KNOWN |
|
|
|
|
IEEE80211_RADIOTAP_HE_DATA1_BW_RU_ALLOC_KNOWN);
|
|
|
|
|
|
|
|
he->data2 = cpu_to_le16(IEEE80211_RADIOTAP_HE_DATA2_GI_KNOWN);
|
|
|
|
|
|
|
|
#define HE_PREP(f, val) le16_encode_bits(val, IEEE80211_RADIOTAP_HE_##f)
|
|
|
|
|
2022-05-09 20:39:57 +03:00
|
|
|
he->data6 |= HE_PREP(DATA6_NSTS, status_rate->rate_idx.nss);
|
2019-07-14 18:44:16 +03:00
|
|
|
|
|
|
|
#define CHECK_GI(s) \
|
|
|
|
BUILD_BUG_ON(IEEE80211_RADIOTAP_HE_DATA5_GI_##s != \
|
|
|
|
(int)NL80211_RATE_INFO_HE_GI_##s)
|
|
|
|
|
|
|
|
CHECK_GI(0_8);
|
|
|
|
CHECK_GI(1_6);
|
|
|
|
CHECK_GI(3_2);
|
|
|
|
|
2022-05-09 20:39:57 +03:00
|
|
|
he->data3 |= HE_PREP(DATA3_DATA_MCS, status_rate->rate_idx.mcs);
|
|
|
|
he->data3 |= HE_PREP(DATA3_DATA_DCM, status_rate->rate_idx.he_dcm);
|
2019-07-14 18:44:16 +03:00
|
|
|
|
2022-05-09 20:39:57 +03:00
|
|
|
he->data5 |= HE_PREP(DATA5_GI, status_rate->rate_idx.he_gi);
|
2019-07-14 18:44:16 +03:00
|
|
|
|
2022-05-09 20:39:57 +03:00
|
|
|
switch (status_rate->rate_idx.bw) {
|
2019-07-14 18:44:16 +03:00
|
|
|
case RATE_INFO_BW_20:
|
|
|
|
he->data5 |= HE_PREP(DATA5_DATA_BW_RU_ALLOC,
|
|
|
|
IEEE80211_RADIOTAP_HE_DATA5_DATA_BW_RU_ALLOC_20MHZ);
|
|
|
|
break;
|
|
|
|
case RATE_INFO_BW_40:
|
|
|
|
he->data5 |= HE_PREP(DATA5_DATA_BW_RU_ALLOC,
|
|
|
|
IEEE80211_RADIOTAP_HE_DATA5_DATA_BW_RU_ALLOC_40MHZ);
|
|
|
|
break;
|
|
|
|
case RATE_INFO_BW_80:
|
|
|
|
he->data5 |= HE_PREP(DATA5_DATA_BW_RU_ALLOC,
|
|
|
|
IEEE80211_RADIOTAP_HE_DATA5_DATA_BW_RU_ALLOC_80MHZ);
|
|
|
|
break;
|
|
|
|
case RATE_INFO_BW_160:
|
|
|
|
he->data5 |= HE_PREP(DATA5_DATA_BW_RU_ALLOC,
|
|
|
|
IEEE80211_RADIOTAP_HE_DATA5_DATA_BW_RU_ALLOC_160MHZ);
|
|
|
|
break;
|
|
|
|
case RATE_INFO_BW_HE_RU:
|
|
|
|
#define CHECK_RU_ALLOC(s) \
|
|
|
|
BUILD_BUG_ON(IEEE80211_RADIOTAP_HE_DATA5_DATA_BW_RU_ALLOC_##s##T != \
|
|
|
|
NL80211_RATE_INFO_HE_RU_ALLOC_##s + 4)
|
|
|
|
|
|
|
|
CHECK_RU_ALLOC(26);
|
|
|
|
CHECK_RU_ALLOC(52);
|
|
|
|
CHECK_RU_ALLOC(106);
|
|
|
|
CHECK_RU_ALLOC(242);
|
|
|
|
CHECK_RU_ALLOC(484);
|
|
|
|
CHECK_RU_ALLOC(996);
|
|
|
|
CHECK_RU_ALLOC(2x996);
|
|
|
|
|
|
|
|
he->data5 |= HE_PREP(DATA5_DATA_BW_RU_ALLOC,
|
2022-05-09 20:39:57 +03:00
|
|
|
status_rate->rate_idx.he_ru_alloc + 4);
|
2019-07-14 18:44:16 +03:00
|
|
|
break;
|
|
|
|
default:
|
2022-05-09 20:39:57 +03:00
|
|
|
WARN_ONCE(1, "Invalid SU BW %d\n", status_rate->rate_idx.bw);
|
2019-07-14 18:44:16 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
pos += sizeof(struct ieee80211_radiotap_he);
|
|
|
|
}
|
|
|
|
|
2022-05-09 20:39:57 +03:00
|
|
|
if (status_rate || info->status.rates[0].idx < 0)
|
2013-07-27 13:47:04 +04:00
|
|
|
return;
|
|
|
|
|
|
|
|
/* IEEE80211_RADIOTAP_MCS
|
|
|
|
* IEEE80211_RADIOTAP_VHT */
|
|
|
|
if (info->status.rates[0].flags & IEEE80211_TX_RC_MCS) {
|
2021-08-07 00:51:12 +03:00
|
|
|
rthdr->it_present |= cpu_to_le32(BIT(IEEE80211_RADIOTAP_MCS));
|
2011-10-11 20:08:55 +04:00
|
|
|
pos[0] = IEEE80211_RADIOTAP_MCS_HAVE_MCS |
|
|
|
|
IEEE80211_RADIOTAP_MCS_HAVE_GI |
|
|
|
|
IEEE80211_RADIOTAP_MCS_HAVE_BW;
|
|
|
|
if (info->status.rates[0].flags & IEEE80211_TX_RC_SHORT_GI)
|
|
|
|
pos[1] |= IEEE80211_RADIOTAP_MCS_SGI;
|
|
|
|
if (info->status.rates[0].flags & IEEE80211_TX_RC_40_MHZ_WIDTH)
|
|
|
|
pos[1] |= IEEE80211_RADIOTAP_MCS_BW_40;
|
|
|
|
if (info->status.rates[0].flags & IEEE80211_TX_RC_GREEN_FIELD)
|
|
|
|
pos[1] |= IEEE80211_RADIOTAP_MCS_FMT_GF;
|
|
|
|
pos[2] = info->status.rates[0].idx;
|
|
|
|
pos += 3;
|
2013-07-27 13:47:04 +04:00
|
|
|
} else if (info->status.rates[0].flags & IEEE80211_TX_RC_VHT_MCS) {
|
|
|
|
u16 known = local->hw.radiotap_vht_details &
|
|
|
|
(IEEE80211_RADIOTAP_VHT_KNOWN_GI |
|
|
|
|
IEEE80211_RADIOTAP_VHT_KNOWN_BANDWIDTH);
|
|
|
|
|
2021-08-07 00:51:12 +03:00
|
|
|
rthdr->it_present |= cpu_to_le32(BIT(IEEE80211_RADIOTAP_VHT));
|
2013-07-27 13:47:04 +04:00
|
|
|
|
|
|
|
/* required alignment from rthdr */
|
|
|
|
pos = (u8 *)rthdr + ALIGN(pos - (u8 *)rthdr, 2);
|
2011-10-11 20:08:55 +04:00
|
|
|
|
2013-07-27 13:47:04 +04:00
|
|
|
/* u16 known - IEEE80211_RADIOTAP_VHT_KNOWN_* */
|
|
|
|
put_unaligned_le16(known, pos);
|
|
|
|
pos += 2;
|
|
|
|
|
|
|
|
/* u8 flags - IEEE80211_RADIOTAP_VHT_FLAG_* */
|
|
|
|
if (info->status.rates[0].flags & IEEE80211_TX_RC_SHORT_GI)
|
|
|
|
*pos |= IEEE80211_RADIOTAP_VHT_FLAG_SGI;
|
|
|
|
pos++;
|
|
|
|
|
|
|
|
/* u8 bandwidth */
|
|
|
|
if (info->status.rates[0].flags & IEEE80211_TX_RC_40_MHZ_WIDTH)
|
|
|
|
*pos = 1;
|
|
|
|
else if (info->status.rates[0].flags & IEEE80211_TX_RC_80_MHZ_WIDTH)
|
|
|
|
*pos = 4;
|
|
|
|
else if (info->status.rates[0].flags & IEEE80211_TX_RC_160_MHZ_WIDTH)
|
|
|
|
*pos = 11;
|
|
|
|
else /* IEEE80211_TX_RC_{20_MHZ_WIDTH,FIXME:DUP_DATA} */
|
|
|
|
*pos = 0;
|
|
|
|
pos++;
|
|
|
|
|
|
|
|
/* u8 mcs_nss[4] */
|
|
|
|
*pos = (ieee80211_rate_get_vht_mcs(&info->status.rates[0]) << 4) |
|
|
|
|
ieee80211_rate_get_vht_nss(&info->status.rates[0]);
|
|
|
|
pos += 4;
|
|
|
|
|
|
|
|
/* u8 coding */
|
|
|
|
pos++;
|
|
|
|
/* u8 group_id */
|
|
|
|
pos++;
|
|
|
|
/* u16 partial_aid */
|
|
|
|
pos += 2;
|
|
|
|
}
|
2011-10-11 20:08:54 +04:00
|
|
|
}
|
|
|
|
|
2014-11-09 19:50:08 +03:00
|
|
|
/*
|
|
|
|
* Handles the tx for TDLS teardown frames.
|
|
|
|
* If the frame wasn't ACKed by the peer - it will be re-sent through the AP
|
|
|
|
*/
|
|
|
|
static void ieee80211_tdls_td_tx_handle(struct ieee80211_local *local,
|
|
|
|
struct ieee80211_sub_if_data *sdata,
|
|
|
|
struct sk_buff *skb, u32 flags)
|
|
|
|
{
|
|
|
|
struct sk_buff *teardown_skb;
|
|
|
|
struct sk_buff *orig_teardown_skb;
|
|
|
|
bool is_teardown = false;
|
|
|
|
|
|
|
|
/* Get the teardown data we need and free the lock */
|
|
|
|
spin_lock(&sdata->u.mgd.teardown_lock);
|
|
|
|
teardown_skb = sdata->u.mgd.teardown_skb;
|
|
|
|
orig_teardown_skb = sdata->u.mgd.orig_teardown_skb;
|
|
|
|
if ((skb == orig_teardown_skb) && teardown_skb) {
|
|
|
|
sdata->u.mgd.teardown_skb = NULL;
|
|
|
|
sdata->u.mgd.orig_teardown_skb = NULL;
|
|
|
|
is_teardown = true;
|
|
|
|
}
|
|
|
|
spin_unlock(&sdata->u.mgd.teardown_lock);
|
|
|
|
|
|
|
|
if (is_teardown) {
|
|
|
|
/* This mechanism relies on being able to get ACKs */
|
2015-06-02 22:39:54 +03:00
|
|
|
WARN_ON(!ieee80211_hw_check(&local->hw, REPORTS_TX_ACK_STATUS));
|
2014-11-09 19:50:08 +03:00
|
|
|
|
|
|
|
/* Check if peer has ACKed */
|
|
|
|
if (flags & IEEE80211_TX_STAT_ACK) {
|
|
|
|
dev_kfree_skb_any(teardown_skb);
|
|
|
|
} else {
|
|
|
|
tdls_dbg(sdata,
|
|
|
|
"TDLS Resending teardown through AP\n");
|
|
|
|
|
|
|
|
ieee80211_subif_start_xmit(teardown_skb, skb->dev);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-06-01 23:54:13 +03:00
|
|
|
static struct ieee80211_sub_if_data *
|
|
|
|
ieee80211_sdata_from_skb(struct ieee80211_local *local, struct sk_buff *skb)
|
|
|
|
{
|
|
|
|
struct ieee80211_sub_if_data *sdata;
|
|
|
|
|
|
|
|
if (skb->dev) {
|
|
|
|
list_for_each_entry_rcu(sdata, &local->interfaces, list) {
|
|
|
|
if (!sdata->dev)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (skb->dev == sdata->dev)
|
|
|
|
return sdata;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return rcu_dereference(local->p2p_sdata);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ieee80211_report_ack_skb(struct ieee80211_local *local,
|
|
|
|
struct ieee80211_tx_info *info,
|
|
|
|
bool acked, bool dropped)
|
|
|
|
{
|
|
|
|
struct sk_buff *skb;
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&local->ack_status_lock, flags);
|
2016-12-22 21:30:22 +03:00
|
|
|
skb = idr_remove(&local->ack_status_frames, info->ack_frame_id);
|
2015-06-01 23:54:13 +03:00
|
|
|
spin_unlock_irqrestore(&local->ack_status_lock, flags);
|
|
|
|
|
|
|
|
if (!skb)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (info->flags & IEEE80211_TX_INTFL_NL80211_FRAME_TX) {
|
2015-06-02 00:14:59 +03:00
|
|
|
u64 cookie = IEEE80211_SKB_CB(skb)->ack.cookie;
|
2015-06-01 23:54:13 +03:00
|
|
|
struct ieee80211_sub_if_data *sdata;
|
2015-06-02 00:14:59 +03:00
|
|
|
struct ieee80211_hdr *hdr = (void *)skb->data;
|
2022-02-02 11:49:47 +03:00
|
|
|
bool is_valid_ack_signal =
|
|
|
|
!!(info->status.flags & IEEE80211_TX_STATUS_ACK_SIGNAL_VALID);
|
2015-06-01 23:54:13 +03:00
|
|
|
|
|
|
|
rcu_read_lock();
|
|
|
|
sdata = ieee80211_sdata_from_skb(local, skb);
|
2015-06-02 00:14:59 +03:00
|
|
|
if (sdata) {
|
2021-02-06 14:51:12 +03:00
|
|
|
if (skb->protocol == sdata->control_port_protocol ||
|
|
|
|
skb->protocol == cpu_to_be16(ETH_P_PREAUTH))
|
2020-06-22 15:35:42 +03:00
|
|
|
cfg80211_control_port_tx_status(&sdata->wdev,
|
|
|
|
cookie,
|
|
|
|
skb->data,
|
|
|
|
skb->len,
|
|
|
|
acked,
|
|
|
|
GFP_ATOMIC);
|
|
|
|
else if (ieee80211_is_any_nullfunc(hdr->frame_control))
|
2015-06-02 00:14:59 +03:00
|
|
|
cfg80211_probe_status(sdata->dev, hdr->addr1,
|
2018-02-13 08:34:46 +03:00
|
|
|
cookie, acked,
|
|
|
|
info->status.ack_signal,
|
2022-02-02 11:49:47 +03:00
|
|
|
is_valid_ack_signal,
|
2015-06-02 00:14:59 +03:00
|
|
|
GFP_ATOMIC);
|
2020-05-27 19:03:34 +03:00
|
|
|
else if (ieee80211_is_mgmt(hdr->frame_control))
|
2015-06-02 00:14:59 +03:00
|
|
|
cfg80211_mgmt_tx_status(&sdata->wdev, cookie,
|
|
|
|
skb->data, skb->len,
|
|
|
|
acked, GFP_ATOMIC);
|
2020-05-27 19:03:34 +03:00
|
|
|
else
|
2020-06-22 15:35:42 +03:00
|
|
|
pr_warn("Unknown status report in ack skb\n");
|
|
|
|
|
2015-06-02 00:14:59 +03:00
|
|
|
}
|
2015-06-01 23:54:13 +03:00
|
|
|
rcu_read_unlock();
|
|
|
|
|
2018-09-05 08:06:13 +03:00
|
|
|
dev_kfree_skb_any(skb);
|
|
|
|
} else if (dropped) {
|
2015-06-01 23:54:13 +03:00
|
|
|
dev_kfree_skb_any(skb);
|
|
|
|
} else {
|
|
|
|
/* consumes skb */
|
|
|
|
skb_complete_wifi_ack(skb, acked);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-10-26 17:53:06 +04:00
|
|
|
static void ieee80211_report_used_skb(struct ieee80211_local *local,
|
|
|
|
struct sk_buff *skb, bool dropped)
|
|
|
|
{
|
|
|
|
struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
|
2019-11-19 09:06:10 +03:00
|
|
|
u16 tx_time_est = ieee80211_info_get_tx_time_est(info);
|
2012-10-26 17:53:06 +04:00
|
|
|
struct ieee80211_hdr *hdr = (void *)skb->data;
|
|
|
|
bool acked = info->flags & IEEE80211_TX_STAT_ACK;
|
|
|
|
|
|
|
|
if (dropped)
|
|
|
|
acked = false;
|
|
|
|
|
2019-11-19 09:06:10 +03:00
|
|
|
if (tx_time_est) {
|
|
|
|
struct sta_info *sta;
|
|
|
|
|
|
|
|
rcu_read_lock();
|
|
|
|
|
|
|
|
sta = sta_info_get_by_addrs(local, hdr->addr1, hdr->addr2);
|
|
|
|
ieee80211_sta_update_pending_airtime(local, sta,
|
|
|
|
skb_get_queue_mapping(skb),
|
|
|
|
tx_time_est,
|
|
|
|
true);
|
|
|
|
rcu_read_unlock();
|
|
|
|
}
|
|
|
|
|
2015-06-02 00:14:59 +03:00
|
|
|
if (info->flags & IEEE80211_TX_INTFL_MLME_CONN_TX) {
|
2015-06-01 23:54:13 +03:00
|
|
|
struct ieee80211_sub_if_data *sdata;
|
2012-10-26 17:53:06 +04:00
|
|
|
|
|
|
|
rcu_read_lock();
|
|
|
|
|
2015-06-01 23:54:13 +03:00
|
|
|
sdata = ieee80211_sdata_from_skb(local, skb);
|
2012-10-26 17:53:06 +04:00
|
|
|
|
2013-01-29 18:02:27 +04:00
|
|
|
if (!sdata) {
|
2012-10-26 17:53:06 +04:00
|
|
|
skb->dev = NULL;
|
2015-07-27 11:11:11 +03:00
|
|
|
} else {
|
2014-11-09 19:50:08 +03:00
|
|
|
unsigned int hdr_size =
|
|
|
|
ieee80211_hdrlen(hdr->frame_control);
|
|
|
|
|
|
|
|
/* Check to see if packet is a TDLS teardown packet */
|
|
|
|
if (ieee80211_is_data(hdr->frame_control) &&
|
|
|
|
(ieee80211_get_tdls_action(skb, hdr_size) ==
|
2021-08-23 21:02:39 +03:00
|
|
|
WLAN_TDLS_TEARDOWN)) {
|
2014-11-09 19:50:08 +03:00
|
|
|
ieee80211_tdls_td_tx_handle(local, sdata, skb,
|
|
|
|
info->flags);
|
2021-08-23 21:02:39 +03:00
|
|
|
} else if (ieee80211_s1g_is_twt_setup(skb)) {
|
|
|
|
if (!acked) {
|
|
|
|
struct sk_buff *qskb;
|
|
|
|
|
|
|
|
qskb = skb_clone(skb, GFP_ATOMIC);
|
|
|
|
if (qskb) {
|
|
|
|
skb_queue_tail(&sdata->status_queue,
|
|
|
|
qskb);
|
|
|
|
ieee80211_queue_work(&local->hw,
|
|
|
|
&sdata->work);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
2014-11-09 19:50:08 +03:00
|
|
|
ieee80211_mgd_conn_tx_status(sdata,
|
|
|
|
hdr->frame_control,
|
|
|
|
acked);
|
2021-08-23 21:02:39 +03:00
|
|
|
}
|
2012-10-26 17:53:06 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
rcu_read_unlock();
|
2015-06-01 23:54:13 +03:00
|
|
|
} else if (info->ack_frame_id) {
|
|
|
|
ieee80211_report_ack_skb(local, info, acked, dropped);
|
2012-10-26 17:53:06 +04:00
|
|
|
}
|
2016-10-19 16:02:32 +03:00
|
|
|
|
|
|
|
if (!dropped && skb->destructor) {
|
|
|
|
skb->wifi_acked_valid = 1;
|
|
|
|
skb->wifi_acked = acked;
|
|
|
|
}
|
2017-05-28 00:59:27 +03:00
|
|
|
|
|
|
|
ieee80211_led_tx(local);
|
2018-12-15 12:03:06 +03:00
|
|
|
|
|
|
|
if (skb_has_frag_list(skb)) {
|
|
|
|
kfree_skb_list(skb_shinfo(skb)->frag_list);
|
|
|
|
skb_shinfo(skb)->frag_list = NULL;
|
|
|
|
}
|
2012-10-26 17:53:06 +04:00
|
|
|
}
|
|
|
|
|
2010-11-24 10:10:06 +03:00
|
|
|
/*
|
|
|
|
* Use a static threshold for now, best value to be determined
|
|
|
|
* by testing ...
|
|
|
|
* Should it depend on:
|
|
|
|
* - on # of retransmissions
|
|
|
|
* - current throughput (higher value for higher tpt)?
|
|
|
|
*/
|
|
|
|
#define STA_LOST_PKT_THRESHOLD 50
|
2020-08-08 20:25:42 +03:00
|
|
|
#define STA_LOST_PKT_TIME HZ /* 1 sec since last ACK */
|
2014-09-04 09:28:40 +04:00
|
|
|
#define STA_LOST_TDLS_PKT_TIME (10*HZ) /* 10secs since last ACK */
|
2010-11-24 10:10:06 +03:00
|
|
|
|
2014-11-19 22:08:11 +03:00
|
|
|
static void ieee80211_lost_packet(struct sta_info *sta,
|
|
|
|
struct ieee80211_tx_info *info)
|
2014-05-23 22:05:28 +04:00
|
|
|
{
|
2020-08-08 20:25:42 +03:00
|
|
|
unsigned long pkt_time = STA_LOST_PKT_TIME;
|
|
|
|
unsigned int pkt_thr = STA_LOST_PKT_THRESHOLD;
|
|
|
|
|
2016-09-14 10:18:32 +03:00
|
|
|
/* If driver relies on its own algorithm for station kickout, skip
|
|
|
|
* mac80211 packet loss mechanism.
|
|
|
|
*/
|
|
|
|
if (ieee80211_hw_check(&sta->local->hw, REPORTS_LOW_ACK))
|
|
|
|
return;
|
|
|
|
|
2014-05-23 22:05:28 +04:00
|
|
|
/* This packet was aggregated but doesn't carry status info */
|
|
|
|
if ((info->flags & IEEE80211_TX_CTL_AMPDU) &&
|
|
|
|
!(info->flags & IEEE80211_TX_STAT_AMPDU))
|
|
|
|
return;
|
|
|
|
|
mac80211: prepare sta handling for MLO support
Currently in mac80211 each STA object is represented
using sta_info datastructure with the associated
STA specific information and drivers access ieee80211_sta
part of it.
With MLO (Multi Link Operation) support being added
in 802.11be standard, though the association is logically
with a single Multi Link capable STA, at the physical level
communication can happen via different advertised
links (uniquely identified by Channel, operating class,
BSSID) and hence the need to handle multiple link
STA parameters within a composite sta_info object
called the MLD STA. The different link STA part of
MLD STA are identified using the link address which can
be same or different as the MLD STA address and unique
link id based on the link vif.
To support extension of such a model, the sta_info
datastructure is modified to hold multiple link STA
objects with link specific params currently within
sta_info moved to this new structure. Similarly this is
done for ieee80211_sta as well which will be accessed
within mac80211 as well as by drivers, hence trivial
driver changes are expected to support this.
For current non MLO supported drivers, only one link STA
is present and link information is accessed via 'deflink'
member.
For MLO drivers, we still need to define the APIs etc. to
get the correct link ID and access the correct part of
the station info.
Currently in mac80211, all link STA info are accessed directly
via deflink. These will be updated to access via link pointers
indexed by link id with MLO support patches, with link id
being 0 for non MLO supported cases.
Except for couple of macro related changes, below spatch takes
care of updating mac80211 and driver code to access to the
link STA info via deflink.
@ieee80211_sta@
struct ieee80211_sta *s;
struct sta_info *si;
identifier var = {supp_rates, ht_cap, vht_cap, he_cap, he_6ghz_capa, eht_cap, rx_nss, bandwidth, txpwr};
@@
(
s->
- var
+ deflink.var
|
si->sta.
- var
+ deflink.var
)
@sta_info@
struct sta_info *si;
identifier var = {gtk, pcpu_rx_stats, rx_stats, rx_stats_avg, status_stats, tx_stats, cur_max_bandwidth};
@@
(
si->
- var
+ deflink.var
)
Signed-off-by: Sriram R <quic_srirrama@quicinc.com>
Link: https://lore.kernel.org/r/1649086883-13246-1-git-send-email-quic_srirrama@quicinc.com
[remove MLO-drivers notes from commit message, not clear yet; run spatch]
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
2022-04-04 18:41:23 +03:00
|
|
|
sta->deflink.status_stats.lost_packets++;
|
2020-08-08 20:25:42 +03:00
|
|
|
if (sta->sta.tdls) {
|
|
|
|
pkt_time = STA_LOST_TDLS_PKT_TIME;
|
|
|
|
pkt_thr = STA_LOST_PKT_THRESHOLD;
|
|
|
|
}
|
2014-09-04 09:28:40 +04:00
|
|
|
|
|
|
|
/*
|
2022-02-02 11:49:45 +03:00
|
|
|
* If we're in TDLS mode, make sure that all STA_LOST_PKT_THRESHOLD
|
2014-09-04 09:28:40 +04:00
|
|
|
* of the last packets were lost, and that no ACK was received in the
|
|
|
|
* last STA_LOST_TDLS_PKT_TIME ms, before triggering the CQM packet-loss
|
|
|
|
* mechanism.
|
2020-08-08 20:25:42 +03:00
|
|
|
* For non-TDLS, use STA_LOST_PKT_THRESHOLD and STA_LOST_PKT_TIME
|
2014-09-04 09:28:40 +04:00
|
|
|
*/
|
mac80211: prepare sta handling for MLO support
Currently in mac80211 each STA object is represented
using sta_info datastructure with the associated
STA specific information and drivers access ieee80211_sta
part of it.
With MLO (Multi Link Operation) support being added
in 802.11be standard, though the association is logically
with a single Multi Link capable STA, at the physical level
communication can happen via different advertised
links (uniquely identified by Channel, operating class,
BSSID) and hence the need to handle multiple link
STA parameters within a composite sta_info object
called the MLD STA. The different link STA part of
MLD STA are identified using the link address which can
be same or different as the MLD STA address and unique
link id based on the link vif.
To support extension of such a model, the sta_info
datastructure is modified to hold multiple link STA
objects with link specific params currently within
sta_info moved to this new structure. Similarly this is
done for ieee80211_sta as well which will be accessed
within mac80211 as well as by drivers, hence trivial
driver changes are expected to support this.
For current non MLO supported drivers, only one link STA
is present and link information is accessed via 'deflink'
member.
For MLO drivers, we still need to define the APIs etc. to
get the correct link ID and access the correct part of
the station info.
Currently in mac80211, all link STA info are accessed directly
via deflink. These will be updated to access via link pointers
indexed by link id with MLO support patches, with link id
being 0 for non MLO supported cases.
Except for couple of macro related changes, below spatch takes
care of updating mac80211 and driver code to access to the
link STA info via deflink.
@ieee80211_sta@
struct ieee80211_sta *s;
struct sta_info *si;
identifier var = {supp_rates, ht_cap, vht_cap, he_cap, he_6ghz_capa, eht_cap, rx_nss, bandwidth, txpwr};
@@
(
s->
- var
+ deflink.var
|
si->sta.
- var
+ deflink.var
)
@sta_info@
struct sta_info *si;
identifier var = {gtk, pcpu_rx_stats, rx_stats, rx_stats_avg, status_stats, tx_stats, cur_max_bandwidth};
@@
(
si->
- var
+ deflink.var
)
Signed-off-by: Sriram R <quic_srirrama@quicinc.com>
Link: https://lore.kernel.org/r/1649086883-13246-1-git-send-email-quic_srirrama@quicinc.com
[remove MLO-drivers notes from commit message, not clear yet; run spatch]
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
2022-04-04 18:41:23 +03:00
|
|
|
if (sta->deflink.status_stats.lost_packets < pkt_thr ||
|
|
|
|
!time_after(jiffies, sta->deflink.status_stats.last_pkt_time + pkt_time))
|
2014-05-23 22:05:28 +04:00
|
|
|
return;
|
|
|
|
|
|
|
|
cfg80211_cqm_pktloss_notify(sta->sdata->dev, sta->sta.addr,
|
mac80211: prepare sta handling for MLO support
Currently in mac80211 each STA object is represented
using sta_info datastructure with the associated
STA specific information and drivers access ieee80211_sta
part of it.
With MLO (Multi Link Operation) support being added
in 802.11be standard, though the association is logically
with a single Multi Link capable STA, at the physical level
communication can happen via different advertised
links (uniquely identified by Channel, operating class,
BSSID) and hence the need to handle multiple link
STA parameters within a composite sta_info object
called the MLD STA. The different link STA part of
MLD STA are identified using the link address which can
be same or different as the MLD STA address and unique
link id based on the link vif.
To support extension of such a model, the sta_info
datastructure is modified to hold multiple link STA
objects with link specific params currently within
sta_info moved to this new structure. Similarly this is
done for ieee80211_sta as well which will be accessed
within mac80211 as well as by drivers, hence trivial
driver changes are expected to support this.
For current non MLO supported drivers, only one link STA
is present and link information is accessed via 'deflink'
member.
For MLO drivers, we still need to define the APIs etc. to
get the correct link ID and access the correct part of
the station info.
Currently in mac80211, all link STA info are accessed directly
via deflink. These will be updated to access via link pointers
indexed by link id with MLO support patches, with link id
being 0 for non MLO supported cases.
Except for couple of macro related changes, below spatch takes
care of updating mac80211 and driver code to access to the
link STA info via deflink.
@ieee80211_sta@
struct ieee80211_sta *s;
struct sta_info *si;
identifier var = {supp_rates, ht_cap, vht_cap, he_cap, he_6ghz_capa, eht_cap, rx_nss, bandwidth, txpwr};
@@
(
s->
- var
+ deflink.var
|
si->sta.
- var
+ deflink.var
)
@sta_info@
struct sta_info *si;
identifier var = {gtk, pcpu_rx_stats, rx_stats, rx_stats_avg, status_stats, tx_stats, cur_max_bandwidth};
@@
(
si->
- var
+ deflink.var
)
Signed-off-by: Sriram R <quic_srirrama@quicinc.com>
Link: https://lore.kernel.org/r/1649086883-13246-1-git-send-email-quic_srirrama@quicinc.com
[remove MLO-drivers notes from commit message, not clear yet; run spatch]
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
2022-04-04 18:41:23 +03:00
|
|
|
sta->deflink.status_stats.lost_packets,
|
|
|
|
GFP_ATOMIC);
|
|
|
|
sta->deflink.status_stats.lost_packets = 0;
|
2014-05-23 22:05:28 +04:00
|
|
|
}
|
|
|
|
|
2014-11-19 22:08:12 +03:00
|
|
|
static int ieee80211_tx_get_rates(struct ieee80211_hw *hw,
|
|
|
|
struct ieee80211_tx_info *info,
|
|
|
|
int *retry_count)
|
2009-11-18 20:42:47 +03:00
|
|
|
{
|
2014-11-19 22:08:12 +03:00
|
|
|
int count = -1;
|
|
|
|
int i;
|
2009-11-18 20:42:47 +03:00
|
|
|
|
|
|
|
for (i = 0; i < IEEE80211_TX_MAX_RATES; i++) {
|
2012-04-06 22:48:15 +04:00
|
|
|
if ((info->flags & IEEE80211_TX_CTL_AMPDU) &&
|
|
|
|
!(info->flags & IEEE80211_TX_STAT_AMPDU)) {
|
|
|
|
/* just the first aggr frame carry status info */
|
|
|
|
info->status.rates[i].idx = -1;
|
|
|
|
info->status.rates[i].count = 0;
|
|
|
|
break;
|
|
|
|
} else if (info->status.rates[i].idx < 0) {
|
2011-03-21 17:07:55 +03:00
|
|
|
break;
|
|
|
|
} else if (i >= hw->max_report_rates) {
|
|
|
|
/* the HW cannot have attempted that rate */
|
2009-11-18 20:42:47 +03:00
|
|
|
info->status.rates[i].idx = -1;
|
|
|
|
info->status.rates[i].count = 0;
|
2011-03-21 17:07:55 +03:00
|
|
|
break;
|
2009-11-18 20:42:47 +03:00
|
|
|
}
|
|
|
|
|
2014-11-19 22:08:12 +03:00
|
|
|
count += info->status.rates[i].count;
|
2009-11-18 20:42:47 +03:00
|
|
|
}
|
2011-03-21 17:07:55 +03:00
|
|
|
|
2014-11-19 22:08:12 +03:00
|
|
|
if (count < 0)
|
|
|
|
count = 0;
|
|
|
|
|
|
|
|
*retry_count = count;
|
2020-07-22 18:38:30 +03:00
|
|
|
return i - 1;
|
2014-11-19 22:08:12 +03:00
|
|
|
}
|
|
|
|
|
2015-09-02 14:23:30 +03:00
|
|
|
void ieee80211_tx_monitor(struct ieee80211_local *local, struct sk_buff *skb,
|
2019-07-14 18:44:15 +03:00
|
|
|
int retry_count, int shift, bool send_to_cooked,
|
|
|
|
struct ieee80211_tx_status *status)
|
2014-11-19 22:08:12 +03:00
|
|
|
{
|
|
|
|
struct sk_buff *skb2;
|
2015-09-02 14:23:30 +03:00
|
|
|
struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
|
|
|
|
struct ieee80211_sub_if_data *sdata;
|
|
|
|
struct net_device *prev_dev = NULL;
|
|
|
|
int rtap_len;
|
|
|
|
|
|
|
|
/* send frame to monitor interfaces now */
|
2019-07-14 18:44:16 +03:00
|
|
|
rtap_len = ieee80211_tx_radiotap_len(info, status);
|
2015-09-02 14:23:30 +03:00
|
|
|
if (WARN_ON_ONCE(skb_headroom(skb) < rtap_len)) {
|
|
|
|
pr_err("ieee80211_tx_status: headroom too small\n");
|
|
|
|
dev_kfree_skb(skb);
|
|
|
|
return;
|
|
|
|
}
|
2022-06-01 15:16:00 +03:00
|
|
|
ieee80211_add_tx_radiotap_header(local, skb, retry_count,
|
2019-07-14 18:44:16 +03:00
|
|
|
rtap_len, shift, status);
|
2015-09-02 14:23:30 +03:00
|
|
|
|
|
|
|
/* XXX: is this sufficient for BPF? */
|
2016-03-03 04:16:56 +03:00
|
|
|
skb_reset_mac_header(skb);
|
2015-09-02 14:23:30 +03:00
|
|
|
skb->ip_summed = CHECKSUM_UNNECESSARY;
|
|
|
|
skb->pkt_type = PACKET_OTHERHOST;
|
|
|
|
skb->protocol = htons(ETH_P_802_2);
|
|
|
|
memset(skb->cb, 0, sizeof(skb->cb));
|
|
|
|
|
|
|
|
rcu_read_lock();
|
|
|
|
list_for_each_entry_rcu(sdata, &local->interfaces, list) {
|
|
|
|
if (sdata->vif.type == NL80211_IFTYPE_MONITOR) {
|
|
|
|
if (!ieee80211_sdata_running(sdata))
|
|
|
|
continue;
|
|
|
|
|
2016-08-29 23:25:15 +03:00
|
|
|
if ((sdata->u.mntr.flags & MONITOR_FLAG_COOK_FRAMES) &&
|
2015-09-02 14:23:30 +03:00
|
|
|
!send_to_cooked)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (prev_dev) {
|
|
|
|
skb2 = skb_clone(skb, GFP_ATOMIC);
|
|
|
|
if (skb2) {
|
|
|
|
skb2->dev = prev_dev;
|
|
|
|
netif_rx(skb2);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
prev_dev = sdata->dev;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (prev_dev) {
|
|
|
|
skb->dev = prev_dev;
|
|
|
|
netif_rx(skb);
|
|
|
|
skb = NULL;
|
|
|
|
}
|
|
|
|
rcu_read_unlock();
|
|
|
|
dev_kfree_skb(skb);
|
|
|
|
}
|
|
|
|
|
2017-04-26 18:11:37 +03:00
|
|
|
static void __ieee80211_tx_status(struct ieee80211_hw *hw,
|
2020-09-08 15:36:54 +03:00
|
|
|
struct ieee80211_tx_status *status,
|
|
|
|
int rates_idx, int retry_count)
|
2015-09-02 14:23:30 +03:00
|
|
|
{
|
2017-04-26 18:11:37 +03:00
|
|
|
struct sk_buff *skb = status->skb;
|
2014-11-19 22:08:12 +03:00
|
|
|
struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
|
|
|
|
struct ieee80211_local *local = hw_to_local(hw);
|
2017-04-26 18:11:37 +03:00
|
|
|
struct ieee80211_tx_info *info = status->info;
|
|
|
|
struct sta_info *sta;
|
2014-11-19 22:08:12 +03:00
|
|
|
__le16 fc;
|
|
|
|
bool send_to_cooked;
|
|
|
|
bool acked;
|
2019-12-18 17:27:36 +03:00
|
|
|
bool noack_success;
|
2014-11-19 22:08:12 +03:00
|
|
|
struct ieee80211_bar *bar;
|
|
|
|
int shift = 0;
|
2015-01-16 15:27:56 +03:00
|
|
|
int tid = IEEE80211_NUM_TIDS;
|
2014-11-19 22:08:12 +03:00
|
|
|
|
2010-02-09 12:20:28 +03:00
|
|
|
fc = hdr->frame_control;
|
2009-11-18 20:42:47 +03:00
|
|
|
|
2017-04-26 18:11:37 +03:00
|
|
|
if (status->sta) {
|
|
|
|
sta = container_of(status->sta, struct sta_info, sta);
|
2013-07-08 18:55:53 +04:00
|
|
|
shift = ieee80211_vif_get_shift(&sta->sdata->vif);
|
|
|
|
|
2011-09-29 18:04:33 +04:00
|
|
|
if (info->flags & IEEE80211_TX_STATUS_EOSP)
|
2011-09-29 18:04:36 +04:00
|
|
|
clear_sta_flag(sta, WLAN_STA_SP);
|
2011-09-29 18:04:33 +04:00
|
|
|
|
2010-12-02 23:01:08 +03:00
|
|
|
acked = !!(info->flags & IEEE80211_TX_STAT_ACK);
|
2019-12-18 17:27:36 +03:00
|
|
|
noack_success = !!(info->flags &
|
|
|
|
IEEE80211_TX_STAT_NOACK_TRANSMITTED);
|
2016-08-02 11:16:57 +03:00
|
|
|
|
|
|
|
/* mesh Peer Service Period support */
|
|
|
|
if (ieee80211_vif_is_mesh(&sta->sdata->vif) &&
|
|
|
|
ieee80211_is_data_qos(fc))
|
|
|
|
ieee80211_mpsp_trigger_process(
|
|
|
|
ieee80211_get_qos_ctl(hdr), sta, true, acked);
|
|
|
|
|
2015-06-02 22:39:54 +03:00
|
|
|
if (ieee80211_hw_check(&local->hw, HAS_RATE_CONTROL) &&
|
2014-04-02 08:05:09 +04:00
|
|
|
(ieee80211_is_data(hdr->frame_control)) &&
|
2010-04-22 11:27:48 +04:00
|
|
|
(rates_idx != -1))
|
mac80211: prepare sta handling for MLO support
Currently in mac80211 each STA object is represented
using sta_info datastructure with the associated
STA specific information and drivers access ieee80211_sta
part of it.
With MLO (Multi Link Operation) support being added
in 802.11be standard, though the association is logically
with a single Multi Link capable STA, at the physical level
communication can happen via different advertised
links (uniquely identified by Channel, operating class,
BSSID) and hence the need to handle multiple link
STA parameters within a composite sta_info object
called the MLD STA. The different link STA part of
MLD STA are identified using the link address which can
be same or different as the MLD STA address and unique
link id based on the link vif.
To support extension of such a model, the sta_info
datastructure is modified to hold multiple link STA
objects with link specific params currently within
sta_info moved to this new structure. Similarly this is
done for ieee80211_sta as well which will be accessed
within mac80211 as well as by drivers, hence trivial
driver changes are expected to support this.
For current non MLO supported drivers, only one link STA
is present and link information is accessed via 'deflink'
member.
For MLO drivers, we still need to define the APIs etc. to
get the correct link ID and access the correct part of
the station info.
Currently in mac80211, all link STA info are accessed directly
via deflink. These will be updated to access via link pointers
indexed by link id with MLO support patches, with link id
being 0 for non MLO supported cases.
Except for couple of macro related changes, below spatch takes
care of updating mac80211 and driver code to access to the
link STA info via deflink.
@ieee80211_sta@
struct ieee80211_sta *s;
struct sta_info *si;
identifier var = {supp_rates, ht_cap, vht_cap, he_cap, he_6ghz_capa, eht_cap, rx_nss, bandwidth, txpwr};
@@
(
s->
- var
+ deflink.var
|
si->sta.
- var
+ deflink.var
)
@sta_info@
struct sta_info *si;
identifier var = {gtk, pcpu_rx_stats, rx_stats, rx_stats_avg, status_stats, tx_stats, cur_max_bandwidth};
@@
(
si->
- var
+ deflink.var
)
Signed-off-by: Sriram R <quic_srirrama@quicinc.com>
Link: https://lore.kernel.org/r/1649086883-13246-1-git-send-email-quic_srirrama@quicinc.com
[remove MLO-drivers notes from commit message, not clear yet; run spatch]
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
2022-04-04 18:41:23 +03:00
|
|
|
sta->deflink.tx_stats.last_rate =
|
2015-10-16 18:54:47 +03:00
|
|
|
info->status.rates[rates_idx];
|
2010-04-22 11:27:48 +04:00
|
|
|
|
2009-11-18 20:42:47 +03:00
|
|
|
if ((info->flags & IEEE80211_TX_STAT_AMPDU_NO_BACK) &&
|
|
|
|
(ieee80211_is_data_qos(fc))) {
|
2014-11-21 16:26:31 +03:00
|
|
|
u16 ssn;
|
2009-11-18 20:42:47 +03:00
|
|
|
u8 *qc;
|
|
|
|
|
|
|
|
qc = ieee80211_get_qos_ctl(hdr);
|
|
|
|
tid = qc[0] & 0xf;
|
|
|
|
ssn = ((le16_to_cpu(hdr->seq_ctrl) + 0x10)
|
|
|
|
& IEEE80211_SCTL_SEQ);
|
2011-08-20 17:53:55 +04:00
|
|
|
ieee80211_send_bar(&sta->sdata->vif, hdr->addr1,
|
2009-11-18 20:42:47 +03:00
|
|
|
tid, ssn);
|
2014-11-21 16:26:31 +03:00
|
|
|
} else if (ieee80211_is_data_qos(fc)) {
|
|
|
|
u8 *qc = ieee80211_get_qos_ctl(hdr);
|
|
|
|
|
|
|
|
tid = qc[0] & 0xf;
|
2009-11-18 20:42:47 +03:00
|
|
|
}
|
|
|
|
|
2011-08-11 18:17:42 +04:00
|
|
|
if (!acked && ieee80211_is_back_req(fc)) {
|
2014-11-21 16:26:31 +03:00
|
|
|
u16 control;
|
2011-09-15 11:37:46 +04:00
|
|
|
|
2011-08-11 18:17:42 +04:00
|
|
|
/*
|
2011-09-15 11:37:46 +04:00
|
|
|
* BAR failed, store the last SSN and retry sending
|
|
|
|
* the BAR when the next unicast transmission on the
|
|
|
|
* same TID succeeds.
|
2011-08-11 18:17:42 +04:00
|
|
|
*/
|
|
|
|
bar = (struct ieee80211_bar *) skb->data;
|
2011-09-15 11:37:46 +04:00
|
|
|
control = le16_to_cpu(bar->control);
|
|
|
|
if (!(control & IEEE80211_BAR_CTRL_MULTI_TID)) {
|
2011-08-28 23:11:01 +04:00
|
|
|
u16 ssn = le16_to_cpu(bar->start_seq_num);
|
|
|
|
|
2011-09-15 11:37:46 +04:00
|
|
|
tid = (control &
|
2011-08-11 18:17:42 +04:00
|
|
|
IEEE80211_BAR_CTRL_TID_INFO_MASK) >>
|
|
|
|
IEEE80211_BAR_CTRL_TID_INFO_SHIFT;
|
2011-08-28 23:11:01 +04:00
|
|
|
|
2013-01-28 17:42:30 +04:00
|
|
|
ieee80211_set_bar_pending(sta, tid, ssn);
|
2011-08-11 18:17:42 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-11-18 20:42:47 +03:00
|
|
|
if (info->flags & IEEE80211_TX_STAT_TX_FILTERED) {
|
|
|
|
ieee80211_handle_filtered_frame(local, sta, skb);
|
|
|
|
return;
|
2020-09-08 15:36:54 +03:00
|
|
|
} else if (ieee80211_is_data_present(fc)) {
|
2019-12-18 17:27:36 +03:00
|
|
|
if (!acked && !noack_success)
|
mac80211: prepare sta handling for MLO support
Currently in mac80211 each STA object is represented
using sta_info datastructure with the associated
STA specific information and drivers access ieee80211_sta
part of it.
With MLO (Multi Link Operation) support being added
in 802.11be standard, though the association is logically
with a single Multi Link capable STA, at the physical level
communication can happen via different advertised
links (uniquely identified by Channel, operating class,
BSSID) and hence the need to handle multiple link
STA parameters within a composite sta_info object
called the MLD STA. The different link STA part of
MLD STA are identified using the link address which can
be same or different as the MLD STA address and unique
link id based on the link vif.
To support extension of such a model, the sta_info
datastructure is modified to hold multiple link STA
objects with link specific params currently within
sta_info moved to this new structure. Similarly this is
done for ieee80211_sta as well which will be accessed
within mac80211 as well as by drivers, hence trivial
driver changes are expected to support this.
For current non MLO supported drivers, only one link STA
is present and link information is accessed via 'deflink'
member.
For MLO drivers, we still need to define the APIs etc. to
get the correct link ID and access the correct part of
the station info.
Currently in mac80211, all link STA info are accessed directly
via deflink. These will be updated to access via link pointers
indexed by link id with MLO support patches, with link id
being 0 for non MLO supported cases.
Except for couple of macro related changes, below spatch takes
care of updating mac80211 and driver code to access to the
link STA info via deflink.
@ieee80211_sta@
struct ieee80211_sta *s;
struct sta_info *si;
identifier var = {supp_rates, ht_cap, vht_cap, he_cap, he_6ghz_capa, eht_cap, rx_nss, bandwidth, txpwr};
@@
(
s->
- var
+ deflink.var
|
si->sta.
- var
+ deflink.var
)
@sta_info@
struct sta_info *si;
identifier var = {gtk, pcpu_rx_stats, rx_stats, rx_stats_avg, status_stats, tx_stats, cur_max_bandwidth};
@@
(
si->
- var
+ deflink.var
)
Signed-off-by: Sriram R <quic_srirrama@quicinc.com>
Link: https://lore.kernel.org/r/1649086883-13246-1-git-send-email-quic_srirrama@quicinc.com
[remove MLO-drivers notes from commit message, not clear yet; run spatch]
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
2022-04-04 18:41:23 +03:00
|
|
|
sta->deflink.status_stats.msdu_failed[tid]++;
|
2015-10-16 18:54:47 +03:00
|
|
|
|
mac80211: prepare sta handling for MLO support
Currently in mac80211 each STA object is represented
using sta_info datastructure with the associated
STA specific information and drivers access ieee80211_sta
part of it.
With MLO (Multi Link Operation) support being added
in 802.11be standard, though the association is logically
with a single Multi Link capable STA, at the physical level
communication can happen via different advertised
links (uniquely identified by Channel, operating class,
BSSID) and hence the need to handle multiple link
STA parameters within a composite sta_info object
called the MLD STA. The different link STA part of
MLD STA are identified using the link address which can
be same or different as the MLD STA address and unique
link id based on the link vif.
To support extension of such a model, the sta_info
datastructure is modified to hold multiple link STA
objects with link specific params currently within
sta_info moved to this new structure. Similarly this is
done for ieee80211_sta as well which will be accessed
within mac80211 as well as by drivers, hence trivial
driver changes are expected to support this.
For current non MLO supported drivers, only one link STA
is present and link information is accessed via 'deflink'
member.
For MLO drivers, we still need to define the APIs etc. to
get the correct link ID and access the correct part of
the station info.
Currently in mac80211, all link STA info are accessed directly
via deflink. These will be updated to access via link pointers
indexed by link id with MLO support patches, with link id
being 0 for non MLO supported cases.
Except for couple of macro related changes, below spatch takes
care of updating mac80211 and driver code to access to the
link STA info via deflink.
@ieee80211_sta@
struct ieee80211_sta *s;
struct sta_info *si;
identifier var = {supp_rates, ht_cap, vht_cap, he_cap, he_6ghz_capa, eht_cap, rx_nss, bandwidth, txpwr};
@@
(
s->
- var
+ deflink.var
|
si->sta.
- var
+ deflink.var
)
@sta_info@
struct sta_info *si;
identifier var = {gtk, pcpu_rx_stats, rx_stats, rx_stats_avg, status_stats, tx_stats, cur_max_bandwidth};
@@
(
si->
- var
+ deflink.var
)
Signed-off-by: Sriram R <quic_srirrama@quicinc.com>
Link: https://lore.kernel.org/r/1649086883-13246-1-git-send-email-quic_srirrama@quicinc.com
[remove MLO-drivers notes from commit message, not clear yet; run spatch]
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
2022-04-04 18:41:23 +03:00
|
|
|
sta->deflink.status_stats.msdu_retries[tid] +=
|
2020-09-08 15:36:54 +03:00
|
|
|
retry_count;
|
2009-11-18 20:42:47 +03:00
|
|
|
}
|
|
|
|
|
2010-12-02 23:01:08 +03:00
|
|
|
if (!(info->flags & IEEE80211_TX_CTL_INJECTED) && acked)
|
2009-12-01 15:37:02 +03:00
|
|
|
ieee80211_frame_acked(sta, skb);
|
2010-11-24 10:10:06 +03:00
|
|
|
|
2009-11-18 20:42:47 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
/* SNMP counters
|
|
|
|
* Fragments are passed to low-level drivers as separate skbs, so these
|
|
|
|
* are actually fragments, not frames. Update frame counters only for
|
|
|
|
* the first fragment of the frame. */
|
2014-12-10 18:56:11 +03:00
|
|
|
if ((info->flags & IEEE80211_TX_STAT_ACK) ||
|
|
|
|
(info->flags & IEEE80211_TX_STAT_NOACK_TRANSMITTED)) {
|
2011-12-08 16:11:55 +04:00
|
|
|
if (ieee80211_is_first_frag(hdr->seq_ctrl)) {
|
2015-04-22 21:47:28 +03:00
|
|
|
I802_DEBUG_INC(local->dot11TransmittedFrameCount);
|
2014-12-21 16:25:28 +03:00
|
|
|
if (is_multicast_ether_addr(ieee80211_get_DA(hdr)))
|
2015-04-22 21:47:28 +03:00
|
|
|
I802_DEBUG_INC(local->dot11MulticastTransmittedFrameCount);
|
2009-11-18 20:42:47 +03:00
|
|
|
if (retry_count > 0)
|
2015-04-22 21:47:28 +03:00
|
|
|
I802_DEBUG_INC(local->dot11RetryCount);
|
2009-11-18 20:42:47 +03:00
|
|
|
if (retry_count > 1)
|
2015-04-22 21:47:28 +03:00
|
|
|
I802_DEBUG_INC(local->dot11MultipleRetryCount);
|
2009-11-18 20:42:47 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
/* This counter shall be incremented for an acknowledged MPDU
|
|
|
|
* with an individual address in the address 1 field or an MPDU
|
|
|
|
* with a multicast address in the address 1 field of type Data
|
|
|
|
* or Management. */
|
|
|
|
if (!is_multicast_ether_addr(hdr->addr1) ||
|
2011-12-08 16:11:55 +04:00
|
|
|
ieee80211_is_data(fc) ||
|
|
|
|
ieee80211_is_mgmt(fc))
|
2015-04-22 21:47:28 +03:00
|
|
|
I802_DEBUG_INC(local->dot11TransmittedFragmentCount);
|
2009-11-18 20:42:47 +03:00
|
|
|
} else {
|
2011-12-08 16:11:55 +04:00
|
|
|
if (ieee80211_is_first_frag(hdr->seq_ctrl))
|
2015-04-22 21:47:28 +03:00
|
|
|
I802_DEBUG_INC(local->dot11FailedCount);
|
2009-11-18 20:42:47 +03:00
|
|
|
}
|
|
|
|
|
2020-01-14 08:59:40 +03:00
|
|
|
if (ieee80211_is_any_nullfunc(fc) &&
|
2019-11-19 08:35:38 +03:00
|
|
|
ieee80211_has_pm(fc) &&
|
2015-06-02 22:39:54 +03:00
|
|
|
ieee80211_hw_check(&local->hw, REPORTS_TX_ACK_STATUS) &&
|
2010-02-09 12:20:28 +03:00
|
|
|
!(info->flags & IEEE80211_TX_CTL_INJECTED) &&
|
|
|
|
local->ps_sdata && !(local->scanning)) {
|
2021-02-27 08:58:15 +03:00
|
|
|
if (info->flags & IEEE80211_TX_STAT_ACK)
|
2010-02-09 12:20:28 +03:00
|
|
|
local->ps_sdata->u.mgd.flags |=
|
|
|
|
IEEE80211_STA_NULLFUNC_ACKED;
|
2021-02-27 08:58:15 +03:00
|
|
|
mod_timer(&local->dynamic_ps_timer,
|
|
|
|
jiffies + msecs_to_jiffies(10));
|
2010-02-09 12:20:28 +03:00
|
|
|
}
|
|
|
|
|
2012-10-26 17:53:06 +04:00
|
|
|
ieee80211_report_used_skb(local, skb, false);
|
2011-11-06 17:13:34 +04:00
|
|
|
|
2009-11-18 20:42:47 +03:00
|
|
|
/* this was a transmitted frame, but now we want to reuse it */
|
|
|
|
skb_orphan(skb);
|
|
|
|
|
2010-03-11 18:28:24 +03:00
|
|
|
/* Need to make a copy before skb->cb gets cleared */
|
|
|
|
send_to_cooked = !!(info->flags & IEEE80211_TX_CTL_INJECTED) ||
|
2011-12-08 16:11:55 +04:00
|
|
|
!(ieee80211_is_data(fc));
|
2010-03-11 18:28:24 +03:00
|
|
|
|
2009-11-18 20:42:47 +03:00
|
|
|
/*
|
|
|
|
* This is a bit racy but we can avoid a lot of work
|
|
|
|
* with this test...
|
|
|
|
*/
|
2010-03-11 18:28:24 +03:00
|
|
|
if (!local->monitors && (!send_to_cooked || !local->cooked_mntrs)) {
|
2020-09-08 15:37:00 +03:00
|
|
|
if (status->free_list)
|
|
|
|
list_add_tail(&skb->list, status->free_list);
|
|
|
|
else
|
|
|
|
dev_kfree_skb(skb);
|
2009-11-18 20:42:47 +03:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2015-09-02 14:23:30 +03:00
|
|
|
/* send to monitor interfaces */
|
2022-06-01 15:16:00 +03:00
|
|
|
ieee80211_tx_monitor(local, skb, retry_count, shift,
|
2019-07-14 18:44:15 +03:00
|
|
|
send_to_cooked, status);
|
2009-11-18 20:42:47 +03:00
|
|
|
}
|
2017-04-26 18:11:37 +03:00
|
|
|
|
|
|
|
void ieee80211_tx_status(struct ieee80211_hw *hw, struct sk_buff *skb)
|
|
|
|
{
|
|
|
|
struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
|
|
|
|
struct ieee80211_local *local = hw_to_local(hw);
|
|
|
|
struct ieee80211_tx_status status = {
|
|
|
|
.skb = skb,
|
|
|
|
.info = IEEE80211_SKB_CB(skb),
|
|
|
|
};
|
|
|
|
struct sta_info *sta;
|
|
|
|
|
|
|
|
rcu_read_lock();
|
|
|
|
|
2019-11-12 16:08:35 +03:00
|
|
|
sta = sta_info_get_by_addrs(local, hdr->addr1, hdr->addr2);
|
|
|
|
if (sta)
|
2017-04-26 18:11:37 +03:00
|
|
|
status.sta = &sta->sta;
|
|
|
|
|
2020-09-08 15:36:54 +03:00
|
|
|
ieee80211_tx_status_ext(hw, &status);
|
2017-04-26 18:11:37 +03:00
|
|
|
rcu_read_unlock();
|
|
|
|
}
|
2009-11-18 20:42:47 +03:00
|
|
|
EXPORT_SYMBOL(ieee80211_tx_status);
|
2011-04-18 15:22:28 +04:00
|
|
|
|
2017-04-26 18:11:37 +03:00
|
|
|
void ieee80211_tx_status_ext(struct ieee80211_hw *hw,
|
|
|
|
struct ieee80211_tx_status *status)
|
2017-04-26 18:11:36 +03:00
|
|
|
{
|
|
|
|
struct ieee80211_local *local = hw_to_local(hw);
|
2017-04-26 18:11:37 +03:00
|
|
|
struct ieee80211_tx_info *info = status->info;
|
|
|
|
struct ieee80211_sta *pubsta = status->sta;
|
2020-09-08 15:36:58 +03:00
|
|
|
struct sk_buff *skb = status->skb;
|
|
|
|
struct sta_info *sta = NULL;
|
2020-09-08 15:36:54 +03:00
|
|
|
int rates_idx, retry_count;
|
2022-02-02 11:49:47 +03:00
|
|
|
bool acked, noack_success, ack_signal_valid;
|
2020-09-08 15:36:58 +03:00
|
|
|
u16 tx_time_est;
|
2017-04-26 18:11:36 +03:00
|
|
|
|
2020-08-21 19:30:43 +03:00
|
|
|
if (pubsta) {
|
|
|
|
sta = container_of(pubsta, struct sta_info, sta);
|
|
|
|
|
2022-05-09 20:39:57 +03:00
|
|
|
if (status->n_rates)
|
|
|
|
sta->deflink.tx_stats.last_rate_info =
|
|
|
|
status->rates[status->n_rates - 1].rate_idx;
|
2020-08-21 19:30:43 +03:00
|
|
|
}
|
|
|
|
|
2020-09-08 15:36:59 +03:00
|
|
|
if (skb && (tx_time_est =
|
|
|
|
ieee80211_info_get_tx_time_est(IEEE80211_SKB_CB(skb))) > 0) {
|
|
|
|
/* Do this here to avoid the expensive lookup of the sta
|
|
|
|
* in ieee80211_report_used_skb().
|
|
|
|
*/
|
|
|
|
ieee80211_sta_update_pending_airtime(local, sta,
|
|
|
|
skb_get_queue_mapping(skb),
|
|
|
|
tx_time_est,
|
|
|
|
true);
|
|
|
|
ieee80211_info_set_tx_time_est(IEEE80211_SKB_CB(skb), 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!status->info)
|
|
|
|
goto free;
|
|
|
|
|
2020-09-08 15:36:54 +03:00
|
|
|
rates_idx = ieee80211_tx_get_rates(hw, info, &retry_count);
|
2017-04-26 18:11:36 +03:00
|
|
|
|
|
|
|
acked = !!(info->flags & IEEE80211_TX_STAT_ACK);
|
|
|
|
noack_success = !!(info->flags & IEEE80211_TX_STAT_NOACK_TRANSMITTED);
|
2022-02-02 11:49:47 +03:00
|
|
|
ack_signal_valid =
|
|
|
|
!!(info->status.flags & IEEE80211_TX_STATUS_ACK_SIGNAL_VALID);
|
2017-04-26 18:11:36 +03:00
|
|
|
|
|
|
|
if (pubsta) {
|
2020-09-27 13:56:05 +03:00
|
|
|
struct ieee80211_sub_if_data *sdata = sta->sdata;
|
|
|
|
|
2019-12-18 17:27:36 +03:00
|
|
|
if (!acked && !noack_success)
|
mac80211: prepare sta handling for MLO support
Currently in mac80211 each STA object is represented
using sta_info datastructure with the associated
STA specific information and drivers access ieee80211_sta
part of it.
With MLO (Multi Link Operation) support being added
in 802.11be standard, though the association is logically
with a single Multi Link capable STA, at the physical level
communication can happen via different advertised
links (uniquely identified by Channel, operating class,
BSSID) and hence the need to handle multiple link
STA parameters within a composite sta_info object
called the MLD STA. The different link STA part of
MLD STA are identified using the link address which can
be same or different as the MLD STA address and unique
link id based on the link vif.
To support extension of such a model, the sta_info
datastructure is modified to hold multiple link STA
objects with link specific params currently within
sta_info moved to this new structure. Similarly this is
done for ieee80211_sta as well which will be accessed
within mac80211 as well as by drivers, hence trivial
driver changes are expected to support this.
For current non MLO supported drivers, only one link STA
is present and link information is accessed via 'deflink'
member.
For MLO drivers, we still need to define the APIs etc. to
get the correct link ID and access the correct part of
the station info.
Currently in mac80211, all link STA info are accessed directly
via deflink. These will be updated to access via link pointers
indexed by link id with MLO support patches, with link id
being 0 for non MLO supported cases.
Except for couple of macro related changes, below spatch takes
care of updating mac80211 and driver code to access to the
link STA info via deflink.
@ieee80211_sta@
struct ieee80211_sta *s;
struct sta_info *si;
identifier var = {supp_rates, ht_cap, vht_cap, he_cap, he_6ghz_capa, eht_cap, rx_nss, bandwidth, txpwr};
@@
(
s->
- var
+ deflink.var
|
si->sta.
- var
+ deflink.var
)
@sta_info@
struct sta_info *si;
identifier var = {gtk, pcpu_rx_stats, rx_stats, rx_stats_avg, status_stats, tx_stats, cur_max_bandwidth};
@@
(
si->
- var
+ deflink.var
)
Signed-off-by: Sriram R <quic_srirrama@quicinc.com>
Link: https://lore.kernel.org/r/1649086883-13246-1-git-send-email-quic_srirrama@quicinc.com
[remove MLO-drivers notes from commit message, not clear yet; run spatch]
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
2022-04-04 18:41:23 +03:00
|
|
|
sta->deflink.status_stats.retry_failed++;
|
|
|
|
sta->deflink.status_stats.retry_count += retry_count;
|
2017-04-26 18:11:36 +03:00
|
|
|
|
2020-09-08 15:36:54 +03:00
|
|
|
if (ieee80211_hw_check(&local->hw, REPORTS_TX_ACK_STATUS)) {
|
2020-09-27 13:56:05 +03:00
|
|
|
if (sdata->vif.type == NL80211_IFTYPE_STATION &&
|
|
|
|
skb && !(info->flags & IEEE80211_TX_CTL_HW_80211_ENCAP))
|
|
|
|
ieee80211_sta_tx_notify(sdata, (void *) skb->data,
|
|
|
|
acked, info->status.tx_time);
|
|
|
|
|
2020-09-08 15:36:54 +03:00
|
|
|
if (acked) {
|
mac80211: prepare sta handling for MLO support
Currently in mac80211 each STA object is represented
using sta_info datastructure with the associated
STA specific information and drivers access ieee80211_sta
part of it.
With MLO (Multi Link Operation) support being added
in 802.11be standard, though the association is logically
with a single Multi Link capable STA, at the physical level
communication can happen via different advertised
links (uniquely identified by Channel, operating class,
BSSID) and hence the need to handle multiple link
STA parameters within a composite sta_info object
called the MLD STA. The different link STA part of
MLD STA are identified using the link address which can
be same or different as the MLD STA address and unique
link id based on the link vif.
To support extension of such a model, the sta_info
datastructure is modified to hold multiple link STA
objects with link specific params currently within
sta_info moved to this new structure. Similarly this is
done for ieee80211_sta as well which will be accessed
within mac80211 as well as by drivers, hence trivial
driver changes are expected to support this.
For current non MLO supported drivers, only one link STA
is present and link information is accessed via 'deflink'
member.
For MLO drivers, we still need to define the APIs etc. to
get the correct link ID and access the correct part of
the station info.
Currently in mac80211, all link STA info are accessed directly
via deflink. These will be updated to access via link pointers
indexed by link id with MLO support patches, with link id
being 0 for non MLO supported cases.
Except for couple of macro related changes, below spatch takes
care of updating mac80211 and driver code to access to the
link STA info via deflink.
@ieee80211_sta@
struct ieee80211_sta *s;
struct sta_info *si;
identifier var = {supp_rates, ht_cap, vht_cap, he_cap, he_6ghz_capa, eht_cap, rx_nss, bandwidth, txpwr};
@@
(
s->
- var
+ deflink.var
|
si->sta.
- var
+ deflink.var
)
@sta_info@
struct sta_info *si;
identifier var = {gtk, pcpu_rx_stats, rx_stats, rx_stats_avg, status_stats, tx_stats, cur_max_bandwidth};
@@
(
si->
- var
+ deflink.var
)
Signed-off-by: Sriram R <quic_srirrama@quicinc.com>
Link: https://lore.kernel.org/r/1649086883-13246-1-git-send-email-quic_srirrama@quicinc.com
[remove MLO-drivers notes from commit message, not clear yet; run spatch]
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
2022-04-04 18:41:23 +03:00
|
|
|
sta->deflink.status_stats.last_ack = jiffies;
|
2017-04-26 18:11:36 +03:00
|
|
|
|
mac80211: prepare sta handling for MLO support
Currently in mac80211 each STA object is represented
using sta_info datastructure with the associated
STA specific information and drivers access ieee80211_sta
part of it.
With MLO (Multi Link Operation) support being added
in 802.11be standard, though the association is logically
with a single Multi Link capable STA, at the physical level
communication can happen via different advertised
links (uniquely identified by Channel, operating class,
BSSID) and hence the need to handle multiple link
STA parameters within a composite sta_info object
called the MLD STA. The different link STA part of
MLD STA are identified using the link address which can
be same or different as the MLD STA address and unique
link id based on the link vif.
To support extension of such a model, the sta_info
datastructure is modified to hold multiple link STA
objects with link specific params currently within
sta_info moved to this new structure. Similarly this is
done for ieee80211_sta as well which will be accessed
within mac80211 as well as by drivers, hence trivial
driver changes are expected to support this.
For current non MLO supported drivers, only one link STA
is present and link information is accessed via 'deflink'
member.
For MLO drivers, we still need to define the APIs etc. to
get the correct link ID and access the correct part of
the station info.
Currently in mac80211, all link STA info are accessed directly
via deflink. These will be updated to access via link pointers
indexed by link id with MLO support patches, with link id
being 0 for non MLO supported cases.
Except for couple of macro related changes, below spatch takes
care of updating mac80211 and driver code to access to the
link STA info via deflink.
@ieee80211_sta@
struct ieee80211_sta *s;
struct sta_info *si;
identifier var = {supp_rates, ht_cap, vht_cap, he_cap, he_6ghz_capa, eht_cap, rx_nss, bandwidth, txpwr};
@@
(
s->
- var
+ deflink.var
|
si->sta.
- var
+ deflink.var
)
@sta_info@
struct sta_info *si;
identifier var = {gtk, pcpu_rx_stats, rx_stats, rx_stats_avg, status_stats, tx_stats, cur_max_bandwidth};
@@
(
si->
- var
+ deflink.var
)
Signed-off-by: Sriram R <quic_srirrama@quicinc.com>
Link: https://lore.kernel.org/r/1649086883-13246-1-git-send-email-quic_srirrama@quicinc.com
[remove MLO-drivers notes from commit message, not clear yet; run spatch]
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
2022-04-04 18:41:23 +03:00
|
|
|
if (sta->deflink.status_stats.lost_packets)
|
|
|
|
sta->deflink.status_stats.lost_packets = 0;
|
2017-04-26 18:11:36 +03:00
|
|
|
|
2020-09-08 15:36:54 +03:00
|
|
|
/* Track when last packet was ACKed */
|
mac80211: prepare sta handling for MLO support
Currently in mac80211 each STA object is represented
using sta_info datastructure with the associated
STA specific information and drivers access ieee80211_sta
part of it.
With MLO (Multi Link Operation) support being added
in 802.11be standard, though the association is logically
with a single Multi Link capable STA, at the physical level
communication can happen via different advertised
links (uniquely identified by Channel, operating class,
BSSID) and hence the need to handle multiple link
STA parameters within a composite sta_info object
called the MLD STA. The different link STA part of
MLD STA are identified using the link address which can
be same or different as the MLD STA address and unique
link id based on the link vif.
To support extension of such a model, the sta_info
datastructure is modified to hold multiple link STA
objects with link specific params currently within
sta_info moved to this new structure. Similarly this is
done for ieee80211_sta as well which will be accessed
within mac80211 as well as by drivers, hence trivial
driver changes are expected to support this.
For current non MLO supported drivers, only one link STA
is present and link information is accessed via 'deflink'
member.
For MLO drivers, we still need to define the APIs etc. to
get the correct link ID and access the correct part of
the station info.
Currently in mac80211, all link STA info are accessed directly
via deflink. These will be updated to access via link pointers
indexed by link id with MLO support patches, with link id
being 0 for non MLO supported cases.
Except for couple of macro related changes, below spatch takes
care of updating mac80211 and driver code to access to the
link STA info via deflink.
@ieee80211_sta@
struct ieee80211_sta *s;
struct sta_info *si;
identifier var = {supp_rates, ht_cap, vht_cap, he_cap, he_6ghz_capa, eht_cap, rx_nss, bandwidth, txpwr};
@@
(
s->
- var
+ deflink.var
|
si->sta.
- var
+ deflink.var
)
@sta_info@
struct sta_info *si;
identifier var = {gtk, pcpu_rx_stats, rx_stats, rx_stats_avg, status_stats, tx_stats, cur_max_bandwidth};
@@
(
si->
- var
+ deflink.var
)
Signed-off-by: Sriram R <quic_srirrama@quicinc.com>
Link: https://lore.kernel.org/r/1649086883-13246-1-git-send-email-quic_srirrama@quicinc.com
[remove MLO-drivers notes from commit message, not clear yet; run spatch]
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
2022-04-04 18:41:23 +03:00
|
|
|
sta->deflink.status_stats.last_pkt_time = jiffies;
|
2020-09-08 15:36:54 +03:00
|
|
|
|
2020-09-27 13:56:05 +03:00
|
|
|
/* Reset connection monitor */
|
|
|
|
if (sdata->vif.type == NL80211_IFTYPE_STATION &&
|
|
|
|
unlikely(sdata->u.mgd.probe_send_count > 0))
|
|
|
|
sdata->u.mgd.probe_send_count = 0;
|
|
|
|
|
2022-02-02 11:49:47 +03:00
|
|
|
if (ack_signal_valid) {
|
mac80211: prepare sta handling for MLO support
Currently in mac80211 each STA object is represented
using sta_info datastructure with the associated
STA specific information and drivers access ieee80211_sta
part of it.
With MLO (Multi Link Operation) support being added
in 802.11be standard, though the association is logically
with a single Multi Link capable STA, at the physical level
communication can happen via different advertised
links (uniquely identified by Channel, operating class,
BSSID) and hence the need to handle multiple link
STA parameters within a composite sta_info object
called the MLD STA. The different link STA part of
MLD STA are identified using the link address which can
be same or different as the MLD STA address and unique
link id based on the link vif.
To support extension of such a model, the sta_info
datastructure is modified to hold multiple link STA
objects with link specific params currently within
sta_info moved to this new structure. Similarly this is
done for ieee80211_sta as well which will be accessed
within mac80211 as well as by drivers, hence trivial
driver changes are expected to support this.
For current non MLO supported drivers, only one link STA
is present and link information is accessed via 'deflink'
member.
For MLO drivers, we still need to define the APIs etc. to
get the correct link ID and access the correct part of
the station info.
Currently in mac80211, all link STA info are accessed directly
via deflink. These will be updated to access via link pointers
indexed by link id with MLO support patches, with link id
being 0 for non MLO supported cases.
Except for couple of macro related changes, below spatch takes
care of updating mac80211 and driver code to access to the
link STA info via deflink.
@ieee80211_sta@
struct ieee80211_sta *s;
struct sta_info *si;
identifier var = {supp_rates, ht_cap, vht_cap, he_cap, he_6ghz_capa, eht_cap, rx_nss, bandwidth, txpwr};
@@
(
s->
- var
+ deflink.var
|
si->sta.
- var
+ deflink.var
)
@sta_info@
struct sta_info *si;
identifier var = {gtk, pcpu_rx_stats, rx_stats, rx_stats_avg, status_stats, tx_stats, cur_max_bandwidth};
@@
(
si->
- var
+ deflink.var
)
Signed-off-by: Sriram R <quic_srirrama@quicinc.com>
Link: https://lore.kernel.org/r/1649086883-13246-1-git-send-email-quic_srirrama@quicinc.com
[remove MLO-drivers notes from commit message, not clear yet; run spatch]
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
2022-04-04 18:41:23 +03:00
|
|
|
sta->deflink.status_stats.last_ack_signal =
|
2020-09-08 15:36:54 +03:00
|
|
|
(s8)info->status.ack_signal;
|
mac80211: prepare sta handling for MLO support
Currently in mac80211 each STA object is represented
using sta_info datastructure with the associated
STA specific information and drivers access ieee80211_sta
part of it.
With MLO (Multi Link Operation) support being added
in 802.11be standard, though the association is logically
with a single Multi Link capable STA, at the physical level
communication can happen via different advertised
links (uniquely identified by Channel, operating class,
BSSID) and hence the need to handle multiple link
STA parameters within a composite sta_info object
called the MLD STA. The different link STA part of
MLD STA are identified using the link address which can
be same or different as the MLD STA address and unique
link id based on the link vif.
To support extension of such a model, the sta_info
datastructure is modified to hold multiple link STA
objects with link specific params currently within
sta_info moved to this new structure. Similarly this is
done for ieee80211_sta as well which will be accessed
within mac80211 as well as by drivers, hence trivial
driver changes are expected to support this.
For current non MLO supported drivers, only one link STA
is present and link information is accessed via 'deflink'
member.
For MLO drivers, we still need to define the APIs etc. to
get the correct link ID and access the correct part of
the station info.
Currently in mac80211, all link STA info are accessed directly
via deflink. These will be updated to access via link pointers
indexed by link id with MLO support patches, with link id
being 0 for non MLO supported cases.
Except for couple of macro related changes, below spatch takes
care of updating mac80211 and driver code to access to the
link STA info via deflink.
@ieee80211_sta@
struct ieee80211_sta *s;
struct sta_info *si;
identifier var = {supp_rates, ht_cap, vht_cap, he_cap, he_6ghz_capa, eht_cap, rx_nss, bandwidth, txpwr};
@@
(
s->
- var
+ deflink.var
|
si->sta.
- var
+ deflink.var
)
@sta_info@
struct sta_info *si;
identifier var = {gtk, pcpu_rx_stats, rx_stats, rx_stats_avg, status_stats, tx_stats, cur_max_bandwidth};
@@
(
si->
- var
+ deflink.var
)
Signed-off-by: Sriram R <quic_srirrama@quicinc.com>
Link: https://lore.kernel.org/r/1649086883-13246-1-git-send-email-quic_srirrama@quicinc.com
[remove MLO-drivers notes from commit message, not clear yet; run spatch]
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
2022-04-04 18:41:23 +03:00
|
|
|
sta->deflink.status_stats.ack_signal_filled = true;
|
|
|
|
ewma_avg_signal_add(&sta->deflink.status_stats.avg_ack_signal,
|
2020-09-08 15:36:54 +03:00
|
|
|
-info->status.ack_signal);
|
|
|
|
}
|
|
|
|
} else if (test_sta_flag(sta, WLAN_STA_PS_STA)) {
|
2020-11-11 21:33:57 +03:00
|
|
|
/*
|
|
|
|
* The STA is in power save mode, so assume
|
|
|
|
* that this TX packet failed because of that.
|
|
|
|
*/
|
|
|
|
if (skb)
|
|
|
|
ieee80211_handle_filtered_frame(local, sta, skb);
|
2020-09-08 15:36:54 +03:00
|
|
|
return;
|
|
|
|
} else if (noack_success) {
|
|
|
|
/* nothing to do here, do not account as lost */
|
|
|
|
} else {
|
|
|
|
ieee80211_lost_packet(sta, info);
|
|
|
|
}
|
2017-04-26 18:11:36 +03:00
|
|
|
}
|
|
|
|
|
2022-06-01 15:16:00 +03:00
|
|
|
rate_control_tx_status(local, status);
|
2018-09-06 11:57:48 +03:00
|
|
|
if (ieee80211_vif_is_mesh(&sta->sdata->vif))
|
|
|
|
ieee80211s_update_metric(local, sta, status);
|
2017-04-26 18:11:36 +03:00
|
|
|
}
|
|
|
|
|
2020-09-08 15:36:58 +03:00
|
|
|
if (skb && !(info->flags & IEEE80211_TX_CTL_HW_80211_ENCAP))
|
2020-09-08 15:36:54 +03:00
|
|
|
return __ieee80211_tx_status(hw, status, rates_idx,
|
|
|
|
retry_count);
|
|
|
|
|
2017-04-26 18:11:36 +03:00
|
|
|
if (acked || noack_success) {
|
|
|
|
I802_DEBUG_INC(local->dot11TransmittedFrameCount);
|
|
|
|
if (!pubsta)
|
|
|
|
I802_DEBUG_INC(local->dot11MulticastTransmittedFrameCount);
|
|
|
|
if (retry_count > 0)
|
|
|
|
I802_DEBUG_INC(local->dot11RetryCount);
|
|
|
|
if (retry_count > 1)
|
|
|
|
I802_DEBUG_INC(local->dot11MultipleRetryCount);
|
|
|
|
} else {
|
|
|
|
I802_DEBUG_INC(local->dot11FailedCount);
|
|
|
|
}
|
2020-09-08 15:36:58 +03:00
|
|
|
|
2020-09-08 15:36:59 +03:00
|
|
|
free:
|
2020-09-08 15:36:58 +03:00
|
|
|
if (!skb)
|
|
|
|
return;
|
|
|
|
|
|
|
|
ieee80211_report_used_skb(local, skb, false);
|
2020-09-08 15:37:00 +03:00
|
|
|
if (status->free_list)
|
|
|
|
list_add_tail(&skb->list, status->free_list);
|
|
|
|
else
|
|
|
|
dev_kfree_skb(skb);
|
2017-04-26 18:11:36 +03:00
|
|
|
}
|
2017-04-26 18:11:37 +03:00
|
|
|
EXPORT_SYMBOL(ieee80211_tx_status_ext);
|
2017-04-26 18:11:36 +03:00
|
|
|
|
2018-10-11 15:45:03 +03:00
|
|
|
void ieee80211_tx_rate_update(struct ieee80211_hw *hw,
|
|
|
|
struct ieee80211_sta *pubsta,
|
|
|
|
struct ieee80211_tx_info *info)
|
|
|
|
{
|
|
|
|
struct ieee80211_local *local = hw_to_local(hw);
|
|
|
|
struct sta_info *sta = container_of(pubsta, struct sta_info, sta);
|
|
|
|
struct ieee80211_tx_status status = {
|
|
|
|
.info = info,
|
|
|
|
.sta = pubsta,
|
|
|
|
};
|
|
|
|
|
2022-06-01 15:16:00 +03:00
|
|
|
rate_control_tx_status(local, &status);
|
2018-10-11 15:45:03 +03:00
|
|
|
|
|
|
|
if (ieee80211_hw_check(&local->hw, HAS_RATE_CONTROL))
|
mac80211: prepare sta handling for MLO support
Currently in mac80211 each STA object is represented
using sta_info datastructure with the associated
STA specific information and drivers access ieee80211_sta
part of it.
With MLO (Multi Link Operation) support being added
in 802.11be standard, though the association is logically
with a single Multi Link capable STA, at the physical level
communication can happen via different advertised
links (uniquely identified by Channel, operating class,
BSSID) and hence the need to handle multiple link
STA parameters within a composite sta_info object
called the MLD STA. The different link STA part of
MLD STA are identified using the link address which can
be same or different as the MLD STA address and unique
link id based on the link vif.
To support extension of such a model, the sta_info
datastructure is modified to hold multiple link STA
objects with link specific params currently within
sta_info moved to this new structure. Similarly this is
done for ieee80211_sta as well which will be accessed
within mac80211 as well as by drivers, hence trivial
driver changes are expected to support this.
For current non MLO supported drivers, only one link STA
is present and link information is accessed via 'deflink'
member.
For MLO drivers, we still need to define the APIs etc. to
get the correct link ID and access the correct part of
the station info.
Currently in mac80211, all link STA info are accessed directly
via deflink. These will be updated to access via link pointers
indexed by link id with MLO support patches, with link id
being 0 for non MLO supported cases.
Except for couple of macro related changes, below spatch takes
care of updating mac80211 and driver code to access to the
link STA info via deflink.
@ieee80211_sta@
struct ieee80211_sta *s;
struct sta_info *si;
identifier var = {supp_rates, ht_cap, vht_cap, he_cap, he_6ghz_capa, eht_cap, rx_nss, bandwidth, txpwr};
@@
(
s->
- var
+ deflink.var
|
si->sta.
- var
+ deflink.var
)
@sta_info@
struct sta_info *si;
identifier var = {gtk, pcpu_rx_stats, rx_stats, rx_stats_avg, status_stats, tx_stats, cur_max_bandwidth};
@@
(
si->
- var
+ deflink.var
)
Signed-off-by: Sriram R <quic_srirrama@quicinc.com>
Link: https://lore.kernel.org/r/1649086883-13246-1-git-send-email-quic_srirrama@quicinc.com
[remove MLO-drivers notes from commit message, not clear yet; run spatch]
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
2022-04-04 18:41:23 +03:00
|
|
|
sta->deflink.tx_stats.last_rate = info->status.rates[0];
|
2018-10-11 15:45:03 +03:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ieee80211_tx_rate_update);
|
|
|
|
|
2019-11-25 13:04:37 +03:00
|
|
|
void ieee80211_tx_status_8023(struct ieee80211_hw *hw,
|
|
|
|
struct ieee80211_vif *vif,
|
|
|
|
struct sk_buff *skb)
|
|
|
|
{
|
|
|
|
struct ieee80211_sub_if_data *sdata;
|
2020-09-08 15:36:58 +03:00
|
|
|
struct ieee80211_tx_status status = {
|
|
|
|
.skb = skb,
|
|
|
|
.info = IEEE80211_SKB_CB(skb),
|
|
|
|
};
|
2019-11-25 13:04:37 +03:00
|
|
|
struct sta_info *sta;
|
|
|
|
|
|
|
|
sdata = vif_to_sdata(vif);
|
|
|
|
|
|
|
|
rcu_read_lock();
|
|
|
|
|
2020-09-08 15:36:58 +03:00
|
|
|
if (!ieee80211_lookup_ra_sta(sdata, skb, &sta) && !IS_ERR(sta))
|
|
|
|
status.sta = &sta->sta;
|
2019-11-25 13:04:37 +03:00
|
|
|
|
2020-09-08 15:36:58 +03:00
|
|
|
ieee80211_tx_status_ext(hw, &status);
|
2019-11-25 13:04:37 +03:00
|
|
|
|
|
|
|
rcu_read_unlock();
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ieee80211_tx_status_8023);
|
|
|
|
|
2011-04-18 15:22:28 +04:00
|
|
|
void ieee80211_report_low_ack(struct ieee80211_sta *pubsta, u32 num_packets)
|
|
|
|
{
|
|
|
|
struct sta_info *sta = container_of(pubsta, struct sta_info, sta);
|
|
|
|
cfg80211_cqm_pktloss_notify(sta->sdata->dev, sta->sta.addr,
|
|
|
|
num_packets, GFP_ATOMIC);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ieee80211_report_low_ack);
|
2011-11-04 14:18:10 +04:00
|
|
|
|
|
|
|
void ieee80211_free_txskb(struct ieee80211_hw *hw, struct sk_buff *skb)
|
|
|
|
{
|
2011-11-06 17:13:34 +04:00
|
|
|
struct ieee80211_local *local = hw_to_local(hw);
|
|
|
|
|
2012-10-26 17:53:06 +04:00
|
|
|
ieee80211_report_used_skb(local, skb, true);
|
2011-11-04 14:18:10 +04:00
|
|
|
dev_kfree_skb_any(skb);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ieee80211_free_txskb);
|
2012-11-10 06:44:14 +04:00
|
|
|
|
|
|
|
void ieee80211_purge_tx_queue(struct ieee80211_hw *hw,
|
|
|
|
struct sk_buff_head *skbs)
|
|
|
|
{
|
|
|
|
struct sk_buff *skb;
|
|
|
|
|
|
|
|
while ((skb = __skb_dequeue(skbs)))
|
|
|
|
ieee80211_free_txskb(hw, skb);
|
|
|
|
}
|