?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
printf: Remove unused 'bprintf'
[drm/drm-misc.git] / net / mac80211 / airtime.c
blobc61df637232a9bc42369c3ce84f67e0fdc9ca370
1 // SPDX-License-Identifier: ISC
2 /*
3 * Copyright (C) 2019 Felix Fietkau <nbd@nbd.name>
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
289 struct mcs_group {
290 u8 shift;
291 u16 duration[MCS_GROUP_RATES];
292 };
293
294 static 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
484 static u32
485 ieee80211_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
506 static 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
585 u32 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 }
623 EXPORT_SYMBOL_GPL(ieee80211_calc_rx_airtime);
624
625 static 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 stat->bw = ri->bw;
636 stat->nss = ri->nss;
637 stat->rate_idx = ri->mcs;
638
639 if (ri->flags & RATE_INFO_FLAGS_EHT_MCS)
640 stat->encoding = RX_ENC_EHT;
641 else if (ri->flags & RATE_INFO_FLAGS_HE_MCS)
642 stat->encoding = RX_ENC_HE;
643 else if (ri->flags & RATE_INFO_FLAGS_VHT_MCS)
644 stat->encoding = RX_ENC_VHT;
645 else if (ri->flags & RATE_INFO_FLAGS_MCS)
646 stat->encoding = RX_ENC_HT;
647 else
648 stat->encoding = RX_ENC_LEGACY;
649
650 if (ri->flags & RATE_INFO_FLAGS_SHORT_GI)
651 stat->enc_flags |= RX_ENC_FLAG_SHORT_GI;
652
653 switch (stat->encoding) {
654 case RX_ENC_EHT:
655 stat->eht.gi = ri->eht_gi;
656 break;
657 default:
658 stat->he_gi = ri->he_gi;
659 break;
660 }
661
662 if (stat->encoding != RX_ENC_LEGACY)
663 return true;
664
665 stat->rate_idx = 0;
666 for (i = 0; i < sband->n_bitrates; i++) {
667 if (ri->legacy != sband->bitrates[i].bitrate)
668 continue;
669
670 stat->rate_idx = i;
671 return true;
672 }
673
674 return false;
675 }
676
677 static int ieee80211_fill_rx_status(struct ieee80211_rx_status *stat,
678 struct ieee80211_hw *hw,
679 struct ieee80211_tx_rate *rate,
680 struct rate_info *ri, u8 band, int len)
681 {
682 memset(stat, 0, sizeof(*stat));
683 stat->band = band;
684
685 if (ieee80211_fill_rate_info(hw, stat, band, ri))
686 return 0;
687
688 if (!ieee80211_rate_valid(rate))
689 return -1;
690
691 if (rate->flags & IEEE80211_TX_RC_160_MHZ_WIDTH)
692 stat->bw = RATE_INFO_BW_160;
693 else if (rate->flags & IEEE80211_TX_RC_80_MHZ_WIDTH)
694 stat->bw = RATE_INFO_BW_80;
695 else if (rate->flags & IEEE80211_TX_RC_40_MHZ_WIDTH)
696 stat->bw = RATE_INFO_BW_40;
697 else
698 stat->bw = RATE_INFO_BW_20;
699
700 stat->enc_flags = 0;
701 if (rate->flags & IEEE80211_TX_RC_USE_SHORT_PREAMBLE)
702 stat->enc_flags |= RX_ENC_FLAG_SHORTPRE;
703 if (rate->flags & IEEE80211_TX_RC_SHORT_GI)
704 stat->enc_flags |= RX_ENC_FLAG_SHORT_GI;
705
706 stat->rate_idx = rate->idx;
707 if (rate->flags & IEEE80211_TX_RC_VHT_MCS) {
708 stat->encoding = RX_ENC_VHT;
709 stat->rate_idx = ieee80211_rate_get_vht_mcs(rate);
710 stat->nss = ieee80211_rate_get_vht_nss(rate);
711 } else if (rate->flags & IEEE80211_TX_RC_MCS) {
712 stat->encoding = RX_ENC_HT;
713 } else {
714 stat->encoding = RX_ENC_LEGACY;
715 }
716
717 return 0;
718 }
719
720 static u32 ieee80211_calc_tx_airtime_rate(struct ieee80211_hw *hw,
721 struct ieee80211_tx_rate *rate,
722 struct rate_info *ri,
723 u8 band, int len)
724 {
725 struct ieee80211_rx_status stat;
726
727 if (ieee80211_fill_rx_status(&stat, hw, rate, ri, band, len))
728 return 0;
729
730 return ieee80211_calc_rx_airtime(hw, &stat, len);
731 }
732
733 u32 ieee80211_calc_tx_airtime(struct ieee80211_hw *hw,
734 struct ieee80211_tx_info *info,
735 int len)
736 {
737 u32 duration = 0;
738 int i;
739
740 for (i = 0; i < ARRAY_SIZE(info->status.rates); i++) {
741 struct ieee80211_tx_rate *rate = &info->status.rates[i];
742 u32 cur_duration;
743
744 cur_duration = ieee80211_calc_tx_airtime_rate(hw, rate, NULL,
745 info->band, len);
746 if (!cur_duration)
747 break;
748
749 duration += cur_duration * rate->count;
750 }
751
752 return duration;
753 }
754 EXPORT_SYMBOL_GPL(ieee80211_calc_tx_airtime);
755
756 u32 ieee80211_calc_expected_tx_airtime(struct ieee80211_hw *hw,
757 struct ieee80211_vif *vif,
758 struct ieee80211_sta *pubsta,
759 int len, bool ampdu)
760 {
761 struct ieee80211_supported_band *sband;
762 struct ieee80211_chanctx_conf *conf;
763 int rateidx;
764 bool cck, short_pream;
765 u32 basic_rates;
766 u8 band = 0;
767 u16 rate;
768
769 len += 38; /* Ethernet header length */
770
771 conf = rcu_dereference(vif->bss_conf.chanctx_conf);
772 if (conf)
773 band = conf->def.chan->band;
774
775 if (pubsta) {
776 struct sta_info *sta = container_of(pubsta, struct sta_info,
777 sta);
778 struct ieee80211_rx_status stat;
779 struct ieee80211_tx_rate *tx_rate = &sta->deflink.tx_stats.last_rate;
780 struct rate_info *ri = &sta->deflink.tx_stats.last_rate_info;
781 u32 duration, overhead;
782 u8 agg_shift;
783
784 if (ieee80211_fill_rx_status(&stat, hw, tx_rate, ri, band, len))
785 return 0;
786
787 if (stat.encoding == RX_ENC_LEGACY || !ampdu)
788 return ieee80211_calc_rx_airtime(hw, &stat, len);
789
790 duration = ieee80211_get_rate_duration(hw, &stat, &overhead);
791 /*
792 * Assume that HT/VHT transmission on any AC except VO will
793 * use aggregation. Since we don't have reliable reporting
794 * of aggregation length, assume an average size based on the
795 * tx rate.
796 * This will not be very accurate, but much better than simply
797 * assuming un-aggregated tx in all cases.
798 */
799 if (duration > 400 * 1024) /* <= VHT20 MCS2 1S */
800 agg_shift = 1;
801 else if (duration > 250 * 1024) /* <= VHT20 MCS3 1S or MCS1 2S */
802 agg_shift = 2;
803 else if (duration > 150 * 1024) /* <= VHT20 MCS5 1S or MCS2 2S */
804 agg_shift = 3;
805 else if (duration > 70 * 1024) /* <= VHT20 MCS5 2S */
806 agg_shift = 4;
807 else if (stat.encoding != RX_ENC_HE ||
808 duration > 20 * 1024) /* <= HE40 MCS6 2S */
809 agg_shift = 5;
810 else
811 agg_shift = 6;
812
813 duration *= len;
814 duration /= AVG_PKT_SIZE;
815 duration /= 1024;
816 duration += (overhead >> agg_shift);
817
818 return max_t(u32, duration, 4);
819 }
820
821 if (!conf)
822 return 0;
823
824 /* No station to get latest rate from, so calculate the worst-case
825 * duration using the lowest configured basic rate.
826 */
827 sband = hw->wiphy->bands[band];
828
829 basic_rates = vif->bss_conf.basic_rates;
830 short_pream = vif->bss_conf.use_short_preamble;
831
832 rateidx = basic_rates ? ffs(basic_rates) - 1 : 0;
833 rate = sband->bitrates[rateidx].bitrate;
834 cck = sband->bitrates[rateidx].flags & IEEE80211_RATE_MANDATORY_B;
835
836 return ieee80211_calc_legacy_rate_duration(rate, short_pream, cck, len);
837 }
Kernel DRM miscellaneous fixes and cross-tree changes