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/ieee80211.h>
14 #include <net/mac80211.h>
16 #include "rc80211_minstrel.h"
17 #include "rc80211_minstrel_ht.h"
19 #define AVG_PKT_SIZE 1200
20 #define SAMPLE_COLUMNS 10
23 /* Number of bits for an average sized packet */
24 #define MCS_NBITS (AVG_PKT_SIZE << 3)
26 /* Number of symbols for a packet with (bps) bits per symbol */
27 #define MCS_NSYMS(bps) ((MCS_NBITS + (bps) - 1) / (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) MCS_SYMBOL_TIME(sgi, MCS_NSYMS((streams) * (bps)))
40 * Define group sort order: HT40 -> SGI -> #streams
42 #define GROUP_IDX(_streams, _sgi, _ht40) \
43 MINSTREL_MAX_STREAMS * 2 * _ht40 + \
44 MINSTREL_MAX_STREAMS * _sgi + \
47 /* MCS rate information for an MCS group */
48 #define MCS_GROUP(_streams, _sgi, _ht40) \
49 [GROUP_IDX(_streams, _sgi, _ht40)] = { \
50 .streams = _streams, \
52 (_sgi ? IEEE80211_TX_RC_SHORT_GI : 0) | \
53 (_ht40 ? IEEE80211_TX_RC_40_MHZ_WIDTH : 0), \
55 MCS_DURATION(_streams, _sgi, _ht40 ? 54 : 26), \
56 MCS_DURATION(_streams, _sgi, _ht40 ? 108 : 52), \
57 MCS_DURATION(_streams, _sgi, _ht40 ? 162 : 78), \
58 MCS_DURATION(_streams, _sgi, _ht40 ? 216 : 104), \
59 MCS_DURATION(_streams, _sgi, _ht40 ? 324 : 156), \
60 MCS_DURATION(_streams, _sgi, _ht40 ? 432 : 208), \
61 MCS_DURATION(_streams, _sgi, _ht40 ? 486 : 234), \
62 MCS_DURATION(_streams, _sgi, _ht40 ? 540 : 260) \
66 #define CCK_DURATION(_bitrate, _short, _len) \
67 (1000 * (10 /* SIFS */ + \
68 (_short ? 72 + 24 : 144 + 48 ) + \
69 (8 * (_len + 4) * 10) / (_bitrate)))
71 #define CCK_ACK_DURATION(_bitrate, _short) \
72 (CCK_DURATION((_bitrate > 10 ? 20 : 10), false, 60) + \
73 CCK_DURATION(_bitrate, _short, AVG_PKT_SIZE))
75 #define CCK_DURATION_LIST(_short) \
76 CCK_ACK_DURATION(10, _short), \
77 CCK_ACK_DURATION(20, _short), \
78 CCK_ACK_DURATION(55, _short), \
79 CCK_ACK_DURATION(110, _short)
82 [MINSTREL_MAX_STREAMS * MINSTREL_STREAM_GROUPS] = { \
85 CCK_DURATION_LIST(false), \
86 CCK_DURATION_LIST(true) \
91 * To enable sufficiently targeted rate sampling, MCS rates are divided into
92 * groups, based on the number of streams and flags (HT40, SGI) that they
95 * Sortorder has to be fixed for GROUP_IDX macro to be applicable:
96 * HT40 -> SGI -> #streams
98 const struct mcs_group minstrel_mcs_groups
[] = {
101 #if MINSTREL_MAX_STREAMS >= 3
107 #if MINSTREL_MAX_STREAMS >= 3
113 #if MINSTREL_MAX_STREAMS >= 3
119 #if MINSTREL_MAX_STREAMS >= 3
127 #define MINSTREL_CCK_GROUP (ARRAY_SIZE(minstrel_mcs_groups) - 1)
129 static u8 sample_table
[SAMPLE_COLUMNS
][MCS_GROUP_RATES
];
132 * Perform EWMA (Exponentially Weighted Moving Average) calculation
135 minstrel_ewma(int old
, int new, int weight
)
137 return (new * (100 - weight
) + old
* weight
) / 100;
141 * Look up an MCS group index based on mac80211 rate information
144 minstrel_ht_get_group_idx(struct ieee80211_tx_rate
*rate
)
146 return GROUP_IDX((rate
->idx
/ MCS_GROUP_RATES
) + 1,
147 !!(rate
->flags
& IEEE80211_TX_RC_SHORT_GI
),
148 !!(rate
->flags
& IEEE80211_TX_RC_40_MHZ_WIDTH
));
151 static struct minstrel_rate_stats
*
152 minstrel_ht_get_stats(struct minstrel_priv
*mp
, struct minstrel_ht_sta
*mi
,
153 struct ieee80211_tx_rate
*rate
)
157 if (rate
->flags
& IEEE80211_TX_RC_MCS
) {
158 group
= minstrel_ht_get_group_idx(rate
);
159 idx
= rate
->idx
% MCS_GROUP_RATES
;
161 group
= MINSTREL_CCK_GROUP
;
163 for (idx
= 0; idx
< ARRAY_SIZE(mp
->cck_rates
); idx
++)
164 if (rate
->idx
== mp
->cck_rates
[idx
])
168 if (!(mi
->groups
[group
].supported
& BIT(idx
)))
171 return &mi
->groups
[group
].rates
[idx
];
174 static inline struct minstrel_rate_stats
*
175 minstrel_get_ratestats(struct minstrel_ht_sta
*mi
, int index
)
177 return &mi
->groups
[index
/ MCS_GROUP_RATES
].rates
[index
% MCS_GROUP_RATES
];
182 * Recalculate success probabilities and counters for a rate using EWMA
185 minstrel_calc_rate_ewma(struct minstrel_rate_stats
*mr
)
187 if (unlikely(mr
->attempts
> 0)) {
188 mr
->sample_skipped
= 0;
189 mr
->cur_prob
= MINSTREL_FRAC(mr
->success
, mr
->attempts
);
191 mr
->probability
= mr
->cur_prob
;
193 mr
->probability
= minstrel_ewma(mr
->probability
,
194 mr
->cur_prob
, EWMA_LEVEL
);
195 mr
->att_hist
+= mr
->attempts
;
196 mr
->succ_hist
+= mr
->success
;
198 mr
->sample_skipped
++;
200 mr
->last_success
= mr
->success
;
201 mr
->last_attempts
= mr
->attempts
;
207 * Calculate throughput based on the average A-MPDU length, taking into account
208 * the expected number of retransmissions and their expected length
211 minstrel_ht_calc_tp(struct minstrel_ht_sta
*mi
, int group
, int rate
)
213 struct minstrel_rate_stats
*mr
;
214 unsigned int nsecs
= 0;
217 mr
= &mi
->groups
[group
].rates
[rate
];
219 if (mr
->probability
< MINSTREL_FRAC(1, 10)) {
224 if (group
!= MINSTREL_CCK_GROUP
)
225 nsecs
= 1000 * mi
->overhead
/ MINSTREL_TRUNC(mi
->avg_ampdu_len
);
227 nsecs
+= minstrel_mcs_groups
[group
].duration
[rate
];
228 tp
= 1000000 * ((mr
->probability
* 1000) / nsecs
);
230 mr
->cur_tp
= MINSTREL_TRUNC(tp
);
234 * Update rate statistics and select new primary rates
236 * Rules for rate selection:
237 * - max_prob_rate must use only one stream, as a tradeoff between delivery
238 * probability and throughput during strong fluctuations
239 * - as long as the max prob rate has a probability of more than 3/4, pick
240 * higher throughput rates, even if the probablity is a bit lower
243 minstrel_ht_update_stats(struct minstrel_priv
*mp
, struct minstrel_ht_sta
*mi
)
245 struct minstrel_mcs_group_data
*mg
;
246 struct minstrel_rate_stats
*mr
;
247 int cur_prob
, cur_prob_tp
, cur_tp
, cur_tp2
;
249 int prob_max_streams
= 1;
251 if (mi
->ampdu_packets
> 0) {
252 mi
->avg_ampdu_len
= minstrel_ewma(mi
->avg_ampdu_len
,
253 MINSTREL_FRAC(mi
->ampdu_len
, mi
->ampdu_packets
), EWMA_LEVEL
);
255 mi
->ampdu_packets
= 0;
259 mi
->sample_count
= 0;
261 mi
->max_tp_rate2
= 0;
262 mi
->max_prob_rate
= 0;
264 for (group
= 0; group
< ARRAY_SIZE(minstrel_mcs_groups
); group
++) {
270 mg
= &mi
->groups
[group
];
275 mg
->max_tp_rate2
= 0;
276 mg
->max_prob_rate
= 0;
279 for (i
= 0; i
< MCS_GROUP_RATES
; i
++) {
280 if (!(mg
->supported
& BIT(i
)))
284 mr
->retry_updated
= false;
285 index
= MCS_GROUP_RATES
* group
+ i
;
286 minstrel_calc_rate_ewma(mr
);
287 minstrel_ht_calc_tp(mi
, group
, i
);
292 if ((mr
->cur_tp
> cur_prob_tp
&& mr
->probability
>
293 MINSTREL_FRAC(3, 4)) || mr
->probability
> cur_prob
) {
294 mg
->max_prob_rate
= index
;
295 cur_prob
= mr
->probability
;
296 cur_prob_tp
= mr
->cur_tp
;
299 if (mr
->cur_tp
> cur_tp
) {
300 swap(index
, mg
->max_tp_rate
);
302 mr
= minstrel_get_ratestats(mi
, index
);
305 if (index
>= mg
->max_tp_rate
)
308 if (mr
->cur_tp
> cur_tp2
) {
309 mg
->max_tp_rate2
= index
;
310 cur_tp2
= mr
->cur_tp
;
315 /* try to sample all available rates during each interval */
316 mi
->sample_count
*= 8;
322 for (group
= 0; group
< ARRAY_SIZE(minstrel_mcs_groups
); group
++) {
323 mg
= &mi
->groups
[group
];
327 mr
= minstrel_get_ratestats(mi
, mg
->max_tp_rate
);
328 if (cur_tp
< mr
->cur_tp
) {
329 mi
->max_tp_rate2
= mi
->max_tp_rate
;
331 mi
->max_tp_rate
= mg
->max_tp_rate
;
333 prob_max_streams
= minstrel_mcs_groups
[group
].streams
- 1;
336 mr
= minstrel_get_ratestats(mi
, mg
->max_tp_rate2
);
337 if (cur_tp2
< mr
->cur_tp
) {
338 mi
->max_tp_rate2
= mg
->max_tp_rate2
;
339 cur_tp2
= mr
->cur_tp
;
343 if (prob_max_streams
< 1)
344 prob_max_streams
= 1;
346 for (group
= 0; group
< ARRAY_SIZE(minstrel_mcs_groups
); group
++) {
347 mg
= &mi
->groups
[group
];
350 mr
= minstrel_get_ratestats(mi
, mg
->max_prob_rate
);
351 if (cur_prob_tp
< mr
->cur_tp
&&
352 minstrel_mcs_groups
[group
].streams
<= prob_max_streams
) {
353 mi
->max_prob_rate
= mg
->max_prob_rate
;
354 cur_prob
= mr
->cur_prob
;
355 cur_prob_tp
= mr
->cur_tp
;
360 mi
->stats_update
= jiffies
;
364 minstrel_ht_txstat_valid(struct minstrel_priv
*mp
, struct ieee80211_tx_rate
*rate
)
372 if (rate
->flags
& IEEE80211_TX_RC_MCS
)
375 return rate
->idx
== mp
->cck_rates
[0] ||
376 rate
->idx
== mp
->cck_rates
[1] ||
377 rate
->idx
== mp
->cck_rates
[2] ||
378 rate
->idx
== mp
->cck_rates
[3];
382 minstrel_next_sample_idx(struct minstrel_ht_sta
*mi
)
384 struct minstrel_mcs_group_data
*mg
;
388 mi
->sample_group
%= ARRAY_SIZE(minstrel_mcs_groups
);
389 mg
= &mi
->groups
[mi
->sample_group
];
394 if (++mg
->index
>= MCS_GROUP_RATES
) {
396 if (++mg
->column
>= ARRAY_SIZE(sample_table
))
404 minstrel_downgrade_rate(struct minstrel_ht_sta
*mi
, unsigned int *idx
,
407 int group
, orig_group
;
409 orig_group
= group
= *idx
/ MCS_GROUP_RATES
;
413 if (!mi
->groups
[group
].supported
)
416 if (minstrel_mcs_groups
[group
].streams
>
417 minstrel_mcs_groups
[orig_group
].streams
)
421 *idx
= mi
->groups
[group
].max_tp_rate
;
423 *idx
= mi
->groups
[group
].max_tp_rate2
;
429 minstrel_aggr_check(struct ieee80211_sta
*pubsta
, struct sk_buff
*skb
)
431 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*) skb
->data
;
432 struct sta_info
*sta
= container_of(pubsta
, struct sta_info
, sta
);
435 if (unlikely(!ieee80211_is_data_qos(hdr
->frame_control
)))
438 if (unlikely(skb
->protocol
== cpu_to_be16(ETH_P_PAE
)))
441 tid
= *ieee80211_get_qos_ctl(hdr
) & IEEE80211_QOS_CTL_TID_MASK
;
442 if (likely(sta
->ampdu_mlme
.tid_tx
[tid
]))
445 if (skb_get_queue_mapping(skb
) == IEEE80211_AC_VO
)
448 ieee80211_start_tx_ba_session(pubsta
, tid
, 5000);
452 minstrel_ht_tx_status(void *priv
, struct ieee80211_supported_band
*sband
,
453 struct ieee80211_sta
*sta
, void *priv_sta
,
456 struct minstrel_ht_sta_priv
*msp
= priv_sta
;
457 struct minstrel_ht_sta
*mi
= &msp
->ht
;
458 struct ieee80211_tx_info
*info
= IEEE80211_SKB_CB(skb
);
459 struct ieee80211_tx_rate
*ar
= info
->status
.rates
;
460 struct minstrel_rate_stats
*rate
, *rate2
;
461 struct minstrel_priv
*mp
= priv
;
466 return mac80211_minstrel
.tx_status(priv
, sband
, sta
, &msp
->legacy
, skb
);
468 /* This packet was aggregated but doesn't carry status info */
469 if ((info
->flags
& IEEE80211_TX_CTL_AMPDU
) &&
470 !(info
->flags
& IEEE80211_TX_STAT_AMPDU
))
473 if (!(info
->flags
& IEEE80211_TX_STAT_AMPDU
)) {
474 info
->status
.ampdu_ack_len
=
475 (info
->flags
& IEEE80211_TX_STAT_ACK
? 1 : 0);
476 info
->status
.ampdu_len
= 1;
480 mi
->ampdu_len
+= info
->status
.ampdu_len
;
482 if (!mi
->sample_wait
&& !mi
->sample_tries
&& mi
->sample_count
> 0) {
483 mi
->sample_wait
= 16 + 2 * MINSTREL_TRUNC(mi
->avg_ampdu_len
);
484 mi
->sample_tries
= 2;
488 if (info
->flags
& IEEE80211_TX_CTL_RATE_CTRL_PROBE
)
489 mi
->sample_packets
+= info
->status
.ampdu_len
;
491 last
= !minstrel_ht_txstat_valid(mp
, &ar
[0]);
492 for (i
= 0; !last
; i
++) {
493 last
= (i
== IEEE80211_TX_MAX_RATES
- 1) ||
494 !minstrel_ht_txstat_valid(mp
, &ar
[i
+ 1]);
496 rate
= minstrel_ht_get_stats(mp
, mi
, &ar
[i
]);
499 rate
->success
+= info
->status
.ampdu_ack_len
;
501 rate
->attempts
+= ar
[i
].count
* info
->status
.ampdu_len
;
505 * check for sudden death of spatial multiplexing,
506 * downgrade to a lower number of streams if necessary.
508 rate
= minstrel_get_ratestats(mi
, mi
->max_tp_rate
);
509 if (rate
->attempts
> 30 &&
510 MINSTREL_FRAC(rate
->success
, rate
->attempts
) <
511 MINSTREL_FRAC(20, 100))
512 minstrel_downgrade_rate(mi
, &mi
->max_tp_rate
, true);
514 rate2
= minstrel_get_ratestats(mi
, mi
->max_tp_rate2
);
515 if (rate2
->attempts
> 30 &&
516 MINSTREL_FRAC(rate2
->success
, rate2
->attempts
) <
517 MINSTREL_FRAC(20, 100))
518 minstrel_downgrade_rate(mi
, &mi
->max_tp_rate2
, false);
520 if (time_after(jiffies
, mi
->stats_update
+ (mp
->update_interval
/ 2 * HZ
) / 1000)) {
521 minstrel_ht_update_stats(mp
, mi
);
522 if (!(info
->flags
& IEEE80211_TX_CTL_AMPDU
) &&
523 mi
->max_prob_rate
/ MCS_GROUP_RATES
!= MINSTREL_CCK_GROUP
)
524 minstrel_aggr_check(sta
, skb
);
529 minstrel_calc_retransmit(struct minstrel_priv
*mp
, struct minstrel_ht_sta
*mi
,
532 struct minstrel_rate_stats
*mr
;
533 const struct mcs_group
*group
;
534 unsigned int tx_time
, tx_time_rtscts
, tx_time_data
;
535 unsigned int cw
= mp
->cw_min
;
536 unsigned int ctime
= 0;
537 unsigned int t_slot
= 9; /* FIXME */
538 unsigned int ampdu_len
= MINSTREL_TRUNC(mi
->avg_ampdu_len
);
539 unsigned int overhead
= 0, overhead_rtscts
= 0;
541 mr
= minstrel_get_ratestats(mi
, index
);
542 if (mr
->probability
< MINSTREL_FRAC(1, 10)) {
544 mr
->retry_count_rtscts
= 1;
549 mr
->retry_count_rtscts
= 2;
550 mr
->retry_updated
= true;
552 group
= &minstrel_mcs_groups
[index
/ MCS_GROUP_RATES
];
553 tx_time_data
= group
->duration
[index
% MCS_GROUP_RATES
] * ampdu_len
/ 1000;
555 /* Contention time for first 2 tries */
556 ctime
= (t_slot
* cw
) >> 1;
557 cw
= min((cw
<< 1) | 1, mp
->cw_max
);
558 ctime
+= (t_slot
* cw
) >> 1;
559 cw
= min((cw
<< 1) | 1, mp
->cw_max
);
561 if (index
/ MCS_GROUP_RATES
!= MINSTREL_CCK_GROUP
) {
562 overhead
= mi
->overhead
;
563 overhead_rtscts
= mi
->overhead_rtscts
;
566 /* Total TX time for data and Contention after first 2 tries */
567 tx_time
= ctime
+ 2 * (overhead
+ tx_time_data
);
568 tx_time_rtscts
= ctime
+ 2 * (overhead_rtscts
+ tx_time_data
);
570 /* See how many more tries we can fit inside segment size */
572 /* Contention time for this try */
573 ctime
= (t_slot
* cw
) >> 1;
574 cw
= min((cw
<< 1) | 1, mp
->cw_max
);
576 /* Total TX time after this try */
577 tx_time
+= ctime
+ overhead
+ tx_time_data
;
578 tx_time_rtscts
+= ctime
+ overhead_rtscts
+ tx_time_data
;
580 if (tx_time_rtscts
< mp
->segment_size
)
581 mr
->retry_count_rtscts
++;
582 } while ((tx_time
< mp
->segment_size
) &&
583 (++mr
->retry_count
< mp
->max_retry
));
588 minstrel_ht_set_rate(struct minstrel_priv
*mp
, struct minstrel_ht_sta
*mi
,
589 struct ieee80211_tx_rate
*rate
, int index
,
590 bool sample
, bool rtscts
)
592 const struct mcs_group
*group
= &minstrel_mcs_groups
[index
/ MCS_GROUP_RATES
];
593 struct minstrel_rate_stats
*mr
;
595 mr
= minstrel_get_ratestats(mi
, index
);
596 if (!mr
->retry_updated
)
597 minstrel_calc_retransmit(mp
, mi
, index
);
601 else if (mr
->probability
< MINSTREL_FRAC(20, 100))
604 rate
->count
= mr
->retry_count_rtscts
;
606 rate
->count
= mr
->retry_count
;
610 rate
->flags
|= IEEE80211_TX_RC_USE_RTS_CTS
;
612 if (index
/ MCS_GROUP_RATES
== MINSTREL_CCK_GROUP
) {
613 rate
->idx
= mp
->cck_rates
[index
% ARRAY_SIZE(mp
->cck_rates
)];
617 rate
->flags
|= IEEE80211_TX_RC_MCS
| group
->flags
;
618 rate
->idx
= index
% MCS_GROUP_RATES
+ (group
->streams
- 1) * MCS_GROUP_RATES
;
622 minstrel_get_duration(int index
)
624 const struct mcs_group
*group
= &minstrel_mcs_groups
[index
/ MCS_GROUP_RATES
];
625 return group
->duration
[index
% MCS_GROUP_RATES
];
629 minstrel_get_sample_rate(struct minstrel_priv
*mp
, struct minstrel_ht_sta
*mi
)
631 struct minstrel_rate_stats
*mr
;
632 struct minstrel_mcs_group_data
*mg
;
635 if (mi
->sample_wait
> 0) {
640 if (!mi
->sample_tries
)
644 mg
= &mi
->groups
[mi
->sample_group
];
645 sample_idx
= sample_table
[mg
->column
][mg
->index
];
646 mr
= &mg
->rates
[sample_idx
];
647 sample_idx
+= mi
->sample_group
* MCS_GROUP_RATES
;
648 minstrel_next_sample_idx(mi
);
651 * Sampling might add some overhead (RTS, no aggregation)
652 * to the frame. Hence, don't use sampling for the currently
655 if (sample_idx
== mi
->max_tp_rate
)
658 * When not using MRR, do not sample if the probability is already
659 * higher than 95% to avoid wasting airtime
661 if (!mp
->has_mrr
&& (mr
->probability
> MINSTREL_FRAC(95, 100)))
665 * Make sure that lower rates get sampled only occasionally,
666 * if the link is working perfectly.
668 if (minstrel_get_duration(sample_idx
) >
669 minstrel_get_duration(mi
->max_tp_rate
)) {
670 if (mr
->sample_skipped
< 20)
673 if (mi
->sample_slow
++ > 2)
681 minstrel_ht_check_cck_shortpreamble(struct minstrel_priv
*mp
,
682 struct minstrel_ht_sta
*mi
, bool val
)
684 u8 supported
= mi
->groups
[MINSTREL_CCK_GROUP
].supported
;
686 if (!supported
|| !mi
->cck_supported_short
)
689 if (supported
& (mi
->cck_supported_short
<< (val
* 4)))
692 supported
^= mi
->cck_supported_short
| (mi
->cck_supported_short
<< 4);
693 mi
->groups
[MINSTREL_CCK_GROUP
].supported
= supported
;
697 minstrel_ht_get_rate(void *priv
, struct ieee80211_sta
*sta
, void *priv_sta
,
698 struct ieee80211_tx_rate_control
*txrc
)
700 struct ieee80211_tx_info
*info
= IEEE80211_SKB_CB(txrc
->skb
);
701 struct ieee80211_tx_rate
*ar
= info
->status
.rates
;
702 struct minstrel_ht_sta_priv
*msp
= priv_sta
;
703 struct minstrel_ht_sta
*mi
= &msp
->ht
;
704 struct minstrel_priv
*mp
= priv
;
708 if (rate_control_send_low(sta
, priv_sta
, txrc
))
712 return mac80211_minstrel
.get_rate(priv
, sta
, &msp
->legacy
, txrc
);
714 info
->flags
|= mi
->tx_flags
;
715 minstrel_ht_check_cck_shortpreamble(mp
, mi
, txrc
->short_preamble
);
717 /* Don't use EAPOL frames for sampling on non-mrr hw */
718 if (mp
->hw
->max_rates
== 1 &&
719 txrc
->skb
->protocol
== cpu_to_be16(ETH_P_PAE
))
722 sample_idx
= minstrel_get_sample_rate(mp
, mi
);
724 #ifdef CONFIG_MAC80211_DEBUGFS
725 /* use fixed index if set */
726 if (mp
->fixed_rate_idx
!= -1) {
727 mi
->max_tp_rate
= mp
->fixed_rate_idx
;
728 mi
->max_tp_rate2
= mp
->fixed_rate_idx
;
729 mi
->max_prob_rate
= mp
->fixed_rate_idx
;
734 if (sample_idx
>= 0) {
736 minstrel_ht_set_rate(mp
, mi
, &ar
[0], sample_idx
,
738 info
->flags
|= IEEE80211_TX_CTL_RATE_CTRL_PROBE
;
740 minstrel_ht_set_rate(mp
, mi
, &ar
[0], mi
->max_tp_rate
,
744 if (mp
->hw
->max_rates
>= 3) {
746 * At least 3 tx rates supported, use
747 * sample_rate -> max_tp_rate -> max_prob_rate for sampling and
748 * max_tp_rate -> max_tp_rate2 -> max_prob_rate by default.
751 minstrel_ht_set_rate(mp
, mi
, &ar
[1], mi
->max_tp_rate
,
754 minstrel_ht_set_rate(mp
, mi
, &ar
[1], mi
->max_tp_rate2
,
757 minstrel_ht_set_rate(mp
, mi
, &ar
[2], mi
->max_prob_rate
,
762 } else if (mp
->hw
->max_rates
== 2) {
764 * Only 2 tx rates supported, use
765 * sample_rate -> max_prob_rate for sampling and
766 * max_tp_rate -> max_prob_rate by default.
768 minstrel_ht_set_rate(mp
, mi
, &ar
[1], mi
->max_prob_rate
,
774 /* Not using MRR, only use the first rate */
782 if (mi
->total_packets
== ~0) {
783 mi
->total_packets
= 0;
784 mi
->sample_packets
= 0;
789 minstrel_ht_update_cck(struct minstrel_priv
*mp
, struct minstrel_ht_sta
*mi
,
790 struct ieee80211_supported_band
*sband
,
791 struct ieee80211_sta
*sta
)
795 if (sband
->band
!= IEEE80211_BAND_2GHZ
)
798 mi
->cck_supported
= 0;
799 mi
->cck_supported_short
= 0;
800 for (i
= 0; i
< 4; i
++) {
801 if (!rate_supported(sta
, sband
->band
, mp
->cck_rates
[i
]))
804 mi
->cck_supported
|= BIT(i
);
805 if (sband
->bitrates
[i
].flags
& IEEE80211_RATE_SHORT_PREAMBLE
)
806 mi
->cck_supported_short
|= BIT(i
);
809 mi
->groups
[MINSTREL_CCK_GROUP
].supported
= mi
->cck_supported
;
813 minstrel_ht_update_caps(void *priv
, struct ieee80211_supported_band
*sband
,
814 struct ieee80211_sta
*sta
, void *priv_sta
)
816 struct minstrel_priv
*mp
= priv
;
817 struct minstrel_ht_sta_priv
*msp
= priv_sta
;
818 struct minstrel_ht_sta
*mi
= &msp
->ht
;
819 struct ieee80211_mcs_info
*mcs
= &sta
->ht_cap
.mcs
;
820 u16 sta_cap
= sta
->ht_cap
.cap
;
826 /* fall back to the old minstrel for legacy stations */
827 if (!sta
->ht_cap
.ht_supported
)
830 BUILD_BUG_ON(ARRAY_SIZE(minstrel_mcs_groups
) !=
831 MINSTREL_MAX_STREAMS
* MINSTREL_STREAM_GROUPS
+ 1);
834 memset(mi
, 0, sizeof(*mi
));
835 mi
->stats_update
= jiffies
;
837 ack_dur
= ieee80211_frame_duration(sband
->band
, 10, 60, 1, 1);
838 mi
->overhead
= ieee80211_frame_duration(sband
->band
, 0, 60, 1, 1) + ack_dur
;
839 mi
->overhead_rtscts
= mi
->overhead
+ 2 * ack_dur
;
841 mi
->avg_ampdu_len
= MINSTREL_FRAC(1, 1);
843 /* When using MRR, sample more on the first attempt, without delay */
845 mi
->sample_count
= 16;
848 mi
->sample_count
= 8;
851 mi
->sample_tries
= 4;
853 stbc
= (sta_cap
& IEEE80211_HT_CAP_RX_STBC
) >>
854 IEEE80211_HT_CAP_RX_STBC_SHIFT
;
855 mi
->tx_flags
|= stbc
<< IEEE80211_TX_CTL_STBC_SHIFT
;
857 if (sta_cap
& IEEE80211_HT_CAP_LDPC_CODING
)
858 mi
->tx_flags
|= IEEE80211_TX_CTL_LDPC
;
860 for (i
= 0; i
< ARRAY_SIZE(mi
->groups
); i
++) {
861 mi
->groups
[i
].supported
= 0;
862 if (i
== MINSTREL_CCK_GROUP
) {
863 minstrel_ht_update_cck(mp
, mi
, sband
, sta
);
867 if (minstrel_mcs_groups
[i
].flags
& IEEE80211_TX_RC_SHORT_GI
) {
868 if (minstrel_mcs_groups
[i
].flags
& IEEE80211_TX_RC_40_MHZ_WIDTH
) {
869 if (!(sta_cap
& IEEE80211_HT_CAP_SGI_40
))
872 if (!(sta_cap
& IEEE80211_HT_CAP_SGI_20
))
877 if (minstrel_mcs_groups
[i
].flags
& IEEE80211_TX_RC_40_MHZ_WIDTH
&&
878 sta
->bandwidth
< IEEE80211_STA_RX_BW_40
)
881 /* Mark MCS > 7 as unsupported if STA is in static SMPS mode */
882 if (sta
->smps_mode
== IEEE80211_SMPS_STATIC
&&
883 minstrel_mcs_groups
[i
].streams
> 1)
886 mi
->groups
[i
].supported
=
887 mcs
->rx_mask
[minstrel_mcs_groups
[i
].streams
- 1];
889 if (mi
->groups
[i
].supported
)
900 memset(&msp
->legacy
, 0, sizeof(msp
->legacy
));
901 msp
->legacy
.r
= msp
->ratelist
;
902 msp
->legacy
.sample_table
= msp
->sample_table
;
903 return mac80211_minstrel
.rate_init(priv
, sband
, sta
, &msp
->legacy
);
907 minstrel_ht_rate_init(void *priv
, struct ieee80211_supported_band
*sband
,
908 struct ieee80211_sta
*sta
, void *priv_sta
)
910 minstrel_ht_update_caps(priv
, sband
, sta
, priv_sta
);
914 minstrel_ht_rate_update(void *priv
, struct ieee80211_supported_band
*sband
,
915 struct ieee80211_sta
*sta
, void *priv_sta
,
918 minstrel_ht_update_caps(priv
, sband
, sta
, priv_sta
);
922 minstrel_ht_alloc_sta(void *priv
, struct ieee80211_sta
*sta
, gfp_t gfp
)
924 struct ieee80211_supported_band
*sband
;
925 struct minstrel_ht_sta_priv
*msp
;
926 struct minstrel_priv
*mp
= priv
;
927 struct ieee80211_hw
*hw
= mp
->hw
;
931 for (i
= 0; i
< IEEE80211_NUM_BANDS
; i
++) {
932 sband
= hw
->wiphy
->bands
[i
];
933 if (sband
&& sband
->n_bitrates
> max_rates
)
934 max_rates
= sband
->n_bitrates
;
937 msp
= kzalloc(sizeof(*msp
), gfp
);
941 msp
->ratelist
= kzalloc(sizeof(struct minstrel_rate
) * max_rates
, gfp
);
945 msp
->sample_table
= kmalloc(SAMPLE_COLUMNS
* max_rates
, gfp
);
946 if (!msp
->sample_table
)
952 kfree(msp
->ratelist
);
959 minstrel_ht_free_sta(void *priv
, struct ieee80211_sta
*sta
, void *priv_sta
)
961 struct minstrel_ht_sta_priv
*msp
= priv_sta
;
963 kfree(msp
->sample_table
);
964 kfree(msp
->ratelist
);
969 minstrel_ht_alloc(struct ieee80211_hw
*hw
, struct dentry
*debugfsdir
)
971 return mac80211_minstrel
.alloc(hw
, debugfsdir
);
975 minstrel_ht_free(void *priv
)
977 mac80211_minstrel
.free(priv
);
980 static struct rate_control_ops mac80211_minstrel_ht
= {
981 .name
= "minstrel_ht",
982 .tx_status
= minstrel_ht_tx_status
,
983 .get_rate
= minstrel_ht_get_rate
,
984 .rate_init
= minstrel_ht_rate_init
,
985 .rate_update
= minstrel_ht_rate_update
,
986 .alloc_sta
= minstrel_ht_alloc_sta
,
987 .free_sta
= minstrel_ht_free_sta
,
988 .alloc
= minstrel_ht_alloc
,
989 .free
= minstrel_ht_free
,
990 #ifdef CONFIG_MAC80211_DEBUGFS
991 .add_sta_debugfs
= minstrel_ht_add_sta_debugfs
,
992 .remove_sta_debugfs
= minstrel_ht_remove_sta_debugfs
,
998 init_sample_table(void)
1000 int col
, i
, new_idx
;
1001 u8 rnd
[MCS_GROUP_RATES
];
1003 memset(sample_table
, 0xff, sizeof(sample_table
));
1004 for (col
= 0; col
< SAMPLE_COLUMNS
; col
++) {
1005 for (i
= 0; i
< MCS_GROUP_RATES
; i
++) {
1006 get_random_bytes(rnd
, sizeof(rnd
));
1007 new_idx
= (i
+ rnd
[i
]) % MCS_GROUP_RATES
;
1009 while (sample_table
[col
][new_idx
] != 0xff)
1010 new_idx
= (new_idx
+ 1) % MCS_GROUP_RATES
;
1012 sample_table
[col
][new_idx
] = i
;
1018 rc80211_minstrel_ht_init(void)
1020 init_sample_table();
1021 return ieee80211_rate_control_register(&mac80211_minstrel_ht
);
1025 rc80211_minstrel_ht_exit(void)
1027 ieee80211_rate_control_unregister(&mac80211_minstrel_ht
);