Merge tag 'rtc-5.6' of git://git.kernel.org/pub/scm/linux/kernel/git/abelloni/linux
[linux-2.6-microblaze.git] / net / mac80211 / airtime.c
1 // SPDX-License-Identifier: ISC
2 /*
3  * Copyright (C) 2019 Felix Fietkau <nbd@nbd.name>
4  */
5
6 #include <net/mac80211.h>
7 #include "ieee80211_i.h"
8 #include "sta_info.h"
9
10 #define AVG_PKT_SIZE    1024
11
12 /* Number of bits for an average sized packet */
13 #define MCS_NBITS (AVG_PKT_SIZE << 3)
14
15 /* Number of kilo-symbols (symbols * 1024) for a packet with (bps) bits per
16  * symbol. We use k-symbols to avoid rounding in the _TIME macros below.
17  */
18 #define MCS_N_KSYMS(bps) DIV_ROUND_UP(MCS_NBITS << 10, (bps))
19
20 /* Transmission time (in 1024 * usec) for a packet containing (ksyms) * 1024
21  * symbols.
22  */
23 #define MCS_SYMBOL_TIME(sgi, ksyms)                                     \
24         (sgi ?                                                          \
25           ((ksyms) * 4 * 18) / 20 :             /* 3.6 us per sym */    \
26           ((ksyms) * 4)                 /* 4.0 us per sym */    \
27         )
28
29 /* Transmit duration for the raw data part of an average sized packet */
30 #define MCS_DURATION(streams, sgi, bps) \
31         ((u32)MCS_SYMBOL_TIME(sgi, MCS_N_KSYMS((streams) * (bps))))
32
33 #define MCS_DURATION_S(shift, streams, sgi, bps)                \
34         ((u16)((MCS_DURATION(streams, sgi, bps) >> shift)))
35
36 /* These should match the values in enum nl80211_he_gi */
37 #define HE_GI_08 0
38 #define HE_GI_16 1
39 #define HE_GI_32 2
40
41 /* Transmission time (1024 usec) for a packet containing (ksyms) * k-symbols */
42 #define HE_SYMBOL_TIME(gi, ksyms)                                       \
43         (gi == HE_GI_08 ?                                               \
44          ((ksyms) * 16 * 17) / 20 :             /* 13.6 us per sym */   \
45          (gi == HE_GI_16 ?                                              \
46           ((ksyms) * 16 * 18) / 20 :            /* 14.4 us per sym */   \
47           ((ksyms) * 16)                        /* 16.0 us per sym */   \
48          ))
49
50 /* Transmit duration for the raw data part of an average sized packet */
51 #define HE_DURATION(streams, gi, bps) \
52         ((u32)HE_SYMBOL_TIME(gi, MCS_N_KSYMS((streams) * (bps))))
53
54 #define HE_DURATION_S(shift, streams, gi, bps)          \
55         (HE_DURATION(streams, gi, bps) >> shift)
56
57 #define BW_20                   0
58 #define BW_40                   1
59 #define BW_80                   2
60 #define BW_160                  3
61
62 /*
63  * Define group sort order: HT40 -> SGI -> #streams
64  */
65 #define IEEE80211_MAX_STREAMS           4
66 #define IEEE80211_HT_STREAM_GROUPS      4 /* BW(=2) * SGI(=2) */
67 #define IEEE80211_VHT_STREAM_GROUPS     8 /* BW(=4) * SGI(=2) */
68
69 #define IEEE80211_HE_MAX_STREAMS        8
70 #define IEEE80211_HE_STREAM_GROUPS      12 /* BW(=4) * GI(=3) */
71
72 #define IEEE80211_HT_GROUPS_NB  (IEEE80211_MAX_STREAMS *        \
73                                  IEEE80211_HT_STREAM_GROUPS)
74 #define IEEE80211_VHT_GROUPS_NB (IEEE80211_MAX_STREAMS *        \
75                                          IEEE80211_VHT_STREAM_GROUPS)
76 #define IEEE80211_HE_GROUPS_NB  (IEEE80211_HE_MAX_STREAMS *     \
77                                  IEEE80211_HE_STREAM_GROUPS)
78 #define IEEE80211_GROUPS_NB     (IEEE80211_HT_GROUPS_NB +       \
79                                  IEEE80211_VHT_GROUPS_NB +      \
80                                  IEEE80211_HE_GROUPS_NB)
81
82 #define IEEE80211_HT_GROUP_0    0
83 #define IEEE80211_VHT_GROUP_0   (IEEE80211_HT_GROUP_0 + IEEE80211_HT_GROUPS_NB)
84 #define IEEE80211_HE_GROUP_0    (IEEE80211_VHT_GROUP_0 + IEEE80211_VHT_GROUPS_NB)
85
86 #define MCS_GROUP_RATES         12
87
88 #define HT_GROUP_IDX(_streams, _sgi, _ht40)     \
89         IEEE80211_HT_GROUP_0 +                  \
90         IEEE80211_MAX_STREAMS * 2 * _ht40 +     \
91         IEEE80211_MAX_STREAMS * _sgi +          \
92         _streams - 1
93
94 #define _MAX(a, b) (((a)>(b))?(a):(b))
95
96 #define GROUP_SHIFT(duration)                                           \
97         _MAX(0, 16 - __builtin_clz(duration))
98
99 /* MCS rate information for an MCS group */
100 #define __MCS_GROUP(_streams, _sgi, _ht40, _s)                          \
101         [HT_GROUP_IDX(_streams, _sgi, _ht40)] = {                       \
102         .shift = _s,                                                    \
103         .duration = {                                                   \
104                 MCS_DURATION_S(_s, _streams, _sgi, _ht40 ? 54 : 26),    \
105                 MCS_DURATION_S(_s, _streams, _sgi, _ht40 ? 108 : 52),   \
106                 MCS_DURATION_S(_s, _streams, _sgi, _ht40 ? 162 : 78),   \
107                 MCS_DURATION_S(_s, _streams, _sgi, _ht40 ? 216 : 104),  \
108                 MCS_DURATION_S(_s, _streams, _sgi, _ht40 ? 324 : 156),  \
109                 MCS_DURATION_S(_s, _streams, _sgi, _ht40 ? 432 : 208),  \
110                 MCS_DURATION_S(_s, _streams, _sgi, _ht40 ? 486 : 234),  \
111                 MCS_DURATION_S(_s, _streams, _sgi, _ht40 ? 540 : 260)   \
112         }                                                               \
113 }
114
115 #define MCS_GROUP_SHIFT(_streams, _sgi, _ht40)                          \
116         GROUP_SHIFT(MCS_DURATION(_streams, _sgi, _ht40 ? 54 : 26))
117
118 #define MCS_GROUP(_streams, _sgi, _ht40)                                \
119         __MCS_GROUP(_streams, _sgi, _ht40,                              \
120                     MCS_GROUP_SHIFT(_streams, _sgi, _ht40))
121
122 #define VHT_GROUP_IDX(_streams, _sgi, _bw)                              \
123         (IEEE80211_VHT_GROUP_0 +                                        \
124          IEEE80211_MAX_STREAMS * 2 * (_bw) +                            \
125          IEEE80211_MAX_STREAMS * (_sgi) +                               \
126          (_streams) - 1)
127
128 #define BW2VBPS(_bw, r4, r3, r2, r1)                                    \
129         (_bw == BW_160 ? r4 : _bw == BW_80 ? r3 : _bw == BW_40 ? r2 : r1)
130
131 #define __VHT_GROUP(_streams, _sgi, _bw, _s)                            \
132         [VHT_GROUP_IDX(_streams, _sgi, _bw)] = {                        \
133         .shift = _s,                                                    \
134         .duration = {                                                   \
135                 MCS_DURATION_S(_s, _streams, _sgi,                      \
136                                BW2VBPS(_bw,  234,  117,  54,  26)),     \
137                 MCS_DURATION_S(_s, _streams, _sgi,                      \
138                                BW2VBPS(_bw,  468,  234, 108,  52)),     \
139                 MCS_DURATION_S(_s, _streams, _sgi,                      \
140                                BW2VBPS(_bw,  702,  351, 162,  78)),     \
141                 MCS_DURATION_S(_s, _streams, _sgi,                      \
142                                BW2VBPS(_bw,  936,  468, 216, 104)),     \
143                 MCS_DURATION_S(_s, _streams, _sgi,                      \
144                                BW2VBPS(_bw, 1404,  702, 324, 156)),     \
145                 MCS_DURATION_S(_s, _streams, _sgi,                      \
146                                BW2VBPS(_bw, 1872,  936, 432, 208)),     \
147                 MCS_DURATION_S(_s, _streams, _sgi,                      \
148                                BW2VBPS(_bw, 2106, 1053, 486, 234)),     \
149                 MCS_DURATION_S(_s, _streams, _sgi,                      \
150                                BW2VBPS(_bw, 2340, 1170, 540, 260)),     \
151                 MCS_DURATION_S(_s, _streams, _sgi,                      \
152                                BW2VBPS(_bw, 2808, 1404, 648, 312)),     \
153                 MCS_DURATION_S(_s, _streams, _sgi,                      \
154                                BW2VBPS(_bw, 3120, 1560, 720, 346))      \
155         }                                                               \
156 }
157
158 #define VHT_GROUP_SHIFT(_streams, _sgi, _bw)                            \
159         GROUP_SHIFT(MCS_DURATION(_streams, _sgi,                        \
160                                  BW2VBPS(_bw, 243, 117,  54,  26)))
161
162 #define VHT_GROUP(_streams, _sgi, _bw)                                  \
163         __VHT_GROUP(_streams, _sgi, _bw,                                \
164                     VHT_GROUP_SHIFT(_streams, _sgi, _bw))
165
166
167 #define HE_GROUP_IDX(_streams, _gi, _bw)                                \
168         (IEEE80211_HE_GROUP_0 +                                 \
169          IEEE80211_HE_MAX_STREAMS * 3 * (_bw) +                 \
170          IEEE80211_HE_MAX_STREAMS * (_gi) +                             \
171          (_streams) - 1)
172
173 #define __HE_GROUP(_streams, _gi, _bw, _s)                              \
174         [HE_GROUP_IDX(_streams, _gi, _bw)] = {                  \
175         .shift = _s,                                                    \
176         .duration = {                                                   \
177                 HE_DURATION_S(_s, _streams, _gi,                        \
178                               BW2VBPS(_bw,   979,  489,  230,  115)),   \
179                 HE_DURATION_S(_s, _streams, _gi,                        \
180                               BW2VBPS(_bw,  1958,  979,  475,  230)),   \
181                 HE_DURATION_S(_s, _streams, _gi,                        \
182                               BW2VBPS(_bw,  2937, 1468,  705,  345)),   \
183                 HE_DURATION_S(_s, _streams, _gi,                        \
184                               BW2VBPS(_bw,  3916, 1958,  936,  475)),   \
185                 HE_DURATION_S(_s, _streams, _gi,                        \
186                               BW2VBPS(_bw,  5875, 2937, 1411,  705)),   \
187                 HE_DURATION_S(_s, _streams, _gi,                        \
188                               BW2VBPS(_bw,  7833, 3916, 1872,  936)),   \
189                 HE_DURATION_S(_s, _streams, _gi,                        \
190                               BW2VBPS(_bw,  8827, 4406, 2102, 1051)),   \
191                 HE_DURATION_S(_s, _streams, _gi,                        \
192                               BW2VBPS(_bw,  9806, 4896, 2347, 1166)),   \
193                 HE_DURATION_S(_s, _streams, _gi,                        \
194                               BW2VBPS(_bw, 11764, 5875, 2808, 1411)),   \
195                 HE_DURATION_S(_s, _streams, _gi,                        \
196                               BW2VBPS(_bw, 13060, 6523, 3124, 1555)),   \
197                 HE_DURATION_S(_s, _streams, _gi,                        \
198                               BW2VBPS(_bw, 14702, 7344, 3513, 1756)),   \
199                 HE_DURATION_S(_s, _streams, _gi,                        \
200                               BW2VBPS(_bw, 16329, 8164, 3902, 1944))    \
201         }                                                               \
202 }
203
204 #define HE_GROUP_SHIFT(_streams, _gi, _bw)                              \
205         GROUP_SHIFT(HE_DURATION(_streams, _gi,                  \
206                                 BW2VBPS(_bw,   979,  489,  230,  115)))
207
208 #define HE_GROUP(_streams, _gi, _bw)                                    \
209         __HE_GROUP(_streams, _gi, _bw,                          \
210                    HE_GROUP_SHIFT(_streams, _gi, _bw))
211 struct mcs_group {
212         u8 shift;
213         u16 duration[MCS_GROUP_RATES];
214 };
215
216 static const struct mcs_group airtime_mcs_groups[] = {
217         MCS_GROUP(1, 0, BW_20),
218         MCS_GROUP(2, 0, BW_20),
219         MCS_GROUP(3, 0, BW_20),
220         MCS_GROUP(4, 0, BW_20),
221
222         MCS_GROUP(1, 1, BW_20),
223         MCS_GROUP(2, 1, BW_20),
224         MCS_GROUP(3, 1, BW_20),
225         MCS_GROUP(4, 1, BW_20),
226
227         MCS_GROUP(1, 0, BW_40),
228         MCS_GROUP(2, 0, BW_40),
229         MCS_GROUP(3, 0, BW_40),
230         MCS_GROUP(4, 0, BW_40),
231
232         MCS_GROUP(1, 1, BW_40),
233         MCS_GROUP(2, 1, BW_40),
234         MCS_GROUP(3, 1, BW_40),
235         MCS_GROUP(4, 1, BW_40),
236
237         VHT_GROUP(1, 0, BW_20),
238         VHT_GROUP(2, 0, BW_20),
239         VHT_GROUP(3, 0, BW_20),
240         VHT_GROUP(4, 0, BW_20),
241
242         VHT_GROUP(1, 1, BW_20),
243         VHT_GROUP(2, 1, BW_20),
244         VHT_GROUP(3, 1, BW_20),
245         VHT_GROUP(4, 1, BW_20),
246
247         VHT_GROUP(1, 0, BW_40),
248         VHT_GROUP(2, 0, BW_40),
249         VHT_GROUP(3, 0, BW_40),
250         VHT_GROUP(4, 0, BW_40),
251
252         VHT_GROUP(1, 1, BW_40),
253         VHT_GROUP(2, 1, BW_40),
254         VHT_GROUP(3, 1, BW_40),
255         VHT_GROUP(4, 1, BW_40),
256
257         VHT_GROUP(1, 0, BW_80),
258         VHT_GROUP(2, 0, BW_80),
259         VHT_GROUP(3, 0, BW_80),
260         VHT_GROUP(4, 0, BW_80),
261
262         VHT_GROUP(1, 1, BW_80),
263         VHT_GROUP(2, 1, BW_80),
264         VHT_GROUP(3, 1, BW_80),
265         VHT_GROUP(4, 1, BW_80),
266
267         VHT_GROUP(1, 0, BW_160),
268         VHT_GROUP(2, 0, BW_160),
269         VHT_GROUP(3, 0, BW_160),
270         VHT_GROUP(4, 0, BW_160),
271
272         VHT_GROUP(1, 1, BW_160),
273         VHT_GROUP(2, 1, BW_160),
274         VHT_GROUP(3, 1, BW_160),
275         VHT_GROUP(4, 1, BW_160),
276
277         HE_GROUP(1, HE_GI_08, BW_20),
278         HE_GROUP(2, HE_GI_08, BW_20),
279         HE_GROUP(3, HE_GI_08, BW_20),
280         HE_GROUP(4, HE_GI_08, BW_20),
281         HE_GROUP(5, HE_GI_08, BW_20),
282         HE_GROUP(6, HE_GI_08, BW_20),
283         HE_GROUP(7, HE_GI_08, BW_20),
284         HE_GROUP(8, HE_GI_08, BW_20),
285
286         HE_GROUP(1, HE_GI_16, BW_20),
287         HE_GROUP(2, HE_GI_16, BW_20),
288         HE_GROUP(3, HE_GI_16, BW_20),
289         HE_GROUP(4, HE_GI_16, BW_20),
290         HE_GROUP(5, HE_GI_16, BW_20),
291         HE_GROUP(6, HE_GI_16, BW_20),
292         HE_GROUP(7, HE_GI_16, BW_20),
293         HE_GROUP(8, HE_GI_16, BW_20),
294
295         HE_GROUP(1, HE_GI_32, BW_20),
296         HE_GROUP(2, HE_GI_32, BW_20),
297         HE_GROUP(3, HE_GI_32, BW_20),
298         HE_GROUP(4, HE_GI_32, BW_20),
299         HE_GROUP(5, HE_GI_32, BW_20),
300         HE_GROUP(6, HE_GI_32, BW_20),
301         HE_GROUP(7, HE_GI_32, BW_20),
302         HE_GROUP(8, HE_GI_32, BW_20),
303
304         HE_GROUP(1, HE_GI_08, BW_40),
305         HE_GROUP(2, HE_GI_08, BW_40),
306         HE_GROUP(3, HE_GI_08, BW_40),
307         HE_GROUP(4, HE_GI_08, BW_40),
308         HE_GROUP(5, HE_GI_08, BW_40),
309         HE_GROUP(6, HE_GI_08, BW_40),
310         HE_GROUP(7, HE_GI_08, BW_40),
311         HE_GROUP(8, HE_GI_08, BW_40),
312
313         HE_GROUP(1, HE_GI_16, BW_40),
314         HE_GROUP(2, HE_GI_16, BW_40),
315         HE_GROUP(3, HE_GI_16, BW_40),
316         HE_GROUP(4, HE_GI_16, BW_40),
317         HE_GROUP(5, HE_GI_16, BW_40),
318         HE_GROUP(6, HE_GI_16, BW_40),
319         HE_GROUP(7, HE_GI_16, BW_40),
320         HE_GROUP(8, HE_GI_16, BW_40),
321
322         HE_GROUP(1, HE_GI_32, BW_40),
323         HE_GROUP(2, HE_GI_32, BW_40),
324         HE_GROUP(3, HE_GI_32, BW_40),
325         HE_GROUP(4, HE_GI_32, BW_40),
326         HE_GROUP(5, HE_GI_32, BW_40),
327         HE_GROUP(6, HE_GI_32, BW_40),
328         HE_GROUP(7, HE_GI_32, BW_40),
329         HE_GROUP(8, HE_GI_32, BW_40),
330
331         HE_GROUP(1, HE_GI_08, BW_80),
332         HE_GROUP(2, HE_GI_08, BW_80),
333         HE_GROUP(3, HE_GI_08, BW_80),
334         HE_GROUP(4, HE_GI_08, BW_80),
335         HE_GROUP(5, HE_GI_08, BW_80),
336         HE_GROUP(6, HE_GI_08, BW_80),
337         HE_GROUP(7, HE_GI_08, BW_80),
338         HE_GROUP(8, HE_GI_08, BW_80),
339
340         HE_GROUP(1, HE_GI_16, BW_80),
341         HE_GROUP(2, HE_GI_16, BW_80),
342         HE_GROUP(3, HE_GI_16, BW_80),
343         HE_GROUP(4, HE_GI_16, BW_80),
344         HE_GROUP(5, HE_GI_16, BW_80),
345         HE_GROUP(6, HE_GI_16, BW_80),
346         HE_GROUP(7, HE_GI_16, BW_80),
347         HE_GROUP(8, HE_GI_16, BW_80),
348
349         HE_GROUP(1, HE_GI_32, BW_80),
350         HE_GROUP(2, HE_GI_32, BW_80),
351         HE_GROUP(3, HE_GI_32, BW_80),
352         HE_GROUP(4, HE_GI_32, BW_80),
353         HE_GROUP(5, HE_GI_32, BW_80),
354         HE_GROUP(6, HE_GI_32, BW_80),
355         HE_GROUP(7, HE_GI_32, BW_80),
356         HE_GROUP(8, HE_GI_32, BW_80),
357
358         HE_GROUP(1, HE_GI_08, BW_160),
359         HE_GROUP(2, HE_GI_08, BW_160),
360         HE_GROUP(3, HE_GI_08, BW_160),
361         HE_GROUP(4, HE_GI_08, BW_160),
362         HE_GROUP(5, HE_GI_08, BW_160),
363         HE_GROUP(6, HE_GI_08, BW_160),
364         HE_GROUP(7, HE_GI_08, BW_160),
365         HE_GROUP(8, HE_GI_08, BW_160),
366
367         HE_GROUP(1, HE_GI_16, BW_160),
368         HE_GROUP(2, HE_GI_16, BW_160),
369         HE_GROUP(3, HE_GI_16, BW_160),
370         HE_GROUP(4, HE_GI_16, BW_160),
371         HE_GROUP(5, HE_GI_16, BW_160),
372         HE_GROUP(6, HE_GI_16, BW_160),
373         HE_GROUP(7, HE_GI_16, BW_160),
374         HE_GROUP(8, HE_GI_16, BW_160),
375
376         HE_GROUP(1, HE_GI_32, BW_160),
377         HE_GROUP(2, HE_GI_32, BW_160),
378         HE_GROUP(3, HE_GI_32, BW_160),
379         HE_GROUP(4, HE_GI_32, BW_160),
380         HE_GROUP(5, HE_GI_32, BW_160),
381         HE_GROUP(6, HE_GI_32, BW_160),
382         HE_GROUP(7, HE_GI_32, BW_160),
383         HE_GROUP(8, HE_GI_32, BW_160),
384 };
385
386 static u32
387 ieee80211_calc_legacy_rate_duration(u16 bitrate, bool short_pre,
388                                     bool cck, int len)
389 {
390         u32 duration;
391
392         if (cck) {
393                 duration = 144 + 48; /* preamble + PLCP */
394                 if (short_pre)
395                         duration >>= 1;
396
397                 duration += 10; /* SIFS */
398         } else {
399                 duration = 20 + 16; /* premable + SIFS */
400         }
401
402         len <<= 3;
403         duration += (len * 10) / bitrate;
404
405         return duration;
406 }
407
408 u32 ieee80211_calc_rx_airtime(struct ieee80211_hw *hw,
409                               struct ieee80211_rx_status *status,
410                               int len)
411 {
412         struct ieee80211_supported_band *sband;
413         const struct ieee80211_rate *rate;
414         bool sgi = status->enc_flags & RX_ENC_FLAG_SHORT_GI;
415         bool sp = status->enc_flags & RX_ENC_FLAG_SHORTPRE;
416         int bw, streams;
417         int group, idx;
418         u32 duration;
419         bool cck;
420
421         switch (status->bw) {
422         case RATE_INFO_BW_20:
423                 bw = BW_20;
424                 break;
425         case RATE_INFO_BW_40:
426                 bw = BW_40;
427                 break;
428         case RATE_INFO_BW_80:
429                 bw = BW_80;
430                 break;
431         case RATE_INFO_BW_160:
432                 bw = BW_160;
433                 break;
434         default:
435                 WARN_ON_ONCE(1);
436                 return 0;
437         }
438
439         switch (status->encoding) {
440         case RX_ENC_LEGACY:
441                 if (WARN_ON_ONCE(status->band > NL80211_BAND_5GHZ))
442                         return 0;
443
444                 sband = hw->wiphy->bands[status->band];
445                 if (!sband || status->rate_idx >= sband->n_bitrates)
446                         return 0;
447
448                 rate = &sband->bitrates[status->rate_idx];
449                 cck = rate->flags & IEEE80211_RATE_MANDATORY_B;
450
451                 return ieee80211_calc_legacy_rate_duration(rate->bitrate, sp,
452                                                            cck, len);
453
454         case RX_ENC_VHT:
455                 streams = status->nss;
456                 idx = status->rate_idx;
457                 group = VHT_GROUP_IDX(streams, sgi, bw);
458                 break;
459         case RX_ENC_HT:
460                 streams = ((status->rate_idx >> 3) & 3) + 1;
461                 idx = status->rate_idx & 7;
462                 group = HT_GROUP_IDX(streams, sgi, bw);
463                 break;
464         case RX_ENC_HE:
465                 streams = status->nss;
466                 idx = status->rate_idx;
467                 group = HE_GROUP_IDX(streams, status->he_gi, bw);
468                 break;
469         default:
470                 WARN_ON_ONCE(1);
471                 return 0;
472         }
473
474         if (WARN_ON_ONCE((status->encoding != RX_ENC_HE && streams > 4) ||
475                          (status->encoding == RX_ENC_HE && streams > 8)))
476                 return 0;
477
478         duration = airtime_mcs_groups[group].duration[idx];
479         duration <<= airtime_mcs_groups[group].shift;
480         duration *= len;
481         duration /= AVG_PKT_SIZE;
482         duration /= 1024;
483
484         duration += 36 + (streams << 2);
485
486         return duration;
487 }
488 EXPORT_SYMBOL_GPL(ieee80211_calc_rx_airtime);
489
490 static u32 ieee80211_calc_tx_airtime_rate(struct ieee80211_hw *hw,
491                                           struct ieee80211_tx_rate *rate,
492                                           u8 band, int len)
493 {
494         struct ieee80211_rx_status stat = {
495                 .band = band,
496         };
497
498         if (rate->idx < 0 || !rate->count)
499                 return 0;
500
501         if (rate->flags & IEEE80211_TX_RC_80_MHZ_WIDTH)
502                 stat.bw = RATE_INFO_BW_80;
503         else if (rate->flags & IEEE80211_TX_RC_40_MHZ_WIDTH)
504                 stat.bw = RATE_INFO_BW_40;
505         else
506                 stat.bw = RATE_INFO_BW_20;
507
508         stat.enc_flags = 0;
509         if (rate->flags & IEEE80211_TX_RC_USE_SHORT_PREAMBLE)
510                 stat.enc_flags |= RX_ENC_FLAG_SHORTPRE;
511         if (rate->flags & IEEE80211_TX_RC_SHORT_GI)
512                 stat.enc_flags |= RX_ENC_FLAG_SHORT_GI;
513
514         stat.rate_idx = rate->idx;
515         if (rate->flags & IEEE80211_TX_RC_VHT_MCS) {
516                 stat.encoding = RX_ENC_VHT;
517                 stat.rate_idx = ieee80211_rate_get_vht_mcs(rate);
518                 stat.nss = ieee80211_rate_get_vht_nss(rate);
519         } else if (rate->flags & IEEE80211_TX_RC_MCS) {
520                 stat.encoding = RX_ENC_HT;
521         } else {
522                 stat.encoding = RX_ENC_LEGACY;
523         }
524
525         return ieee80211_calc_rx_airtime(hw, &stat, len);
526 }
527
528 u32 ieee80211_calc_tx_airtime(struct ieee80211_hw *hw,
529                               struct ieee80211_tx_info *info,
530                               int len)
531 {
532         u32 duration = 0;
533         int i;
534
535         for (i = 0; i < ARRAY_SIZE(info->status.rates); i++) {
536                 struct ieee80211_tx_rate *rate = &info->status.rates[i];
537                 u32 cur_duration;
538
539                 cur_duration = ieee80211_calc_tx_airtime_rate(hw, rate,
540                                                               info->band, len);
541                 if (!cur_duration)
542                         break;
543
544                 duration += cur_duration * rate->count;
545         }
546
547         return duration;
548 }
549 EXPORT_SYMBOL_GPL(ieee80211_calc_tx_airtime);
550
551 u32 ieee80211_calc_expected_tx_airtime(struct ieee80211_hw *hw,
552                                        struct ieee80211_vif *vif,
553                                        struct ieee80211_sta *pubsta,
554                                        int len)
555 {
556         struct ieee80211_supported_band *sband;
557         struct ieee80211_chanctx_conf *conf;
558         int rateidx, shift = 0;
559         bool cck, short_pream;
560         u32 basic_rates;
561         u8 band = 0;
562         u16 rate;
563
564         len += 38; /* Ethernet header length */
565
566         conf = rcu_dereference(vif->chanctx_conf);
567         if (conf) {
568                 band = conf->def.chan->band;
569                 shift = ieee80211_chandef_get_shift(&conf->def);
570         }
571
572         if (pubsta) {
573                 struct sta_info *sta = container_of(pubsta, struct sta_info,
574                                                     sta);
575
576                 return ieee80211_calc_tx_airtime_rate(hw,
577                                                       &sta->tx_stats.last_rate,
578                                                       band, len);
579         }
580
581         if (!conf)
582                 return 0;
583
584         /* No station to get latest rate from, so calculate the worst-case
585          * duration using the lowest configured basic rate.
586          */
587         sband = hw->wiphy->bands[band];
588
589         basic_rates = vif->bss_conf.basic_rates;
590         short_pream = vif->bss_conf.use_short_preamble;
591
592         rateidx = basic_rates ? ffs(basic_rates) - 1 : 0;
593         rate = sband->bitrates[rateidx].bitrate << shift;
594         cck = sband->bitrates[rateidx].flags & IEEE80211_RATE_MANDATORY_B;
595
596         return ieee80211_calc_legacy_rate_duration(rate, short_pream, cck, len);
597 }