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