]> git.proxmox.com Git - mirror_ubuntu-jammy-kernel.git/blob - drivers/net/wireless/mediatek/mt76/airtime.c
projects / mirror_ubuntu-jammy-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge git://git.kernel.org/pub/scm/linux/kernel/git/netdev/net
[mirror_ubuntu-jammy-kernel.git] / drivers / net / wireless / mediatek / mt76 / airtime.c
1 // SPDX-License-Identifier: ISC
2 /*
3 * Copyright (C) 2019 Felix Fietkau <nbd@nbd.name>
4 */
5
6 #include "mt76.h"
7
8 #define AVG_PKT_SIZE 1024
9
10 /* Number of bits for an average sized packet */
11 #define MCS_NBITS (AVG_PKT_SIZE << 3)
12
13 /* Number of symbols for a packet with (bps) bits per symbol */
14 #define MCS_NSYMS(bps) DIV_ROUND_UP(MCS_NBITS, (bps))
15
16 /* Transmission time (1024 usec) for a packet containing (syms) * symbols */
17 #define MCS_SYMBOL_TIME(sgi, syms) \
18 (sgi ? \
19 ((syms) * 18 * 1024 + 4 * 1024) / 5 : /* syms * 3.6 us */ \
20 ((syms) * 1024) << 2 /* syms * 4 us */ \
21 )
22
23 /* Transmit duration for the raw data part of an average sized packet */
24 #define MCS_DURATION(streams, sgi, bps) \
25 MCS_SYMBOL_TIME(sgi, MCS_NSYMS((streams) * (bps)))
26
27 #define BW_20 0
28 #define BW_40 1
29 #define BW_80 2
30
31 /*
32 * Define group sort order: HT40 -> SGI -> #streams
33 */
34 #define MT_MAX_STREAMS 4
35 #define MT_HT_STREAM_GROUPS 4 /* BW(=2) * SGI(=2) */
36 #define MT_VHT_STREAM_GROUPS 6 /* BW(=3) * SGI(=2) */
37
38 #define MT_HT_GROUPS_NB (MT_MAX_STREAMS * \
39 MT_HT_STREAM_GROUPS)
40 #define MT_VHT_GROUPS_NB (MT_MAX_STREAMS * \
41 MT_VHT_STREAM_GROUPS)
42 #define MT_GROUPS_NB (MT_HT_GROUPS_NB + \
43 MT_VHT_GROUPS_NB)
44
45 #define MT_HT_GROUP_0 0
46 #define MT_VHT_GROUP_0 (MT_HT_GROUP_0 + MT_HT_GROUPS_NB)
47
48 #define MCS_GROUP_RATES 10
49
50 #define HT_GROUP_IDX(_streams, _sgi, _ht40) \
51 MT_HT_GROUP_0 + \
52 MT_MAX_STREAMS * 2 * _ht40 + \
53 MT_MAX_STREAMS * _sgi + \
54 _streams - 1
55
56 #define _MAX(a, b) (((a)>(b))?(a):(b))
57
58 #define GROUP_SHIFT(duration) \
59 _MAX(0, 16 - __builtin_clz(duration))
60
61 /* MCS rate information for an MCS group */
62 #define __MCS_GROUP(_streams, _sgi, _ht40, _s) \
63 [HT_GROUP_IDX(_streams, _sgi, _ht40)] = { \
64 .shift = _s, \
65 .duration = { \
66 MCS_DURATION(_streams, _sgi, _ht40 ? 54 : 26) >> _s, \
67 MCS_DURATION(_streams, _sgi, _ht40 ? 108 : 52) >> _s, \
68 MCS_DURATION(_streams, _sgi, _ht40 ? 162 : 78) >> _s, \
69 MCS_DURATION(_streams, _sgi, _ht40 ? 216 : 104) >> _s, \
70 MCS_DURATION(_streams, _sgi, _ht40 ? 324 : 156) >> _s, \
71 MCS_DURATION(_streams, _sgi, _ht40 ? 432 : 208) >> _s, \
72 MCS_DURATION(_streams, _sgi, _ht40 ? 486 : 234) >> _s, \
73 MCS_DURATION(_streams, _sgi, _ht40 ? 540 : 260) >> _s \
74 } \
75 }
76
77 #define MCS_GROUP_SHIFT(_streams, _sgi, _ht40) \
78 GROUP_SHIFT(MCS_DURATION(_streams, _sgi, _ht40 ? 54 : 26))
79
80 #define MCS_GROUP(_streams, _sgi, _ht40) \
81 __MCS_GROUP(_streams, _sgi, _ht40, \
82 MCS_GROUP_SHIFT(_streams, _sgi, _ht40))
83
84 #define VHT_GROUP_IDX(_streams, _sgi, _bw) \
85 (MT_VHT_GROUP_0 + \
86 MT_MAX_STREAMS * 2 * (_bw) + \
87 MT_MAX_STREAMS * (_sgi) + \
88 (_streams) - 1)
89
90 #define BW2VBPS(_bw, r3, r2, r1) \
91 (_bw == BW_80 ? r3 : _bw == BW_40 ? r2 : r1)
92
93 #define __VHT_GROUP(_streams, _sgi, _bw, _s) \
94 [VHT_GROUP_IDX(_streams, _sgi, _bw)] = { \
95 .shift = _s, \
96 .duration = { \
97 MCS_DURATION(_streams, _sgi, \
98 BW2VBPS(_bw, 117, 54, 26)) >> _s, \
99 MCS_DURATION(_streams, _sgi, \
100 BW2VBPS(_bw, 234, 108, 52)) >> _s, \
101 MCS_DURATION(_streams, _sgi, \
102 BW2VBPS(_bw, 351, 162, 78)) >> _s, \
103 MCS_DURATION(_streams, _sgi, \
104 BW2VBPS(_bw, 468, 216, 104)) >> _s, \
105 MCS_DURATION(_streams, _sgi, \
106 BW2VBPS(_bw, 702, 324, 156)) >> _s, \
107 MCS_DURATION(_streams, _sgi, \
108 BW2VBPS(_bw, 936, 432, 208)) >> _s, \
109 MCS_DURATION(_streams, _sgi, \
110 BW2VBPS(_bw, 1053, 486, 234)) >> _s, \
111 MCS_DURATION(_streams, _sgi, \
112 BW2VBPS(_bw, 1170, 540, 260)) >> _s, \
113 MCS_DURATION(_streams, _sgi, \
114 BW2VBPS(_bw, 1404, 648, 312)) >> _s, \
115 MCS_DURATION(_streams, _sgi, \
116 BW2VBPS(_bw, 1560, 720, 346)) >> _s \
117 } \
118 }
119
120 #define VHT_GROUP_SHIFT(_streams, _sgi, _bw) \
121 GROUP_SHIFT(MCS_DURATION(_streams, _sgi, \
122 BW2VBPS(_bw, 117, 54, 26)))
123
124 #define VHT_GROUP(_streams, _sgi, _bw) \
125 __VHT_GROUP(_streams, _sgi, _bw, \
126 VHT_GROUP_SHIFT(_streams, _sgi, _bw))
127
128 struct mcs_group {
129 u8 shift;
130 u16 duration[MCS_GROUP_RATES];
131 };
132
133 static const struct mcs_group airtime_mcs_groups[] = {
134 MCS_GROUP(1, 0, BW_20),
135 MCS_GROUP(2, 0, BW_20),
136 MCS_GROUP(3, 0, BW_20),
137 MCS_GROUP(4, 0, BW_20),
138
139 MCS_GROUP(1, 1, BW_20),
140 MCS_GROUP(2, 1, BW_20),
141 MCS_GROUP(3, 1, BW_20),
142 MCS_GROUP(4, 1, BW_20),
143
144 MCS_GROUP(1, 0, BW_40),
145 MCS_GROUP(2, 0, BW_40),
146 MCS_GROUP(3, 0, BW_40),
147 MCS_GROUP(4, 0, BW_40),
148
149 MCS_GROUP(1, 1, BW_40),
150 MCS_GROUP(2, 1, BW_40),
151 MCS_GROUP(3, 1, BW_40),
152 MCS_GROUP(4, 1, BW_40),
153
154 VHT_GROUP(1, 0, BW_20),
155 VHT_GROUP(2, 0, BW_20),
156 VHT_GROUP(3, 0, BW_20),
157 VHT_GROUP(4, 0, BW_20),
158
159 VHT_GROUP(1, 1, BW_20),
160 VHT_GROUP(2, 1, BW_20),
161 VHT_GROUP(3, 1, BW_20),
162 VHT_GROUP(4, 1, BW_20),
163
164 VHT_GROUP(1, 0, BW_40),
165 VHT_GROUP(2, 0, BW_40),
166 VHT_GROUP(3, 0, BW_40),
167 VHT_GROUP(4, 0, BW_40),
168
169 VHT_GROUP(1, 1, BW_40),
170 VHT_GROUP(2, 1, BW_40),
171 VHT_GROUP(3, 1, BW_40),
172 VHT_GROUP(4, 1, BW_40),
173
174 VHT_GROUP(1, 0, BW_80),
175 VHT_GROUP(2, 0, BW_80),
176 VHT_GROUP(3, 0, BW_80),
177 VHT_GROUP(4, 0, BW_80),
178
179 VHT_GROUP(1, 1, BW_80),
180 VHT_GROUP(2, 1, BW_80),
181 VHT_GROUP(3, 1, BW_80),
182 VHT_GROUP(4, 1, BW_80),
183 };
184
185 static u32
186 mt76_calc_legacy_rate_duration(const struct ieee80211_rate *rate, bool short_pre,
187 int len)
188 {
189 u32 duration;
190
191 switch (rate->hw_value >> 8) {
192 case MT_PHY_TYPE_CCK:
193 duration = 144 + 48; /* preamble + PLCP */
194 if (short_pre)
195 duration >>= 1;
196
197 duration += 10; /* SIFS */
198 break;
199 case MT_PHY_TYPE_OFDM:
200 duration = 20 + 16; /* premable + SIFS */
201 break;
202 default:
203 WARN_ON_ONCE(1);
204 return 0;
205 }
206
207 len <<= 3;
208 duration += (len * 10) / rate->bitrate;
209
210 return duration;
211 }
212
213 u32 mt76_calc_rx_airtime(struct mt76_dev *dev, struct mt76_rx_status *status,
214 int len)
215 {
216 struct ieee80211_supported_band *sband;
217 const struct ieee80211_rate *rate;
218 bool sgi = status->enc_flags & RX_ENC_FLAG_SHORT_GI;
219 bool sp = status->enc_flags & RX_ENC_FLAG_SHORTPRE;
220 int bw, streams;
221 u32 duration;
222 int group, idx;
223
224 switch (status->bw) {
225 case RATE_INFO_BW_20:
226 bw = BW_20;
227 break;
228 case RATE_INFO_BW_40:
229 bw = BW_40;
230 break;
231 case RATE_INFO_BW_80:
232 bw = BW_80;
233 break;
234 default:
235 WARN_ON_ONCE(1);
236 return 0;
237 }
238
239 switch (status->encoding) {
240 case RX_ENC_LEGACY:
241 if (WARN_ON_ONCE(status->band > NL80211_BAND_5GHZ))
242 return 0;
243
244 sband = dev->hw->wiphy->bands[status->band];
245 if (!sband || status->rate_idx > sband->n_bitrates)
246 return 0;
247
248 rate = &sband->bitrates[status->rate_idx];
249
250 return mt76_calc_legacy_rate_duration(rate, sp, len);
251 case RX_ENC_VHT:
252 streams = status->nss;
253 idx = status->rate_idx;
254 group = VHT_GROUP_IDX(streams, sgi, bw);
255 break;
256 case RX_ENC_HT:
257 streams = ((status->rate_idx >> 3) & 3) + 1;
258 idx = status->rate_idx & 7;
259 group = HT_GROUP_IDX(streams, sgi, bw);
260 break;
261 default:
262 WARN_ON_ONCE(1);
263 return 0;
264 }
265
266 if (WARN_ON_ONCE(streams > 4))
267 return 0;
268
269 duration = airtime_mcs_groups[group].duration[idx];
270 duration <<= airtime_mcs_groups[group].shift;
271 duration *= len;
272 duration /= AVG_PKT_SIZE;
273 duration /= 1024;
274
275 duration += 36 + (streams << 2);
276
277 return duration;
278 }
279
280 u32 mt76_calc_tx_airtime(struct mt76_dev *dev, struct ieee80211_tx_info *info,
281 int len)
282 {
283 struct mt76_rx_status stat = {
284 .band = info->band,
285 };
286 u32 duration = 0;
287 int i;
288
289 for (i = 0; i < ARRAY_SIZE(info->status.rates); i++) {
290 struct ieee80211_tx_rate *rate = &info->status.rates[i];
291 u32 cur_duration;
292
293 if (rate->idx < 0 || !rate->count)
294 break;
295
296 if (rate->flags & IEEE80211_TX_RC_80_MHZ_WIDTH)
297 stat.bw = RATE_INFO_BW_80;
298 else if (rate->flags & IEEE80211_TX_RC_40_MHZ_WIDTH)
299 stat.bw = RATE_INFO_BW_40;
300 else
301 stat.bw = RATE_INFO_BW_20;
302
303 stat.enc_flags = 0;
304 if (rate->flags & IEEE80211_TX_RC_USE_SHORT_PREAMBLE)
305 stat.enc_flags |= RX_ENC_FLAG_SHORTPRE;
306 if (rate->flags & IEEE80211_TX_RC_SHORT_GI)
307 stat.enc_flags |= RX_ENC_FLAG_SHORT_GI;
308
309 stat.rate_idx = rate->idx;
310 if (rate->flags & IEEE80211_TX_RC_VHT_MCS) {
311 stat.encoding = RX_ENC_VHT;
312 stat.rate_idx = ieee80211_rate_get_vht_mcs(rate);
313 stat.nss = ieee80211_rate_get_vht_nss(rate);
314 } else if (rate->flags & IEEE80211_TX_RC_MCS) {
315 stat.encoding = RX_ENC_HT;
316 } else {
317 stat.encoding = RX_ENC_LEGACY;
318 }
319
320 cur_duration = mt76_calc_rx_airtime(dev, &stat, len);
321 duration += cur_duration * rate->count;
322 }
323
324 return duration;
325 }
326 EXPORT_SYMBOL_GPL(mt76_calc_tx_airtime);
Ubuntu Jammy Linux kernel mirror