airtime.c 19 KB

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