projects/linux·blob master · refs

870 lines · 23.9 KiB

1// SPDX-License-Identifier: ISC
2/*
3 * Copyright (C) 2019 Felix Fietkau <[email protected]>
4 * Copyright (C) 2021-2022 Intel Corporation
5 */
6
7#include <net/mac80211.h>
8#include "ieee80211_i.h"
9#include "sta_info.h"
10
11#define AVG_PKT_SIZE 1024
12
13/* Number of bits for an average sized packet */
14#define MCS_NBITS (AVG_PKT_SIZE << 3)
15
16/* Number of kilo-symbols (symbols * 1024) for a packet with (bps) bits per
17 * symbol. We use k-symbols to avoid rounding in the _TIME macros below.
18 */
19#define MCS_N_KSYMS(bps) DIV_ROUND_UP(MCS_NBITS << 10, (bps))
20
21/* Transmission time (in 1024 * usec) for a packet containing (ksyms) * 1024
22 * symbols.
23 */
24#define MCS_SYMBOL_TIME(sgi, ksyms) \
25 (sgi ? \
26 ((ksyms) * 4 * 18) / 20 : /* 3.6 us per sym */ \
27 ((ksyms) * 4) /* 4.0 us per sym */ \
28 )
29
30/* Transmit duration for the raw data part of an average sized packet */
31#define MCS_DURATION(streams, sgi, bps) \
32 ((u32)MCS_SYMBOL_TIME(sgi, MCS_N_KSYMS((streams) * (bps))))
33
34#define MCS_DURATION_S(shift, streams, sgi, bps) \
35 ((u16)((MCS_DURATION(streams, sgi, bps) >> shift)))
36
37/* These should match the values in enum nl80211_he_gi */
38#define HE_GI_08 0
39#define HE_GI_16 1
40#define HE_GI_32 2
41
42/* Transmission time (1024 usec) for a packet containing (ksyms) * k-symbols */
43#define HE_SYMBOL_TIME(gi, ksyms) \
44 (gi == HE_GI_08 ? \
45 ((ksyms) * 16 * 17) / 20 : /* 13.6 us per sym */ \
46 (gi == HE_GI_16 ? \
47 ((ksyms) * 16 * 18) / 20 : /* 14.4 us per sym */ \
48 ((ksyms) * 16) /* 16.0 us per sym */ \
49 ))
50
51/* Transmit duration for the raw data part of an average sized packet */
52#define HE_DURATION(streams, gi, bps) \
53 ((u32)HE_SYMBOL_TIME(gi, MCS_N_KSYMS((streams) * (bps))))
54
55#define HE_DURATION_S(shift, streams, gi, bps) \
56 (HE_DURATION(streams, gi, bps) >> shift)
57
58/* gi in HE/EHT is identical. It matches enum nl80211_eht_gi as well */
59#define EHT_GI_08 HE_GI_08
60#define EHT_GI_16 HE_GI_16
61#define EHT_GI_32 HE_GI_32
62
63#define EHT_DURATION(streams, gi, bps) \
64 HE_DURATION(streams, gi, bps)
65#define EHT_DURATION_S(shift, streams, gi, bps) \
66 HE_DURATION_S(shift, streams, gi, bps)
67
68#define BW_20 0
69#define BW_40 1
70#define BW_80 2
71#define BW_160 3
72#define BW_320 4
73
74/*
75 * Define group sort order: HT40 -> SGI -> #streams
76 */
77#define IEEE80211_MAX_STREAMS 4
78#define IEEE80211_HT_STREAM_GROUPS 4 /* BW(=2) * SGI(=2) */
79#define IEEE80211_VHT_STREAM_GROUPS 8 /* BW(=4) * SGI(=2) */
80
81#define IEEE80211_HE_MAX_STREAMS 8
82#define IEEE80211_HE_STREAM_GROUPS 12 /* BW(=4) * GI(=3) */
83
84#define IEEE80211_EHT_MAX_STREAMS 8
85#define IEEE80211_EHT_STREAM_GROUPS 15 /* BW(=5) * GI(=3) */
86
87#define IEEE80211_HT_GROUPS_NB (IEEE80211_MAX_STREAMS * \
88 IEEE80211_HT_STREAM_GROUPS)
89#define IEEE80211_VHT_GROUPS_NB (IEEE80211_MAX_STREAMS * \
90 IEEE80211_VHT_STREAM_GROUPS)
91#define IEEE80211_HE_GROUPS_NB (IEEE80211_HE_MAX_STREAMS * \
92 IEEE80211_HE_STREAM_GROUPS)
93#define IEEE80211_EHT_GROUPS_NB (IEEE80211_EHT_MAX_STREAMS * \
94 IEEE80211_EHT_STREAM_GROUPS)
95
96#define IEEE80211_HT_GROUP_0 0
97#define IEEE80211_VHT_GROUP_0 (IEEE80211_HT_GROUP_0 + IEEE80211_HT_GROUPS_NB)
98#define IEEE80211_HE_GROUP_0 (IEEE80211_VHT_GROUP_0 + IEEE80211_VHT_GROUPS_NB)
99#define IEEE80211_EHT_GROUP_0 (IEEE80211_HE_GROUP_0 + IEEE80211_HE_GROUPS_NB)
100
101#define MCS_GROUP_RATES 14
102
103#define HT_GROUP_IDX(_streams, _sgi, _ht40) \
104 IEEE80211_HT_GROUP_0 + \
105 IEEE80211_MAX_STREAMS * 2 * _ht40 + \
106 IEEE80211_MAX_STREAMS * _sgi + \
107 _streams - 1
108
109#define _MAX(a, b) (((a)>(b))?(a):(b))
110
111#define GROUP_SHIFT(duration) \
112 _MAX(0, 16 - __builtin_clz(duration))
113
114/* MCS rate information for an MCS group */
115#define __MCS_GROUP(_streams, _sgi, _ht40, _s) \
116 [HT_GROUP_IDX(_streams, _sgi, _ht40)] = { \
117 .shift = _s, \
118 .duration = { \
119 MCS_DURATION_S(_s, _streams, _sgi, _ht40 ? 54 : 26), \
120 MCS_DURATION_S(_s, _streams, _sgi, _ht40 ? 108 : 52), \
121 MCS_DURATION_S(_s, _streams, _sgi, _ht40 ? 162 : 78), \
122 MCS_DURATION_S(_s, _streams, _sgi, _ht40 ? 216 : 104), \
123 MCS_DURATION_S(_s, _streams, _sgi, _ht40 ? 324 : 156), \
124 MCS_DURATION_S(_s, _streams, _sgi, _ht40 ? 432 : 208), \
125 MCS_DURATION_S(_s, _streams, _sgi, _ht40 ? 486 : 234), \
126 MCS_DURATION_S(_s, _streams, _sgi, _ht40 ? 540 : 260) \
127 } \
128}
129
130#define MCS_GROUP_SHIFT(_streams, _sgi, _ht40) \
131 GROUP_SHIFT(MCS_DURATION(_streams, _sgi, _ht40 ? 54 : 26))
132
133#define MCS_GROUP(_streams, _sgi, _ht40) \
134 __MCS_GROUP(_streams, _sgi, _ht40, \
135 MCS_GROUP_SHIFT(_streams, _sgi, _ht40))
136
137#define VHT_GROUP_IDX(_streams, _sgi, _bw) \
138 (IEEE80211_VHT_GROUP_0 + \
139 IEEE80211_MAX_STREAMS * 2 * (_bw) + \
140 IEEE80211_MAX_STREAMS * (_sgi) + \
141 (_streams) - 1)
142
143#define BW2VBPS(_bw, r4, r3, r2, r1) \
144 (_bw == BW_160 ? r4 : _bw == BW_80 ? r3 : _bw == BW_40 ? r2 : r1)
145
146#define __VHT_GROUP(_streams, _sgi, _bw, _s) \
147 [VHT_GROUP_IDX(_streams, _sgi, _bw)] = { \
148 .shift = _s, \
149 .duration = { \
150 MCS_DURATION_S(_s, _streams, _sgi, \
151 BW2VBPS(_bw, 234, 117, 54, 26)), \
152 MCS_DURATION_S(_s, _streams, _sgi, \
153 BW2VBPS(_bw, 468, 234, 108, 52)), \
154 MCS_DURATION_S(_s, _streams, _sgi, \
155 BW2VBPS(_bw, 702, 351, 162, 78)), \
156 MCS_DURATION_S(_s, _streams, _sgi, \
157 BW2VBPS(_bw, 936, 468, 216, 104)), \
158 MCS_DURATION_S(_s, _streams, _sgi, \
159 BW2VBPS(_bw, 1404, 702, 324, 156)), \
160 MCS_DURATION_S(_s, _streams, _sgi, \
161 BW2VBPS(_bw, 1872, 936, 432, 208)), \
162 MCS_DURATION_S(_s, _streams, _sgi, \
163 BW2VBPS(_bw, 2106, 1053, 486, 234)), \
164 MCS_DURATION_S(_s, _streams, _sgi, \
165 BW2VBPS(_bw, 2340, 1170, 540, 260)), \
166 MCS_DURATION_S(_s, _streams, _sgi, \
167 BW2VBPS(_bw, 2808, 1404, 648, 312)), \
168 MCS_DURATION_S(_s, _streams, _sgi, \
169 BW2VBPS(_bw, 3120, 1560, 720, 346)) \
170 } \
171}
172
173#define VHT_GROUP_SHIFT(_streams, _sgi, _bw) \
174 GROUP_SHIFT(MCS_DURATION(_streams, _sgi, \
175 BW2VBPS(_bw, 243, 117, 54, 26)))
176
177#define VHT_GROUP(_streams, _sgi, _bw) \
178 __VHT_GROUP(_streams, _sgi, _bw, \
179 VHT_GROUP_SHIFT(_streams, _sgi, _bw))
180
181
182#define HE_GROUP_IDX(_streams, _gi, _bw) \
183 (IEEE80211_HE_GROUP_0 + \
184 IEEE80211_HE_MAX_STREAMS * 3 * (_bw) + \
185 IEEE80211_HE_MAX_STREAMS * (_gi) + \
186 (_streams) - 1)
187
188#define __HE_GROUP(_streams, _gi, _bw, _s) \
189 [HE_GROUP_IDX(_streams, _gi, _bw)] = { \
190 .shift = _s, \
191 .duration = { \
192 HE_DURATION_S(_s, _streams, _gi, \
193 BW2VBPS(_bw, 979, 489, 230, 115)), \
194 HE_DURATION_S(_s, _streams, _gi, \
195 BW2VBPS(_bw, 1958, 979, 475, 230)), \
196 HE_DURATION_S(_s, _streams, _gi, \
197 BW2VBPS(_bw, 2937, 1468, 705, 345)), \
198 HE_DURATION_S(_s, _streams, _gi, \
199 BW2VBPS(_bw, 3916, 1958, 936, 475)), \
200 HE_DURATION_S(_s, _streams, _gi, \
201 BW2VBPS(_bw, 5875, 2937, 1411, 705)), \
202 HE_DURATION_S(_s, _streams, _gi, \
203 BW2VBPS(_bw, 7833, 3916, 1872, 936)), \
204 HE_DURATION_S(_s, _streams, _gi, \
205 BW2VBPS(_bw, 8827, 4406, 2102, 1051)), \
206 HE_DURATION_S(_s, _streams, _gi, \
207 BW2VBPS(_bw, 9806, 4896, 2347, 1166)), \
208 HE_DURATION_S(_s, _streams, _gi, \
209 BW2VBPS(_bw, 11764, 5875, 2808, 1411)), \
210 HE_DURATION_S(_s, _streams, _gi, \
211 BW2VBPS(_bw, 13060, 6523, 3124, 1555)), \
212 HE_DURATION_S(_s, _streams, _gi, \
213 BW2VBPS(_bw, 14702, 7344, 3513, 1756)), \
214 HE_DURATION_S(_s, _streams, _gi, \
215 BW2VBPS(_bw, 16329, 8164, 3902, 1944)) \
216 } \
217}
218
219#define HE_GROUP_SHIFT(_streams, _gi, _bw) \
220 GROUP_SHIFT(HE_DURATION(_streams, _gi, \
221 BW2VBPS(_bw, 979, 489, 230, 115)))
222
223#define HE_GROUP(_streams, _gi, _bw) \
224 __HE_GROUP(_streams, _gi, _bw, \
225 HE_GROUP_SHIFT(_streams, _gi, _bw))
226
227#define EHT_BW2VBPS(_bw, r5, r4, r3, r2, r1) \
228 ((_bw) == BW_320 ? r5 : BW2VBPS(_bw, r4, r3, r2, r1))
229
230#define EHT_GROUP_IDX(_streams, _gi, _bw) \
231 (IEEE80211_EHT_GROUP_0 + \
232 IEEE80211_EHT_MAX_STREAMS * 3 * (_bw) + \
233 IEEE80211_EHT_MAX_STREAMS * (_gi) + \
234 (_streams) - 1)
235
236#define __EHT_GROUP(_streams, _gi, _bw, _s) \
237 [EHT_GROUP_IDX(_streams, _gi, _bw)] = { \
238 .shift = _s, \
239 .duration = { \
240 EHT_DURATION_S(_s, _streams, _gi, \
241 EHT_BW2VBPS(_bw, 1960, 980, 490, 234, 117)), \
242 EHT_DURATION_S(_s, _streams, _gi, \
243 EHT_BW2VBPS(_bw, 3920, 1960, 980, 468, 234)), \
244 EHT_DURATION_S(_s, _streams, _gi, \
245 EHT_BW2VBPS(_bw, 5880, 2937, 1470, 702, 351)), \
246 EHT_DURATION_S(_s, _streams, _gi, \
247 EHT_BW2VBPS(_bw, 7840, 3920, 1960, 936, 468)), \
248 EHT_DURATION_S(_s, _streams, _gi, \
249 EHT_BW2VBPS(_bw, 11760, 5880, 2940, 1404, 702)), \
250 EHT_DURATION_S(_s, _streams, _gi, \
251 EHT_BW2VBPS(_bw, 15680, 7840, 3920, 1872, 936)), \
252 EHT_DURATION_S(_s, _streams, _gi, \
253 EHT_BW2VBPS(_bw, 17640, 8820, 4410, 2106, 1053)), \
254 EHT_DURATION_S(_s, _streams, _gi, \
255 EHT_BW2VBPS(_bw, 19600, 9800, 4900, 2340, 1170)), \
256 EHT_DURATION_S(_s, _streams, _gi, \
257 EHT_BW2VBPS(_bw, 23520, 11760, 5880, 2808, 1404)), \
258 EHT_DURATION_S(_s, _streams, _gi, \
259 EHT_BW2VBPS(_bw, 26133, 13066, 6533, 3120, 1560)), \
260 EHT_DURATION_S(_s, _streams, _gi, \
261 EHT_BW2VBPS(_bw, 29400, 14700, 7350, 3510, 1755)), \
262 EHT_DURATION_S(_s, _streams, _gi, \
263 EHT_BW2VBPS(_bw, 32666, 16333, 8166, 3900, 1950)), \
264 EHT_DURATION_S(_s, _streams, _gi, \
265 EHT_BW2VBPS(_bw, 35280, 17640, 8820, 4212, 2106)), \
266 EHT_DURATION_S(_s, _streams, _gi, \
267 EHT_BW2VBPS(_bw, 39200, 19600, 9800, 4680, 2340)) \
268 } \
269}
270
271#define EHT_GROUP_SHIFT(_streams, _gi, _bw) \
272 GROUP_SHIFT(EHT_DURATION(_streams, _gi, \
273 EHT_BW2VBPS(_bw, 1960, 980, 490, 234, 117)))
274
275#define EHT_GROUP(_streams, _gi, _bw) \
276 __EHT_GROUP(_streams, _gi, _bw, \
277 EHT_GROUP_SHIFT(_streams, _gi, _bw))
278
279#define EHT_GROUP_RANGE(_gi, _bw) \
280 EHT_GROUP(1, _gi, _bw), \
281 EHT_GROUP(2, _gi, _bw), \
282 EHT_GROUP(3, _gi, _bw), \
283 EHT_GROUP(4, _gi, _bw), \
284 EHT_GROUP(5, _gi, _bw), \
285 EHT_GROUP(6, _gi, _bw), \
286 EHT_GROUP(7, _gi, _bw), \
287 EHT_GROUP(8, _gi, _bw)
288
289struct mcs_group {
290 u8 shift;
291 u16 duration[MCS_GROUP_RATES];
292};
293
294static const struct mcs_group airtime_mcs_groups[] = {
295 MCS_GROUP(1, 0, BW_20),
296 MCS_GROUP(2, 0, BW_20),
297 MCS_GROUP(3, 0, BW_20),
298 MCS_GROUP(4, 0, BW_20),
299
300 MCS_GROUP(1, 1, BW_20),
301 MCS_GROUP(2, 1, BW_20),
302 MCS_GROUP(3, 1, BW_20),
303 MCS_GROUP(4, 1, BW_20),
304
305 MCS_GROUP(1, 0, BW_40),
306 MCS_GROUP(2, 0, BW_40),
307 MCS_GROUP(3, 0, BW_40),
308 MCS_GROUP(4, 0, BW_40),
309
310 MCS_GROUP(1, 1, BW_40),
311 MCS_GROUP(2, 1, BW_40),
312 MCS_GROUP(3, 1, BW_40),
313 MCS_GROUP(4, 1, BW_40),
314
315 VHT_GROUP(1, 0, BW_20),
316 VHT_GROUP(2, 0, BW_20),
317 VHT_GROUP(3, 0, BW_20),
318 VHT_GROUP(4, 0, BW_20),
319
320 VHT_GROUP(1, 1, BW_20),
321 VHT_GROUP(2, 1, BW_20),
322 VHT_GROUP(3, 1, BW_20),
323 VHT_GROUP(4, 1, BW_20),
324
325 VHT_GROUP(1, 0, BW_40),
326 VHT_GROUP(2, 0, BW_40),
327 VHT_GROUP(3, 0, BW_40),
328 VHT_GROUP(4, 0, BW_40),
329
330 VHT_GROUP(1, 1, BW_40),
331 VHT_GROUP(2, 1, BW_40),
332 VHT_GROUP(3, 1, BW_40),
333 VHT_GROUP(4, 1, BW_40),
334
335 VHT_GROUP(1, 0, BW_80),
336 VHT_GROUP(2, 0, BW_80),
337 VHT_GROUP(3, 0, BW_80),
338 VHT_GROUP(4, 0, BW_80),
339
340 VHT_GROUP(1, 1, BW_80),
341 VHT_GROUP(2, 1, BW_80),
342 VHT_GROUP(3, 1, BW_80),
343 VHT_GROUP(4, 1, BW_80),
344
345 VHT_GROUP(1, 0, BW_160),
346 VHT_GROUP(2, 0, BW_160),
347 VHT_GROUP(3, 0, BW_160),
348 VHT_GROUP(4, 0, BW_160),
349
350 VHT_GROUP(1, 1, BW_160),
351 VHT_GROUP(2, 1, BW_160),
352 VHT_GROUP(3, 1, BW_160),
353 VHT_GROUP(4, 1, BW_160),
354
355 HE_GROUP(1, HE_GI_08, BW_20),
356 HE_GROUP(2, HE_GI_08, BW_20),
357 HE_GROUP(3, HE_GI_08, BW_20),
358 HE_GROUP(4, HE_GI_08, BW_20),
359 HE_GROUP(5, HE_GI_08, BW_20),
360 HE_GROUP(6, HE_GI_08, BW_20),
361 HE_GROUP(7, HE_GI_08, BW_20),
362 HE_GROUP(8, HE_GI_08, BW_20),
363
364 HE_GROUP(1, HE_GI_16, BW_20),
365 HE_GROUP(2, HE_GI_16, BW_20),
366 HE_GROUP(3, HE_GI_16, BW_20),
367 HE_GROUP(4, HE_GI_16, BW_20),
368 HE_GROUP(5, HE_GI_16, BW_20),
369 HE_GROUP(6, HE_GI_16, BW_20),
370 HE_GROUP(7, HE_GI_16, BW_20),
371 HE_GROUP(8, HE_GI_16, BW_20),
372
373 HE_GROUP(1, HE_GI_32, BW_20),
374 HE_GROUP(2, HE_GI_32, BW_20),
375 HE_GROUP(3, HE_GI_32, BW_20),
376 HE_GROUP(4, HE_GI_32, BW_20),
377 HE_GROUP(5, HE_GI_32, BW_20),
378 HE_GROUP(6, HE_GI_32, BW_20),
379 HE_GROUP(7, HE_GI_32, BW_20),
380 HE_GROUP(8, HE_GI_32, BW_20),
381
382 HE_GROUP(1, HE_GI_08, BW_40),
383 HE_GROUP(2, HE_GI_08, BW_40),
384 HE_GROUP(3, HE_GI_08, BW_40),
385 HE_GROUP(4, HE_GI_08, BW_40),
386 HE_GROUP(5, HE_GI_08, BW_40),
387 HE_GROUP(6, HE_GI_08, BW_40),
388 HE_GROUP(7, HE_GI_08, BW_40),
389 HE_GROUP(8, HE_GI_08, BW_40),
390
391 HE_GROUP(1, HE_GI_16, BW_40),
392 HE_GROUP(2, HE_GI_16, BW_40),
393 HE_GROUP(3, HE_GI_16, BW_40),
394 HE_GROUP(4, HE_GI_16, BW_40),
395 HE_GROUP(5, HE_GI_16, BW_40),
396 HE_GROUP(6, HE_GI_16, BW_40),
397 HE_GROUP(7, HE_GI_16, BW_40),
398 HE_GROUP(8, HE_GI_16, BW_40),
399
400 HE_GROUP(1, HE_GI_32, BW_40),
401 HE_GROUP(2, HE_GI_32, BW_40),
402 HE_GROUP(3, HE_GI_32, BW_40),
403 HE_GROUP(4, HE_GI_32, BW_40),
404 HE_GROUP(5, HE_GI_32, BW_40),
405 HE_GROUP(6, HE_GI_32, BW_40),
406 HE_GROUP(7, HE_GI_32, BW_40),
407 HE_GROUP(8, HE_GI_32, BW_40),
408
409 HE_GROUP(1, HE_GI_08, BW_80),
410 HE_GROUP(2, HE_GI_08, BW_80),
411 HE_GROUP(3, HE_GI_08, BW_80),
412 HE_GROUP(4, HE_GI_08, BW_80),
413 HE_GROUP(5, HE_GI_08, BW_80),
414 HE_GROUP(6, HE_GI_08, BW_80),
415 HE_GROUP(7, HE_GI_08, BW_80),
416 HE_GROUP(8, HE_GI_08, BW_80),
417
418 HE_GROUP(1, HE_GI_16, BW_80),
419 HE_GROUP(2, HE_GI_16, BW_80),
420 HE_GROUP(3, HE_GI_16, BW_80),
421 HE_GROUP(4, HE_GI_16, BW_80),
422 HE_GROUP(5, HE_GI_16, BW_80),
423 HE_GROUP(6, HE_GI_16, BW_80),
424 HE_GROUP(7, HE_GI_16, BW_80),
425 HE_GROUP(8, HE_GI_16, BW_80),
426
427 HE_GROUP(1, HE_GI_32, BW_80),
428 HE_GROUP(2, HE_GI_32, BW_80),
429 HE_GROUP(3, HE_GI_32, BW_80),
430 HE_GROUP(4, HE_GI_32, BW_80),
431 HE_GROUP(5, HE_GI_32, BW_80),
432 HE_GROUP(6, HE_GI_32, BW_80),
433 HE_GROUP(7, HE_GI_32, BW_80),
434 HE_GROUP(8, HE_GI_32, BW_80),
435
436 HE_GROUP(1, HE_GI_08, BW_160),
437 HE_GROUP(2, HE_GI_08, BW_160),
438 HE_GROUP(3, HE_GI_08, BW_160),
439 HE_GROUP(4, HE_GI_08, BW_160),
440 HE_GROUP(5, HE_GI_08, BW_160),
441 HE_GROUP(6, HE_GI_08, BW_160),
442 HE_GROUP(7, HE_GI_08, BW_160),
443 HE_GROUP(8, HE_GI_08, BW_160),
444
445 HE_GROUP(1, HE_GI_16, BW_160),
446 HE_GROUP(2, HE_GI_16, BW_160),
447 HE_GROUP(3, HE_GI_16, BW_160),
448 HE_GROUP(4, HE_GI_16, BW_160),
449 HE_GROUP(5, HE_GI_16, BW_160),
450 HE_GROUP(6, HE_GI_16, BW_160),
451 HE_GROUP(7, HE_GI_16, BW_160),
452 HE_GROUP(8, HE_GI_16, BW_160),
453
454 HE_GROUP(1, HE_GI_32, BW_160),
455 HE_GROUP(2, HE_GI_32, BW_160),
456 HE_GROUP(3, HE_GI_32, BW_160),
457 HE_GROUP(4, HE_GI_32, BW_160),
458 HE_GROUP(5, HE_GI_32, BW_160),
459 HE_GROUP(6, HE_GI_32, BW_160),
460 HE_GROUP(7, HE_GI_32, BW_160),
461 HE_GROUP(8, HE_GI_32, BW_160),
462
463 EHT_GROUP_RANGE(EHT_GI_08, BW_20),
464 EHT_GROUP_RANGE(EHT_GI_16, BW_20),
465 EHT_GROUP_RANGE(EHT_GI_32, BW_20),
466
467 EHT_GROUP_RANGE(EHT_GI_08, BW_40),
468 EHT_GROUP_RANGE(EHT_GI_16, BW_40),
469 EHT_GROUP_RANGE(EHT_GI_32, BW_40),
470
471 EHT_GROUP_RANGE(EHT_GI_08, BW_80),
472 EHT_GROUP_RANGE(EHT_GI_16, BW_80),
473 EHT_GROUP_RANGE(EHT_GI_32, BW_80),
474
475 EHT_GROUP_RANGE(EHT_GI_08, BW_160),
476 EHT_GROUP_RANGE(EHT_GI_16, BW_160),
477 EHT_GROUP_RANGE(EHT_GI_32, BW_160),
478
479 EHT_GROUP_RANGE(EHT_GI_08, BW_320),
480 EHT_GROUP_RANGE(EHT_GI_16, BW_320),
481 EHT_GROUP_RANGE(EHT_GI_32, BW_320),
482};
483
484static u32
485ieee80211_calc_legacy_rate_duration(u16 bitrate, bool short_pre,
486 bool cck, int len)
487{
488 u32 duration;
489
490 if (cck) {
491 duration = 144 + 48; /* preamble + PLCP */
492 if (short_pre)
493 duration >>= 1;
494
495 duration += 10; /* SIFS */
496 } else {
497 duration = 20 + 16; /* premable + SIFS */
498 }
499
500 len <<= 3;
501 duration += (len * 10) / bitrate;
502
503 return duration;
504}
505
506static u32 ieee80211_get_rate_duration(struct ieee80211_hw *hw,
507 struct ieee80211_rx_status *status,
508 u32 *overhead)
509{
510 bool sgi = status->enc_flags & RX_ENC_FLAG_SHORT_GI;
511 int bw, streams;
512 int group, idx;
513 u32 duration;
514
515 switch (status->bw) {
516 case RATE_INFO_BW_20:
517 bw = BW_20;
518 break;
519 case RATE_INFO_BW_40:
520 bw = BW_40;
521 break;
522 case RATE_INFO_BW_80:
523 bw = BW_80;
524 break;
525 case RATE_INFO_BW_160:
526 bw = BW_160;
527 break;
528 case RATE_INFO_BW_320:
529 bw = BW_320;
530 break;
531 default:
532 WARN_ON_ONCE(1);
533 return 0;
534 }
535
536 switch (status->encoding) {
537 case RX_ENC_VHT:
538 streams = status->nss;
539 idx = status->rate_idx;
540 group = VHT_GROUP_IDX(streams, sgi, bw);
541 break;
542 case RX_ENC_HT:
543 streams = ((status->rate_idx >> 3) & 3) + 1;
544 idx = status->rate_idx & 7;
545 group = HT_GROUP_IDX(streams, sgi, bw);
546 break;
547 case RX_ENC_HE:
548 streams = status->nss;
549 idx = status->rate_idx;
550 group = HE_GROUP_IDX(streams, status->he_gi, bw);
551 break;
552 case RX_ENC_EHT:
553 streams = status->nss;
554 idx = status->rate_idx;
555 group = EHT_GROUP_IDX(streams, status->eht.gi, bw);
556 break;
557 default:
558 WARN_ON_ONCE(1);
559 return 0;
560 }
561
562 switch (status->encoding) {
563 case RX_ENC_EHT:
564 case RX_ENC_HE:
565 if (WARN_ON_ONCE(streams > 8))
566 return 0;
567 break;
568 default:
569 if (WARN_ON_ONCE(streams > 4))
570 return 0;
571 break;
572 }
573
574 if (idx >= MCS_GROUP_RATES)
575 return 0;
576
577 duration = airtime_mcs_groups[group].duration[idx];
578 duration <<= airtime_mcs_groups[group].shift;
579 *overhead = 36 + (streams << 2);
580
581 return duration;
582}
583
584
585u32 ieee80211_calc_rx_airtime(struct ieee80211_hw *hw,
586 struct ieee80211_rx_status *status,
587 int len)
588{
589 struct ieee80211_supported_band *sband;
590 u32 duration, overhead = 0;
591
592 if (status->encoding == RX_ENC_LEGACY) {
593 const struct ieee80211_rate *rate;
594 bool sp = status->enc_flags & RX_ENC_FLAG_SHORTPRE;
595 bool cck;
596
597 /* on 60GHz or sub-1GHz band, there are no legacy rates */
598 if (WARN_ON_ONCE(status->band == NL80211_BAND_60GHZ ||
599 status->band == NL80211_BAND_S1GHZ))
600 return 0;
601
602 sband = hw->wiphy->bands[status->band];
603 if (!sband || status->rate_idx >= sband->n_bitrates)
604 return 0;
605
606 rate = &sband->bitrates[status->rate_idx];
607 cck = rate->flags & IEEE80211_RATE_MANDATORY_B;
608
609 return ieee80211_calc_legacy_rate_duration(rate->bitrate, sp,
610 cck, len);
611 }
612
613 duration = ieee80211_get_rate_duration(hw, status, &overhead);
614 if (!duration)
615 return 0;
616
617 duration *= len;
618 duration /= AVG_PKT_SIZE;
619 duration /= 1024;
620
621 return duration + overhead;
622}
623EXPORT_SYMBOL_GPL(ieee80211_calc_rx_airtime);
624
625static bool ieee80211_fill_rate_info(struct ieee80211_hw *hw,
626 struct ieee80211_rx_status *stat, u8 band,
627 struct rate_info *ri)
628{
629 struct ieee80211_supported_band *sband = hw->wiphy->bands[band];
630 int i;
631
632 if (!ri || !sband)
633 return false;
634
635 /*
636 * ieee80211_get_rate_duration() only handles these widths. Drivers
637 * may also report e.g. HE/EHT RU allocations, which cannot be used
638 * to estimate airtime here.
639 */
640 switch (ri->bw) {
641 case RATE_INFO_BW_20:
642 case RATE_INFO_BW_40:
643 case RATE_INFO_BW_80:
644 case RATE_INFO_BW_160:
645 case RATE_INFO_BW_320:
646 break;
647 default:
648 return false;
649 }
650
651 stat->bw = ri->bw;
652 stat->nss = ri->nss;
653 stat->rate_idx = ri->mcs;
654
655 if (ri->flags & RATE_INFO_FLAGS_EHT_MCS)
656 stat->encoding = RX_ENC_EHT;
657 else if (ri->flags & RATE_INFO_FLAGS_HE_MCS)
658 stat->encoding = RX_ENC_HE;
659 else if (ri->flags & RATE_INFO_FLAGS_VHT_MCS)
660 stat->encoding = RX_ENC_VHT;
661 else if (ri->flags & RATE_INFO_FLAGS_MCS)
662 stat->encoding = RX_ENC_HT;
663 else
664 stat->encoding = RX_ENC_LEGACY;
665
666 if (ri->flags & RATE_INFO_FLAGS_SHORT_GI)
667 stat->enc_flags |= RX_ENC_FLAG_SHORT_GI;
668
669 switch (stat->encoding) {
670 case RX_ENC_EHT:
671 stat->eht.gi = ri->eht_gi;
672 break;
673 default:
674 stat->he_gi = ri->he_gi;
675 break;
676 }
677
678 if (stat->encoding != RX_ENC_LEGACY)
679 return true;
680
681 stat->rate_idx = 0;
682 for (i = 0; i < sband->n_bitrates; i++) {
683 if (ri->legacy != sband->bitrates[i].bitrate)
684 continue;
685
686 stat->rate_idx = i;
687 return true;
688 }
689
690 return false;
691}
692
693static int ieee80211_fill_rx_status(struct ieee80211_rx_status *stat,
694 struct ieee80211_hw *hw,
695 struct ieee80211_tx_rate *rate,
696 struct rate_info *ri, u8 band, int len)
697{
698 memset(stat, 0, sizeof(*stat));
699 stat->band = band;
700
701 if (ieee80211_fill_rate_info(hw, stat, band, ri))
702 return 0;
703
704 if (!rate || !ieee80211_rate_valid(rate))
705 return -1;
706
707 if (rate->flags & IEEE80211_TX_RC_160_MHZ_WIDTH)
708 stat->bw = RATE_INFO_BW_160;
709 else if (rate->flags & IEEE80211_TX_RC_80_MHZ_WIDTH)
710 stat->bw = RATE_INFO_BW_80;
711 else if (rate->flags & IEEE80211_TX_RC_40_MHZ_WIDTH)
712 stat->bw = RATE_INFO_BW_40;
713 else
714 stat->bw = RATE_INFO_BW_20;
715
716 stat->enc_flags = 0;
717 if (rate->flags & IEEE80211_TX_RC_USE_SHORT_PREAMBLE)
718 stat->enc_flags |= RX_ENC_FLAG_SHORTPRE;
719 if (rate->flags & IEEE80211_TX_RC_SHORT_GI)
720 stat->enc_flags |= RX_ENC_FLAG_SHORT_GI;
721
722 stat->rate_idx = rate->idx;
723 if (rate->flags & IEEE80211_TX_RC_VHT_MCS) {
724 stat->encoding = RX_ENC_VHT;
725 stat->rate_idx = ieee80211_rate_get_vht_mcs(rate);
726 stat->nss = ieee80211_rate_get_vht_nss(rate);
727 } else if (rate->flags & IEEE80211_TX_RC_MCS) {
728 stat->encoding = RX_ENC_HT;
729 } else {
730 stat->encoding = RX_ENC_LEGACY;
731 }
732
733 return 0;
734}
735
736static u32 ieee80211_calc_tx_airtime_rate(struct ieee80211_hw *hw,
737 struct ieee80211_tx_rate *rate,
738 struct rate_info *ri,
739 u8 band, int len)
740{
741 struct ieee80211_rx_status stat;
742
743 if (ieee80211_fill_rx_status(&stat, hw, rate, ri, band, len))
744 return 0;
745
746 return ieee80211_calc_rx_airtime(hw, &stat, len);
747}
748
749u32 ieee80211_calc_tx_airtime(struct ieee80211_hw *hw,
750 struct ieee80211_tx_info *info,
751 int len)
752{
753 u32 duration = 0;
754 int i;
755
756 for (i = 0; i < ARRAY_SIZE(info->status.rates); i++) {
757 struct ieee80211_tx_rate *rate = &info->status.rates[i];
758 u32 cur_duration;
759
760 cur_duration = ieee80211_calc_tx_airtime_rate(hw, rate, NULL,
761 info->band, len);
762 if (!cur_duration)
763 break;
764
765 duration += cur_duration * rate->count;
766 }
767
768 return duration;
769}
770EXPORT_SYMBOL_GPL(ieee80211_calc_tx_airtime);
771
772u32 ieee80211_rate_expected_tx_airtime(struct ieee80211_hw *hw,
773 struct ieee80211_tx_rate *tx_rate,
774 struct rate_info *ri,
775 enum nl80211_band band,
776 bool ampdu, int len)
777{
778 struct ieee80211_rx_status stat;
779 u32 duration, overhead;
780 u8 agg_shift;
781
782 if (ieee80211_fill_rx_status(&stat, hw, tx_rate, ri, band, len))
783 return 0;
784
785 if (stat.encoding == RX_ENC_LEGACY || !ampdu)
786 return ieee80211_calc_rx_airtime(hw, &stat, len) * 1024;
787
788 duration = ieee80211_get_rate_duration(hw, &stat, &overhead);
789 if (!duration)
790 return 0;
791
792 /*
793 * Assume that HT/VHT transmission on any AC except VO will
794 * use aggregation. Since we don't have reliable reporting
795 * of aggregation length, assume an average size based on the
796 * tx rate.
797 * This will not be very accurate, but much better than simply
798 * assuming un-aggregated tx in all cases.
799 */
800 if (duration > 400 * 1024) /* <= VHT20 MCS2 1S */
801 agg_shift = 1;
802 else if (duration > 250 * 1024) /* <= VHT20 MCS3 1S or MCS1 2S */
803 agg_shift = 2;
804 else if (duration > 150 * 1024) /* <= VHT20 MCS5 1S or MCS2 2S */
805 agg_shift = 3;
806 else if (duration > 70 * 1024) /* <= VHT20 MCS5 2S */
807 agg_shift = 4;
808 else if (stat.encoding != RX_ENC_HE ||
809 duration > 20 * 1024) /* <= HE40 MCS6 2S */
810 agg_shift = 5;
811 else
812 agg_shift = 6;
813
814 duration *= len;
815 duration /= AVG_PKT_SIZE;
816 duration += (overhead * 1024 >> agg_shift);
817
818 return duration;
819}
820
821u32 ieee80211_calc_expected_tx_airtime(struct ieee80211_hw *hw,
822 struct ieee80211_vif *vif,
823 struct ieee80211_sta *pubsta,
824 int len, bool ampdu)
825{
826 struct ieee80211_supported_band *sband;
827 struct ieee80211_chanctx_conf *conf;
828 int rateidx;
829 bool cck, short_pream;
830 u32 basic_rates;
831 u8 band = 0;
832 u16 rate;
833
834 len += 38; /* Ethernet header length */
835
836 conf = rcu_dereference(vif->bss_conf.chanctx_conf);
837 if (conf)
838 band = conf->def.chan->band;
839
840 if (pubsta) {
841 struct sta_info *sta = container_of(pubsta, struct sta_info,
842 sta);
843 struct ieee80211_tx_rate *tx_rate = &sta->deflink.tx_stats.last_rate;
844 struct rate_info *ri = &sta->deflink.tx_stats.last_rate_info;
845 u32 duration;
846
847 duration = ieee80211_rate_expected_tx_airtime(hw, tx_rate, ri,
848 band, true, len);
849 duration /= 1024;
850
851 return max_t(u32, duration, 4);
852 }
853
854 if (!conf)
855 return 0;
856
857 /* No station to get latest rate from, so calculate the worst-case
858 * duration using the lowest configured basic rate.
859 */
860 sband = hw->wiphy->bands[band];
861
862 basic_rates = vif->bss_conf.basic_rates;
863 short_pream = vif->bss_conf.use_short_preamble;
864
865 rateidx = basic_rates ? ffs(basic_rates) - 1 : 0;
866 rate = sband->bitrates[rateidx].bitrate;
867 cck = sband->bitrates[rateidx].flags & IEEE80211_RATE_MANDATORY_B;
868
869 return ieee80211_calc_legacy_rate_duration(rate, short_pream, cck, len);
870}