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 } 838