airtime.c (19566B)
1// SPDX-License-Identifier: ISC 2/* 3 * Copyright (C) 2019 Felix Fietkau <nbd@nbd.name> 4 * Copyright (C) 2021 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#define BW_20 0 59#define BW_40 1 60#define BW_80 2 61#define BW_160 3 62 63/* 64 * Define group sort order: HT40 -> SGI -> #streams 65 */ 66#define IEEE80211_MAX_STREAMS 4 67#define IEEE80211_HT_STREAM_GROUPS 4 /* BW(=2) * SGI(=2) */ 68#define IEEE80211_VHT_STREAM_GROUPS 8 /* BW(=4) * SGI(=2) */ 69 70#define IEEE80211_HE_MAX_STREAMS 8 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 77#define IEEE80211_HT_GROUP_0 0 78#define IEEE80211_VHT_GROUP_0 (IEEE80211_HT_GROUP_0 + IEEE80211_HT_GROUPS_NB) 79#define IEEE80211_HE_GROUP_0 (IEEE80211_VHT_GROUP_0 + IEEE80211_VHT_GROUPS_NB) 80 81#define MCS_GROUP_RATES 12 82 83#define HT_GROUP_IDX(_streams, _sgi, _ht40) \ 84 IEEE80211_HT_GROUP_0 + \ 85 IEEE80211_MAX_STREAMS * 2 * _ht40 + \ 86 IEEE80211_MAX_STREAMS * _sgi + \ 87 _streams - 1 88 89#define _MAX(a, b) (((a)>(b))?(a):(b)) 90 91#define GROUP_SHIFT(duration) \ 92 _MAX(0, 16 - __builtin_clz(duration)) 93 94/* MCS rate information for an MCS group */ 95#define __MCS_GROUP(_streams, _sgi, _ht40, _s) \ 96 [HT_GROUP_IDX(_streams, _sgi, _ht40)] = { \ 97 .shift = _s, \ 98 .duration = { \ 99 MCS_DURATION_S(_s, _streams, _sgi, _ht40 ? 54 : 26), \ 100 MCS_DURATION_S(_s, _streams, _sgi, _ht40 ? 108 : 52), \ 101 MCS_DURATION_S(_s, _streams, _sgi, _ht40 ? 162 : 78), \ 102 MCS_DURATION_S(_s, _streams, _sgi, _ht40 ? 216 : 104), \ 103 MCS_DURATION_S(_s, _streams, _sgi, _ht40 ? 324 : 156), \ 104 MCS_DURATION_S(_s, _streams, _sgi, _ht40 ? 432 : 208), \ 105 MCS_DURATION_S(_s, _streams, _sgi, _ht40 ? 486 : 234), \ 106 MCS_DURATION_S(_s, _streams, _sgi, _ht40 ? 540 : 260) \ 107 } \ 108} 109 110#define MCS_GROUP_SHIFT(_streams, _sgi, _ht40) \ 111 GROUP_SHIFT(MCS_DURATION(_streams, _sgi, _ht40 ? 54 : 26)) 112 113#define MCS_GROUP(_streams, _sgi, _ht40) \ 114 __MCS_GROUP(_streams, _sgi, _ht40, \ 115 MCS_GROUP_SHIFT(_streams, _sgi, _ht40)) 116 117#define VHT_GROUP_IDX(_streams, _sgi, _bw) \ 118 (IEEE80211_VHT_GROUP_0 + \ 119 IEEE80211_MAX_STREAMS * 2 * (_bw) + \ 120 IEEE80211_MAX_STREAMS * (_sgi) + \ 121 (_streams) - 1) 122 123#define BW2VBPS(_bw, r4, r3, r2, r1) \ 124 (_bw == BW_160 ? r4 : _bw == BW_80 ? r3 : _bw == BW_40 ? r2 : r1) 125 126#define __VHT_GROUP(_streams, _sgi, _bw, _s) \ 127 [VHT_GROUP_IDX(_streams, _sgi, _bw)] = { \ 128 .shift = _s, \ 129 .duration = { \ 130 MCS_DURATION_S(_s, _streams, _sgi, \ 131 BW2VBPS(_bw, 234, 117, 54, 26)), \ 132 MCS_DURATION_S(_s, _streams, _sgi, \ 133 BW2VBPS(_bw, 468, 234, 108, 52)), \ 134 MCS_DURATION_S(_s, _streams, _sgi, \ 135 BW2VBPS(_bw, 702, 351, 162, 78)), \ 136 MCS_DURATION_S(_s, _streams, _sgi, \ 137 BW2VBPS(_bw, 936, 468, 216, 104)), \ 138 MCS_DURATION_S(_s, _streams, _sgi, \ 139 BW2VBPS(_bw, 1404, 702, 324, 156)), \ 140 MCS_DURATION_S(_s, _streams, _sgi, \ 141 BW2VBPS(_bw, 1872, 936, 432, 208)), \ 142 MCS_DURATION_S(_s, _streams, _sgi, \ 143 BW2VBPS(_bw, 2106, 1053, 486, 234)), \ 144 MCS_DURATION_S(_s, _streams, _sgi, \ 145 BW2VBPS(_bw, 2340, 1170, 540, 260)), \ 146 MCS_DURATION_S(_s, _streams, _sgi, \ 147 BW2VBPS(_bw, 2808, 1404, 648, 312)), \ 148 MCS_DURATION_S(_s, _streams, _sgi, \ 149 BW2VBPS(_bw, 3120, 1560, 720, 346)) \ 150 } \ 151} 152 153#define VHT_GROUP_SHIFT(_streams, _sgi, _bw) \ 154 GROUP_SHIFT(MCS_DURATION(_streams, _sgi, \ 155 BW2VBPS(_bw, 243, 117, 54, 26))) 156 157#define VHT_GROUP(_streams, _sgi, _bw) \ 158 __VHT_GROUP(_streams, _sgi, _bw, \ 159 VHT_GROUP_SHIFT(_streams, _sgi, _bw)) 160 161 162#define HE_GROUP_IDX(_streams, _gi, _bw) \ 163 (IEEE80211_HE_GROUP_0 + \ 164 IEEE80211_HE_MAX_STREAMS * 3 * (_bw) + \ 165 IEEE80211_HE_MAX_STREAMS * (_gi) + \ 166 (_streams) - 1) 167 168#define __HE_GROUP(_streams, _gi, _bw, _s) \ 169 [HE_GROUP_IDX(_streams, _gi, _bw)] = { \ 170 .shift = _s, \ 171 .duration = { \ 172 HE_DURATION_S(_s, _streams, _gi, \ 173 BW2VBPS(_bw, 979, 489, 230, 115)), \ 174 HE_DURATION_S(_s, _streams, _gi, \ 175 BW2VBPS(_bw, 1958, 979, 475, 230)), \ 176 HE_DURATION_S(_s, _streams, _gi, \ 177 BW2VBPS(_bw, 2937, 1468, 705, 345)), \ 178 HE_DURATION_S(_s, _streams, _gi, \ 179 BW2VBPS(_bw, 3916, 1958, 936, 475)), \ 180 HE_DURATION_S(_s, _streams, _gi, \ 181 BW2VBPS(_bw, 5875, 2937, 1411, 705)), \ 182 HE_DURATION_S(_s, _streams, _gi, \ 183 BW2VBPS(_bw, 7833, 3916, 1872, 936)), \ 184 HE_DURATION_S(_s, _streams, _gi, \ 185 BW2VBPS(_bw, 8827, 4406, 2102, 1051)), \ 186 HE_DURATION_S(_s, _streams, _gi, \ 187 BW2VBPS(_bw, 9806, 4896, 2347, 1166)), \ 188 HE_DURATION_S(_s, _streams, _gi, \ 189 BW2VBPS(_bw, 11764, 5875, 2808, 1411)), \ 190 HE_DURATION_S(_s, _streams, _gi, \ 191 BW2VBPS(_bw, 13060, 6523, 3124, 1555)), \ 192 HE_DURATION_S(_s, _streams, _gi, \ 193 BW2VBPS(_bw, 14702, 7344, 3513, 1756)), \ 194 HE_DURATION_S(_s, _streams, _gi, \ 195 BW2VBPS(_bw, 16329, 8164, 3902, 1944)) \ 196 } \ 197} 198 199#define HE_GROUP_SHIFT(_streams, _gi, _bw) \ 200 GROUP_SHIFT(HE_DURATION(_streams, _gi, \ 201 BW2VBPS(_bw, 979, 489, 230, 115))) 202 203#define HE_GROUP(_streams, _gi, _bw) \ 204 __HE_GROUP(_streams, _gi, _bw, \ 205 HE_GROUP_SHIFT(_streams, _gi, _bw)) 206struct mcs_group { 207 u8 shift; 208 u16 duration[MCS_GROUP_RATES]; 209}; 210 211static const struct mcs_group airtime_mcs_groups[] = { 212 MCS_GROUP(1, 0, BW_20), 213 MCS_GROUP(2, 0, BW_20), 214 MCS_GROUP(3, 0, BW_20), 215 MCS_GROUP(4, 0, BW_20), 216 217 MCS_GROUP(1, 1, BW_20), 218 MCS_GROUP(2, 1, BW_20), 219 MCS_GROUP(3, 1, BW_20), 220 MCS_GROUP(4, 1, BW_20), 221 222 MCS_GROUP(1, 0, BW_40), 223 MCS_GROUP(2, 0, BW_40), 224 MCS_GROUP(3, 0, BW_40), 225 MCS_GROUP(4, 0, BW_40), 226 227 MCS_GROUP(1, 1, BW_40), 228 MCS_GROUP(2, 1, BW_40), 229 MCS_GROUP(3, 1, BW_40), 230 MCS_GROUP(4, 1, BW_40), 231 232 VHT_GROUP(1, 0, BW_20), 233 VHT_GROUP(2, 0, BW_20), 234 VHT_GROUP(3, 0, BW_20), 235 VHT_GROUP(4, 0, BW_20), 236 237 VHT_GROUP(1, 1, BW_20), 238 VHT_GROUP(2, 1, BW_20), 239 VHT_GROUP(3, 1, BW_20), 240 VHT_GROUP(4, 1, BW_20), 241 242 VHT_GROUP(1, 0, BW_40), 243 VHT_GROUP(2, 0, BW_40), 244 VHT_GROUP(3, 0, BW_40), 245 VHT_GROUP(4, 0, BW_40), 246 247 VHT_GROUP(1, 1, BW_40), 248 VHT_GROUP(2, 1, BW_40), 249 VHT_GROUP(3, 1, BW_40), 250 VHT_GROUP(4, 1, BW_40), 251 252 VHT_GROUP(1, 0, BW_80), 253 VHT_GROUP(2, 0, BW_80), 254 VHT_GROUP(3, 0, BW_80), 255 VHT_GROUP(4, 0, BW_80), 256 257 VHT_GROUP(1, 1, BW_80), 258 VHT_GROUP(2, 1, BW_80), 259 VHT_GROUP(3, 1, BW_80), 260 VHT_GROUP(4, 1, BW_80), 261 262 VHT_GROUP(1, 0, BW_160), 263 VHT_GROUP(2, 0, BW_160), 264 VHT_GROUP(3, 0, BW_160), 265 VHT_GROUP(4, 0, BW_160), 266 267 VHT_GROUP(1, 1, BW_160), 268 VHT_GROUP(2, 1, BW_160), 269 VHT_GROUP(3, 1, BW_160), 270 VHT_GROUP(4, 1, BW_160), 271 272 HE_GROUP(1, HE_GI_08, BW_20), 273 HE_GROUP(2, HE_GI_08, BW_20), 274 HE_GROUP(3, HE_GI_08, BW_20), 275 HE_GROUP(4, HE_GI_08, BW_20), 276 HE_GROUP(5, HE_GI_08, BW_20), 277 HE_GROUP(6, HE_GI_08, BW_20), 278 HE_GROUP(7, HE_GI_08, BW_20), 279 HE_GROUP(8, HE_GI_08, BW_20), 280 281 HE_GROUP(1, HE_GI_16, BW_20), 282 HE_GROUP(2, HE_GI_16, BW_20), 283 HE_GROUP(3, HE_GI_16, BW_20), 284 HE_GROUP(4, HE_GI_16, BW_20), 285 HE_GROUP(5, HE_GI_16, BW_20), 286 HE_GROUP(6, HE_GI_16, BW_20), 287 HE_GROUP(7, HE_GI_16, BW_20), 288 HE_GROUP(8, HE_GI_16, BW_20), 289 290 HE_GROUP(1, HE_GI_32, BW_20), 291 HE_GROUP(2, HE_GI_32, BW_20), 292 HE_GROUP(3, HE_GI_32, BW_20), 293 HE_GROUP(4, HE_GI_32, BW_20), 294 HE_GROUP(5, HE_GI_32, BW_20), 295 HE_GROUP(6, HE_GI_32, BW_20), 296 HE_GROUP(7, HE_GI_32, BW_20), 297 HE_GROUP(8, HE_GI_32, BW_20), 298 299 HE_GROUP(1, HE_GI_08, BW_40), 300 HE_GROUP(2, HE_GI_08, BW_40), 301 HE_GROUP(3, HE_GI_08, BW_40), 302 HE_GROUP(4, HE_GI_08, BW_40), 303 HE_GROUP(5, HE_GI_08, BW_40), 304 HE_GROUP(6, HE_GI_08, BW_40), 305 HE_GROUP(7, HE_GI_08, BW_40), 306 HE_GROUP(8, HE_GI_08, BW_40), 307 308 HE_GROUP(1, HE_GI_16, BW_40), 309 HE_GROUP(2, HE_GI_16, BW_40), 310 HE_GROUP(3, HE_GI_16, BW_40), 311 HE_GROUP(4, HE_GI_16, BW_40), 312 HE_GROUP(5, HE_GI_16, BW_40), 313 HE_GROUP(6, HE_GI_16, BW_40), 314 HE_GROUP(7, HE_GI_16, BW_40), 315 HE_GROUP(8, HE_GI_16, BW_40), 316 317 HE_GROUP(1, HE_GI_32, BW_40), 318 HE_GROUP(2, HE_GI_32, BW_40), 319 HE_GROUP(3, HE_GI_32, BW_40), 320 HE_GROUP(4, HE_GI_32, BW_40), 321 HE_GROUP(5, HE_GI_32, BW_40), 322 HE_GROUP(6, HE_GI_32, BW_40), 323 HE_GROUP(7, HE_GI_32, BW_40), 324 HE_GROUP(8, HE_GI_32, BW_40), 325 326 HE_GROUP(1, HE_GI_08, BW_80), 327 HE_GROUP(2, HE_GI_08, BW_80), 328 HE_GROUP(3, HE_GI_08, BW_80), 329 HE_GROUP(4, HE_GI_08, BW_80), 330 HE_GROUP(5, HE_GI_08, BW_80), 331 HE_GROUP(6, HE_GI_08, BW_80), 332 HE_GROUP(7, HE_GI_08, BW_80), 333 HE_GROUP(8, HE_GI_08, BW_80), 334 335 HE_GROUP(1, HE_GI_16, BW_80), 336 HE_GROUP(2, HE_GI_16, BW_80), 337 HE_GROUP(3, HE_GI_16, BW_80), 338 HE_GROUP(4, HE_GI_16, BW_80), 339 HE_GROUP(5, HE_GI_16, BW_80), 340 HE_GROUP(6, HE_GI_16, BW_80), 341 HE_GROUP(7, HE_GI_16, BW_80), 342 HE_GROUP(8, HE_GI_16, BW_80), 343 344 HE_GROUP(1, HE_GI_32, BW_80), 345 HE_GROUP(2, HE_GI_32, BW_80), 346 HE_GROUP(3, HE_GI_32, BW_80), 347 HE_GROUP(4, HE_GI_32, BW_80), 348 HE_GROUP(5, HE_GI_32, BW_80), 349 HE_GROUP(6, HE_GI_32, BW_80), 350 HE_GROUP(7, HE_GI_32, BW_80), 351 HE_GROUP(8, HE_GI_32, BW_80), 352 353 HE_GROUP(1, HE_GI_08, BW_160), 354 HE_GROUP(2, HE_GI_08, BW_160), 355 HE_GROUP(3, HE_GI_08, BW_160), 356 HE_GROUP(4, HE_GI_08, BW_160), 357 HE_GROUP(5, HE_GI_08, BW_160), 358 HE_GROUP(6, HE_GI_08, BW_160), 359 HE_GROUP(7, HE_GI_08, BW_160), 360 HE_GROUP(8, HE_GI_08, BW_160), 361 362 HE_GROUP(1, HE_GI_16, BW_160), 363 HE_GROUP(2, HE_GI_16, BW_160), 364 HE_GROUP(3, HE_GI_16, BW_160), 365 HE_GROUP(4, HE_GI_16, BW_160), 366 HE_GROUP(5, HE_GI_16, BW_160), 367 HE_GROUP(6, HE_GI_16, BW_160), 368 HE_GROUP(7, HE_GI_16, BW_160), 369 HE_GROUP(8, HE_GI_16, BW_160), 370 371 HE_GROUP(1, HE_GI_32, BW_160), 372 HE_GROUP(2, HE_GI_32, BW_160), 373 HE_GROUP(3, HE_GI_32, BW_160), 374 HE_GROUP(4, HE_GI_32, BW_160), 375 HE_GROUP(5, HE_GI_32, BW_160), 376 HE_GROUP(6, HE_GI_32, BW_160), 377 HE_GROUP(7, HE_GI_32, BW_160), 378 HE_GROUP(8, HE_GI_32, BW_160), 379}; 380 381static u32 382ieee80211_calc_legacy_rate_duration(u16 bitrate, bool short_pre, 383 bool cck, int len) 384{ 385 u32 duration; 386 387 if (cck) { 388 duration = 144 + 48; /* preamble + PLCP */ 389 if (short_pre) 390 duration >>= 1; 391 392 duration += 10; /* SIFS */ 393 } else { 394 duration = 20 + 16; /* premable + SIFS */ 395 } 396 397 len <<= 3; 398 duration += (len * 10) / bitrate; 399 400 return duration; 401} 402 403static u32 ieee80211_get_rate_duration(struct ieee80211_hw *hw, 404 struct ieee80211_rx_status *status, 405 u32 *overhead) 406{ 407 bool sgi = status->enc_flags & RX_ENC_FLAG_SHORT_GI; 408 int bw, streams; 409 int group, idx; 410 u32 duration; 411 412 switch (status->bw) { 413 case RATE_INFO_BW_20: 414 bw = BW_20; 415 break; 416 case RATE_INFO_BW_40: 417 bw = BW_40; 418 break; 419 case RATE_INFO_BW_80: 420 bw = BW_80; 421 break; 422 case RATE_INFO_BW_160: 423 bw = BW_160; 424 break; 425 default: 426 WARN_ON_ONCE(1); 427 return 0; 428 } 429 430 switch (status->encoding) { 431 case RX_ENC_VHT: 432 streams = status->nss; 433 idx = status->rate_idx; 434 group = VHT_GROUP_IDX(streams, sgi, bw); 435 break; 436 case RX_ENC_HT: 437 streams = ((status->rate_idx >> 3) & 3) + 1; 438 idx = status->rate_idx & 7; 439 group = HT_GROUP_IDX(streams, sgi, bw); 440 break; 441 case RX_ENC_HE: 442 streams = status->nss; 443 idx = status->rate_idx; 444 group = HE_GROUP_IDX(streams, status->he_gi, bw); 445 break; 446 default: 447 WARN_ON_ONCE(1); 448 return 0; 449 } 450 451 if (WARN_ON_ONCE((status->encoding != RX_ENC_HE && streams > 4) || 452 (status->encoding == RX_ENC_HE && streams > 8))) 453 return 0; 454 455 duration = airtime_mcs_groups[group].duration[idx]; 456 duration <<= airtime_mcs_groups[group].shift; 457 *overhead = 36 + (streams << 2); 458 459 return duration; 460} 461 462 463u32 ieee80211_calc_rx_airtime(struct ieee80211_hw *hw, 464 struct ieee80211_rx_status *status, 465 int len) 466{ 467 struct ieee80211_supported_band *sband; 468 u32 duration, overhead = 0; 469 470 if (status->encoding == RX_ENC_LEGACY) { 471 const struct ieee80211_rate *rate; 472 bool sp = status->enc_flags & RX_ENC_FLAG_SHORTPRE; 473 bool cck; 474 475 /* on 60GHz or sub-1GHz band, there are no legacy rates */ 476 if (WARN_ON_ONCE(status->band == NL80211_BAND_60GHZ || 477 status->band == NL80211_BAND_S1GHZ)) 478 return 0; 479 480 sband = hw->wiphy->bands[status->band]; 481 if (!sband || status->rate_idx >= sband->n_bitrates) 482 return 0; 483 484 rate = &sband->bitrates[status->rate_idx]; 485 cck = rate->flags & IEEE80211_RATE_MANDATORY_B; 486 487 return ieee80211_calc_legacy_rate_duration(rate->bitrate, sp, 488 cck, len); 489 } 490 491 duration = ieee80211_get_rate_duration(hw, status, &overhead); 492 if (!duration) 493 return 0; 494 495 duration *= len; 496 duration /= AVG_PKT_SIZE; 497 duration /= 1024; 498 499 return duration + overhead; 500} 501EXPORT_SYMBOL_GPL(ieee80211_calc_rx_airtime); 502 503static bool ieee80211_fill_rate_info(struct ieee80211_hw *hw, 504 struct ieee80211_rx_status *stat, u8 band, 505 struct rate_info *ri) 506{ 507 struct ieee80211_supported_band *sband = hw->wiphy->bands[band]; 508 int i; 509 510 if (!ri || !sband) 511 return false; 512 513 stat->bw = ri->bw; 514 stat->nss = ri->nss; 515 stat->rate_idx = ri->mcs; 516 517 if (ri->flags & RATE_INFO_FLAGS_HE_MCS) 518 stat->encoding = RX_ENC_HE; 519 else if (ri->flags & RATE_INFO_FLAGS_VHT_MCS) 520 stat->encoding = RX_ENC_VHT; 521 else if (ri->flags & RATE_INFO_FLAGS_MCS) 522 stat->encoding = RX_ENC_HT; 523 else 524 stat->encoding = RX_ENC_LEGACY; 525 526 if (ri->flags & RATE_INFO_FLAGS_SHORT_GI) 527 stat->enc_flags |= RX_ENC_FLAG_SHORT_GI; 528 529 stat->he_gi = ri->he_gi; 530 531 if (stat->encoding != RX_ENC_LEGACY) 532 return true; 533 534 stat->rate_idx = 0; 535 for (i = 0; i < sband->n_bitrates; i++) { 536 if (ri->legacy != sband->bitrates[i].bitrate) 537 continue; 538 539 stat->rate_idx = i; 540 return true; 541 } 542 543 return false; 544} 545 546static int ieee80211_fill_rx_status(struct ieee80211_rx_status *stat, 547 struct ieee80211_hw *hw, 548 struct ieee80211_tx_rate *rate, 549 struct rate_info *ri, u8 band, int len) 550{ 551 memset(stat, 0, sizeof(*stat)); 552 stat->band = band; 553 554 if (ieee80211_fill_rate_info(hw, stat, band, ri)) 555 return 0; 556 557 if (rate->idx < 0 || !rate->count) 558 return -1; 559 560 if (rate->flags & IEEE80211_TX_RC_160_MHZ_WIDTH) 561 stat->bw = RATE_INFO_BW_160; 562 else if (rate->flags & IEEE80211_TX_RC_80_MHZ_WIDTH) 563 stat->bw = RATE_INFO_BW_80; 564 else if (rate->flags & IEEE80211_TX_RC_40_MHZ_WIDTH) 565 stat->bw = RATE_INFO_BW_40; 566 else 567 stat->bw = RATE_INFO_BW_20; 568 569 stat->enc_flags = 0; 570 if (rate->flags & IEEE80211_TX_RC_USE_SHORT_PREAMBLE) 571 stat->enc_flags |= RX_ENC_FLAG_SHORTPRE; 572 if (rate->flags & IEEE80211_TX_RC_SHORT_GI) 573 stat->enc_flags |= RX_ENC_FLAG_SHORT_GI; 574 575 stat->rate_idx = rate->idx; 576 if (rate->flags & IEEE80211_TX_RC_VHT_MCS) { 577 stat->encoding = RX_ENC_VHT; 578 stat->rate_idx = ieee80211_rate_get_vht_mcs(rate); 579 stat->nss = ieee80211_rate_get_vht_nss(rate); 580 } else if (rate->flags & IEEE80211_TX_RC_MCS) { 581 stat->encoding = RX_ENC_HT; 582 } else { 583 stat->encoding = RX_ENC_LEGACY; 584 } 585 586 return 0; 587} 588 589static u32 ieee80211_calc_tx_airtime_rate(struct ieee80211_hw *hw, 590 struct ieee80211_tx_rate *rate, 591 struct rate_info *ri, 592 u8 band, int len) 593{ 594 struct ieee80211_rx_status stat; 595 596 if (ieee80211_fill_rx_status(&stat, hw, rate, ri, band, len)) 597 return 0; 598 599 return ieee80211_calc_rx_airtime(hw, &stat, len); 600} 601 602u32 ieee80211_calc_tx_airtime(struct ieee80211_hw *hw, 603 struct ieee80211_tx_info *info, 604 int len) 605{ 606 u32 duration = 0; 607 int i; 608 609 for (i = 0; i < ARRAY_SIZE(info->status.rates); i++) { 610 struct ieee80211_tx_rate *rate = &info->status.rates[i]; 611 u32 cur_duration; 612 613 cur_duration = ieee80211_calc_tx_airtime_rate(hw, rate, NULL, 614 info->band, len); 615 if (!cur_duration) 616 break; 617 618 duration += cur_duration * rate->count; 619 } 620 621 return duration; 622} 623EXPORT_SYMBOL_GPL(ieee80211_calc_tx_airtime); 624 625u32 ieee80211_calc_expected_tx_airtime(struct ieee80211_hw *hw, 626 struct ieee80211_vif *vif, 627 struct ieee80211_sta *pubsta, 628 int len, bool ampdu) 629{ 630 struct ieee80211_supported_band *sband; 631 struct ieee80211_chanctx_conf *conf; 632 int rateidx, shift = 0; 633 bool cck, short_pream; 634 u32 basic_rates; 635 u8 band = 0; 636 u16 rate; 637 638 len += 38; /* Ethernet header length */ 639 640 conf = rcu_dereference(vif->chanctx_conf); 641 if (conf) { 642 band = conf->def.chan->band; 643 shift = ieee80211_chandef_get_shift(&conf->def); 644 } 645 646 if (pubsta) { 647 struct sta_info *sta = container_of(pubsta, struct sta_info, 648 sta); 649 struct ieee80211_rx_status stat; 650 struct ieee80211_tx_rate *tx_rate = &sta->deflink.tx_stats.last_rate; 651 struct rate_info *ri = &sta->deflink.tx_stats.last_rate_info; 652 u32 duration, overhead; 653 u8 agg_shift; 654 655 if (ieee80211_fill_rx_status(&stat, hw, tx_rate, ri, band, len)) 656 return 0; 657 658 if (stat.encoding == RX_ENC_LEGACY || !ampdu) 659 return ieee80211_calc_rx_airtime(hw, &stat, len); 660 661 duration = ieee80211_get_rate_duration(hw, &stat, &overhead); 662 /* 663 * Assume that HT/VHT transmission on any AC except VO will 664 * use aggregation. Since we don't have reliable reporting 665 * of aggregation length, assume an average size based on the 666 * tx rate. 667 * This will not be very accurate, but much better than simply 668 * assuming un-aggregated tx in all cases. 669 */ 670 if (duration > 400 * 1024) /* <= VHT20 MCS2 1S */ 671 agg_shift = 1; 672 else if (duration > 250 * 1024) /* <= VHT20 MCS3 1S or MCS1 2S */ 673 agg_shift = 2; 674 else if (duration > 150 * 1024) /* <= VHT20 MCS5 1S or MCS2 2S */ 675 agg_shift = 3; 676 else if (duration > 70 * 1024) /* <= VHT20 MCS5 2S */ 677 agg_shift = 4; 678 else if (stat.encoding != RX_ENC_HE || 679 duration > 20 * 1024) /* <= HE40 MCS6 2S */ 680 agg_shift = 5; 681 else 682 agg_shift = 6; 683 684 duration *= len; 685 duration /= AVG_PKT_SIZE; 686 duration /= 1024; 687 duration += (overhead >> agg_shift); 688 689 return max_t(u32, duration, 4); 690 } 691 692 if (!conf) 693 return 0; 694 695 /* No station to get latest rate from, so calculate the worst-case 696 * duration using the lowest configured basic rate. 697 */ 698 sband = hw->wiphy->bands[band]; 699 700 basic_rates = vif->bss_conf.basic_rates; 701 short_pream = vif->bss_conf.use_short_preamble; 702 703 rateidx = basic_rates ? ffs(basic_rates) - 1 : 0; 704 rate = sband->bitrates[rateidx].bitrate << shift; 705 cck = sband->bitrates[rateidx].flags & IEEE80211_RATE_MANDATORY_B; 706 707 return ieee80211_calc_legacy_rate_duration(rate, short_pream, cck, len); 708}