2 * Copyright (C) 2010-2013 Felix Fietkau <nbd@openwrt.org>
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License version 2 as
6 * published by the Free Software Foundation.
8 #include <linux/netdevice.h>
9 #include <linux/types.h>
10 #include <linux/skbuff.h>
11 #include <linux/debugfs.h>
12 #include <linux/random.h>
13 #include <linux/moduleparam.h>
14 #include <linux/ieee80211.h>
15 #include <net/mac80211.h>
17 #include "rc80211_minstrel.h"
18 #include "rc80211_minstrel_ht.h"
20 #define AVG_PKT_SIZE 1200
22 /* Number of bits for an average sized packet */
23 #define MCS_NBITS (AVG_PKT_SIZE << 3)
25 /* Number of symbols for a packet with (bps) bits per symbol */
26 #define MCS_NSYMS(bps) DIV_ROUND_UP(MCS_NBITS, (bps))
28 /* Transmission time (nanoseconds) for a packet containing (syms) symbols */
29 #define MCS_SYMBOL_TIME(sgi, syms) \
31 ((syms) * 18000 + 4000) / 5 : /* syms * 3.6 us */ \
32 ((syms) * 1000) << 2 /* syms * 4 us */ \
35 /* Transmit duration for the raw data part of an average sized packet */
36 #define MCS_DURATION(streams, sgi, bps) MCS_SYMBOL_TIME(sgi, MCS_NSYMS((streams) * (bps)))
43 * Define group sort order: HT40 -> SGI -> #streams
45 #define GROUP_IDX(_streams, _sgi, _ht40) \
46 MINSTREL_HT_GROUP_0 + \
47 MINSTREL_MAX_STREAMS * 2 * _ht40 + \
48 MINSTREL_MAX_STREAMS * _sgi + \
51 /* MCS rate information for an MCS group */
52 #define MCS_GROUP(_streams, _sgi, _ht40) \
53 [GROUP_IDX(_streams, _sgi, _ht40)] = { \
54 .streams = _streams, \
56 IEEE80211_TX_RC_MCS | \
57 (_sgi ? IEEE80211_TX_RC_SHORT_GI : 0) | \
58 (_ht40 ? IEEE80211_TX_RC_40_MHZ_WIDTH : 0), \
60 MCS_DURATION(_streams, _sgi, _ht40 ? 54 : 26), \
61 MCS_DURATION(_streams, _sgi, _ht40 ? 108 : 52), \
62 MCS_DURATION(_streams, _sgi, _ht40 ? 162 : 78), \
63 MCS_DURATION(_streams, _sgi, _ht40 ? 216 : 104), \
64 MCS_DURATION(_streams, _sgi, _ht40 ? 324 : 156), \
65 MCS_DURATION(_streams, _sgi, _ht40 ? 432 : 208), \
66 MCS_DURATION(_streams, _sgi, _ht40 ? 486 : 234), \
67 MCS_DURATION(_streams, _sgi, _ht40 ? 540 : 260) \
71 #define VHT_GROUP_IDX(_streams, _sgi, _bw) \
72 (MINSTREL_VHT_GROUP_0 + \
73 MINSTREL_MAX_STREAMS * 2 * (_bw) + \
74 MINSTREL_MAX_STREAMS * (_sgi) + \
77 #define BW2VBPS(_bw, r3, r2, r1) \
78 (_bw == BW_80 ? r3 : _bw == BW_40 ? r2 : r1)
80 #define VHT_GROUP(_streams, _sgi, _bw) \
81 [VHT_GROUP_IDX(_streams, _sgi, _bw)] = { \
82 .streams = _streams, \
84 IEEE80211_TX_RC_VHT_MCS | \
85 (_sgi ? IEEE80211_TX_RC_SHORT_GI : 0) | \
86 (_bw == BW_80 ? IEEE80211_TX_RC_80_MHZ_WIDTH : \
87 _bw == BW_40 ? IEEE80211_TX_RC_40_MHZ_WIDTH : 0), \
89 MCS_DURATION(_streams, _sgi, \
90 BW2VBPS(_bw, 117, 54, 26)), \
91 MCS_DURATION(_streams, _sgi, \
92 BW2VBPS(_bw, 234, 108, 52)), \
93 MCS_DURATION(_streams, _sgi, \
94 BW2VBPS(_bw, 351, 162, 78)), \
95 MCS_DURATION(_streams, _sgi, \
96 BW2VBPS(_bw, 468, 216, 104)), \
97 MCS_DURATION(_streams, _sgi, \
98 BW2VBPS(_bw, 702, 324, 156)), \
99 MCS_DURATION(_streams, _sgi, \
100 BW2VBPS(_bw, 936, 432, 208)), \
101 MCS_DURATION(_streams, _sgi, \
102 BW2VBPS(_bw, 1053, 486, 234)), \
103 MCS_DURATION(_streams, _sgi, \
104 BW2VBPS(_bw, 1170, 540, 260)), \
105 MCS_DURATION(_streams, _sgi, \
106 BW2VBPS(_bw, 1404, 648, 312)), \
107 MCS_DURATION(_streams, _sgi, \
108 BW2VBPS(_bw, 1560, 720, 346)) \
112 #define CCK_DURATION(_bitrate, _short, _len) \
113 (1000 * (10 /* SIFS */ + \
114 (_short ? 72 + 24 : 144 + 48) + \
115 (8 * (_len + 4) * 10) / (_bitrate)))
117 #define CCK_ACK_DURATION(_bitrate, _short) \
118 (CCK_DURATION((_bitrate > 10 ? 20 : 10), false, 60) + \
119 CCK_DURATION(_bitrate, _short, AVG_PKT_SIZE))
121 #define CCK_DURATION_LIST(_short) \
122 CCK_ACK_DURATION(10, _short), \
123 CCK_ACK_DURATION(20, _short), \
124 CCK_ACK_DURATION(55, _short), \
125 CCK_ACK_DURATION(110, _short)
128 [MINSTREL_CCK_GROUP] = { \
132 CCK_DURATION_LIST(false), \
133 CCK_DURATION_LIST(true) \
137 #ifdef CONFIG_MAC80211_RC_MINSTREL_VHT
138 static bool minstrel_vht_only
= true;
139 module_param(minstrel_vht_only
, bool, 0644);
140 MODULE_PARM_DESC(minstrel_vht_only
,
141 "Use only VHT rates when VHT is supported by sta.");
145 * To enable sufficiently targeted rate sampling, MCS rates are divided into
146 * groups, based on the number of streams and flags (HT40, SGI) that they
149 * Sortorder has to be fixed for GROUP_IDX macro to be applicable:
150 * BW -> SGI -> #streams
152 const struct mcs_group minstrel_mcs_groups
[] = {
153 MCS_GROUP(1, 0, BW_20
),
154 MCS_GROUP(2, 0, BW_20
),
155 #if MINSTREL_MAX_STREAMS >= 3
156 MCS_GROUP(3, 0, BW_20
),
159 MCS_GROUP(1, 1, BW_20
),
160 MCS_GROUP(2, 1, BW_20
),
161 #if MINSTREL_MAX_STREAMS >= 3
162 MCS_GROUP(3, 1, BW_20
),
165 MCS_GROUP(1, 0, BW_40
),
166 MCS_GROUP(2, 0, BW_40
),
167 #if MINSTREL_MAX_STREAMS >= 3
168 MCS_GROUP(3, 0, BW_40
),
171 MCS_GROUP(1, 1, BW_40
),
172 MCS_GROUP(2, 1, BW_40
),
173 #if MINSTREL_MAX_STREAMS >= 3
174 MCS_GROUP(3, 1, BW_40
),
179 #ifdef CONFIG_MAC80211_RC_MINSTREL_VHT
180 VHT_GROUP(1, 0, BW_20
),
181 VHT_GROUP(2, 0, BW_20
),
182 #if MINSTREL_MAX_STREAMS >= 3
183 VHT_GROUP(3, 0, BW_20
),
186 VHT_GROUP(1, 1, BW_20
),
187 VHT_GROUP(2, 1, BW_20
),
188 #if MINSTREL_MAX_STREAMS >= 3
189 VHT_GROUP(3, 1, BW_20
),
192 VHT_GROUP(1, 0, BW_40
),
193 VHT_GROUP(2, 0, BW_40
),
194 #if MINSTREL_MAX_STREAMS >= 3
195 VHT_GROUP(3, 0, BW_40
),
198 VHT_GROUP(1, 1, BW_40
),
199 VHT_GROUP(2, 1, BW_40
),
200 #if MINSTREL_MAX_STREAMS >= 3
201 VHT_GROUP(3, 1, BW_40
),
204 VHT_GROUP(1, 0, BW_80
),
205 VHT_GROUP(2, 0, BW_80
),
206 #if MINSTREL_MAX_STREAMS >= 3
207 VHT_GROUP(3, 0, BW_80
),
210 VHT_GROUP(1, 1, BW_80
),
211 VHT_GROUP(2, 1, BW_80
),
212 #if MINSTREL_MAX_STREAMS >= 3
213 VHT_GROUP(3, 1, BW_80
),
218 static u8 sample_table
[SAMPLE_COLUMNS
][MCS_GROUP_RATES
] __read_mostly
;
221 minstrel_ht_update_rates(struct minstrel_priv
*mp
, struct minstrel_ht_sta
*mi
);
224 * Some VHT MCSes are invalid (when Ndbps / Nes is not an integer)
225 * e.g for MCS9@20MHzx1Nss: Ndbps=8x52*(5/6) Nes=1
227 * Returns the valid mcs map for struct minstrel_mcs_group_data.supported
230 minstrel_get_valid_vht_rates(int bw
, int nss
, __le16 mcs_map
)
235 if (nss
!= 3 && nss
!= 6)
237 } else if (bw
== BW_80
) {
238 if (nss
== 3 || nss
== 7)
243 WARN_ON(bw
!= BW_40
);
246 switch ((le16_to_cpu(mcs_map
) >> (2 * (nss
- 1))) & 3) {
247 case IEEE80211_VHT_MCS_SUPPORT_0_7
:
250 case IEEE80211_VHT_MCS_SUPPORT_0_8
:
253 case IEEE80211_VHT_MCS_SUPPORT_0_9
:
259 return 0x3ff & ~mask
;
263 * Look up an MCS group index based on mac80211 rate information
266 minstrel_ht_get_group_idx(struct ieee80211_tx_rate
*rate
)
268 return GROUP_IDX((rate
->idx
/ 8) + 1,
269 !!(rate
->flags
& IEEE80211_TX_RC_SHORT_GI
),
270 !!(rate
->flags
& IEEE80211_TX_RC_40_MHZ_WIDTH
));
274 minstrel_vht_get_group_idx(struct ieee80211_tx_rate
*rate
)
276 return VHT_GROUP_IDX(ieee80211_rate_get_vht_nss(rate
),
277 !!(rate
->flags
& IEEE80211_TX_RC_SHORT_GI
),
278 !!(rate
->flags
& IEEE80211_TX_RC_40_MHZ_WIDTH
) +
279 2*!!(rate
->flags
& IEEE80211_TX_RC_80_MHZ_WIDTH
));
282 static struct minstrel_rate_stats
*
283 minstrel_ht_get_stats(struct minstrel_priv
*mp
, struct minstrel_ht_sta
*mi
,
284 struct ieee80211_tx_rate
*rate
)
288 if (rate
->flags
& IEEE80211_TX_RC_MCS
) {
289 group
= minstrel_ht_get_group_idx(rate
);
291 } else if (rate
->flags
& IEEE80211_TX_RC_VHT_MCS
) {
292 group
= minstrel_vht_get_group_idx(rate
);
293 idx
= ieee80211_rate_get_vht_mcs(rate
);
295 group
= MINSTREL_CCK_GROUP
;
297 for (idx
= 0; idx
< ARRAY_SIZE(mp
->cck_rates
); idx
++)
298 if (rate
->idx
== mp
->cck_rates
[idx
])
302 if (!(mi
->groups
[group
].supported
& BIT(idx
)))
305 return &mi
->groups
[group
].rates
[idx
];
308 static inline struct minstrel_rate_stats
*
309 minstrel_get_ratestats(struct minstrel_ht_sta
*mi
, int index
)
311 return &mi
->groups
[index
/ MCS_GROUP_RATES
].rates
[index
% MCS_GROUP_RATES
];
316 * Recalculate success probabilities and counters for a rate using EWMA
319 minstrel_calc_rate_ewma(struct minstrel_rate_stats
*mr
)
321 if (unlikely(mr
->attempts
> 0)) {
322 mr
->sample_skipped
= 0;
323 mr
->cur_prob
= MINSTREL_FRAC(mr
->success
, mr
->attempts
);
325 mr
->probability
= mr
->cur_prob
;
327 mr
->probability
= minstrel_ewma(mr
->probability
,
328 mr
->cur_prob
, EWMA_LEVEL
);
329 mr
->att_hist
+= mr
->attempts
;
330 mr
->succ_hist
+= mr
->success
;
332 mr
->sample_skipped
++;
334 mr
->last_success
= mr
->success
;
335 mr
->last_attempts
= mr
->attempts
;
341 * Calculate throughput based on the average A-MPDU length, taking into account
342 * the expected number of retransmissions and their expected length
345 minstrel_ht_calc_tp(struct minstrel_ht_sta
*mi
, int group
, int rate
)
347 struct minstrel_rate_stats
*mr
;
348 unsigned int nsecs
= 0;
352 mr
= &mi
->groups
[group
].rates
[rate
];
353 prob
= mr
->probability
;
355 if (prob
< MINSTREL_FRAC(1, 10)) {
361 * For the throughput calculation, limit the probability value to 90% to
362 * account for collision related packet error rate fluctuation
364 if (prob
> MINSTREL_FRAC(9, 10))
365 prob
= MINSTREL_FRAC(9, 10);
367 if (group
!= MINSTREL_CCK_GROUP
)
368 nsecs
= 1000 * mi
->overhead
/ MINSTREL_TRUNC(mi
->avg_ampdu_len
);
370 nsecs
+= minstrel_mcs_groups
[group
].duration
[rate
];
372 /* prob is scaled - see MINSTREL_FRAC above */
373 tp
= 1000000 * ((prob
* 1000) / nsecs
);
374 mr
->cur_tp
= MINSTREL_TRUNC(tp
);
378 * Find & sort topmost throughput rates
380 * If multiple rates provide equal throughput the sorting is based on their
381 * current success probability. Higher success probability is preferred among
382 * MCS groups, CCK rates do not provide aggregation and are therefore at last.
385 minstrel_ht_sort_best_tp_rates(struct minstrel_ht_sta
*mi
, u16 index
,
388 int cur_group
, cur_idx
, cur_thr
, cur_prob
;
389 int tmp_group
, tmp_idx
, tmp_thr
, tmp_prob
;
390 int j
= MAX_THR_RATES
;
392 cur_group
= index
/ MCS_GROUP_RATES
;
393 cur_idx
= index
% MCS_GROUP_RATES
;
394 cur_thr
= mi
->groups
[cur_group
].rates
[cur_idx
].cur_tp
;
395 cur_prob
= mi
->groups
[cur_group
].rates
[cur_idx
].probability
;
397 tmp_group
= tp_list
[j
- 1] / MCS_GROUP_RATES
;
398 tmp_idx
= tp_list
[j
- 1] % MCS_GROUP_RATES
;
399 tmp_thr
= mi
->groups
[tmp_group
].rates
[tmp_idx
].cur_tp
;
400 tmp_prob
= mi
->groups
[tmp_group
].rates
[tmp_idx
].probability
;
402 while (j
> 0 && (cur_thr
> tmp_thr
||
403 (cur_thr
== tmp_thr
&& cur_prob
> tmp_prob
))) {
405 tmp_group
= tp_list
[j
- 1] / MCS_GROUP_RATES
;
406 tmp_idx
= tp_list
[j
- 1] % MCS_GROUP_RATES
;
407 tmp_thr
= mi
->groups
[tmp_group
].rates
[tmp_idx
].cur_tp
;
408 tmp_prob
= mi
->groups
[tmp_group
].rates
[tmp_idx
].probability
;
411 if (j
< MAX_THR_RATES
- 1) {
412 memmove(&tp_list
[j
+ 1], &tp_list
[j
], (sizeof(*tp_list
) *
413 (MAX_THR_RATES
- (j
+ 1))));
415 if (j
< MAX_THR_RATES
)
420 * Find and set the topmost probability rate per sta and per group
423 minstrel_ht_set_best_prob_rate(struct minstrel_ht_sta
*mi
, u16 index
)
425 struct minstrel_mcs_group_data
*mg
;
426 struct minstrel_rate_stats
*mr
;
427 int tmp_group
, tmp_idx
, tmp_tp
, tmp_prob
, max_tp_group
;
429 mg
= &mi
->groups
[index
/ MCS_GROUP_RATES
];
430 mr
= &mg
->rates
[index
% MCS_GROUP_RATES
];
432 tmp_group
= mi
->max_prob_rate
/ MCS_GROUP_RATES
;
433 tmp_idx
= mi
->max_prob_rate
% MCS_GROUP_RATES
;
434 tmp_tp
= mi
->groups
[tmp_group
].rates
[tmp_idx
].cur_tp
;
435 tmp_prob
= mi
->groups
[tmp_group
].rates
[tmp_idx
].probability
;
437 /* if max_tp_rate[0] is from MCS_GROUP max_prob_rate get selected from
438 * MCS_GROUP as well as CCK_GROUP rates do not allow aggregation */
439 max_tp_group
= mi
->max_tp_rate
[0] / MCS_GROUP_RATES
;
440 if((index
/ MCS_GROUP_RATES
== MINSTREL_CCK_GROUP
) &&
441 (max_tp_group
!= MINSTREL_CCK_GROUP
))
444 if (mr
->probability
> MINSTREL_FRAC(75, 100)) {
445 if (mr
->cur_tp
> tmp_tp
)
446 mi
->max_prob_rate
= index
;
447 if (mr
->cur_tp
> mg
->rates
[mg
->max_group_prob_rate
].cur_tp
)
448 mg
->max_group_prob_rate
= index
;
450 if (mr
->probability
> tmp_prob
)
451 mi
->max_prob_rate
= index
;
452 if (mr
->probability
> mg
->rates
[mg
->max_group_prob_rate
].probability
)
453 mg
->max_group_prob_rate
= index
;
459 * Assign new rate set per sta and use CCK rates only if the fastest
460 * rate (max_tp_rate[0]) is from CCK group. This prohibits such sorted
461 * rate sets where MCS and CCK rates are mixed, because CCK rates can
462 * not use aggregation.
465 minstrel_ht_assign_best_tp_rates(struct minstrel_ht_sta
*mi
,
466 u16 tmp_mcs_tp_rate
[MAX_THR_RATES
],
467 u16 tmp_cck_tp_rate
[MAX_THR_RATES
])
469 unsigned int tmp_group
, tmp_idx
, tmp_cck_tp
, tmp_mcs_tp
;
472 tmp_group
= tmp_cck_tp_rate
[0] / MCS_GROUP_RATES
;
473 tmp_idx
= tmp_cck_tp_rate
[0] % MCS_GROUP_RATES
;
474 tmp_cck_tp
= mi
->groups
[tmp_group
].rates
[tmp_idx
].cur_tp
;
476 tmp_group
= tmp_mcs_tp_rate
[0] / MCS_GROUP_RATES
;
477 tmp_idx
= tmp_mcs_tp_rate
[0] % MCS_GROUP_RATES
;
478 tmp_mcs_tp
= mi
->groups
[tmp_group
].rates
[tmp_idx
].cur_tp
;
480 if (tmp_cck_tp
> tmp_mcs_tp
) {
481 for(i
= 0; i
< MAX_THR_RATES
; i
++) {
482 minstrel_ht_sort_best_tp_rates(mi
, tmp_cck_tp_rate
[i
],
490 * Try to increase robustness of max_prob rate by decrease number of
491 * streams if possible.
494 minstrel_ht_prob_rate_reduce_streams(struct minstrel_ht_sta
*mi
)
496 struct minstrel_mcs_group_data
*mg
;
497 struct minstrel_rate_stats
*mr
;
498 int tmp_max_streams
, group
;
501 tmp_max_streams
= minstrel_mcs_groups
[mi
->max_tp_rate
[0] /
502 MCS_GROUP_RATES
].streams
;
503 for (group
= 0; group
< ARRAY_SIZE(minstrel_mcs_groups
); group
++) {
504 mg
= &mi
->groups
[group
];
505 if (!mg
->supported
|| group
== MINSTREL_CCK_GROUP
)
507 mr
= minstrel_get_ratestats(mi
, mg
->max_group_prob_rate
);
508 if (tmp_tp
< mr
->cur_tp
&&
509 (minstrel_mcs_groups
[group
].streams
< tmp_max_streams
)) {
510 mi
->max_prob_rate
= mg
->max_group_prob_rate
;
517 * Update rate statistics and select new primary rates
519 * Rules for rate selection:
520 * - max_prob_rate must use only one stream, as a tradeoff between delivery
521 * probability and throughput during strong fluctuations
522 * - as long as the max prob rate has a probability of more than 75%, pick
523 * higher throughput rates, even if the probablity is a bit lower
526 minstrel_ht_update_stats(struct minstrel_priv
*mp
, struct minstrel_ht_sta
*mi
)
528 struct minstrel_mcs_group_data
*mg
;
529 struct minstrel_rate_stats
*mr
;
531 u16 tmp_mcs_tp_rate
[MAX_THR_RATES
], tmp_group_tp_rate
[MAX_THR_RATES
];
532 u16 tmp_cck_tp_rate
[MAX_THR_RATES
], index
;
534 if (mi
->ampdu_packets
> 0) {
535 mi
->avg_ampdu_len
= minstrel_ewma(mi
->avg_ampdu_len
,
536 MINSTREL_FRAC(mi
->ampdu_len
, mi
->ampdu_packets
), EWMA_LEVEL
);
538 mi
->ampdu_packets
= 0;
542 mi
->sample_count
= 0;
544 /* Initialize global rate indexes */
545 for(j
= 0; j
< MAX_THR_RATES
; j
++){
546 tmp_mcs_tp_rate
[j
] = 0;
547 tmp_cck_tp_rate
[j
] = 0;
550 /* Find best rate sets within all MCS groups*/
551 for (group
= 0; group
< ARRAY_SIZE(minstrel_mcs_groups
); group
++) {
553 mg
= &mi
->groups
[group
];
559 /* (re)Initialize group rate indexes */
560 for(j
= 0; j
< MAX_THR_RATES
; j
++)
561 tmp_group_tp_rate
[j
] = group
;
563 for (i
= 0; i
< MCS_GROUP_RATES
; i
++) {
564 if (!(mg
->supported
& BIT(i
)))
567 index
= MCS_GROUP_RATES
* group
+ i
;
570 mr
->retry_updated
= false;
571 minstrel_calc_rate_ewma(mr
);
572 minstrel_ht_calc_tp(mi
, group
, i
);
577 /* Find max throughput rate set */
578 if (group
!= MINSTREL_CCK_GROUP
) {
579 minstrel_ht_sort_best_tp_rates(mi
, index
,
581 } else if (group
== MINSTREL_CCK_GROUP
) {
582 minstrel_ht_sort_best_tp_rates(mi
, index
,
586 /* Find max throughput rate set within a group */
587 minstrel_ht_sort_best_tp_rates(mi
, index
,
590 /* Find max probability rate per group and global */
591 minstrel_ht_set_best_prob_rate(mi
, index
);
594 memcpy(mg
->max_group_tp_rate
, tmp_group_tp_rate
,
595 sizeof(mg
->max_group_tp_rate
));
598 /* Assign new rate set per sta */
599 minstrel_ht_assign_best_tp_rates(mi
, tmp_mcs_tp_rate
, tmp_cck_tp_rate
);
600 memcpy(mi
->max_tp_rate
, tmp_mcs_tp_rate
, sizeof(mi
->max_tp_rate
));
602 /* Try to increase robustness of max_prob_rate*/
603 minstrel_ht_prob_rate_reduce_streams(mi
);
605 /* try to sample all available rates during each interval */
606 mi
->sample_count
*= 8;
608 #ifdef CONFIG_MAC80211_DEBUGFS
609 /* use fixed index if set */
610 if (mp
->fixed_rate_idx
!= -1) {
611 for (i
= 0; i
< 4; i
++)
612 mi
->max_tp_rate
[i
] = mp
->fixed_rate_idx
;
613 mi
->max_prob_rate
= mp
->fixed_rate_idx
;
617 /* Reset update timer */
618 mi
->stats_update
= jiffies
;
622 minstrel_ht_txstat_valid(struct minstrel_priv
*mp
, struct ieee80211_tx_rate
*rate
)
630 if (rate
->flags
& IEEE80211_TX_RC_MCS
||
631 rate
->flags
& IEEE80211_TX_RC_VHT_MCS
)
634 return rate
->idx
== mp
->cck_rates
[0] ||
635 rate
->idx
== mp
->cck_rates
[1] ||
636 rate
->idx
== mp
->cck_rates
[2] ||
637 rate
->idx
== mp
->cck_rates
[3];
641 minstrel_next_sample_idx(struct minstrel_ht_sta
*mi
)
643 struct minstrel_mcs_group_data
*mg
;
647 mi
->sample_group
%= ARRAY_SIZE(minstrel_mcs_groups
);
648 mg
= &mi
->groups
[mi
->sample_group
];
653 if (++mg
->index
>= MCS_GROUP_RATES
) {
655 if (++mg
->column
>= ARRAY_SIZE(sample_table
))
663 minstrel_downgrade_rate(struct minstrel_ht_sta
*mi
, u16
*idx
, bool primary
)
665 int group
, orig_group
;
667 orig_group
= group
= *idx
/ MCS_GROUP_RATES
;
671 if (!mi
->groups
[group
].supported
)
674 if (minstrel_mcs_groups
[group
].streams
>
675 minstrel_mcs_groups
[orig_group
].streams
)
679 *idx
= mi
->groups
[group
].max_group_tp_rate
[0];
681 *idx
= mi
->groups
[group
].max_group_tp_rate
[1];
687 minstrel_aggr_check(struct ieee80211_sta
*pubsta
, struct sk_buff
*skb
)
689 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*) skb
->data
;
690 struct sta_info
*sta
= container_of(pubsta
, struct sta_info
, sta
);
693 if (unlikely(!ieee80211_is_data_qos(hdr
->frame_control
)))
696 if (unlikely(skb
->protocol
== cpu_to_be16(ETH_P_PAE
)))
699 tid
= *ieee80211_get_qos_ctl(hdr
) & IEEE80211_QOS_CTL_TID_MASK
;
700 if (likely(sta
->ampdu_mlme
.tid_tx
[tid
]))
703 if (skb_get_queue_mapping(skb
) == IEEE80211_AC_VO
)
706 ieee80211_start_tx_ba_session(pubsta
, tid
, 5000);
710 minstrel_ht_tx_status(void *priv
, struct ieee80211_supported_band
*sband
,
711 struct ieee80211_sta
*sta
, void *priv_sta
,
714 struct minstrel_ht_sta_priv
*msp
= priv_sta
;
715 struct minstrel_ht_sta
*mi
= &msp
->ht
;
716 struct ieee80211_tx_info
*info
= IEEE80211_SKB_CB(skb
);
717 struct ieee80211_tx_rate
*ar
= info
->status
.rates
;
718 struct minstrel_rate_stats
*rate
, *rate2
;
719 struct minstrel_priv
*mp
= priv
;
720 bool last
, update
= false;
724 return mac80211_minstrel
.tx_status(priv
, sband
, sta
, &msp
->legacy
, skb
);
726 /* This packet was aggregated but doesn't carry status info */
727 if ((info
->flags
& IEEE80211_TX_CTL_AMPDU
) &&
728 !(info
->flags
& IEEE80211_TX_STAT_AMPDU
))
731 if (!(info
->flags
& IEEE80211_TX_STAT_AMPDU
)) {
732 info
->status
.ampdu_ack_len
=
733 (info
->flags
& IEEE80211_TX_STAT_ACK
? 1 : 0);
734 info
->status
.ampdu_len
= 1;
738 mi
->ampdu_len
+= info
->status
.ampdu_len
;
740 if (!mi
->sample_wait
&& !mi
->sample_tries
&& mi
->sample_count
> 0) {
741 mi
->sample_wait
= 16 + 2 * MINSTREL_TRUNC(mi
->avg_ampdu_len
);
742 mi
->sample_tries
= 1;
746 if (info
->flags
& IEEE80211_TX_CTL_RATE_CTRL_PROBE
)
747 mi
->sample_packets
+= info
->status
.ampdu_len
;
749 last
= !minstrel_ht_txstat_valid(mp
, &ar
[0]);
750 for (i
= 0; !last
; i
++) {
751 last
= (i
== IEEE80211_TX_MAX_RATES
- 1) ||
752 !minstrel_ht_txstat_valid(mp
, &ar
[i
+ 1]);
754 rate
= minstrel_ht_get_stats(mp
, mi
, &ar
[i
]);
757 rate
->success
+= info
->status
.ampdu_ack_len
;
759 rate
->attempts
+= ar
[i
].count
* info
->status
.ampdu_len
;
763 * check for sudden death of spatial multiplexing,
764 * downgrade to a lower number of streams if necessary.
766 rate
= minstrel_get_ratestats(mi
, mi
->max_tp_rate
[0]);
767 if (rate
->attempts
> 30 &&
768 MINSTREL_FRAC(rate
->success
, rate
->attempts
) <
769 MINSTREL_FRAC(20, 100)) {
770 minstrel_downgrade_rate(mi
, &mi
->max_tp_rate
[0], true);
774 rate2
= minstrel_get_ratestats(mi
, mi
->max_tp_rate
[1]);
775 if (rate2
->attempts
> 30 &&
776 MINSTREL_FRAC(rate2
->success
, rate2
->attempts
) <
777 MINSTREL_FRAC(20, 100)) {
778 minstrel_downgrade_rate(mi
, &mi
->max_tp_rate
[1], false);
782 if (time_after(jiffies
, mi
->stats_update
+ (mp
->update_interval
/ 2 * HZ
) / 1000)) {
784 minstrel_ht_update_stats(mp
, mi
);
785 if (!(info
->flags
& IEEE80211_TX_CTL_AMPDU
) &&
786 mi
->max_prob_rate
/ MCS_GROUP_RATES
!= MINSTREL_CCK_GROUP
)
787 minstrel_aggr_check(sta
, skb
);
791 minstrel_ht_update_rates(mp
, mi
);
795 minstrel_calc_retransmit(struct minstrel_priv
*mp
, struct minstrel_ht_sta
*mi
,
798 struct minstrel_rate_stats
*mr
;
799 const struct mcs_group
*group
;
800 unsigned int tx_time
, tx_time_rtscts
, tx_time_data
;
801 unsigned int cw
= mp
->cw_min
;
802 unsigned int ctime
= 0;
803 unsigned int t_slot
= 9; /* FIXME */
804 unsigned int ampdu_len
= MINSTREL_TRUNC(mi
->avg_ampdu_len
);
805 unsigned int overhead
= 0, overhead_rtscts
= 0;
807 mr
= minstrel_get_ratestats(mi
, index
);
808 if (mr
->probability
< MINSTREL_FRAC(1, 10)) {
810 mr
->retry_count_rtscts
= 1;
815 mr
->retry_count_rtscts
= 2;
816 mr
->retry_updated
= true;
818 group
= &minstrel_mcs_groups
[index
/ MCS_GROUP_RATES
];
819 tx_time_data
= group
->duration
[index
% MCS_GROUP_RATES
] * ampdu_len
/ 1000;
821 /* Contention time for first 2 tries */
822 ctime
= (t_slot
* cw
) >> 1;
823 cw
= min((cw
<< 1) | 1, mp
->cw_max
);
824 ctime
+= (t_slot
* cw
) >> 1;
825 cw
= min((cw
<< 1) | 1, mp
->cw_max
);
827 if (index
/ MCS_GROUP_RATES
!= MINSTREL_CCK_GROUP
) {
828 overhead
= mi
->overhead
;
829 overhead_rtscts
= mi
->overhead_rtscts
;
832 /* Total TX time for data and Contention after first 2 tries */
833 tx_time
= ctime
+ 2 * (overhead
+ tx_time_data
);
834 tx_time_rtscts
= ctime
+ 2 * (overhead_rtscts
+ tx_time_data
);
836 /* See how many more tries we can fit inside segment size */
838 /* Contention time for this try */
839 ctime
= (t_slot
* cw
) >> 1;
840 cw
= min((cw
<< 1) | 1, mp
->cw_max
);
842 /* Total TX time after this try */
843 tx_time
+= ctime
+ overhead
+ tx_time_data
;
844 tx_time_rtscts
+= ctime
+ overhead_rtscts
+ tx_time_data
;
846 if (tx_time_rtscts
< mp
->segment_size
)
847 mr
->retry_count_rtscts
++;
848 } while ((tx_time
< mp
->segment_size
) &&
849 (++mr
->retry_count
< mp
->max_retry
));
854 minstrel_ht_set_rate(struct minstrel_priv
*mp
, struct minstrel_ht_sta
*mi
,
855 struct ieee80211_sta_rates
*ratetbl
, int offset
, int index
)
857 const struct mcs_group
*group
= &minstrel_mcs_groups
[index
/ MCS_GROUP_RATES
];
858 struct minstrel_rate_stats
*mr
;
860 u16 flags
= group
->flags
;
862 mr
= minstrel_get_ratestats(mi
, index
);
863 if (!mr
->retry_updated
)
864 minstrel_calc_retransmit(mp
, mi
, index
);
866 if (mr
->probability
< MINSTREL_FRAC(20, 100) || !mr
->retry_count
) {
867 ratetbl
->rate
[offset
].count
= 2;
868 ratetbl
->rate
[offset
].count_rts
= 2;
869 ratetbl
->rate
[offset
].count_cts
= 2;
871 ratetbl
->rate
[offset
].count
= mr
->retry_count
;
872 ratetbl
->rate
[offset
].count_cts
= mr
->retry_count
;
873 ratetbl
->rate
[offset
].count_rts
= mr
->retry_count_rtscts
;
876 if (index
/ MCS_GROUP_RATES
== MINSTREL_CCK_GROUP
)
877 idx
= mp
->cck_rates
[index
% ARRAY_SIZE(mp
->cck_rates
)];
878 else if (flags
& IEEE80211_TX_RC_VHT_MCS
)
879 idx
= ((group
->streams
- 1) << 4) |
880 ((index
% MCS_GROUP_RATES
) & 0xF);
882 idx
= index
% MCS_GROUP_RATES
+ (group
->streams
- 1) * 8;
885 ratetbl
->rate
[offset
].count
= ratetbl
->rate
[offset
].count_rts
;
886 flags
|= IEEE80211_TX_RC_USE_RTS_CTS
;
889 ratetbl
->rate
[offset
].idx
= idx
;
890 ratetbl
->rate
[offset
].flags
= flags
;
894 minstrel_ht_update_rates(struct minstrel_priv
*mp
, struct minstrel_ht_sta
*mi
)
896 struct ieee80211_sta_rates
*rates
;
899 rates
= kzalloc(sizeof(*rates
), GFP_ATOMIC
);
903 /* Start with max_tp_rate[0] */
904 minstrel_ht_set_rate(mp
, mi
, rates
, i
++, mi
->max_tp_rate
[0]);
906 if (mp
->hw
->max_rates
>= 3) {
907 /* At least 3 tx rates supported, use max_tp_rate[1] next */
908 minstrel_ht_set_rate(mp
, mi
, rates
, i
++, mi
->max_tp_rate
[1]);
911 if (mp
->hw
->max_rates
>= 2) {
913 * At least 2 tx rates supported, use max_prob_rate next */
914 minstrel_ht_set_rate(mp
, mi
, rates
, i
++, mi
->max_prob_rate
);
917 rates
->rate
[i
].idx
= -1;
918 rate_control_set_rates(mp
->hw
, mi
->sta
, rates
);
922 minstrel_get_duration(int index
)
924 const struct mcs_group
*group
= &minstrel_mcs_groups
[index
/ MCS_GROUP_RATES
];
925 return group
->duration
[index
% MCS_GROUP_RATES
];
929 minstrel_get_sample_rate(struct minstrel_priv
*mp
, struct minstrel_ht_sta
*mi
)
931 struct minstrel_rate_stats
*mr
;
932 struct minstrel_mcs_group_data
*mg
;
933 unsigned int sample_dur
, sample_group
, cur_max_tp_streams
;
936 if (mi
->sample_wait
> 0) {
941 if (!mi
->sample_tries
)
944 sample_group
= mi
->sample_group
;
945 mg
= &mi
->groups
[sample_group
];
946 sample_idx
= sample_table
[mg
->column
][mg
->index
];
947 minstrel_next_sample_idx(mi
);
949 if (!(mg
->supported
& BIT(sample_idx
)))
952 mr
= &mg
->rates
[sample_idx
];
953 sample_idx
+= sample_group
* MCS_GROUP_RATES
;
956 * Sampling might add some overhead (RTS, no aggregation)
957 * to the frame. Hence, don't use sampling for the currently
960 if (sample_idx
== mi
->max_tp_rate
[0] ||
961 sample_idx
== mi
->max_tp_rate
[1] ||
962 sample_idx
== mi
->max_prob_rate
)
966 * Do not sample if the probability is already higher than 95%
967 * to avoid wasting airtime.
969 if (mr
->probability
> MINSTREL_FRAC(95, 100))
973 * Make sure that lower rates get sampled only occasionally,
974 * if the link is working perfectly.
977 cur_max_tp_streams
= minstrel_mcs_groups
[mi
->max_tp_rate
[0] /
978 MCS_GROUP_RATES
].streams
;
979 sample_dur
= minstrel_get_duration(sample_idx
);
980 if (sample_dur
>= minstrel_get_duration(mi
->max_tp_rate
[1]) &&
981 (cur_max_tp_streams
- 1 <
982 minstrel_mcs_groups
[sample_group
].streams
||
983 sample_dur
>= minstrel_get_duration(mi
->max_prob_rate
))) {
984 if (mr
->sample_skipped
< 20)
987 if (mi
->sample_slow
++ > 2)
996 minstrel_ht_check_cck_shortpreamble(struct minstrel_priv
*mp
,
997 struct minstrel_ht_sta
*mi
, bool val
)
999 u8 supported
= mi
->groups
[MINSTREL_CCK_GROUP
].supported
;
1001 if (!supported
|| !mi
->cck_supported_short
)
1004 if (supported
& (mi
->cck_supported_short
<< (val
* 4)))
1007 supported
^= mi
->cck_supported_short
| (mi
->cck_supported_short
<< 4);
1008 mi
->groups
[MINSTREL_CCK_GROUP
].supported
= supported
;
1012 minstrel_ht_get_rate(void *priv
, struct ieee80211_sta
*sta
, void *priv_sta
,
1013 struct ieee80211_tx_rate_control
*txrc
)
1015 const struct mcs_group
*sample_group
;
1016 struct ieee80211_tx_info
*info
= IEEE80211_SKB_CB(txrc
->skb
);
1017 struct ieee80211_tx_rate
*rate
= &info
->status
.rates
[0];
1018 struct minstrel_ht_sta_priv
*msp
= priv_sta
;
1019 struct minstrel_ht_sta
*mi
= &msp
->ht
;
1020 struct minstrel_priv
*mp
= priv
;
1023 if (rate_control_send_low(sta
, priv_sta
, txrc
))
1027 return mac80211_minstrel
.get_rate(priv
, sta
, &msp
->legacy
, txrc
);
1029 info
->flags
|= mi
->tx_flags
;
1030 minstrel_ht_check_cck_shortpreamble(mp
, mi
, txrc
->short_preamble
);
1032 #ifdef CONFIG_MAC80211_DEBUGFS
1033 if (mp
->fixed_rate_idx
!= -1)
1037 /* Don't use EAPOL frames for sampling on non-mrr hw */
1038 if (mp
->hw
->max_rates
== 1 &&
1039 (info
->control
.flags
& IEEE80211_TX_CTRL_PORT_CTRL_PROTO
))
1042 sample_idx
= minstrel_get_sample_rate(mp
, mi
);
1044 mi
->total_packets
++;
1047 if (mi
->total_packets
== ~0) {
1048 mi
->total_packets
= 0;
1049 mi
->sample_packets
= 0;
1055 sample_group
= &minstrel_mcs_groups
[sample_idx
/ MCS_GROUP_RATES
];
1056 info
->flags
|= IEEE80211_TX_CTL_RATE_CTRL_PROBE
;
1059 if (sample_idx
/ MCS_GROUP_RATES
== MINSTREL_CCK_GROUP
) {
1060 int idx
= sample_idx
% ARRAY_SIZE(mp
->cck_rates
);
1061 rate
->idx
= mp
->cck_rates
[idx
];
1062 } else if (sample_group
->flags
& IEEE80211_TX_RC_VHT_MCS
) {
1063 ieee80211_rate_set_vht(rate
, sample_idx
% MCS_GROUP_RATES
,
1064 sample_group
->streams
);
1066 rate
->idx
= sample_idx
% MCS_GROUP_RATES
+
1067 (sample_group
->streams
- 1) * 8;
1070 rate
->flags
= sample_group
->flags
;
1074 minstrel_ht_update_cck(struct minstrel_priv
*mp
, struct minstrel_ht_sta
*mi
,
1075 struct ieee80211_supported_band
*sband
,
1076 struct ieee80211_sta
*sta
)
1080 if (sband
->band
!= IEEE80211_BAND_2GHZ
)
1083 if (!(mp
->hw
->flags
& IEEE80211_HW_SUPPORTS_HT_CCK_RATES
))
1086 mi
->cck_supported
= 0;
1087 mi
->cck_supported_short
= 0;
1088 for (i
= 0; i
< 4; i
++) {
1089 if (!rate_supported(sta
, sband
->band
, mp
->cck_rates
[i
]))
1092 mi
->cck_supported
|= BIT(i
);
1093 if (sband
->bitrates
[i
].flags
& IEEE80211_RATE_SHORT_PREAMBLE
)
1094 mi
->cck_supported_short
|= BIT(i
);
1097 mi
->groups
[MINSTREL_CCK_GROUP
].supported
= mi
->cck_supported
;
1101 minstrel_ht_update_caps(void *priv
, struct ieee80211_supported_band
*sband
,
1102 struct cfg80211_chan_def
*chandef
,
1103 struct ieee80211_sta
*sta
, void *priv_sta
)
1105 struct minstrel_priv
*mp
= priv
;
1106 struct minstrel_ht_sta_priv
*msp
= priv_sta
;
1107 struct minstrel_ht_sta
*mi
= &msp
->ht
;
1108 struct ieee80211_mcs_info
*mcs
= &sta
->ht_cap
.mcs
;
1109 u16 sta_cap
= sta
->ht_cap
.cap
;
1110 struct ieee80211_sta_vht_cap
*vht_cap
= &sta
->vht_cap
;
1112 int n_supported
= 0;
1117 /* fall back to the old minstrel for legacy stations */
1118 if (!sta
->ht_cap
.ht_supported
)
1121 BUILD_BUG_ON(ARRAY_SIZE(minstrel_mcs_groups
) != MINSTREL_GROUPS_NB
);
1123 #ifdef CONFIG_MAC80211_RC_MINSTREL_VHT
1124 if (vht_cap
->vht_supported
)
1125 use_vht
= vht_cap
->vht_mcs
.tx_mcs_map
!= cpu_to_le16(~0);
1131 memset(mi
, 0, sizeof(*mi
));
1134 mi
->stats_update
= jiffies
;
1136 ack_dur
= ieee80211_frame_duration(sband
->band
, 10, 60, 1, 1, 0);
1137 mi
->overhead
= ieee80211_frame_duration(sband
->band
, 0, 60, 1, 1, 0);
1138 mi
->overhead
+= ack_dur
;
1139 mi
->overhead_rtscts
= mi
->overhead
+ 2 * ack_dur
;
1141 mi
->avg_ampdu_len
= MINSTREL_FRAC(1, 1);
1143 /* When using MRR, sample more on the first attempt, without delay */
1145 mi
->sample_count
= 16;
1146 mi
->sample_wait
= 0;
1148 mi
->sample_count
= 8;
1149 mi
->sample_wait
= 8;
1151 mi
->sample_tries
= 4;
1153 /* TODO tx_flags for vht - ATM the RC API is not fine-grained enough */
1155 stbc
= (sta_cap
& IEEE80211_HT_CAP_RX_STBC
) >>
1156 IEEE80211_HT_CAP_RX_STBC_SHIFT
;
1157 mi
->tx_flags
|= stbc
<< IEEE80211_TX_CTL_STBC_SHIFT
;
1159 if (sta_cap
& IEEE80211_HT_CAP_LDPC_CODING
)
1160 mi
->tx_flags
|= IEEE80211_TX_CTL_LDPC
;
1163 for (i
= 0; i
< ARRAY_SIZE(mi
->groups
); i
++) {
1164 u32 gflags
= minstrel_mcs_groups
[i
].flags
;
1167 mi
->groups
[i
].supported
= 0;
1168 if (i
== MINSTREL_CCK_GROUP
) {
1169 minstrel_ht_update_cck(mp
, mi
, sband
, sta
);
1173 if (gflags
& IEEE80211_TX_RC_SHORT_GI
) {
1174 if (gflags
& IEEE80211_TX_RC_40_MHZ_WIDTH
) {
1175 if (!(sta_cap
& IEEE80211_HT_CAP_SGI_40
))
1178 if (!(sta_cap
& IEEE80211_HT_CAP_SGI_20
))
1183 if (gflags
& IEEE80211_TX_RC_40_MHZ_WIDTH
&&
1184 sta
->bandwidth
< IEEE80211_STA_RX_BW_40
)
1187 nss
= minstrel_mcs_groups
[i
].streams
;
1189 /* Mark MCS > 7 as unsupported if STA is in static SMPS mode */
1190 if (sta
->smps_mode
== IEEE80211_SMPS_STATIC
&& nss
> 1)
1194 if (gflags
& IEEE80211_TX_RC_MCS
) {
1195 #ifdef CONFIG_MAC80211_RC_MINSTREL_VHT
1196 if (use_vht
&& minstrel_vht_only
)
1199 mi
->groups
[i
].supported
= mcs
->rx_mask
[nss
- 1];
1200 if (mi
->groups
[i
].supported
)
1206 if (!vht_cap
->vht_supported
||
1207 WARN_ON(!(gflags
& IEEE80211_TX_RC_VHT_MCS
)) ||
1208 WARN_ON(gflags
& IEEE80211_TX_RC_160_MHZ_WIDTH
))
1211 if (gflags
& IEEE80211_TX_RC_80_MHZ_WIDTH
) {
1212 if (sta
->bandwidth
< IEEE80211_STA_RX_BW_80
||
1213 ((gflags
& IEEE80211_TX_RC_SHORT_GI
) &&
1214 !(vht_cap
->cap
& IEEE80211_VHT_CAP_SHORT_GI_80
))) {
1219 if (gflags
& IEEE80211_TX_RC_40_MHZ_WIDTH
)
1221 else if (gflags
& IEEE80211_TX_RC_80_MHZ_WIDTH
)
1226 mi
->groups
[i
].supported
= minstrel_get_valid_vht_rates(bw
, nss
,
1227 vht_cap
->vht_mcs
.tx_mcs_map
);
1229 if (mi
->groups
[i
].supported
)
1236 /* create an initial rate table with the lowest supported rates */
1237 minstrel_ht_update_stats(mp
, mi
);
1238 minstrel_ht_update_rates(mp
, mi
);
1244 memset(&msp
->legacy
, 0, sizeof(msp
->legacy
));
1245 msp
->legacy
.r
= msp
->ratelist
;
1246 msp
->legacy
.sample_table
= msp
->sample_table
;
1247 return mac80211_minstrel
.rate_init(priv
, sband
, chandef
, sta
,
1252 minstrel_ht_rate_init(void *priv
, struct ieee80211_supported_band
*sband
,
1253 struct cfg80211_chan_def
*chandef
,
1254 struct ieee80211_sta
*sta
, void *priv_sta
)
1256 minstrel_ht_update_caps(priv
, sband
, chandef
, sta
, priv_sta
);
1260 minstrel_ht_rate_update(void *priv
, struct ieee80211_supported_band
*sband
,
1261 struct cfg80211_chan_def
*chandef
,
1262 struct ieee80211_sta
*sta
, void *priv_sta
,
1265 minstrel_ht_update_caps(priv
, sband
, chandef
, sta
, priv_sta
);
1269 minstrel_ht_alloc_sta(void *priv
, struct ieee80211_sta
*sta
, gfp_t gfp
)
1271 struct ieee80211_supported_band
*sband
;
1272 struct minstrel_ht_sta_priv
*msp
;
1273 struct minstrel_priv
*mp
= priv
;
1274 struct ieee80211_hw
*hw
= mp
->hw
;
1278 for (i
= 0; i
< IEEE80211_NUM_BANDS
; i
++) {
1279 sband
= hw
->wiphy
->bands
[i
];
1280 if (sband
&& sband
->n_bitrates
> max_rates
)
1281 max_rates
= sband
->n_bitrates
;
1284 msp
= kzalloc(sizeof(*msp
), gfp
);
1288 msp
->ratelist
= kzalloc(sizeof(struct minstrel_rate
) * max_rates
, gfp
);
1292 msp
->sample_table
= kmalloc(SAMPLE_COLUMNS
* max_rates
, gfp
);
1293 if (!msp
->sample_table
)
1299 kfree(msp
->ratelist
);
1306 minstrel_ht_free_sta(void *priv
, struct ieee80211_sta
*sta
, void *priv_sta
)
1308 struct minstrel_ht_sta_priv
*msp
= priv_sta
;
1310 kfree(msp
->sample_table
);
1311 kfree(msp
->ratelist
);
1316 minstrel_ht_alloc(struct ieee80211_hw
*hw
, struct dentry
*debugfsdir
)
1318 return mac80211_minstrel
.alloc(hw
, debugfsdir
);
1322 minstrel_ht_free(void *priv
)
1324 mac80211_minstrel
.free(priv
);
1327 static u32
minstrel_ht_get_expected_throughput(void *priv_sta
)
1329 struct minstrel_ht_sta_priv
*msp
= priv_sta
;
1330 struct minstrel_ht_sta
*mi
= &msp
->ht
;
1334 return mac80211_minstrel
.get_expected_throughput(priv_sta
);
1336 i
= mi
->max_tp_rate
[0] / MCS_GROUP_RATES
;
1337 j
= mi
->max_tp_rate
[0] % MCS_GROUP_RATES
;
1339 /* convert cur_tp from pkt per second in kbps */
1340 return mi
->groups
[i
].rates
[j
].cur_tp
* AVG_PKT_SIZE
* 8 / 1024;
1343 static const struct rate_control_ops mac80211_minstrel_ht
= {
1344 .name
= "minstrel_ht",
1345 .tx_status
= minstrel_ht_tx_status
,
1346 .get_rate
= minstrel_ht_get_rate
,
1347 .rate_init
= minstrel_ht_rate_init
,
1348 .rate_update
= minstrel_ht_rate_update
,
1349 .alloc_sta
= minstrel_ht_alloc_sta
,
1350 .free_sta
= minstrel_ht_free_sta
,
1351 .alloc
= minstrel_ht_alloc
,
1352 .free
= minstrel_ht_free
,
1353 #ifdef CONFIG_MAC80211_DEBUGFS
1354 .add_sta_debugfs
= minstrel_ht_add_sta_debugfs
,
1355 .remove_sta_debugfs
= minstrel_ht_remove_sta_debugfs
,
1357 .get_expected_throughput
= minstrel_ht_get_expected_throughput
,
1361 static void __init
init_sample_table(void)
1363 int col
, i
, new_idx
;
1364 u8 rnd
[MCS_GROUP_RATES
];
1366 memset(sample_table
, 0xff, sizeof(sample_table
));
1367 for (col
= 0; col
< SAMPLE_COLUMNS
; col
++) {
1368 prandom_bytes(rnd
, sizeof(rnd
));
1369 for (i
= 0; i
< MCS_GROUP_RATES
; i
++) {
1370 new_idx
= (i
+ rnd
[i
]) % MCS_GROUP_RATES
;
1371 while (sample_table
[col
][new_idx
] != 0xff)
1372 new_idx
= (new_idx
+ 1) % MCS_GROUP_RATES
;
1374 sample_table
[col
][new_idx
] = i
;
1380 rc80211_minstrel_ht_init(void)
1382 init_sample_table();
1383 return ieee80211_rate_control_register(&mac80211_minstrel_ht
);
1387 rc80211_minstrel_ht_exit(void)
1389 ieee80211_rate_control_unregister(&mac80211_minstrel_ht
);