1 // SPDX-License-Identifier: GPL-2.0-only
3 * Copyright (C) 2010-2013 Felix Fietkau <nbd@openwrt.org>
4 * Copyright (C) 2019-2020 Intel Corporation
6 #include <linux/netdevice.h>
7 #include <linux/types.h>
8 #include <linux/skbuff.h>
9 #include <linux/debugfs.h>
10 #include <linux/random.h>
11 #include <linux/moduleparam.h>
12 #include <linux/ieee80211.h>
13 #include <net/mac80211.h>
16 #include "rc80211_minstrel_ht.h"
18 #define AVG_AMPDU_SIZE 16
19 #define AVG_PKT_SIZE 1200
21 #define SAMPLE_SWITCH_THR 100
23 /* Number of bits for an average sized packet */
24 #define MCS_NBITS ((AVG_PKT_SIZE * AVG_AMPDU_SIZE) << 3)
26 /* Number of symbols for a packet with (bps) bits per symbol */
27 #define MCS_NSYMS(bps) DIV_ROUND_UP(MCS_NBITS, (bps))
29 /* Transmission time (nanoseconds) for a packet containing (syms) symbols */
30 #define MCS_SYMBOL_TIME(sgi, syms) \
32 ((syms) * 18000 + 4000) / 5 : /* syms * 3.6 us */ \
33 ((syms) * 1000) << 2 /* syms * 4 us */ \
36 /* Transmit duration for the raw data part of an average sized packet */
37 #define MCS_DURATION(streams, sgi, bps) \
38 (MCS_SYMBOL_TIME(sgi, MCS_NSYMS((streams) * (bps))) / AVG_AMPDU_SIZE)
45 * Define group sort order: HT40 -> SGI -> #streams
47 #define GROUP_IDX(_streams, _sgi, _ht40) \
48 MINSTREL_HT_GROUP_0 + \
49 MINSTREL_MAX_STREAMS * 2 * _ht40 + \
50 MINSTREL_MAX_STREAMS * _sgi + \
53 #define _MAX(a, b) (((a)>(b))?(a):(b))
55 #define GROUP_SHIFT(duration) \
56 _MAX(0, 16 - __builtin_clz(duration))
58 /* MCS rate information for an MCS group */
59 #define __MCS_GROUP(_streams, _sgi, _ht40, _s) \
60 [GROUP_IDX(_streams, _sgi, _ht40)] = { \
61 .streams = _streams, \
65 IEEE80211_TX_RC_MCS | \
66 (_sgi ? IEEE80211_TX_RC_SHORT_GI : 0) | \
67 (_ht40 ? IEEE80211_TX_RC_40_MHZ_WIDTH : 0), \
69 MCS_DURATION(_streams, _sgi, _ht40 ? 54 : 26) >> _s, \
70 MCS_DURATION(_streams, _sgi, _ht40 ? 108 : 52) >> _s, \
71 MCS_DURATION(_streams, _sgi, _ht40 ? 162 : 78) >> _s, \
72 MCS_DURATION(_streams, _sgi, _ht40 ? 216 : 104) >> _s, \
73 MCS_DURATION(_streams, _sgi, _ht40 ? 324 : 156) >> _s, \
74 MCS_DURATION(_streams, _sgi, _ht40 ? 432 : 208) >> _s, \
75 MCS_DURATION(_streams, _sgi, _ht40 ? 486 : 234) >> _s, \
76 MCS_DURATION(_streams, _sgi, _ht40 ? 540 : 260) >> _s \
80 #define MCS_GROUP_SHIFT(_streams, _sgi, _ht40) \
81 GROUP_SHIFT(MCS_DURATION(_streams, _sgi, _ht40 ? 54 : 26))
83 #define MCS_GROUP(_streams, _sgi, _ht40) \
84 __MCS_GROUP(_streams, _sgi, _ht40, \
85 MCS_GROUP_SHIFT(_streams, _sgi, _ht40))
87 #define VHT_GROUP_IDX(_streams, _sgi, _bw) \
88 (MINSTREL_VHT_GROUP_0 + \
89 MINSTREL_MAX_STREAMS * 2 * (_bw) + \
90 MINSTREL_MAX_STREAMS * (_sgi) + \
93 #define BW2VBPS(_bw, r3, r2, r1) \
94 (_bw == BW_80 ? r3 : _bw == BW_40 ? r2 : r1)
96 #define __VHT_GROUP(_streams, _sgi, _bw, _s) \
97 [VHT_GROUP_IDX(_streams, _sgi, _bw)] = { \
98 .streams = _streams, \
102 IEEE80211_TX_RC_VHT_MCS | \
103 (_sgi ? IEEE80211_TX_RC_SHORT_GI : 0) | \
104 (_bw == BW_80 ? IEEE80211_TX_RC_80_MHZ_WIDTH : \
105 _bw == BW_40 ? IEEE80211_TX_RC_40_MHZ_WIDTH : 0), \
107 MCS_DURATION(_streams, _sgi, \
108 BW2VBPS(_bw, 117, 54, 26)) >> _s, \
109 MCS_DURATION(_streams, _sgi, \
110 BW2VBPS(_bw, 234, 108, 52)) >> _s, \
111 MCS_DURATION(_streams, _sgi, \
112 BW2VBPS(_bw, 351, 162, 78)) >> _s, \
113 MCS_DURATION(_streams, _sgi, \
114 BW2VBPS(_bw, 468, 216, 104)) >> _s, \
115 MCS_DURATION(_streams, _sgi, \
116 BW2VBPS(_bw, 702, 324, 156)) >> _s, \
117 MCS_DURATION(_streams, _sgi, \
118 BW2VBPS(_bw, 936, 432, 208)) >> _s, \
119 MCS_DURATION(_streams, _sgi, \
120 BW2VBPS(_bw, 1053, 486, 234)) >> _s, \
121 MCS_DURATION(_streams, _sgi, \
122 BW2VBPS(_bw, 1170, 540, 260)) >> _s, \
123 MCS_DURATION(_streams, _sgi, \
124 BW2VBPS(_bw, 1404, 648, 312)) >> _s, \
125 MCS_DURATION(_streams, _sgi, \
126 BW2VBPS(_bw, 1560, 720, 346)) >> _s \
130 #define VHT_GROUP_SHIFT(_streams, _sgi, _bw) \
131 GROUP_SHIFT(MCS_DURATION(_streams, _sgi, \
132 BW2VBPS(_bw, 117, 54, 26)))
134 #define VHT_GROUP(_streams, _sgi, _bw) \
135 __VHT_GROUP(_streams, _sgi, _bw, \
136 VHT_GROUP_SHIFT(_streams, _sgi, _bw))
138 #define CCK_DURATION(_bitrate, _short) \
139 (1000 * (10 /* SIFS */ + \
140 (_short ? 72 + 24 : 144 + 48) + \
141 (8 * (AVG_PKT_SIZE + 4) * 10) / (_bitrate)))
143 #define CCK_DURATION_LIST(_short, _s) \
144 CCK_DURATION(10, _short) >> _s, \
145 CCK_DURATION(20, _short) >> _s, \
146 CCK_DURATION(55, _short) >> _s, \
147 CCK_DURATION(110, _short) >> _s
149 #define __CCK_GROUP(_s) \
150 [MINSTREL_CCK_GROUP] = { \
155 CCK_DURATION_LIST(false, _s), \
156 CCK_DURATION_LIST(true, _s) \
160 #define CCK_GROUP_SHIFT \
161 GROUP_SHIFT(CCK_DURATION(10, false))
163 #define CCK_GROUP __CCK_GROUP(CCK_GROUP_SHIFT)
165 #define OFDM_DURATION(_bitrate) \
166 (1000 * (16 /* SIFS + signal ext */ + \
167 16 /* T_PREAMBLE */ + \
169 4 * (((16 + 80 * (AVG_PKT_SIZE + 4) + 6) / \
172 #define OFDM_DURATION_LIST(_s) \
173 OFDM_DURATION(60) >> _s, \
174 OFDM_DURATION(90) >> _s, \
175 OFDM_DURATION(120) >> _s, \
176 OFDM_DURATION(180) >> _s, \
177 OFDM_DURATION(240) >> _s, \
178 OFDM_DURATION(360) >> _s, \
179 OFDM_DURATION(480) >> _s, \
180 OFDM_DURATION(540) >> _s
182 #define __OFDM_GROUP(_s) \
183 [MINSTREL_OFDM_GROUP] = { \
188 OFDM_DURATION_LIST(_s), \
192 #define OFDM_GROUP_SHIFT \
193 GROUP_SHIFT(OFDM_DURATION(60))
195 #define OFDM_GROUP __OFDM_GROUP(OFDM_GROUP_SHIFT)
198 static bool minstrel_vht_only
= true;
199 module_param(minstrel_vht_only
, bool, 0644);
200 MODULE_PARM_DESC(minstrel_vht_only
,
201 "Use only VHT rates when VHT is supported by sta.");
204 * To enable sufficiently targeted rate sampling, MCS rates are divided into
205 * groups, based on the number of streams and flags (HT40, SGI) that they
208 * Sortorder has to be fixed for GROUP_IDX macro to be applicable:
209 * BW -> SGI -> #streams
211 const struct mcs_group minstrel_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
),
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
),
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
),
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
),
235 VHT_GROUP(1, 0, BW_20
),
236 VHT_GROUP(2, 0, BW_20
),
237 VHT_GROUP(3, 0, BW_20
),
238 VHT_GROUP(4, 0, BW_20
),
240 VHT_GROUP(1, 1, BW_20
),
241 VHT_GROUP(2, 1, BW_20
),
242 VHT_GROUP(3, 1, BW_20
),
243 VHT_GROUP(4, 1, BW_20
),
245 VHT_GROUP(1, 0, BW_40
),
246 VHT_GROUP(2, 0, BW_40
),
247 VHT_GROUP(3, 0, BW_40
),
248 VHT_GROUP(4, 0, BW_40
),
250 VHT_GROUP(1, 1, BW_40
),
251 VHT_GROUP(2, 1, BW_40
),
252 VHT_GROUP(3, 1, BW_40
),
253 VHT_GROUP(4, 1, BW_40
),
255 VHT_GROUP(1, 0, BW_80
),
256 VHT_GROUP(2, 0, BW_80
),
257 VHT_GROUP(3, 0, BW_80
),
258 VHT_GROUP(4, 0, BW_80
),
260 VHT_GROUP(1, 1, BW_80
),
261 VHT_GROUP(2, 1, BW_80
),
262 VHT_GROUP(3, 1, BW_80
),
263 VHT_GROUP(4, 1, BW_80
),
266 const s16 minstrel_cck_bitrates
[4] = { 10, 20, 55, 110 };
267 const s16 minstrel_ofdm_bitrates
[8] = { 60, 90, 120, 180, 240, 360, 480, 540 };
268 static u8 sample_table
[SAMPLE_COLUMNS
][MCS_GROUP_RATES
] __read_mostly
;
269 static const u8 minstrel_sample_seq
[] = {
270 MINSTREL_SAMPLE_TYPE_INC
,
271 MINSTREL_SAMPLE_TYPE_JUMP
,
272 MINSTREL_SAMPLE_TYPE_INC
,
273 MINSTREL_SAMPLE_TYPE_JUMP
,
274 MINSTREL_SAMPLE_TYPE_INC
,
275 MINSTREL_SAMPLE_TYPE_SLOW
,
279 minstrel_ht_update_rates(struct minstrel_priv
*mp
, struct minstrel_ht_sta
*mi
);
282 * Some VHT MCSes are invalid (when Ndbps / Nes is not an integer)
283 * e.g for MCS9@20MHzx1Nss: Ndbps=8x52*(5/6) Nes=1
285 * Returns the valid mcs map for struct minstrel_mcs_group_data.supported
288 minstrel_get_valid_vht_rates(int bw
, int nss
, __le16 mcs_map
)
293 if (nss
!= 3 && nss
!= 6)
295 } else if (bw
== BW_80
) {
296 if (nss
== 3 || nss
== 7)
301 WARN_ON(bw
!= BW_40
);
304 switch ((le16_to_cpu(mcs_map
) >> (2 * (nss
- 1))) & 3) {
305 case IEEE80211_VHT_MCS_SUPPORT_0_7
:
308 case IEEE80211_VHT_MCS_SUPPORT_0_8
:
311 case IEEE80211_VHT_MCS_SUPPORT_0_9
:
317 return 0x3ff & ~mask
;
321 minstrel_ht_is_legacy_group(int group
)
323 return group
== MINSTREL_CCK_GROUP
||
324 group
== MINSTREL_OFDM_GROUP
;
328 * Look up an MCS group index based on mac80211 rate information
331 minstrel_ht_get_group_idx(struct ieee80211_tx_rate
*rate
)
333 return GROUP_IDX((rate
->idx
/ 8) + 1,
334 !!(rate
->flags
& IEEE80211_TX_RC_SHORT_GI
),
335 !!(rate
->flags
& IEEE80211_TX_RC_40_MHZ_WIDTH
));
339 minstrel_vht_get_group_idx(struct ieee80211_tx_rate
*rate
)
341 return VHT_GROUP_IDX(ieee80211_rate_get_vht_nss(rate
),
342 !!(rate
->flags
& IEEE80211_TX_RC_SHORT_GI
),
343 !!(rate
->flags
& IEEE80211_TX_RC_40_MHZ_WIDTH
) +
344 2*!!(rate
->flags
& IEEE80211_TX_RC_80_MHZ_WIDTH
));
347 static struct minstrel_rate_stats
*
348 minstrel_ht_get_stats(struct minstrel_priv
*mp
, struct minstrel_ht_sta
*mi
,
349 struct ieee80211_tx_rate
*rate
)
353 if (rate
->flags
& IEEE80211_TX_RC_MCS
) {
354 group
= minstrel_ht_get_group_idx(rate
);
359 if (rate
->flags
& IEEE80211_TX_RC_VHT_MCS
) {
360 group
= minstrel_vht_get_group_idx(rate
);
361 idx
= ieee80211_rate_get_vht_mcs(rate
);
365 group
= MINSTREL_CCK_GROUP
;
366 for (idx
= 0; idx
< ARRAY_SIZE(mp
->cck_rates
); idx
++) {
367 if (rate
->idx
!= mp
->cck_rates
[idx
])
371 if ((mi
->supported
[group
] & BIT(idx
+ 4)) &&
372 (rate
->flags
& IEEE80211_TX_RC_USE_SHORT_PREAMBLE
))
377 group
= MINSTREL_OFDM_GROUP
;
378 for (idx
= 0; idx
< ARRAY_SIZE(mp
->ofdm_rates
[0]); idx
++)
379 if (rate
->idx
== mp
->ofdm_rates
[mi
->band
][idx
])
384 return &mi
->groups
[group
].rates
[idx
];
387 static inline struct minstrel_rate_stats
*
388 minstrel_get_ratestats(struct minstrel_ht_sta
*mi
, int index
)
390 return &mi
->groups
[MI_RATE_GROUP(index
)].rates
[MI_RATE_IDX(index
)];
393 static inline int minstrel_get_duration(int index
)
395 const struct mcs_group
*group
= &minstrel_mcs_groups
[MI_RATE_GROUP(index
)];
396 unsigned int duration
= group
->duration
[MI_RATE_IDX(index
)];
398 return duration
<< group
->shift
;
402 minstrel_ht_avg_ampdu_len(struct minstrel_ht_sta
*mi
)
406 if (mi
->avg_ampdu_len
)
407 return MINSTREL_TRUNC(mi
->avg_ampdu_len
);
409 if (minstrel_ht_is_legacy_group(MI_RATE_GROUP(mi
->max_tp_rate
[0])))
412 duration
= minstrel_get_duration(mi
->max_tp_rate
[0]);
414 if (duration
> 400 * 1000)
417 if (duration
> 250 * 1000)
420 if (duration
> 150 * 1000)
427 * Return current throughput based on the average A-MPDU length, taking into
428 * account the expected number of retransmissions and their expected length
431 minstrel_ht_get_tp_avg(struct minstrel_ht_sta
*mi
, int group
, int rate
,
434 unsigned int nsecs
= 0, overhead
= mi
->overhead
;
435 unsigned int ampdu_len
= 1;
437 /* do not account throughput if success prob is below 10% */
438 if (prob_avg
< MINSTREL_FRAC(10, 100))
441 if (minstrel_ht_is_legacy_group(group
))
442 overhead
= mi
->overhead_legacy
;
444 ampdu_len
= minstrel_ht_avg_ampdu_len(mi
);
446 nsecs
= 1000 * overhead
/ ampdu_len
;
447 nsecs
+= minstrel_mcs_groups
[group
].duration
[rate
] <<
448 minstrel_mcs_groups
[group
].shift
;
451 * For the throughput calculation, limit the probability value to 90% to
452 * account for collision related packet error rate fluctuation
453 * (prob is scaled - see MINSTREL_FRAC above)
455 if (prob_avg
> MINSTREL_FRAC(90, 100))
456 prob_avg
= MINSTREL_FRAC(90, 100);
458 return MINSTREL_TRUNC(100 * ((prob_avg
* 1000000) / nsecs
));
462 * Find & sort topmost throughput rates
464 * If multiple rates provide equal throughput the sorting is based on their
465 * current success probability. Higher success probability is preferred among
466 * MCS groups, CCK rates do not provide aggregation and are therefore at last.
469 minstrel_ht_sort_best_tp_rates(struct minstrel_ht_sta
*mi
, u16 index
,
472 int cur_group
, cur_idx
, cur_tp_avg
, cur_prob
;
473 int tmp_group
, tmp_idx
, tmp_tp_avg
, tmp_prob
;
474 int j
= MAX_THR_RATES
;
476 cur_group
= MI_RATE_GROUP(index
);
477 cur_idx
= MI_RATE_IDX(index
);
478 cur_prob
= mi
->groups
[cur_group
].rates
[cur_idx
].prob_avg
;
479 cur_tp_avg
= minstrel_ht_get_tp_avg(mi
, cur_group
, cur_idx
, cur_prob
);
482 tmp_group
= MI_RATE_GROUP(tp_list
[j
- 1]);
483 tmp_idx
= MI_RATE_IDX(tp_list
[j
- 1]);
484 tmp_prob
= mi
->groups
[tmp_group
].rates
[tmp_idx
].prob_avg
;
485 tmp_tp_avg
= minstrel_ht_get_tp_avg(mi
, tmp_group
, tmp_idx
,
487 if (cur_tp_avg
< tmp_tp_avg
||
488 (cur_tp_avg
== tmp_tp_avg
&& cur_prob
<= tmp_prob
))
493 if (j
< MAX_THR_RATES
- 1) {
494 memmove(&tp_list
[j
+ 1], &tp_list
[j
], (sizeof(*tp_list
) *
495 (MAX_THR_RATES
- (j
+ 1))));
497 if (j
< MAX_THR_RATES
)
502 * Find and set the topmost probability rate per sta and per group
505 minstrel_ht_set_best_prob_rate(struct minstrel_ht_sta
*mi
, u16
*dest
, u16 index
)
507 struct minstrel_mcs_group_data
*mg
;
508 struct minstrel_rate_stats
*mrs
;
509 int tmp_group
, tmp_idx
, tmp_tp_avg
, tmp_prob
;
510 int max_tp_group
, max_tp_idx
, max_tp_prob
;
511 int cur_tp_avg
, cur_group
, cur_idx
;
512 int max_gpr_group
, max_gpr_idx
;
513 int max_gpr_tp_avg
, max_gpr_prob
;
515 cur_group
= MI_RATE_GROUP(index
);
516 cur_idx
= MI_RATE_IDX(index
);
517 mg
= &mi
->groups
[cur_group
];
518 mrs
= &mg
->rates
[cur_idx
];
520 tmp_group
= MI_RATE_GROUP(*dest
);
521 tmp_idx
= MI_RATE_IDX(*dest
);
522 tmp_prob
= mi
->groups
[tmp_group
].rates
[tmp_idx
].prob_avg
;
523 tmp_tp_avg
= minstrel_ht_get_tp_avg(mi
, tmp_group
, tmp_idx
, tmp_prob
);
525 /* if max_tp_rate[0] is from MCS_GROUP max_prob_rate get selected from
526 * MCS_GROUP as well as CCK_GROUP rates do not allow aggregation */
527 max_tp_group
= MI_RATE_GROUP(mi
->max_tp_rate
[0]);
528 max_tp_idx
= MI_RATE_IDX(mi
->max_tp_rate
[0]);
529 max_tp_prob
= mi
->groups
[max_tp_group
].rates
[max_tp_idx
].prob_avg
;
531 if (minstrel_ht_is_legacy_group(MI_RATE_GROUP(index
)) &&
532 !minstrel_ht_is_legacy_group(max_tp_group
))
535 /* skip rates faster than max tp rate with lower prob */
536 if (minstrel_get_duration(mi
->max_tp_rate
[0]) > minstrel_get_duration(index
) &&
537 mrs
->prob_avg
< max_tp_prob
)
540 max_gpr_group
= MI_RATE_GROUP(mg
->max_group_prob_rate
);
541 max_gpr_idx
= MI_RATE_IDX(mg
->max_group_prob_rate
);
542 max_gpr_prob
= mi
->groups
[max_gpr_group
].rates
[max_gpr_idx
].prob_avg
;
544 if (mrs
->prob_avg
> MINSTREL_FRAC(75, 100)) {
545 cur_tp_avg
= minstrel_ht_get_tp_avg(mi
, cur_group
, cur_idx
,
547 if (cur_tp_avg
> tmp_tp_avg
)
550 max_gpr_tp_avg
= minstrel_ht_get_tp_avg(mi
, max_gpr_group
,
553 if (cur_tp_avg
> max_gpr_tp_avg
)
554 mg
->max_group_prob_rate
= index
;
556 if (mrs
->prob_avg
> tmp_prob
)
558 if (mrs
->prob_avg
> max_gpr_prob
)
559 mg
->max_group_prob_rate
= index
;
565 * Assign new rate set per sta and use CCK rates only if the fastest
566 * rate (max_tp_rate[0]) is from CCK group. This prohibits such sorted
567 * rate sets where MCS and CCK rates are mixed, because CCK rates can
568 * not use aggregation.
571 minstrel_ht_assign_best_tp_rates(struct minstrel_ht_sta
*mi
,
572 u16 tmp_mcs_tp_rate
[MAX_THR_RATES
],
573 u16 tmp_legacy_tp_rate
[MAX_THR_RATES
])
575 unsigned int tmp_group
, tmp_idx
, tmp_cck_tp
, tmp_mcs_tp
, tmp_prob
;
578 tmp_group
= MI_RATE_GROUP(tmp_legacy_tp_rate
[0]);
579 tmp_idx
= MI_RATE_IDX(tmp_legacy_tp_rate
[0]);
580 tmp_prob
= mi
->groups
[tmp_group
].rates
[tmp_idx
].prob_avg
;
581 tmp_cck_tp
= minstrel_ht_get_tp_avg(mi
, tmp_group
, tmp_idx
, tmp_prob
);
583 tmp_group
= MI_RATE_GROUP(tmp_mcs_tp_rate
[0]);
584 tmp_idx
= MI_RATE_IDX(tmp_mcs_tp_rate
[0]);
585 tmp_prob
= mi
->groups
[tmp_group
].rates
[tmp_idx
].prob_avg
;
586 tmp_mcs_tp
= minstrel_ht_get_tp_avg(mi
, tmp_group
, tmp_idx
, tmp_prob
);
588 if (tmp_cck_tp
> tmp_mcs_tp
) {
589 for(i
= 0; i
< MAX_THR_RATES
; i
++) {
590 minstrel_ht_sort_best_tp_rates(mi
, tmp_legacy_tp_rate
[i
],
598 * Try to increase robustness of max_prob rate by decrease number of
599 * streams if possible.
602 minstrel_ht_prob_rate_reduce_streams(struct minstrel_ht_sta
*mi
)
604 struct minstrel_mcs_group_data
*mg
;
605 int tmp_max_streams
, group
, tmp_idx
, tmp_prob
;
608 if (!mi
->sta
->ht_cap
.ht_supported
)
611 group
= MI_RATE_GROUP(mi
->max_tp_rate
[0]);
612 tmp_max_streams
= minstrel_mcs_groups
[group
].streams
;
613 for (group
= 0; group
< ARRAY_SIZE(minstrel_mcs_groups
); group
++) {
614 mg
= &mi
->groups
[group
];
615 if (!mi
->supported
[group
] || group
== MINSTREL_CCK_GROUP
)
618 tmp_idx
= MI_RATE_IDX(mg
->max_group_prob_rate
);
619 tmp_prob
= mi
->groups
[group
].rates
[tmp_idx
].prob_avg
;
621 if (tmp_tp
< minstrel_ht_get_tp_avg(mi
, group
, tmp_idx
, tmp_prob
) &&
622 (minstrel_mcs_groups
[group
].streams
< tmp_max_streams
)) {
623 mi
->max_prob_rate
= mg
->max_group_prob_rate
;
624 tmp_tp
= minstrel_ht_get_tp_avg(mi
, group
,
632 __minstrel_ht_get_sample_rate(struct minstrel_ht_sta
*mi
,
633 enum minstrel_sample_type type
)
635 u16
*rates
= mi
->sample
[type
].sample_rates
;
639 for (i
= 0; i
< MINSTREL_SAMPLE_RATES
; i
++) {
652 minstrel_ewma(int old
, int new, int weight
)
657 incr
= (EWMA_DIV
- weight
) * diff
/ EWMA_DIV
;
662 static inline int minstrel_filter_avg_add(u16
*prev_1
, u16
*prev_2
, s32 in
)
676 val
= MINSTREL_AVG_COEFF1
* in
;
677 val
+= MINSTREL_AVG_COEFF2
* out_1
;
678 val
+= MINSTREL_AVG_COEFF3
* out_2
;
679 val
>>= MINSTREL_SCALE
;
681 if (val
> 1 << MINSTREL_SCALE
)
682 val
= 1 << MINSTREL_SCALE
;
694 * Recalculate statistics and counters of a given rate
697 minstrel_ht_calc_rate_stats(struct minstrel_priv
*mp
,
698 struct minstrel_rate_stats
*mrs
)
700 unsigned int cur_prob
;
702 if (unlikely(mrs
->attempts
> 0)) {
703 cur_prob
= MINSTREL_FRAC(mrs
->success
, mrs
->attempts
);
704 minstrel_filter_avg_add(&mrs
->prob_avg
,
705 &mrs
->prob_avg_1
, cur_prob
);
706 mrs
->att_hist
+= mrs
->attempts
;
707 mrs
->succ_hist
+= mrs
->success
;
710 mrs
->last_success
= mrs
->success
;
711 mrs
->last_attempts
= mrs
->attempts
;
717 minstrel_ht_find_sample_rate(struct minstrel_ht_sta
*mi
, int type
, int idx
)
721 for (i
= 0; i
< MINSTREL_SAMPLE_RATES
; i
++) {
722 u16 cur
= mi
->sample
[type
].sample_rates
[i
];
735 minstrel_ht_move_sample_rates(struct minstrel_ht_sta
*mi
, int type
,
736 u32 fast_rate_dur
, u32 slow_rate_dur
)
738 u16
*rates
= mi
->sample
[type
].sample_rates
;
741 for (i
= 0, j
= 0; i
< MINSTREL_SAMPLE_RATES
; i
++) {
750 duration
= minstrel_get_duration(cur
);
752 case MINSTREL_SAMPLE_TYPE_SLOW
:
753 valid
= duration
> fast_rate_dur
&&
754 duration
< slow_rate_dur
;
756 case MINSTREL_SAMPLE_TYPE_INC
:
757 case MINSTREL_SAMPLE_TYPE_JUMP
:
758 valid
= duration
< fast_rate_dur
;
781 minstrel_ht_group_min_rate_offset(struct minstrel_ht_sta
*mi
, int group
,
784 u16 supported
= mi
->supported
[group
];
787 for (i
= 0; i
< MCS_GROUP_RATES
&& supported
; i
++, supported
>>= 1) {
788 if (!(supported
& BIT(0)))
791 if (minstrel_get_duration(MI_RATE(group
, i
)) >= max_duration
)
801 * Incremental update rates:
802 * Flip through groups and pick the first group rate that is faster than the
803 * highest currently selected rate
806 minstrel_ht_next_inc_rate(struct minstrel_ht_sta
*mi
, u32 fast_rate_dur
)
808 u8 type
= MINSTREL_SAMPLE_TYPE_INC
;
812 group
= mi
->sample
[type
].sample_group
;
813 for (i
= 0; i
< ARRAY_SIZE(minstrel_mcs_groups
); i
++) {
814 group
= (group
+ 1) % ARRAY_SIZE(minstrel_mcs_groups
);
816 index
= minstrel_ht_group_min_rate_offset(mi
, group
,
821 index
= MI_RATE(group
, index
& 0xf);
822 if (!minstrel_ht_find_sample_rate(mi
, type
, index
))
828 mi
->sample
[type
].sample_group
= group
;
834 minstrel_ht_next_group_sample_rate(struct minstrel_ht_sta
*mi
, int group
,
835 u16 supported
, int offset
)
837 struct minstrel_mcs_group_data
*mg
= &mi
->groups
[group
];
841 for (i
= 0; i
< MCS_GROUP_RATES
; i
++) {
842 idx
= sample_table
[mg
->column
][mg
->index
];
843 if (++mg
->index
>= MCS_GROUP_RATES
) {
845 if (++mg
->column
>= ARRAY_SIZE(sample_table
))
852 if (!(supported
& BIT(idx
)))
855 return MI_RATE(group
, idx
);
863 * Sample random rates, use those that are faster than the highest
864 * currently selected rate. Rates between the fastest and the slowest
865 * get sorted into the slow sample bucket, but only if it has room
868 minstrel_ht_next_jump_rate(struct minstrel_ht_sta
*mi
, u32 fast_rate_dur
,
869 u32 slow_rate_dur
, int *slow_rate_ofs
)
871 struct minstrel_rate_stats
*mrs
;
872 u32 max_duration
= slow_rate_dur
;
873 int i
, index
, offset
;
879 if (*slow_rate_ofs
>= MINSTREL_SAMPLE_RATES
)
880 max_duration
= fast_rate_dur
;
882 slow_rates
= mi
->sample
[MINSTREL_SAMPLE_TYPE_SLOW
].sample_rates
;
883 group
= mi
->sample
[MINSTREL_SAMPLE_TYPE_JUMP
].sample_group
;
884 for (i
= 0; i
< ARRAY_SIZE(minstrel_mcs_groups
); i
++) {
887 group
= (group
+ 1) % ARRAY_SIZE(minstrel_mcs_groups
);
889 supported
= mi
->supported
[group
];
893 offset
= minstrel_ht_group_min_rate_offset(mi
, group
,
898 index
= minstrel_ht_next_group_sample_rate(mi
, group
, supported
,
903 duration
= minstrel_get_duration(index
);
904 if (duration
< fast_rate_dur
)
905 type
= MINSTREL_SAMPLE_TYPE_JUMP
;
907 type
= MINSTREL_SAMPLE_TYPE_SLOW
;
909 if (minstrel_ht_find_sample_rate(mi
, type
, index
))
912 if (type
== MINSTREL_SAMPLE_TYPE_JUMP
)
915 if (*slow_rate_ofs
>= MINSTREL_SAMPLE_RATES
)
918 if (duration
>= slow_rate_dur
)
921 /* skip slow rates with high success probability */
922 mrs
= minstrel_get_ratestats(mi
, index
);
923 if (mrs
->prob_avg
> MINSTREL_FRAC(95, 100))
926 slow_rates
[(*slow_rate_ofs
)++] = index
;
927 if (*slow_rate_ofs
>= MINSTREL_SAMPLE_RATES
)
928 max_duration
= fast_rate_dur
;
933 mi
->sample
[MINSTREL_SAMPLE_TYPE_JUMP
].sample_group
= group
;
939 minstrel_ht_refill_sample_rates(struct minstrel_ht_sta
*mi
)
941 u32 prob_dur
= minstrel_get_duration(mi
->max_prob_rate
);
942 u32 tp_dur
= minstrel_get_duration(mi
->max_tp_rate
[0]);
943 u32 tp2_dur
= minstrel_get_duration(mi
->max_tp_rate
[1]);
944 u32 fast_rate_dur
= min(min(tp_dur
, tp2_dur
), prob_dur
);
945 u32 slow_rate_dur
= max(max(tp_dur
, tp2_dur
), prob_dur
);
949 rates
= mi
->sample
[MINSTREL_SAMPLE_TYPE_INC
].sample_rates
;
950 i
= minstrel_ht_move_sample_rates(mi
, MINSTREL_SAMPLE_TYPE_INC
,
951 fast_rate_dur
, slow_rate_dur
);
952 while (i
< MINSTREL_SAMPLE_RATES
) {
953 rates
[i
] = minstrel_ht_next_inc_rate(mi
, tp_dur
);
960 rates
= mi
->sample
[MINSTREL_SAMPLE_TYPE_JUMP
].sample_rates
;
961 i
= minstrel_ht_move_sample_rates(mi
, MINSTREL_SAMPLE_TYPE_JUMP
,
962 fast_rate_dur
, slow_rate_dur
);
963 j
= minstrel_ht_move_sample_rates(mi
, MINSTREL_SAMPLE_TYPE_SLOW
,
964 fast_rate_dur
, slow_rate_dur
);
965 while (i
< MINSTREL_SAMPLE_RATES
) {
966 rates
[i
] = minstrel_ht_next_jump_rate(mi
, fast_rate_dur
,
974 for (i
= 0; i
< ARRAY_SIZE(mi
->sample
); i
++)
975 memcpy(mi
->sample
[i
].cur_sample_rates
, mi
->sample
[i
].sample_rates
,
976 sizeof(mi
->sample
[i
].cur_sample_rates
));
981 * Update rate statistics and select new primary rates
983 * Rules for rate selection:
984 * - max_prob_rate must use only one stream, as a tradeoff between delivery
985 * probability and throughput during strong fluctuations
986 * - as long as the max prob rate has a probability of more than 75%, pick
987 * higher throughput rates, even if the probablity is a bit lower
990 minstrel_ht_update_stats(struct minstrel_priv
*mp
, struct minstrel_ht_sta
*mi
)
992 struct minstrel_mcs_group_data
*mg
;
993 struct minstrel_rate_stats
*mrs
;
994 int group
, i
, j
, cur_prob
;
995 u16 tmp_mcs_tp_rate
[MAX_THR_RATES
], tmp_group_tp_rate
[MAX_THR_RATES
];
996 u16 tmp_legacy_tp_rate
[MAX_THR_RATES
], tmp_max_prob_rate
;
998 bool ht_supported
= mi
->sta
->ht_cap
.ht_supported
;
1000 if (mi
->ampdu_packets
> 0) {
1001 if (!ieee80211_hw_check(mp
->hw
, TX_STATUS_NO_AMPDU_LEN
))
1002 mi
->avg_ampdu_len
= minstrel_ewma(mi
->avg_ampdu_len
,
1003 MINSTREL_FRAC(mi
->ampdu_len
, mi
->ampdu_packets
),
1006 mi
->avg_ampdu_len
= 0;
1008 mi
->ampdu_packets
= 0;
1011 if (mi
->supported
[MINSTREL_CCK_GROUP
])
1012 group
= MINSTREL_CCK_GROUP
;
1013 else if (mi
->supported
[MINSTREL_OFDM_GROUP
])
1014 group
= MINSTREL_OFDM_GROUP
;
1018 index
= MI_RATE(group
, 0);
1019 for (j
= 0; j
< ARRAY_SIZE(tmp_legacy_tp_rate
); j
++)
1020 tmp_legacy_tp_rate
[j
] = index
;
1022 if (mi
->supported
[MINSTREL_VHT_GROUP_0
])
1023 group
= MINSTREL_VHT_GROUP_0
;
1024 else if (ht_supported
)
1025 group
= MINSTREL_HT_GROUP_0
;
1026 else if (mi
->supported
[MINSTREL_CCK_GROUP
])
1027 group
= MINSTREL_CCK_GROUP
;
1029 group
= MINSTREL_OFDM_GROUP
;
1031 index
= MI_RATE(group
, 0);
1032 tmp_max_prob_rate
= index
;
1033 for (j
= 0; j
< ARRAY_SIZE(tmp_mcs_tp_rate
); j
++)
1034 tmp_mcs_tp_rate
[j
] = index
;
1036 /* Find best rate sets within all MCS groups*/
1037 for (group
= 0; group
< ARRAY_SIZE(minstrel_mcs_groups
); group
++) {
1038 u16
*tp_rate
= tmp_mcs_tp_rate
;
1041 mg
= &mi
->groups
[group
];
1042 if (!mi
->supported
[group
])
1045 /* (re)Initialize group rate indexes */
1046 for(j
= 0; j
< MAX_THR_RATES
; j
++)
1047 tmp_group_tp_rate
[j
] = MI_RATE(group
, 0);
1049 if (group
== MINSTREL_CCK_GROUP
&& ht_supported
)
1050 tp_rate
= tmp_legacy_tp_rate
;
1052 for (i
= MCS_GROUP_RATES
- 1; i
>= 0; i
--) {
1053 if (!(mi
->supported
[group
] & BIT(i
)))
1056 index
= MI_RATE(group
, i
);
1058 mrs
= &mg
->rates
[i
];
1059 mrs
->retry_updated
= false;
1060 minstrel_ht_calc_rate_stats(mp
, mrs
);
1063 last_prob
= max(last_prob
, mrs
->prob_avg
);
1065 mrs
->prob_avg
= max(last_prob
, mrs
->prob_avg
);
1066 cur_prob
= mrs
->prob_avg
;
1068 if (minstrel_ht_get_tp_avg(mi
, group
, i
, cur_prob
) == 0)
1071 /* Find max throughput rate set */
1072 minstrel_ht_sort_best_tp_rates(mi
, index
, tp_rate
);
1074 /* Find max throughput rate set within a group */
1075 minstrel_ht_sort_best_tp_rates(mi
, index
,
1079 memcpy(mg
->max_group_tp_rate
, tmp_group_tp_rate
,
1080 sizeof(mg
->max_group_tp_rate
));
1083 /* Assign new rate set per sta */
1084 minstrel_ht_assign_best_tp_rates(mi
, tmp_mcs_tp_rate
,
1085 tmp_legacy_tp_rate
);
1086 memcpy(mi
->max_tp_rate
, tmp_mcs_tp_rate
, sizeof(mi
->max_tp_rate
));
1088 for (group
= 0; group
< ARRAY_SIZE(minstrel_mcs_groups
); group
++) {
1089 if (!mi
->supported
[group
])
1092 mg
= &mi
->groups
[group
];
1093 mg
->max_group_prob_rate
= MI_RATE(group
, 0);
1095 for (i
= 0; i
< MCS_GROUP_RATES
; i
++) {
1096 if (!(mi
->supported
[group
] & BIT(i
)))
1099 index
= MI_RATE(group
, i
);
1101 /* Find max probability rate per group and global */
1102 minstrel_ht_set_best_prob_rate(mi
, &tmp_max_prob_rate
,
1107 mi
->max_prob_rate
= tmp_max_prob_rate
;
1109 /* Try to increase robustness of max_prob_rate*/
1110 minstrel_ht_prob_rate_reduce_streams(mi
);
1111 minstrel_ht_refill_sample_rates(mi
);
1113 #ifdef CONFIG_MAC80211_DEBUGFS
1114 /* use fixed index if set */
1115 if (mp
->fixed_rate_idx
!= -1) {
1116 for (i
= 0; i
< 4; i
++)
1117 mi
->max_tp_rate
[i
] = mp
->fixed_rate_idx
;
1118 mi
->max_prob_rate
= mp
->fixed_rate_idx
;
1122 /* Reset update timer */
1123 mi
->last_stats_update
= jiffies
;
1124 mi
->sample_time
= jiffies
;
1128 minstrel_ht_txstat_valid(struct minstrel_priv
*mp
, struct minstrel_ht_sta
*mi
,
1129 struct ieee80211_tx_rate
*rate
)
1139 if (rate
->flags
& IEEE80211_TX_RC_MCS
||
1140 rate
->flags
& IEEE80211_TX_RC_VHT_MCS
)
1143 for (i
= 0; i
< ARRAY_SIZE(mp
->cck_rates
); i
++)
1144 if (rate
->idx
== mp
->cck_rates
[i
])
1147 for (i
= 0; i
< ARRAY_SIZE(mp
->ofdm_rates
[0]); i
++)
1148 if (rate
->idx
== mp
->ofdm_rates
[mi
->band
][i
])
1155 minstrel_downgrade_rate(struct minstrel_ht_sta
*mi
, u16
*idx
, bool primary
)
1157 int group
, orig_group
;
1159 orig_group
= group
= MI_RATE_GROUP(*idx
);
1163 if (!mi
->supported
[group
])
1166 if (minstrel_mcs_groups
[group
].streams
>
1167 minstrel_mcs_groups
[orig_group
].streams
)
1171 *idx
= mi
->groups
[group
].max_group_tp_rate
[0];
1173 *idx
= mi
->groups
[group
].max_group_tp_rate
[1];
1179 minstrel_ht_tx_status(void *priv
, struct ieee80211_supported_band
*sband
,
1180 void *priv_sta
, struct ieee80211_tx_status
*st
)
1182 struct ieee80211_tx_info
*info
= st
->info
;
1183 struct minstrel_ht_sta
*mi
= priv_sta
;
1184 struct ieee80211_tx_rate
*ar
= info
->status
.rates
;
1185 struct minstrel_rate_stats
*rate
, *rate2
;
1186 struct minstrel_priv
*mp
= priv
;
1187 u32 update_interval
= mp
->update_interval
;
1188 bool last
, update
= false;
1191 /* Ignore packet that was sent with noAck flag */
1192 if (info
->flags
& IEEE80211_TX_CTL_NO_ACK
)
1195 /* This packet was aggregated but doesn't carry status info */
1196 if ((info
->flags
& IEEE80211_TX_CTL_AMPDU
) &&
1197 !(info
->flags
& IEEE80211_TX_STAT_AMPDU
))
1200 if (!(info
->flags
& IEEE80211_TX_STAT_AMPDU
)) {
1201 info
->status
.ampdu_ack_len
=
1202 (info
->flags
& IEEE80211_TX_STAT_ACK
? 1 : 0);
1203 info
->status
.ampdu_len
= 1;
1207 if (mi
->total_packets
>= ~0 - info
->status
.ampdu_len
) {
1208 mi
->total_packets
= 0;
1209 mi
->sample_packets
= 0;
1212 mi
->total_packets
+= info
->status
.ampdu_len
;
1213 if (info
->flags
& IEEE80211_TX_CTL_RATE_CTRL_PROBE
)
1214 mi
->sample_packets
+= info
->status
.ampdu_len
;
1216 mi
->ampdu_packets
++;
1217 mi
->ampdu_len
+= info
->status
.ampdu_len
;
1219 last
= !minstrel_ht_txstat_valid(mp
, mi
, &ar
[0]);
1220 for (i
= 0; !last
; i
++) {
1221 last
= (i
== IEEE80211_TX_MAX_RATES
- 1) ||
1222 !minstrel_ht_txstat_valid(mp
, mi
, &ar
[i
+ 1]);
1224 rate
= minstrel_ht_get_stats(mp
, mi
, &ar
[i
]);
1226 rate
->success
+= info
->status
.ampdu_ack_len
;
1228 rate
->attempts
+= ar
[i
].count
* info
->status
.ampdu_len
;
1231 if (mp
->hw
->max_rates
> 1) {
1233 * check for sudden death of spatial multiplexing,
1234 * downgrade to a lower number of streams if necessary.
1236 rate
= minstrel_get_ratestats(mi
, mi
->max_tp_rate
[0]);
1237 if (rate
->attempts
> 30 &&
1238 rate
->success
< rate
->attempts
/ 4) {
1239 minstrel_downgrade_rate(mi
, &mi
->max_tp_rate
[0], true);
1243 rate2
= minstrel_get_ratestats(mi
, mi
->max_tp_rate
[1]);
1244 if (rate2
->attempts
> 30 &&
1245 rate2
->success
< rate2
->attempts
/ 4) {
1246 minstrel_downgrade_rate(mi
, &mi
->max_tp_rate
[1], false);
1251 if (time_after(jiffies
, mi
->last_stats_update
+ update_interval
)) {
1253 minstrel_ht_update_stats(mp
, mi
);
1257 minstrel_ht_update_rates(mp
, mi
);
1261 minstrel_calc_retransmit(struct minstrel_priv
*mp
, struct minstrel_ht_sta
*mi
,
1264 struct minstrel_rate_stats
*mrs
;
1265 unsigned int tx_time
, tx_time_rtscts
, tx_time_data
;
1266 unsigned int cw
= mp
->cw_min
;
1267 unsigned int ctime
= 0;
1268 unsigned int t_slot
= 9; /* FIXME */
1269 unsigned int ampdu_len
= minstrel_ht_avg_ampdu_len(mi
);
1270 unsigned int overhead
= 0, overhead_rtscts
= 0;
1272 mrs
= minstrel_get_ratestats(mi
, index
);
1273 if (mrs
->prob_avg
< MINSTREL_FRAC(1, 10)) {
1274 mrs
->retry_count
= 1;
1275 mrs
->retry_count_rtscts
= 1;
1279 mrs
->retry_count
= 2;
1280 mrs
->retry_count_rtscts
= 2;
1281 mrs
->retry_updated
= true;
1283 tx_time_data
= minstrel_get_duration(index
) * ampdu_len
/ 1000;
1285 /* Contention time for first 2 tries */
1286 ctime
= (t_slot
* cw
) >> 1;
1287 cw
= min((cw
<< 1) | 1, mp
->cw_max
);
1288 ctime
+= (t_slot
* cw
) >> 1;
1289 cw
= min((cw
<< 1) | 1, mp
->cw_max
);
1291 if (minstrel_ht_is_legacy_group(MI_RATE_GROUP(index
))) {
1292 overhead
= mi
->overhead_legacy
;
1293 overhead_rtscts
= mi
->overhead_legacy_rtscts
;
1295 overhead
= mi
->overhead
;
1296 overhead_rtscts
= mi
->overhead_rtscts
;
1299 /* Total TX time for data and Contention after first 2 tries */
1300 tx_time
= ctime
+ 2 * (overhead
+ tx_time_data
);
1301 tx_time_rtscts
= ctime
+ 2 * (overhead_rtscts
+ tx_time_data
);
1303 /* See how many more tries we can fit inside segment size */
1305 /* Contention time for this try */
1306 ctime
= (t_slot
* cw
) >> 1;
1307 cw
= min((cw
<< 1) | 1, mp
->cw_max
);
1309 /* Total TX time after this try */
1310 tx_time
+= ctime
+ overhead
+ tx_time_data
;
1311 tx_time_rtscts
+= ctime
+ overhead_rtscts
+ tx_time_data
;
1313 if (tx_time_rtscts
< mp
->segment_size
)
1314 mrs
->retry_count_rtscts
++;
1315 } while ((tx_time
< mp
->segment_size
) &&
1316 (++mrs
->retry_count
< mp
->max_retry
));
1321 minstrel_ht_set_rate(struct minstrel_priv
*mp
, struct minstrel_ht_sta
*mi
,
1322 struct ieee80211_sta_rates
*ratetbl
, int offset
, int index
)
1324 int group_idx
= MI_RATE_GROUP(index
);
1325 const struct mcs_group
*group
= &minstrel_mcs_groups
[group_idx
];
1326 struct minstrel_rate_stats
*mrs
;
1328 u16 flags
= group
->flags
;
1330 mrs
= minstrel_get_ratestats(mi
, index
);
1331 if (!mrs
->retry_updated
)
1332 minstrel_calc_retransmit(mp
, mi
, index
);
1334 if (mrs
->prob_avg
< MINSTREL_FRAC(20, 100) || !mrs
->retry_count
) {
1335 ratetbl
->rate
[offset
].count
= 2;
1336 ratetbl
->rate
[offset
].count_rts
= 2;
1337 ratetbl
->rate
[offset
].count_cts
= 2;
1339 ratetbl
->rate
[offset
].count
= mrs
->retry_count
;
1340 ratetbl
->rate
[offset
].count_cts
= mrs
->retry_count
;
1341 ratetbl
->rate
[offset
].count_rts
= mrs
->retry_count_rtscts
;
1344 index
= MI_RATE_IDX(index
);
1345 if (group_idx
== MINSTREL_CCK_GROUP
)
1346 idx
= mp
->cck_rates
[index
% ARRAY_SIZE(mp
->cck_rates
)];
1347 else if (group_idx
== MINSTREL_OFDM_GROUP
)
1348 idx
= mp
->ofdm_rates
[mi
->band
][index
%
1349 ARRAY_SIZE(mp
->ofdm_rates
[0])];
1350 else if (flags
& IEEE80211_TX_RC_VHT_MCS
)
1351 idx
= ((group
->streams
- 1) << 4) |
1354 idx
= index
+ (group
->streams
- 1) * 8;
1356 /* enable RTS/CTS if needed:
1357 * - if station is in dynamic SMPS (and streams > 1)
1358 * - for fallback rates, to increase chances of getting through
1361 (mi
->sta
->smps_mode
== IEEE80211_SMPS_DYNAMIC
&&
1362 group
->streams
> 1)) {
1363 ratetbl
->rate
[offset
].count
= ratetbl
->rate
[offset
].count_rts
;
1364 flags
|= IEEE80211_TX_RC_USE_RTS_CTS
;
1367 ratetbl
->rate
[offset
].idx
= idx
;
1368 ratetbl
->rate
[offset
].flags
= flags
;
1372 minstrel_ht_get_prob_avg(struct minstrel_ht_sta
*mi
, int rate
)
1374 int group
= MI_RATE_GROUP(rate
);
1375 rate
= MI_RATE_IDX(rate
);
1376 return mi
->groups
[group
].rates
[rate
].prob_avg
;
1380 minstrel_ht_get_max_amsdu_len(struct minstrel_ht_sta
*mi
)
1382 int group
= MI_RATE_GROUP(mi
->max_prob_rate
);
1383 const struct mcs_group
*g
= &minstrel_mcs_groups
[group
];
1384 int rate
= MI_RATE_IDX(mi
->max_prob_rate
);
1385 unsigned int duration
;
1387 /* Disable A-MSDU if max_prob_rate is bad */
1388 if (mi
->groups
[group
].rates
[rate
].prob_avg
< MINSTREL_FRAC(50, 100))
1391 duration
= g
->duration
[rate
];
1392 duration
<<= g
->shift
;
1394 /* If the rate is slower than single-stream MCS1, make A-MSDU limit small */
1395 if (duration
> MCS_DURATION(1, 0, 52))
1399 * If the rate is slower than single-stream MCS4, limit A-MSDU to usual
1402 if (duration
> MCS_DURATION(1, 0, 104))
1406 * If the rate is slower than single-stream MCS7, or if the max throughput
1407 * rate success probability is less than 75%, limit A-MSDU to twice the usual
1410 if (duration
> MCS_DURATION(1, 0, 260) ||
1411 (minstrel_ht_get_prob_avg(mi
, mi
->max_tp_rate
[0]) <
1412 MINSTREL_FRAC(75, 100)))
1416 * HT A-MPDU limits maximum MPDU size under BA agreement to 4095 bytes.
1417 * Since aggregation sessions are started/stopped without txq flush, use
1418 * the limit here to avoid the complexity of having to de-aggregate
1419 * packets in the queue.
1421 if (!mi
->sta
->vht_cap
.vht_supported
)
1422 return IEEE80211_MAX_MPDU_LEN_HT_BA
;
1429 minstrel_ht_update_rates(struct minstrel_priv
*mp
, struct minstrel_ht_sta
*mi
)
1431 struct ieee80211_sta_rates
*rates
;
1434 rates
= kzalloc(sizeof(*rates
), GFP_ATOMIC
);
1438 /* Start with max_tp_rate[0] */
1439 minstrel_ht_set_rate(mp
, mi
, rates
, i
++, mi
->max_tp_rate
[0]);
1441 if (mp
->hw
->max_rates
>= 3) {
1442 /* At least 3 tx rates supported, use max_tp_rate[1] next */
1443 minstrel_ht_set_rate(mp
, mi
, rates
, i
++, mi
->max_tp_rate
[1]);
1446 if (mp
->hw
->max_rates
>= 2) {
1447 minstrel_ht_set_rate(mp
, mi
, rates
, i
++, mi
->max_prob_rate
);
1450 mi
->sta
->max_rc_amsdu_len
= minstrel_ht_get_max_amsdu_len(mi
);
1451 rates
->rate
[i
].idx
= -1;
1452 rate_control_set_rates(mp
->hw
, mi
->sta
, rates
);
1456 minstrel_ht_get_sample_rate(struct minstrel_priv
*mp
, struct minstrel_ht_sta
*mi
)
1460 if (mp
->hw
->max_rates
> 1) {
1461 seq
= mi
->sample_seq
;
1462 mi
->sample_seq
= (seq
+ 1) % ARRAY_SIZE(minstrel_sample_seq
);
1463 seq
= minstrel_sample_seq
[seq
];
1465 seq
= MINSTREL_SAMPLE_TYPE_INC
;
1468 return __minstrel_ht_get_sample_rate(mi
, seq
);
1472 minstrel_ht_get_rate(void *priv
, struct ieee80211_sta
*sta
, void *priv_sta
,
1473 struct ieee80211_tx_rate_control
*txrc
)
1475 const struct mcs_group
*sample_group
;
1476 struct ieee80211_tx_info
*info
= IEEE80211_SKB_CB(txrc
->skb
);
1477 struct ieee80211_tx_rate
*rate
= &info
->status
.rates
[0];
1478 struct minstrel_ht_sta
*mi
= priv_sta
;
1479 struct minstrel_priv
*mp
= priv
;
1482 info
->flags
|= mi
->tx_flags
;
1484 #ifdef CONFIG_MAC80211_DEBUGFS
1485 if (mp
->fixed_rate_idx
!= -1)
1489 /* Don't use EAPOL frames for sampling on non-mrr hw */
1490 if (mp
->hw
->max_rates
== 1 &&
1491 (info
->control
.flags
& IEEE80211_TX_CTRL_PORT_CTRL_PROTO
))
1494 if (time_is_after_jiffies(mi
->sample_time
))
1497 mi
->sample_time
= jiffies
+ MINSTREL_SAMPLE_INTERVAL
;
1498 sample_idx
= minstrel_ht_get_sample_rate(mp
, mi
);
1502 sample_group
= &minstrel_mcs_groups
[MI_RATE_GROUP(sample_idx
)];
1503 sample_idx
= MI_RATE_IDX(sample_idx
);
1505 if (sample_group
== &minstrel_mcs_groups
[MINSTREL_CCK_GROUP
] &&
1506 (sample_idx
>= 4) != txrc
->short_preamble
)
1509 info
->flags
|= IEEE80211_TX_CTL_RATE_CTRL_PROBE
;
1512 if (sample_group
== &minstrel_mcs_groups
[MINSTREL_CCK_GROUP
]) {
1513 int idx
= sample_idx
% ARRAY_SIZE(mp
->cck_rates
);
1514 rate
->idx
= mp
->cck_rates
[idx
];
1515 } else if (sample_group
== &minstrel_mcs_groups
[MINSTREL_OFDM_GROUP
]) {
1516 int idx
= sample_idx
% ARRAY_SIZE(mp
->ofdm_rates
[0]);
1517 rate
->idx
= mp
->ofdm_rates
[mi
->band
][idx
];
1518 } else if (sample_group
->flags
& IEEE80211_TX_RC_VHT_MCS
) {
1519 ieee80211_rate_set_vht(rate
, MI_RATE_IDX(sample_idx
),
1520 sample_group
->streams
);
1522 rate
->idx
= sample_idx
+ (sample_group
->streams
- 1) * 8;
1525 rate
->flags
= sample_group
->flags
;
1529 minstrel_ht_update_cck(struct minstrel_priv
*mp
, struct minstrel_ht_sta
*mi
,
1530 struct ieee80211_supported_band
*sband
,
1531 struct ieee80211_sta
*sta
)
1535 if (sband
->band
!= NL80211_BAND_2GHZ
)
1538 if (sta
->ht_cap
.ht_supported
&&
1539 !ieee80211_hw_check(mp
->hw
, SUPPORTS_HT_CCK_RATES
))
1542 for (i
= 0; i
< 4; i
++) {
1543 if (mp
->cck_rates
[i
] == 0xff ||
1544 !rate_supported(sta
, sband
->band
, mp
->cck_rates
[i
]))
1547 mi
->supported
[MINSTREL_CCK_GROUP
] |= BIT(i
);
1548 if (sband
->bitrates
[i
].flags
& IEEE80211_RATE_SHORT_PREAMBLE
)
1549 mi
->supported
[MINSTREL_CCK_GROUP
] |= BIT(i
+ 4);
1554 minstrel_ht_update_ofdm(struct minstrel_priv
*mp
, struct minstrel_ht_sta
*mi
,
1555 struct ieee80211_supported_band
*sband
,
1556 struct ieee80211_sta
*sta
)
1561 if (sta
->ht_cap
.ht_supported
)
1564 rates
= mp
->ofdm_rates
[sband
->band
];
1565 for (i
= 0; i
< ARRAY_SIZE(mp
->ofdm_rates
[0]); i
++) {
1566 if (rates
[i
] == 0xff ||
1567 !rate_supported(sta
, sband
->band
, rates
[i
]))
1570 mi
->supported
[MINSTREL_OFDM_GROUP
] |= BIT(i
);
1575 minstrel_ht_update_caps(void *priv
, struct ieee80211_supported_band
*sband
,
1576 struct cfg80211_chan_def
*chandef
,
1577 struct ieee80211_sta
*sta
, void *priv_sta
)
1579 struct minstrel_priv
*mp
= priv
;
1580 struct minstrel_ht_sta
*mi
= priv_sta
;
1581 struct ieee80211_mcs_info
*mcs
= &sta
->ht_cap
.mcs
;
1582 u16 ht_cap
= sta
->ht_cap
.cap
;
1583 struct ieee80211_sta_vht_cap
*vht_cap
= &sta
->vht_cap
;
1584 const struct ieee80211_rate
*ctl_rate
;
1587 int n_supported
= 0;
1592 BUILD_BUG_ON(ARRAY_SIZE(minstrel_mcs_groups
) != MINSTREL_GROUPS_NB
);
1594 if (vht_cap
->vht_supported
)
1595 use_vht
= vht_cap
->vht_mcs
.tx_mcs_map
!= cpu_to_le16(~0);
1599 memset(mi
, 0, sizeof(*mi
));
1602 mi
->band
= sband
->band
;
1603 mi
->last_stats_update
= jiffies
;
1605 ack_dur
= ieee80211_frame_duration(sband
->band
, 10, 60, 1, 1, 0);
1606 mi
->overhead
= ieee80211_frame_duration(sband
->band
, 0, 60, 1, 1, 0);
1607 mi
->overhead
+= ack_dur
;
1608 mi
->overhead_rtscts
= mi
->overhead
+ 2 * ack_dur
;
1610 ctl_rate
= &sband
->bitrates
[rate_lowest_index(sband
, sta
)];
1611 erp
= ctl_rate
->flags
& IEEE80211_RATE_ERP_G
;
1612 ack_dur
= ieee80211_frame_duration(sband
->band
, 10,
1613 ctl_rate
->bitrate
, erp
, 1,
1614 ieee80211_chandef_get_shift(chandef
));
1615 mi
->overhead_legacy
= ack_dur
;
1616 mi
->overhead_legacy_rtscts
= mi
->overhead_legacy
+ 2 * ack_dur
;
1618 mi
->avg_ampdu_len
= MINSTREL_FRAC(1, 1);
1621 stbc
= (ht_cap
& IEEE80211_HT_CAP_RX_STBC
) >>
1622 IEEE80211_HT_CAP_RX_STBC_SHIFT
;
1624 ldpc
= ht_cap
& IEEE80211_HT_CAP_LDPC_CODING
;
1626 stbc
= (vht_cap
->cap
& IEEE80211_VHT_CAP_RXSTBC_MASK
) >>
1627 IEEE80211_VHT_CAP_RXSTBC_SHIFT
;
1629 ldpc
= vht_cap
->cap
& IEEE80211_VHT_CAP_RXLDPC
;
1632 mi
->tx_flags
|= stbc
<< IEEE80211_TX_CTL_STBC_SHIFT
;
1634 mi
->tx_flags
|= IEEE80211_TX_CTL_LDPC
;
1636 for (i
= 0; i
< ARRAY_SIZE(mi
->groups
); i
++) {
1637 u32 gflags
= minstrel_mcs_groups
[i
].flags
;
1640 mi
->supported
[i
] = 0;
1641 if (minstrel_ht_is_legacy_group(i
))
1644 if (gflags
& IEEE80211_TX_RC_SHORT_GI
) {
1645 if (gflags
& IEEE80211_TX_RC_40_MHZ_WIDTH
) {
1646 if (!(ht_cap
& IEEE80211_HT_CAP_SGI_40
))
1649 if (!(ht_cap
& IEEE80211_HT_CAP_SGI_20
))
1654 if (gflags
& IEEE80211_TX_RC_40_MHZ_WIDTH
&&
1655 sta
->bandwidth
< IEEE80211_STA_RX_BW_40
)
1658 nss
= minstrel_mcs_groups
[i
].streams
;
1660 /* Mark MCS > 7 as unsupported if STA is in static SMPS mode */
1661 if (sta
->smps_mode
== IEEE80211_SMPS_STATIC
&& nss
> 1)
1665 if (gflags
& IEEE80211_TX_RC_MCS
) {
1666 if (use_vht
&& minstrel_vht_only
)
1669 mi
->supported
[i
] = mcs
->rx_mask
[nss
- 1];
1670 if (mi
->supported
[i
])
1676 if (!vht_cap
->vht_supported
||
1677 WARN_ON(!(gflags
& IEEE80211_TX_RC_VHT_MCS
)) ||
1678 WARN_ON(gflags
& IEEE80211_TX_RC_160_MHZ_WIDTH
))
1681 if (gflags
& IEEE80211_TX_RC_80_MHZ_WIDTH
) {
1682 if (sta
->bandwidth
< IEEE80211_STA_RX_BW_80
||
1683 ((gflags
& IEEE80211_TX_RC_SHORT_GI
) &&
1684 !(vht_cap
->cap
& IEEE80211_VHT_CAP_SHORT_GI_80
))) {
1689 if (gflags
& IEEE80211_TX_RC_40_MHZ_WIDTH
)
1691 else if (gflags
& IEEE80211_TX_RC_80_MHZ_WIDTH
)
1696 mi
->supported
[i
] = minstrel_get_valid_vht_rates(bw
, nss
,
1697 vht_cap
->vht_mcs
.tx_mcs_map
);
1699 if (mi
->supported
[i
])
1703 minstrel_ht_update_cck(mp
, mi
, sband
, sta
);
1704 minstrel_ht_update_ofdm(mp
, mi
, sband
, sta
);
1706 /* create an initial rate table with the lowest supported rates */
1707 minstrel_ht_update_stats(mp
, mi
);
1708 minstrel_ht_update_rates(mp
, mi
);
1712 minstrel_ht_rate_init(void *priv
, struct ieee80211_supported_band
*sband
,
1713 struct cfg80211_chan_def
*chandef
,
1714 struct ieee80211_sta
*sta
, void *priv_sta
)
1716 minstrel_ht_update_caps(priv
, sband
, chandef
, sta
, priv_sta
);
1720 minstrel_ht_rate_update(void *priv
, struct ieee80211_supported_band
*sband
,
1721 struct cfg80211_chan_def
*chandef
,
1722 struct ieee80211_sta
*sta
, void *priv_sta
,
1725 minstrel_ht_update_caps(priv
, sband
, chandef
, sta
, priv_sta
);
1729 minstrel_ht_alloc_sta(void *priv
, struct ieee80211_sta
*sta
, gfp_t gfp
)
1731 struct ieee80211_supported_band
*sband
;
1732 struct minstrel_ht_sta
*mi
;
1733 struct minstrel_priv
*mp
= priv
;
1734 struct ieee80211_hw
*hw
= mp
->hw
;
1738 for (i
= 0; i
< NUM_NL80211_BANDS
; i
++) {
1739 sband
= hw
->wiphy
->bands
[i
];
1740 if (sband
&& sband
->n_bitrates
> max_rates
)
1741 max_rates
= sband
->n_bitrates
;
1744 return kzalloc(sizeof(*mi
), gfp
);
1748 minstrel_ht_free_sta(void *priv
, struct ieee80211_sta
*sta
, void *priv_sta
)
1754 minstrel_ht_fill_rate_array(u8
*dest
, struct ieee80211_supported_band
*sband
,
1755 const s16
*bitrates
, int n_rates
, u32 rate_flags
)
1759 for (i
= 0; i
< sband
->n_bitrates
; i
++) {
1760 struct ieee80211_rate
*rate
= &sband
->bitrates
[i
];
1762 if ((rate_flags
& sband
->bitrates
[i
].flags
) != rate_flags
)
1765 for (j
= 0; j
< n_rates
; j
++) {
1766 if (rate
->bitrate
!= bitrates
[j
])
1776 minstrel_ht_init_cck_rates(struct minstrel_priv
*mp
)
1778 static const s16 bitrates
[4] = { 10, 20, 55, 110 };
1779 struct ieee80211_supported_band
*sband
;
1780 u32 rate_flags
= ieee80211_chandef_rate_flags(&mp
->hw
->conf
.chandef
);
1782 memset(mp
->cck_rates
, 0xff, sizeof(mp
->cck_rates
));
1783 sband
= mp
->hw
->wiphy
->bands
[NL80211_BAND_2GHZ
];
1787 BUILD_BUG_ON(ARRAY_SIZE(mp
->cck_rates
) != ARRAY_SIZE(bitrates
));
1788 minstrel_ht_fill_rate_array(mp
->cck_rates
, sband
,
1789 minstrel_cck_bitrates
,
1790 ARRAY_SIZE(minstrel_cck_bitrates
),
1795 minstrel_ht_init_ofdm_rates(struct minstrel_priv
*mp
, enum nl80211_band band
)
1797 static const s16 bitrates
[8] = { 60, 90, 120, 180, 240, 360, 480, 540 };
1798 struct ieee80211_supported_band
*sband
;
1799 u32 rate_flags
= ieee80211_chandef_rate_flags(&mp
->hw
->conf
.chandef
);
1801 memset(mp
->ofdm_rates
[band
], 0xff, sizeof(mp
->ofdm_rates
[band
]));
1802 sband
= mp
->hw
->wiphy
->bands
[band
];
1806 BUILD_BUG_ON(ARRAY_SIZE(mp
->ofdm_rates
[band
]) != ARRAY_SIZE(bitrates
));
1807 minstrel_ht_fill_rate_array(mp
->ofdm_rates
[band
], sband
,
1808 minstrel_ofdm_bitrates
,
1809 ARRAY_SIZE(minstrel_ofdm_bitrates
),
1814 minstrel_ht_alloc(struct ieee80211_hw
*hw
)
1816 struct minstrel_priv
*mp
;
1819 mp
= kzalloc(sizeof(struct minstrel_priv
), GFP_ATOMIC
);
1823 /* contention window settings
1824 * Just an approximation. Using the per-queue values would complicate
1825 * the calculations and is probably unnecessary */
1829 /* maximum time that the hw is allowed to stay in one MRR segment */
1830 mp
->segment_size
= 6000;
1832 if (hw
->max_rate_tries
> 0)
1833 mp
->max_retry
= hw
->max_rate_tries
;
1835 /* safe default, does not necessarily have to match hw properties */
1838 if (hw
->max_rates
>= 4)
1842 mp
->update_interval
= HZ
/ 20;
1844 minstrel_ht_init_cck_rates(mp
);
1845 for (i
= 0; i
< ARRAY_SIZE(mp
->hw
->wiphy
->bands
); i
++)
1846 minstrel_ht_init_ofdm_rates(mp
, i
);
1851 #ifdef CONFIG_MAC80211_DEBUGFS
1852 static void minstrel_ht_add_debugfs(struct ieee80211_hw
*hw
, void *priv
,
1853 struct dentry
*debugfsdir
)
1855 struct minstrel_priv
*mp
= priv
;
1857 mp
->fixed_rate_idx
= (u32
) -1;
1858 debugfs_create_u32("fixed_rate_idx", S_IRUGO
| S_IWUGO
, debugfsdir
,
1859 &mp
->fixed_rate_idx
);
1864 minstrel_ht_free(void *priv
)
1869 static u32
minstrel_ht_get_expected_throughput(void *priv_sta
)
1871 struct minstrel_ht_sta
*mi
= priv_sta
;
1872 int i
, j
, prob
, tp_avg
;
1874 i
= MI_RATE_GROUP(mi
->max_tp_rate
[0]);
1875 j
= MI_RATE_IDX(mi
->max_tp_rate
[0]);
1876 prob
= mi
->groups
[i
].rates
[j
].prob_avg
;
1878 /* convert tp_avg from pkt per second in kbps */
1879 tp_avg
= minstrel_ht_get_tp_avg(mi
, i
, j
, prob
) * 10;
1880 tp_avg
= tp_avg
* AVG_PKT_SIZE
* 8 / 1024;
1885 static const struct rate_control_ops mac80211_minstrel_ht
= {
1886 .name
= "minstrel_ht",
1887 .capa
= RATE_CTRL_CAPA_AMPDU_TRIGGER
,
1888 .tx_status_ext
= minstrel_ht_tx_status
,
1889 .get_rate
= minstrel_ht_get_rate
,
1890 .rate_init
= minstrel_ht_rate_init
,
1891 .rate_update
= minstrel_ht_rate_update
,
1892 .alloc_sta
= minstrel_ht_alloc_sta
,
1893 .free_sta
= minstrel_ht_free_sta
,
1894 .alloc
= minstrel_ht_alloc
,
1895 .free
= minstrel_ht_free
,
1896 #ifdef CONFIG_MAC80211_DEBUGFS
1897 .add_debugfs
= minstrel_ht_add_debugfs
,
1898 .add_sta_debugfs
= minstrel_ht_add_sta_debugfs
,
1900 .get_expected_throughput
= minstrel_ht_get_expected_throughput
,
1904 static void __init
init_sample_table(void)
1906 int col
, i
, new_idx
;
1907 u8 rnd
[MCS_GROUP_RATES
];
1909 memset(sample_table
, 0xff, sizeof(sample_table
));
1910 for (col
= 0; col
< SAMPLE_COLUMNS
; col
++) {
1911 prandom_bytes(rnd
, sizeof(rnd
));
1912 for (i
= 0; i
< MCS_GROUP_RATES
; i
++) {
1913 new_idx
= (i
+ rnd
[i
]) % MCS_GROUP_RATES
;
1914 while (sample_table
[col
][new_idx
] != 0xff)
1915 new_idx
= (new_idx
+ 1) % MCS_GROUP_RATES
;
1917 sample_table
[col
][new_idx
] = i
;
1923 rc80211_minstrel_init(void)
1925 init_sample_table();
1926 return ieee80211_rate_control_register(&mac80211_minstrel_ht
);
1930 rc80211_minstrel_exit(void)
1932 ieee80211_rate_control_unregister(&mac80211_minstrel_ht
);