Commit 4bbb02f1 authored by David S. Miller's avatar David S. Miller
Browse files

Merge tag 'mac80211-next-for-net-next-2019-11-22' of... 

Merge tag 'mac80211-next-for-net-next-2019-11-22' of git://git.kernel.org/pub/scm/linux/kernel/git/jberg/mac80211-next



Johannes Berg says:

====================
The interesting new thing here is AQL, the Airtime Queue Limit
patchset from Kan Yan (Google) and Toke Høiland-Jørgensen (Redhat).
The effect is intended to eventually be similar to BQL, but byte
queue limits are not useful in wifi where the actual throughput can
vary by around 4 orders of magnitude. There are more details in the
patches themselves.
====================

Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parents 41b416f1 7a89233a

drivers/net/wireless/virt_wifi.c

+2 −2
Original line number Original line Diff line number Diff line
@@ -450,7 +450,6 @@ static void virt_wifi_net_device_destructor(struct net_device *dev) 
	 */

	 */

	kfree(dev->ieee80211_ptr);

	kfree(dev->ieee80211_ptr);

	dev->ieee80211_ptr = NULL;

	dev->ieee80211_ptr = NULL;

	free_netdev(dev);

}

}





/* No lock interaction. */

/* No lock interaction. */
@@ -458,7 +457,7 @@ static void virt_wifi_setup(struct net_device *dev) 
{

{

	ether_setup(dev);

	ether_setup(dev);

	dev->netdev_ops = &virt_wifi_ops;

	dev->netdev_ops = &virt_wifi_ops;

	dev->priv_destructor = virt_wifi_net_device_destructor;

	dev->needs_free_netdev  = true;

}

}





/* Called in a RCU read critical section from netif_receive_skb */

/* Called in a RCU read critical section from netif_receive_skb */
@@ -544,6 +543,7 @@ static int virt_wifi_newlink(struct net *src_net, struct net_device *dev, 
		goto unregister_netdev;

		goto unregister_netdev;

	}

	}





	dev->priv_destructor = virt_wifi_net_device_destructor;

	priv->being_deleted = false;

	priv->being_deleted = false;

	priv->is_connected = false;

	priv->is_connected = false;

	priv->is_up = false;

	priv->is_up = false;

include/net/cfg80211.h

+7 −0
Original line number Original line Diff line number Diff line
@@ -2606,6 +2606,13 @@ enum wiphy_params_flags { 




#define IEEE80211_DEFAULT_AIRTIME_WEIGHT	256

#define IEEE80211_DEFAULT_AIRTIME_WEIGHT	256





/* The per TXQ device queue limit in airtime */

#define IEEE80211_DEFAULT_AQL_TXQ_LIMIT_L	5000

#define IEEE80211_DEFAULT_AQL_TXQ_LIMIT_H	12000



/* The per interface airtime threshold to switch to lower queue limit */

#define IEEE80211_AQL_THRESHOLD			24000



/**

/**

 * struct cfg80211_pmksa - PMK Security Association

 * struct cfg80211_pmksa - PMK Security Association

 *

 *

include/net/mac80211.h

+57 −0
Original line number Original line Diff line number Diff line
@@ -1060,6 +1060,22 @@ struct ieee80211_tx_info { 
	};

	};

};

};





static inline u16

ieee80211_info_set_tx_time_est(struct ieee80211_tx_info *info, u16 tx_time_est)

{

	/* We only have 10 bits in tx_time_est, so store airtime

	 * in increments of 4us and clamp the maximum to 2**12-1

	 */

	info->tx_time_est = min_t(u16, tx_time_est, 4095) >> 2;

	return info->tx_time_est << 2;

}



static inline u16

ieee80211_info_get_tx_time_est(struct ieee80211_tx_info *info)

{

	return info->tx_time_est << 2;

}



/**

/**

 * struct ieee80211_tx_status - extended tx status info for rate control

 * struct ieee80211_tx_status - extended tx status info for rate control

 *

 *
@@ -5565,6 +5581,18 @@ void ieee80211_send_eosp_nullfunc(struct ieee80211_sta *pubsta, int tid); 
void ieee80211_sta_register_airtime(struct ieee80211_sta *pubsta, u8 tid,

void ieee80211_sta_register_airtime(struct ieee80211_sta *pubsta, u8 tid,

				    u32 tx_airtime, u32 rx_airtime);

				    u32 tx_airtime, u32 rx_airtime);





/**

 * ieee80211_txq_airtime_check - check if a txq can send frame to device

 *

 * @hw: pointer obtained from ieee80211_alloc_hw()

 * @txq: pointer obtained from station or virtual interface

 *

 * Return true if the AQL's airtime limit has not been reached and the txq can

 * continue to send more packets to the device. Otherwise return false.

 */

bool

ieee80211_txq_airtime_check(struct ieee80211_hw *hw, struct ieee80211_txq *txq);



/**

/**

 * ieee80211_iter_keys - iterate keys programmed into the device

 * ieee80211_iter_keys - iterate keys programmed into the device

 * @hw: pointer obtained from ieee80211_alloc_hw()

 * @hw: pointer obtained from ieee80211_alloc_hw()
@@ -6424,4 +6452,33 @@ void ieee80211_nan_func_match(struct ieee80211_vif *vif, 
			      struct cfg80211_nan_match_params *match,

			      struct cfg80211_nan_match_params *match,

			      gfp_t gfp);

			      gfp_t gfp);





/**

 * ieee80211_calc_rx_airtime - calculate estimated transmission airtime for RX.

 *

 * This function calculates the estimated airtime usage of a frame based on the

 * rate information in the RX status struct and the frame length.

 *

 * @hw: pointer as obtained from ieee80211_alloc_hw()

 * @status: &struct ieee80211_rx_status containing the transmission rate

 *          information.

 * @len: frame length in bytes

 */

u32 ieee80211_calc_rx_airtime(struct ieee80211_hw *hw,

			      struct ieee80211_rx_status *status,

			      int len);



/**

 * ieee80211_calc_tx_airtime - calculate estimated transmission airtime for TX.

 *

 * This function calculates the estimated airtime usage of a frame based on the

 * rate information in the TX info struct and the frame length.

 *

 * @hw: pointer as obtained from ieee80211_alloc_hw()

 * @info: &struct ieee80211_tx_info of the frame.

 * @len: frame length in bytes

 */

u32 ieee80211_calc_tx_airtime(struct ieee80211_hw *hw,

			      struct ieee80211_tx_info *info,

			      int len);



#endif /* MAC80211_H */
 
#endif /* MAC80211_H */

net/mac80211/Makefile

+2 −1
Original line number Original line Diff line number Diff line
@@ -32,7 +32,8 @@ mac80211-y := \ 
	chan.o \

	chan.o \

	trace.o mlme.o \

	trace.o mlme.o \

	tdls.o \

	tdls.o \

	ocb.o

	ocb.o \

	airtime.o





mac80211-$(CONFIG_MAC80211_LEDS) += led.o

mac80211-$(CONFIG_MAC80211_LEDS) += led.o

mac80211-$(CONFIG_MAC80211_DEBUGFS) += \

mac80211-$(CONFIG_MAC80211_DEBUGFS) += \

net/mac80211/airtime.c

0 → 100644
+597 −0
Original line number Original line Diff line number Diff line 
// SPDX-License-Identifier: ISC

/*

 * Copyright (C) 2019 Felix Fietkau <nbd@nbd.name>

 */



#include <net/mac80211.h>

#include "ieee80211_i.h"

#include "sta_info.h"



#define AVG_PKT_SIZE	1024



/* Number of bits for an average sized packet */

#define MCS_NBITS (AVG_PKT_SIZE << 3)



/* Number of kilo-symbols (symbols * 1024) for a packet with (bps) bits per

 * symbol. We use k-symbols to avoid rounding in the _TIME macros below.

 */

#define MCS_N_KSYMS(bps) DIV_ROUND_UP(MCS_NBITS << 10, (bps))



/* Transmission time (in 1024 * usec) for a packet containing (ksyms) * 1024

 * symbols.

 */

#define MCS_SYMBOL_TIME(sgi, ksyms)					\

	(sgi ?								\

	  ((ksyms) * 4 * 18) / 20 :		/* 3.6 us per sym */	\

	  ((ksyms) * 4)			/* 4.0 us per sym */	\

	)



/* Transmit duration for the raw data part of an average sized packet */

#define MCS_DURATION(streams, sgi, bps) \

	((u32)MCS_SYMBOL_TIME(sgi, MCS_N_KSYMS((streams) * (bps))))



#define MCS_DURATION_S(shift, streams, sgi, bps)		\

	((u16)((MCS_DURATION(streams, sgi, bps) >> shift)))



/* These should match the values in enum nl80211_he_gi */

#define HE_GI_08 0

#define HE_GI_16 1

#define HE_GI_32 2



/* Transmission time (1024 usec) for a packet containing (ksyms) * k-symbols */

#define HE_SYMBOL_TIME(gi, ksyms)					\

	(gi == HE_GI_08 ?						\

	 ((ksyms) * 16 * 17) / 20 :		/* 13.6 us per sym */	\

	 (gi == HE_GI_16 ?						\

	  ((ksyms) * 16 * 18) / 20 :		/* 14.4 us per sym */	\

	  ((ksyms) * 16)			/* 16.0 us per sym */	\

	 ))



/* Transmit duration for the raw data part of an average sized packet */

#define HE_DURATION(streams, gi, bps) \

	((u32)HE_SYMBOL_TIME(gi, MCS_N_KSYMS((streams) * (bps))))



#define HE_DURATION_S(shift, streams, gi, bps)		\

	(HE_DURATION(streams, gi, bps) >> shift)



#define BW_20			0

#define BW_40			1

#define BW_80			2

#define BW_160			3



/*

 * Define group sort order: HT40 -> SGI -> #streams

 */

#define IEEE80211_MAX_STREAMS		4

#define IEEE80211_HT_STREAM_GROUPS	4 /* BW(=2) * SGI(=2) */

#define IEEE80211_VHT_STREAM_GROUPS	8 /* BW(=4) * SGI(=2) */



#define IEEE80211_HE_MAX_STREAMS	8

#define IEEE80211_HE_STREAM_GROUPS	12 /* BW(=4) * GI(=3) */



#define IEEE80211_HT_GROUPS_NB	(IEEE80211_MAX_STREAMS *	\

				 IEEE80211_HT_STREAM_GROUPS)

#define IEEE80211_VHT_GROUPS_NB	(IEEE80211_MAX_STREAMS *	\

					 IEEE80211_VHT_STREAM_GROUPS)

#define IEEE80211_HE_GROUPS_NB	(IEEE80211_HE_MAX_STREAMS *	\

				 IEEE80211_HE_STREAM_GROUPS)

#define IEEE80211_GROUPS_NB	(IEEE80211_HT_GROUPS_NB +	\

				 IEEE80211_VHT_GROUPS_NB +	\

				 IEEE80211_HE_GROUPS_NB)



#define IEEE80211_HT_GROUP_0	0

#define IEEE80211_VHT_GROUP_0	(IEEE80211_HT_GROUP_0 + IEEE80211_HT_GROUPS_NB)

#define IEEE80211_HE_GROUP_0	(IEEE80211_VHT_GROUP_0 + IEEE80211_VHT_GROUPS_NB)



#define MCS_GROUP_RATES		12



#define HT_GROUP_IDX(_streams, _sgi, _ht40)	\

	IEEE80211_HT_GROUP_0 +			\

	IEEE80211_MAX_STREAMS * 2 * _ht40 +	\

	IEEE80211_MAX_STREAMS * _sgi +		\

	_streams - 1



#define _MAX(a, b) (((a)>(b))?(a):(b))



#define GROUP_SHIFT(duration)						\

	_MAX(0, 16 - __builtin_clz(duration))



/* MCS rate information for an MCS group */

#define __MCS_GROUP(_streams, _sgi, _ht40, _s)				\

	[HT_GROUP_IDX(_streams, _sgi, _ht40)] = {			\

	.shift = _s,							\

	.duration = {							\

		MCS_DURATION_S(_s, _streams, _sgi, _ht40 ? 54 : 26),	\

		MCS_DURATION_S(_s, _streams, _sgi, _ht40 ? 108 : 52),	\

		MCS_DURATION_S(_s, _streams, _sgi, _ht40 ? 162 : 78),	\

		MCS_DURATION_S(_s, _streams, _sgi, _ht40 ? 216 : 104),	\

		MCS_DURATION_S(_s, _streams, _sgi, _ht40 ? 324 : 156),	\

		MCS_DURATION_S(_s, _streams, _sgi, _ht40 ? 432 : 208),	\

		MCS_DURATION_S(_s, _streams, _sgi, _ht40 ? 486 : 234),	\

		MCS_DURATION_S(_s, _streams, _sgi, _ht40 ? 540 : 260)	\

	}								\

}



#define MCS_GROUP_SHIFT(_streams, _sgi, _ht40)				\

	GROUP_SHIFT(MCS_DURATION(_streams, _sgi, _ht40 ? 54 : 26))



#define MCS_GROUP(_streams, _sgi, _ht40)				\

	__MCS_GROUP(_streams, _sgi, _ht40,				\

		    MCS_GROUP_SHIFT(_streams, _sgi, _ht40))



#define VHT_GROUP_IDX(_streams, _sgi, _bw)				\

	(IEEE80211_VHT_GROUP_0 +					\

	 IEEE80211_MAX_STREAMS * 2 * (_bw) +				\

	 IEEE80211_MAX_STREAMS * (_sgi) +				\

	 (_streams) - 1)



#define BW2VBPS(_bw, r4, r3, r2, r1)					\

	(_bw == BW_160 ? r4 : _bw == BW_80 ? r3 : _bw == BW_40 ? r2 : r1)



#define __VHT_GROUP(_streams, _sgi, _bw, _s)				\

	[VHT_GROUP_IDX(_streams, _sgi, _bw)] = {			\

	.shift = _s,							\

	.duration = {							\

		MCS_DURATION_S(_s, _streams, _sgi,			\

			       BW2VBPS(_bw,  234,  117,  54,  26)),	\

		MCS_DURATION_S(_s, _streams, _sgi,			\

			       BW2VBPS(_bw,  468,  234, 108,  52)),	\

		MCS_DURATION_S(_s, _streams, _sgi,			\

			       BW2VBPS(_bw,  702,  351, 162,  78)),	\

		MCS_DURATION_S(_s, _streams, _sgi,			\

			       BW2VBPS(_bw,  936,  468, 216, 104)),	\

		MCS_DURATION_S(_s, _streams, _sgi,			\

			       BW2VBPS(_bw, 1404,  702, 324, 156)),	\

		MCS_DURATION_S(_s, _streams, _sgi,			\

			       BW2VBPS(_bw, 1872,  936, 432, 208)),	\

		MCS_DURATION_S(_s, _streams, _sgi,			\

			       BW2VBPS(_bw, 2106, 1053, 486, 234)),	\

		MCS_DURATION_S(_s, _streams, _sgi,			\

			       BW2VBPS(_bw, 2340, 1170, 540, 260)),	\

		MCS_DURATION_S(_s, _streams, _sgi,			\

			       BW2VBPS(_bw, 2808, 1404, 648, 312)),	\

		MCS_DURATION_S(_s, _streams, _sgi,			\

			       BW2VBPS(_bw, 3120, 1560, 720, 346))	\

        }								\

}



#define VHT_GROUP_SHIFT(_streams, _sgi, _bw)				\

	GROUP_SHIFT(MCS_DURATION(_streams, _sgi,			\

				 BW2VBPS(_bw, 243, 117,  54,  26)))



#define VHT_GROUP(_streams, _sgi, _bw)					\

	__VHT_GROUP(_streams, _sgi, _bw,				\

		    VHT_GROUP_SHIFT(_streams, _sgi, _bw))





#define HE_GROUP_IDX(_streams, _gi, _bw)				\

	(IEEE80211_HE_GROUP_0 +					\

	 IEEE80211_HE_MAX_STREAMS * 3 * (_bw) +			\

	 IEEE80211_HE_MAX_STREAMS * (_gi) +				\

	 (_streams) - 1)



#define __HE_GROUP(_streams, _gi, _bw, _s)				\

	[HE_GROUP_IDX(_streams, _gi, _bw)] = {			\

	.shift = _s,							\

	.duration = {							\

		HE_DURATION_S(_s, _streams, _gi,			\

			      BW2VBPS(_bw,   979,  489,  230,  115)),	\

		HE_DURATION_S(_s, _streams, _gi,			\

			      BW2VBPS(_bw,  1958,  979,  475,  230)),	\

		HE_DURATION_S(_s, _streams, _gi,			\

			      BW2VBPS(_bw,  2937, 1468,  705,  345)),	\

		HE_DURATION_S(_s, _streams, _gi,			\

			      BW2VBPS(_bw,  3916, 1958,  936,  475)),	\

		HE_DURATION_S(_s, _streams, _gi,			\

			      BW2VBPS(_bw,  5875, 2937, 1411,  705)),	\

		HE_DURATION_S(_s, _streams, _gi,			\

			      BW2VBPS(_bw,  7833, 3916, 1872,  936)),	\

		HE_DURATION_S(_s, _streams, _gi,			\

			      BW2VBPS(_bw,  8827, 4406, 2102, 1051)),	\

		HE_DURATION_S(_s, _streams, _gi,			\

			      BW2VBPS(_bw,  9806, 4896, 2347, 1166)),	\

		HE_DURATION_S(_s, _streams, _gi,			\

			      BW2VBPS(_bw, 11764, 5875, 2808, 1411)),	\

		HE_DURATION_S(_s, _streams, _gi,			\

			      BW2VBPS(_bw, 13060, 6523, 3124, 1555)),	\

		HE_DURATION_S(_s, _streams, _gi,			\

			      BW2VBPS(_bw, 14702, 7344, 3513, 1756)),	\

		HE_DURATION_S(_s, _streams, _gi,			\

			      BW2VBPS(_bw, 16329, 8164, 3902, 1944))	\

        }								\

}



#define HE_GROUP_SHIFT(_streams, _gi, _bw)				\

	GROUP_SHIFT(HE_DURATION(_streams, _gi,			\

				BW2VBPS(_bw,   979,  489,  230,  115)))



#define HE_GROUP(_streams, _gi, _bw)					\

	__HE_GROUP(_streams, _gi, _bw,				\

		   HE_GROUP_SHIFT(_streams, _gi, _bw))

struct mcs_group {

	u8 shift;

	u16 duration[MCS_GROUP_RATES];

};



static const struct mcs_group airtime_mcs_groups[] = {

	MCS_GROUP(1, 0, BW_20),

	MCS_GROUP(2, 0, BW_20),

	MCS_GROUP(3, 0, BW_20),

	MCS_GROUP(4, 0, BW_20),



	MCS_GROUP(1, 1, BW_20),

	MCS_GROUP(2, 1, BW_20),

	MCS_GROUP(3, 1, BW_20),

	MCS_GROUP(4, 1, BW_20),



	MCS_GROUP(1, 0, BW_40),

	MCS_GROUP(2, 0, BW_40),

	MCS_GROUP(3, 0, BW_40),

	MCS_GROUP(4, 0, BW_40),



	MCS_GROUP(1, 1, BW_40),

	MCS_GROUP(2, 1, BW_40),

	MCS_GROUP(3, 1, BW_40),

	MCS_GROUP(4, 1, BW_40),



	VHT_GROUP(1, 0, BW_20),

	VHT_GROUP(2, 0, BW_20),

	VHT_GROUP(3, 0, BW_20),

	VHT_GROUP(4, 0, BW_20),



	VHT_GROUP(1, 1, BW_20),

	VHT_GROUP(2, 1, BW_20),

	VHT_GROUP(3, 1, BW_20),

	VHT_GROUP(4, 1, BW_20),



	VHT_GROUP(1, 0, BW_40),

	VHT_GROUP(2, 0, BW_40),

	VHT_GROUP(3, 0, BW_40),

	VHT_GROUP(4, 0, BW_40),



	VHT_GROUP(1, 1, BW_40),

	VHT_GROUP(2, 1, BW_40),

	VHT_GROUP(3, 1, BW_40),

	VHT_GROUP(4, 1, BW_40),



	VHT_GROUP(1, 0, BW_80),

	VHT_GROUP(2, 0, BW_80),

	VHT_GROUP(3, 0, BW_80),

	VHT_GROUP(4, 0, BW_80),



	VHT_GROUP(1, 1, BW_80),

	VHT_GROUP(2, 1, BW_80),

	VHT_GROUP(3, 1, BW_80),

	VHT_GROUP(4, 1, BW_80),



	VHT_GROUP(1, 0, BW_160),

	VHT_GROUP(2, 0, BW_160),

	VHT_GROUP(3, 0, BW_160),

	VHT_GROUP(4, 0, BW_160),



	VHT_GROUP(1, 1, BW_160),

	VHT_GROUP(2, 1, BW_160),

	VHT_GROUP(3, 1, BW_160),

	VHT_GROUP(4, 1, BW_160),



	HE_GROUP(1, HE_GI_08, BW_20),

	HE_GROUP(2, HE_GI_08, BW_20),

	HE_GROUP(3, HE_GI_08, BW_20),

	HE_GROUP(4, HE_GI_08, BW_20),

	HE_GROUP(5, HE_GI_08, BW_20),

	HE_GROUP(6, HE_GI_08, BW_20),

	HE_GROUP(7, HE_GI_08, BW_20),

	HE_GROUP(8, HE_GI_08, BW_20),



	HE_GROUP(1, HE_GI_16, BW_20),

	HE_GROUP(2, HE_GI_16, BW_20),

	HE_GROUP(3, HE_GI_16, BW_20),

	HE_GROUP(4, HE_GI_16, BW_20),

	HE_GROUP(5, HE_GI_16, BW_20),

	HE_GROUP(6, HE_GI_16, BW_20),

	HE_GROUP(7, HE_GI_16, BW_20),

	HE_GROUP(8, HE_GI_16, BW_20),



	HE_GROUP(1, HE_GI_32, BW_20),

	HE_GROUP(2, HE_GI_32, BW_20),

	HE_GROUP(3, HE_GI_32, BW_20),

	HE_GROUP(4, HE_GI_32, BW_20),

	HE_GROUP(5, HE_GI_32, BW_20),

	HE_GROUP(6, HE_GI_32, BW_20),

	HE_GROUP(7, HE_GI_32, BW_20),

	HE_GROUP(8, HE_GI_32, BW_20),



	HE_GROUP(1, HE_GI_08, BW_40),

	HE_GROUP(2, HE_GI_08, BW_40),

	HE_GROUP(3, HE_GI_08, BW_40),

	HE_GROUP(4, HE_GI_08, BW_40),

	HE_GROUP(5, HE_GI_08, BW_40),

	HE_GROUP(6, HE_GI_08, BW_40),

	HE_GROUP(7, HE_GI_08, BW_40),

	HE_GROUP(8, HE_GI_08, BW_40),



	HE_GROUP(1, HE_GI_16, BW_40),

	HE_GROUP(2, HE_GI_16, BW_40),

	HE_GROUP(3, HE_GI_16, BW_40),

	HE_GROUP(4, HE_GI_16, BW_40),

	HE_GROUP(5, HE_GI_16, BW_40),

	HE_GROUP(6, HE_GI_16, BW_40),

	HE_GROUP(7, HE_GI_16, BW_40),

	HE_GROUP(8, HE_GI_16, BW_40),



	HE_GROUP(1, HE_GI_32, BW_40),

	HE_GROUP(2, HE_GI_32, BW_40),

	HE_GROUP(3, HE_GI_32, BW_40),

	HE_GROUP(4, HE_GI_32, BW_40),

	HE_GROUP(5, HE_GI_32, BW_40),

	HE_GROUP(6, HE_GI_32, BW_40),

	HE_GROUP(7, HE_GI_32, BW_40),

	HE_GROUP(8, HE_GI_32, BW_40),



	HE_GROUP(1, HE_GI_08, BW_80),

	HE_GROUP(2, HE_GI_08, BW_80),

	HE_GROUP(3, HE_GI_08, BW_80),

	HE_GROUP(4, HE_GI_08, BW_80),

	HE_GROUP(5, HE_GI_08, BW_80),

	HE_GROUP(6, HE_GI_08, BW_80),

	HE_GROUP(7, HE_GI_08, BW_80),

	HE_GROUP(8, HE_GI_08, BW_80),



	HE_GROUP(1, HE_GI_16, BW_80),

	HE_GROUP(2, HE_GI_16, BW_80),

	HE_GROUP(3, HE_GI_16, BW_80),

	HE_GROUP(4, HE_GI_16, BW_80),

	HE_GROUP(5, HE_GI_16, BW_80),

	HE_GROUP(6, HE_GI_16, BW_80),

	HE_GROUP(7, HE_GI_16, BW_80),

	HE_GROUP(8, HE_GI_16, BW_80),



	HE_GROUP(1, HE_GI_32, BW_80),

	HE_GROUP(2, HE_GI_32, BW_80),

	HE_GROUP(3, HE_GI_32, BW_80),

	HE_GROUP(4, HE_GI_32, BW_80),

	HE_GROUP(5, HE_GI_32, BW_80),

	HE_GROUP(6, HE_GI_32, BW_80),

	HE_GROUP(7, HE_GI_32, BW_80),

	HE_GROUP(8, HE_GI_32, BW_80),



	HE_GROUP(1, HE_GI_08, BW_160),

	HE_GROUP(2, HE_GI_08, BW_160),

	HE_GROUP(3, HE_GI_08, BW_160),

	HE_GROUP(4, HE_GI_08, BW_160),

	HE_GROUP(5, HE_GI_08, BW_160),

	HE_GROUP(6, HE_GI_08, BW_160),

	HE_GROUP(7, HE_GI_08, BW_160),

	HE_GROUP(8, HE_GI_08, BW_160),



	HE_GROUP(1, HE_GI_16, BW_160),

	HE_GROUP(2, HE_GI_16, BW_160),

	HE_GROUP(3, HE_GI_16, BW_160),

	HE_GROUP(4, HE_GI_16, BW_160),

	HE_GROUP(5, HE_GI_16, BW_160),

	HE_GROUP(6, HE_GI_16, BW_160),

	HE_GROUP(7, HE_GI_16, BW_160),

	HE_GROUP(8, HE_GI_16, BW_160),



	HE_GROUP(1, HE_GI_32, BW_160),

	HE_GROUP(2, HE_GI_32, BW_160),

	HE_GROUP(3, HE_GI_32, BW_160),

	HE_GROUP(4, HE_GI_32, BW_160),

	HE_GROUP(5, HE_GI_32, BW_160),

	HE_GROUP(6, HE_GI_32, BW_160),

	HE_GROUP(7, HE_GI_32, BW_160),

	HE_GROUP(8, HE_GI_32, BW_160),

};



static u32

ieee80211_calc_legacy_rate_duration(u16 bitrate, bool short_pre,

				    bool cck, int len)

{

	u32 duration;



	if (cck) {

		duration = 144 + 48; /* preamble + PLCP */

		if (short_pre)

			duration >>= 1;



		duration += 10; /* SIFS */

	} else {

		duration = 20 + 16; /* premable + SIFS */

	}



	len <<= 3;

	duration += (len * 10) / bitrate;



	return duration;

}



u32 ieee80211_calc_rx_airtime(struct ieee80211_hw *hw,

			      struct ieee80211_rx_status *status,

			      int len)

{

	struct ieee80211_supported_band *sband;

	const struct ieee80211_rate *rate;

	bool sgi = status->enc_flags & RX_ENC_FLAG_SHORT_GI;

	bool sp = status->enc_flags & RX_ENC_FLAG_SHORTPRE;

	int bw, streams;

	int group, idx;

	u32 duration;

	bool cck;



	switch (status->bw) {

	case RATE_INFO_BW_20:

		bw = BW_20;

		break;

	case RATE_INFO_BW_40:

		bw = BW_40;

		break;

	case RATE_INFO_BW_80:

		bw = BW_80;

		break;

	case RATE_INFO_BW_160:

		bw = BW_160;

		break;

	default:

		WARN_ON_ONCE(1);

		return 0;

	}



	switch (status->encoding) {

	case RX_ENC_LEGACY:

		if (WARN_ON_ONCE(status->band > NL80211_BAND_5GHZ))

			return 0;



		sband = hw->wiphy->bands[status->band];

		if (!sband || status->rate_idx > sband->n_bitrates)

			return 0;



		rate = &sband->bitrates[status->rate_idx];

		cck = rate->flags & IEEE80211_RATE_MANDATORY_B;



		return ieee80211_calc_legacy_rate_duration(rate->bitrate, sp,

							   cck, len);



	case RX_ENC_VHT:

		streams = status->nss;

		idx = status->rate_idx;

		group = VHT_GROUP_IDX(streams, sgi, bw);

		break;

	case RX_ENC_HT:

		streams = ((status->rate_idx >> 3) & 3) + 1;

		idx = status->rate_idx & 7;

		group = HT_GROUP_IDX(streams, sgi, bw);

		break;

	case RX_ENC_HE:

		streams = status->nss;

		idx = status->rate_idx;

		group = HE_GROUP_IDX(streams, status->he_gi, bw);

		break;

	default:

		WARN_ON_ONCE(1);

		return 0;

	}



	if (WARN_ON_ONCE((status->encoding != RX_ENC_HE && streams > 4) ||

			 (status->encoding == RX_ENC_HE && streams > 8)))

		return 0;



	duration = airtime_mcs_groups[group].duration[idx];

	duration <<= airtime_mcs_groups[group].shift;

	duration *= len;

	duration /= AVG_PKT_SIZE;

	duration /= 1024;



	duration += 36 + (streams << 2);



	return duration;

}

EXPORT_SYMBOL_GPL(ieee80211_calc_rx_airtime);



static u32 ieee80211_calc_tx_airtime_rate(struct ieee80211_hw *hw,

					  struct ieee80211_tx_rate *rate,

					  u8 band, int len)

{

	struct ieee80211_rx_status stat = {

		.band = band,

	};



	if (rate->idx < 0 || !rate->count)

		return 0;



	if (rate->flags & IEEE80211_TX_RC_80_MHZ_WIDTH)

		stat.bw = RATE_INFO_BW_80;

	else if (rate->flags & IEEE80211_TX_RC_40_MHZ_WIDTH)

		stat.bw = RATE_INFO_BW_40;

	else

		stat.bw = RATE_INFO_BW_20;



	stat.enc_flags = 0;

	if (rate->flags & IEEE80211_TX_RC_USE_SHORT_PREAMBLE)

		stat.enc_flags |= RX_ENC_FLAG_SHORTPRE;

	if (rate->flags & IEEE80211_TX_RC_SHORT_GI)

		stat.enc_flags |= RX_ENC_FLAG_SHORT_GI;



	stat.rate_idx = rate->idx;

	if (rate->flags & IEEE80211_TX_RC_VHT_MCS) {

		stat.encoding = RX_ENC_VHT;

		stat.rate_idx = ieee80211_rate_get_vht_mcs(rate);

		stat.nss = ieee80211_rate_get_vht_nss(rate);

	} else if (rate->flags & IEEE80211_TX_RC_MCS) {

		stat.encoding = RX_ENC_HT;

	} else {

		stat.encoding = RX_ENC_LEGACY;

	}



	return ieee80211_calc_rx_airtime(hw, &stat, len);

}



u32 ieee80211_calc_tx_airtime(struct ieee80211_hw *hw,

			      struct ieee80211_tx_info *info,

			      int len)

{

	u32 duration = 0;

	int i;



	for (i = 0; i < ARRAY_SIZE(info->status.rates); i++) {

		struct ieee80211_tx_rate *rate = &info->status.rates[i];

		u32 cur_duration;



		cur_duration = ieee80211_calc_tx_airtime_rate(hw, rate,

							      info->band, len);

		if (!cur_duration)

			break;



		duration += cur_duration * rate->count;

	}



	return duration;

}

EXPORT_SYMBOL_GPL(ieee80211_calc_tx_airtime);



u32 ieee80211_calc_expected_tx_airtime(struct ieee80211_hw *hw,

				       struct ieee80211_vif *vif,

				       struct ieee80211_sta *pubsta,

				       int len)

{

	struct ieee80211_supported_band *sband;

	struct ieee80211_chanctx_conf *conf;

	int rateidx, shift = 0;

	bool cck, short_pream;

	u32 basic_rates;

	u8 band = 0;

	u16 rate;



	len += 38; /* Ethernet header length */



	conf = rcu_dereference(vif->chanctx_conf);

	if (conf) {

		band = conf->def.chan->band;

		shift = ieee80211_chandef_get_shift(&conf->def);

	}



	if (pubsta) {

		struct sta_info *sta = container_of(pubsta, struct sta_info,

						    sta);



		return ieee80211_calc_tx_airtime_rate(hw,

						      &sta->tx_stats.last_rate,

						      band, len);

	}



	if (!conf)

		return 0;



	/* No station to get latest rate from, so calculate the worst-case

	 * duration using the lowest configured basic rate.

	 */

	sband = hw->wiphy->bands[band];



	basic_rates = vif->bss_conf.basic_rates;

	short_pream = vif->bss_conf.use_short_preamble;



	rateidx = basic_rates ? ffs(basic_rates) - 1 : 0;

	rate = sband->bitrates[rateidx].bitrate << shift;

	cck = sband->bitrates[rateidx].flags & IEEE80211_RATE_MANDATORY_B;



	return ieee80211_calc_legacy_rate_duration(rate, short_pream, cck, len);

}

CRA Git | Maintained and supported by SUSTech CRA and CCSE