net/mac80211/airtime.c

   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 #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))
 206 struct mcs_group {
 207         u8 shift;
 208         u16 duration[MCS_GROUP_RATES];
 209 };
 210
 211 static 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
 381 static u32
 382 ieee80211_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
 403 static 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
 463 u32 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 }
 501 EXPORT_SYMBOL_GPL(ieee80211_calc_rx_airtime);
 502
 503 static 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
 546 static 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
 589 static 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
 602 u32 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 }
 623 EXPORT_SYMBOL_GPL(ieee80211_calc_tx_airtime);
 624
 625 u32 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->bss_conf.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 }