2 * Copyright (C) 2010 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 for a packet containing (syms) symbols */
30 #define MCS_SYMBOL_TIME(sgi, syms) \
32 ((syms) * 18 + 4) / 5 : /* syms * 3.6 us */ \
33 (syms) << 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)))
39 /* MCS rate information for an MCS group */
40 #define MCS_GROUP(_streams, _sgi, _ht40) { \
41 .streams = _streams, \
43 (_sgi ? IEEE80211_TX_RC_SHORT_GI : 0) | \
44 (_ht40 ? IEEE80211_TX_RC_40_MHZ_WIDTH : 0), \
46 MCS_DURATION(_streams, _sgi, _ht40 ? 54 : 26), \
47 MCS_DURATION(_streams, _sgi, _ht40 ? 108 : 52), \
48 MCS_DURATION(_streams, _sgi, _ht40 ? 162 : 78), \
49 MCS_DURATION(_streams, _sgi, _ht40 ? 216 : 104), \
50 MCS_DURATION(_streams, _sgi, _ht40 ? 324 : 156), \
51 MCS_DURATION(_streams, _sgi, _ht40 ? 432 : 208), \
52 MCS_DURATION(_streams, _sgi, _ht40 ? 486 : 234), \
53 MCS_DURATION(_streams, _sgi, _ht40 ? 540 : 260) \
58 * To enable sufficiently targeted rate sampling, MCS rates are divided into
59 * groups, based on the number of streams and flags (HT40, SGI) that they
62 const struct mcs_group minstrel_mcs_groups
[] = {
65 #if MINSTREL_MAX_STREAMS >= 3
71 #if MINSTREL_MAX_STREAMS >= 3
77 #if MINSTREL_MAX_STREAMS >= 3
83 #if MINSTREL_MAX_STREAMS >= 3
88 static u8 sample_table
[SAMPLE_COLUMNS
][MCS_GROUP_RATES
];
91 * Perform EWMA (Exponentially Weighted Moving Average) calculation
94 minstrel_ewma(int old
, int new, int weight
)
96 return (new * (100 - weight
) + old
* weight
) / 100;
100 * Look up an MCS group index based on mac80211 rate information
103 minstrel_ht_get_group_idx(struct ieee80211_tx_rate
*rate
)
105 int streams
= (rate
->idx
/ MCS_GROUP_RATES
) + 1;
106 u32 flags
= IEEE80211_TX_RC_SHORT_GI
| IEEE80211_TX_RC_40_MHZ_WIDTH
;
109 for (i
= 0; i
< ARRAY_SIZE(minstrel_mcs_groups
); i
++) {
110 if (minstrel_mcs_groups
[i
].streams
!= streams
)
112 if (minstrel_mcs_groups
[i
].flags
!= (rate
->flags
& flags
))
122 static inline struct minstrel_rate_stats
*
123 minstrel_get_ratestats(struct minstrel_ht_sta
*mi
, int index
)
125 return &mi
->groups
[index
/ MCS_GROUP_RATES
].rates
[index
% MCS_GROUP_RATES
];
130 * Recalculate success probabilities and counters for a rate using EWMA
133 minstrel_calc_rate_ewma(struct minstrel_priv
*mp
, struct minstrel_rate_stats
*mr
)
135 if (unlikely(mr
->attempts
> 0)) {
136 mr
->sample_skipped
= 0;
137 mr
->cur_prob
= MINSTREL_FRAC(mr
->success
, mr
->attempts
);
139 mr
->probability
= mr
->cur_prob
;
141 mr
->probability
= minstrel_ewma(mr
->probability
,
142 mr
->cur_prob
, EWMA_LEVEL
);
143 mr
->att_hist
+= mr
->attempts
;
144 mr
->succ_hist
+= mr
->success
;
146 mr
->sample_skipped
++;
148 mr
->last_success
= mr
->success
;
149 mr
->last_attempts
= mr
->attempts
;
155 * Calculate throughput based on the average A-MPDU length, taking into account
156 * the expected number of retransmissions and their expected length
159 minstrel_ht_calc_tp(struct minstrel_priv
*mp
, struct minstrel_ht_sta
*mi
,
162 struct minstrel_rate_stats
*mr
;
165 mr
= &mi
->groups
[group
].rates
[rate
];
167 if (mr
->probability
< MINSTREL_FRAC(1, 10)) {
172 usecs
= mi
->overhead
/ MINSTREL_TRUNC(mi
->avg_ampdu_len
);
173 usecs
+= minstrel_mcs_groups
[group
].duration
[rate
];
174 mr
->cur_tp
= MINSTREL_TRUNC((1000000 / usecs
) * mr
->probability
);
178 * Update rate statistics and select new primary rates
180 * Rules for rate selection:
181 * - max_prob_rate must use only one stream, as a tradeoff between delivery
182 * probability and throughput during strong fluctuations
183 * - as long as the max prob rate has a probability of more than 3/4, pick
184 * higher throughput rates, even if the probablity is a bit lower
187 minstrel_ht_update_stats(struct minstrel_priv
*mp
, struct minstrel_ht_sta
*mi
)
189 struct minstrel_mcs_group_data
*mg
;
190 struct minstrel_rate_stats
*mr
;
191 int cur_prob
, cur_prob_tp
, cur_tp
, cur_tp2
;
194 if (mi
->ampdu_packets
> 0) {
195 mi
->avg_ampdu_len
= minstrel_ewma(mi
->avg_ampdu_len
,
196 MINSTREL_FRAC(mi
->ampdu_len
, mi
->ampdu_packets
), EWMA_LEVEL
);
198 mi
->ampdu_packets
= 0;
202 mi
->sample_count
= 0;
204 mi
->max_tp_rate2
= 0;
205 mi
->max_prob_rate
= 0;
207 for (group
= 0; group
< ARRAY_SIZE(minstrel_mcs_groups
); group
++) {
213 mg
= &mi
->groups
[group
];
218 mg
->max_tp_rate2
= 0;
219 mg
->max_prob_rate
= 0;
222 for (i
= 0; i
< MCS_GROUP_RATES
; i
++) {
223 if (!(mg
->supported
& BIT(i
)))
227 mr
->retry_updated
= false;
228 index
= MCS_GROUP_RATES
* group
+ i
;
229 minstrel_calc_rate_ewma(mp
, mr
);
230 minstrel_ht_calc_tp(mp
, mi
, group
, i
);
235 /* ignore the lowest rate of each single-stream group */
236 if (!i
&& minstrel_mcs_groups
[group
].streams
== 1)
239 if ((mr
->cur_tp
> cur_prob_tp
&& mr
->probability
>
240 MINSTREL_FRAC(3, 4)) || mr
->probability
> cur_prob
) {
241 mg
->max_prob_rate
= index
;
242 cur_prob
= mr
->probability
;
243 cur_prob_tp
= mr
->cur_tp
;
246 if (mr
->cur_tp
> cur_tp
) {
247 swap(index
, mg
->max_tp_rate
);
249 mr
= minstrel_get_ratestats(mi
, index
);
252 if (index
>= mg
->max_tp_rate
)
255 if (mr
->cur_tp
> cur_tp2
) {
256 mg
->max_tp_rate2
= index
;
257 cur_tp2
= mr
->cur_tp
;
262 /* try to sample up to half of the available rates during each interval */
263 mi
->sample_count
*= 4;
269 for (group
= 0; group
< ARRAY_SIZE(minstrel_mcs_groups
); group
++) {
270 mg
= &mi
->groups
[group
];
274 mr
= minstrel_get_ratestats(mi
, mg
->max_prob_rate
);
275 if (cur_prob_tp
< mr
->cur_tp
&&
276 minstrel_mcs_groups
[group
].streams
== 1) {
277 mi
->max_prob_rate
= mg
->max_prob_rate
;
278 cur_prob
= mr
->cur_prob
;
279 cur_prob_tp
= mr
->cur_tp
;
282 mr
= minstrel_get_ratestats(mi
, mg
->max_tp_rate
);
283 if (cur_tp
< mr
->cur_tp
) {
284 mi
->max_tp_rate
= mg
->max_tp_rate
;
288 mr
= minstrel_get_ratestats(mi
, mg
->max_tp_rate2
);
289 if (cur_tp2
< mr
->cur_tp
) {
290 mi
->max_tp_rate2
= mg
->max_tp_rate2
;
291 cur_tp2
= mr
->cur_tp
;
295 mi
->stats_update
= jiffies
;
299 minstrel_ht_txstat_valid(struct ieee80211_tx_rate
*rate
)
307 return !!(rate
->flags
& IEEE80211_TX_RC_MCS
);
311 minstrel_next_sample_idx(struct minstrel_ht_sta
*mi
)
313 struct minstrel_mcs_group_data
*mg
;
317 mi
->sample_group
%= ARRAY_SIZE(minstrel_mcs_groups
);
318 mg
= &mi
->groups
[mi
->sample_group
];
323 if (++mg
->index
>= MCS_GROUP_RATES
) {
325 if (++mg
->column
>= ARRAY_SIZE(sample_table
))
333 minstrel_downgrade_rate(struct minstrel_ht_sta
*mi
, unsigned int *idx
,
336 int group
, orig_group
;
338 orig_group
= group
= *idx
/ MCS_GROUP_RATES
;
342 if (!mi
->groups
[group
].supported
)
345 if (minstrel_mcs_groups
[group
].streams
>
346 minstrel_mcs_groups
[orig_group
].streams
)
350 *idx
= mi
->groups
[group
].max_tp_rate
;
352 *idx
= mi
->groups
[group
].max_tp_rate2
;
358 minstrel_aggr_check(struct minstrel_priv
*mp
, struct ieee80211_sta
*pubsta
, struct sk_buff
*skb
)
360 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*) skb
->data
;
361 struct sta_info
*sta
= container_of(pubsta
, struct sta_info
, sta
);
364 if (unlikely(!ieee80211_is_data_qos(hdr
->frame_control
)))
367 if (unlikely(skb
->protocol
== cpu_to_be16(ETH_P_PAE
)))
370 tid
= *ieee80211_get_qos_ctl(hdr
) & IEEE80211_QOS_CTL_TID_MASK
;
371 if (likely(sta
->ampdu_mlme
.tid_tx
[tid
]))
374 if (skb_get_queue_mapping(skb
) == IEEE80211_AC_VO
)
377 ieee80211_start_tx_ba_session(pubsta
, tid
, 5000);
381 minstrel_ht_tx_status(void *priv
, struct ieee80211_supported_band
*sband
,
382 struct ieee80211_sta
*sta
, void *priv_sta
,
385 struct minstrel_ht_sta_priv
*msp
= priv_sta
;
386 struct minstrel_ht_sta
*mi
= &msp
->ht
;
387 struct ieee80211_tx_info
*info
= IEEE80211_SKB_CB(skb
);
388 struct ieee80211_tx_rate
*ar
= info
->status
.rates
;
389 struct minstrel_rate_stats
*rate
, *rate2
;
390 struct minstrel_priv
*mp
= priv
;
396 return mac80211_minstrel
.tx_status(priv
, sband
, sta
, &msp
->legacy
, skb
);
398 /* This packet was aggregated but doesn't carry status info */
399 if ((info
->flags
& IEEE80211_TX_CTL_AMPDU
) &&
400 !(info
->flags
& IEEE80211_TX_STAT_AMPDU
))
403 if (!(info
->flags
& IEEE80211_TX_STAT_AMPDU
)) {
404 info
->status
.ampdu_ack_len
=
405 (info
->flags
& IEEE80211_TX_STAT_ACK
? 1 : 0);
406 info
->status
.ampdu_len
= 1;
410 mi
->ampdu_len
+= info
->status
.ampdu_len
;
412 if (!mi
->sample_wait
&& !mi
->sample_tries
&& mi
->sample_count
> 0) {
413 mi
->sample_wait
= 16 + 2 * MINSTREL_TRUNC(mi
->avg_ampdu_len
);
414 mi
->sample_tries
= 2;
418 if (info
->flags
& IEEE80211_TX_CTL_RATE_CTRL_PROBE
)
419 mi
->sample_packets
+= info
->status
.ampdu_len
;
421 for (i
= 0; !last
; i
++) {
422 last
= (i
== IEEE80211_TX_MAX_RATES
- 1) ||
423 !minstrel_ht_txstat_valid(&ar
[i
+ 1]);
425 if (!minstrel_ht_txstat_valid(&ar
[i
]))
428 group
= minstrel_ht_get_group_idx(&ar
[i
]);
429 rate
= &mi
->groups
[group
].rates
[ar
[i
].idx
% 8];
432 rate
->success
+= info
->status
.ampdu_ack_len
;
434 rate
->attempts
+= ar
[i
].count
* info
->status
.ampdu_len
;
438 * check for sudden death of spatial multiplexing,
439 * downgrade to a lower number of streams if necessary.
441 rate
= minstrel_get_ratestats(mi
, mi
->max_tp_rate
);
442 if (rate
->attempts
> 30 &&
443 MINSTREL_FRAC(rate
->success
, rate
->attempts
) <
444 MINSTREL_FRAC(20, 100))
445 minstrel_downgrade_rate(mi
, &mi
->max_tp_rate
, true);
447 rate2
= minstrel_get_ratestats(mi
, mi
->max_tp_rate2
);
448 if (rate2
->attempts
> 30 &&
449 MINSTREL_FRAC(rate2
->success
, rate2
->attempts
) <
450 MINSTREL_FRAC(20, 100))
451 minstrel_downgrade_rate(mi
, &mi
->max_tp_rate2
, false);
453 if (time_after(jiffies
, mi
->stats_update
+ (mp
->update_interval
/ 2 * HZ
) / 1000)) {
454 minstrel_ht_update_stats(mp
, mi
);
455 minstrel_aggr_check(mp
, sta
, skb
);
460 minstrel_calc_retransmit(struct minstrel_priv
*mp
, struct minstrel_ht_sta
*mi
,
463 struct minstrel_rate_stats
*mr
;
464 const struct mcs_group
*group
;
465 unsigned int tx_time
, tx_time_rtscts
, tx_time_data
;
466 unsigned int cw
= mp
->cw_min
;
467 unsigned int ctime
= 0;
468 unsigned int t_slot
= 9; /* FIXME */
469 unsigned int ampdu_len
= MINSTREL_TRUNC(mi
->avg_ampdu_len
);
471 mr
= minstrel_get_ratestats(mi
, index
);
472 if (mr
->probability
< MINSTREL_FRAC(1, 10)) {
474 mr
->retry_count_rtscts
= 1;
479 mr
->retry_count_rtscts
= 2;
480 mr
->retry_updated
= true;
482 group
= &minstrel_mcs_groups
[index
/ MCS_GROUP_RATES
];
483 tx_time_data
= group
->duration
[index
% MCS_GROUP_RATES
] * ampdu_len
;
485 /* Contention time for first 2 tries */
486 ctime
= (t_slot
* cw
) >> 1;
487 cw
= min((cw
<< 1) | 1, mp
->cw_max
);
488 ctime
+= (t_slot
* cw
) >> 1;
489 cw
= min((cw
<< 1) | 1, mp
->cw_max
);
491 /* Total TX time for data and Contention after first 2 tries */
492 tx_time
= ctime
+ 2 * (mi
->overhead
+ tx_time_data
);
493 tx_time_rtscts
= ctime
+ 2 * (mi
->overhead_rtscts
+ tx_time_data
);
495 /* See how many more tries we can fit inside segment size */
497 /* Contention time for this try */
498 ctime
= (t_slot
* cw
) >> 1;
499 cw
= min((cw
<< 1) | 1, mp
->cw_max
);
501 /* Total TX time after this try */
502 tx_time
+= ctime
+ mi
->overhead
+ tx_time_data
;
503 tx_time_rtscts
+= ctime
+ mi
->overhead_rtscts
+ tx_time_data
;
505 if (tx_time_rtscts
< mp
->segment_size
)
506 mr
->retry_count_rtscts
++;
507 } while ((tx_time
< mp
->segment_size
) &&
508 (++mr
->retry_count
< mp
->max_retry
));
513 minstrel_ht_set_rate(struct minstrel_priv
*mp
, struct minstrel_ht_sta
*mi
,
514 struct ieee80211_tx_rate
*rate
, int index
,
515 struct ieee80211_tx_rate_control
*txrc
,
516 bool sample
, bool rtscts
)
518 const struct mcs_group
*group
= &minstrel_mcs_groups
[index
/ MCS_GROUP_RATES
];
519 struct minstrel_rate_stats
*mr
;
521 mr
= minstrel_get_ratestats(mi
, index
);
522 if (!mr
->retry_updated
)
523 minstrel_calc_retransmit(mp
, mi
, index
);
527 else if (mr
->probability
< MINSTREL_FRAC(20, 100))
530 rate
->count
= mr
->retry_count_rtscts
;
532 rate
->count
= mr
->retry_count
;
534 rate
->flags
= IEEE80211_TX_RC_MCS
| group
->flags
;
536 rate
->flags
|= IEEE80211_TX_RC_USE_RTS_CTS
;
537 rate
->idx
= index
% MCS_GROUP_RATES
+ (group
->streams
- 1) * MCS_GROUP_RATES
;
541 minstrel_get_duration(int index
)
543 const struct mcs_group
*group
= &minstrel_mcs_groups
[index
/ MCS_GROUP_RATES
];
544 return group
->duration
[index
% MCS_GROUP_RATES
];
548 minstrel_get_sample_rate(struct minstrel_priv
*mp
, struct minstrel_ht_sta
*mi
)
550 struct minstrel_rate_stats
*mr
;
551 struct minstrel_mcs_group_data
*mg
;
554 if (mi
->sample_wait
> 0) {
559 if (!mi
->sample_tries
)
563 mg
= &mi
->groups
[mi
->sample_group
];
564 sample_idx
= sample_table
[mg
->column
][mg
->index
];
565 mr
= &mg
->rates
[sample_idx
];
566 sample_idx
+= mi
->sample_group
* MCS_GROUP_RATES
;
567 minstrel_next_sample_idx(mi
);
570 * When not using MRR, do not sample if the probability is already
571 * higher than 95% to avoid wasting airtime
573 if (!mp
->has_mrr
&& (mr
->probability
> MINSTREL_FRAC(95, 100)))
577 * Make sure that lower rates get sampled only occasionally,
578 * if the link is working perfectly.
580 if (minstrel_get_duration(sample_idx
) >
581 minstrel_get_duration(mi
->max_tp_rate
)) {
582 if (mr
->sample_skipped
< 20)
585 if (mi
->sample_slow
++ > 2)
593 minstrel_ht_get_rate(void *priv
, struct ieee80211_sta
*sta
, void *priv_sta
,
594 struct ieee80211_tx_rate_control
*txrc
)
596 struct ieee80211_tx_info
*info
= IEEE80211_SKB_CB(txrc
->skb
);
597 struct ieee80211_tx_rate
*ar
= info
->status
.rates
;
598 struct minstrel_ht_sta_priv
*msp
= priv_sta
;
599 struct minstrel_ht_sta
*mi
= &msp
->ht
;
600 struct minstrel_priv
*mp
= priv
;
604 if (rate_control_send_low(sta
, priv_sta
, txrc
))
608 return mac80211_minstrel
.get_rate(priv
, sta
, &msp
->legacy
, txrc
);
610 info
->flags
|= mi
->tx_flags
;
611 sample_idx
= minstrel_get_sample_rate(mp
, mi
);
612 if (sample_idx
>= 0) {
614 minstrel_ht_set_rate(mp
, mi
, &ar
[0], sample_idx
,
616 info
->flags
|= IEEE80211_TX_CTL_RATE_CTRL_PROBE
;
618 minstrel_ht_set_rate(mp
, mi
, &ar
[0], mi
->max_tp_rate
,
622 if (mp
->hw
->max_rates
>= 3) {
624 * At least 3 tx rates supported, use
625 * sample_rate -> max_tp_rate -> max_prob_rate for sampling and
626 * max_tp_rate -> max_tp_rate2 -> max_prob_rate by default.
629 minstrel_ht_set_rate(mp
, mi
, &ar
[1], mi
->max_tp_rate
,
632 minstrel_ht_set_rate(mp
, mi
, &ar
[1], mi
->max_tp_rate2
,
635 minstrel_ht_set_rate(mp
, mi
, &ar
[2], mi
->max_prob_rate
,
636 txrc
, false, !sample
);
640 } else if (mp
->hw
->max_rates
== 2) {
642 * Only 2 tx rates supported, use
643 * sample_rate -> max_prob_rate for sampling and
644 * max_tp_rate -> max_prob_rate by default.
646 minstrel_ht_set_rate(mp
, mi
, &ar
[1], mi
->max_prob_rate
,
647 txrc
, false, !sample
);
652 /* Not using MRR, only use the first rate */
660 if (mi
->total_packets
== ~0) {
661 mi
->total_packets
= 0;
662 mi
->sample_packets
= 0;
667 minstrel_ht_update_caps(void *priv
, struct ieee80211_supported_band
*sband
,
668 struct ieee80211_sta
*sta
, void *priv_sta
,
669 enum nl80211_channel_type oper_chan_type
)
671 struct minstrel_priv
*mp
= priv
;
672 struct minstrel_ht_sta_priv
*msp
= priv_sta
;
673 struct minstrel_ht_sta
*mi
= &msp
->ht
;
674 struct ieee80211_mcs_info
*mcs
= &sta
->ht_cap
.mcs
;
675 struct ieee80211_local
*local
= hw_to_local(mp
->hw
);
676 u16 sta_cap
= sta
->ht_cap
.cap
;
682 /* fall back to the old minstrel for legacy stations */
683 if (!sta
->ht_cap
.ht_supported
)
686 BUILD_BUG_ON(ARRAY_SIZE(minstrel_mcs_groups
) !=
687 MINSTREL_MAX_STREAMS
* MINSTREL_STREAM_GROUPS
);
690 memset(mi
, 0, sizeof(*mi
));
691 mi
->stats_update
= jiffies
;
693 ack_dur
= ieee80211_frame_duration(local
, 10, 60, 1, 1);
694 mi
->overhead
= ieee80211_frame_duration(local
, 0, 60, 1, 1) + ack_dur
;
695 mi
->overhead_rtscts
= mi
->overhead
+ 2 * ack_dur
;
697 mi
->avg_ampdu_len
= MINSTREL_FRAC(1, 1);
699 /* When using MRR, sample more on the first attempt, without delay */
701 mi
->sample_count
= 16;
704 mi
->sample_count
= 8;
707 mi
->sample_tries
= 4;
709 stbc
= (sta_cap
& IEEE80211_HT_CAP_RX_STBC
) >>
710 IEEE80211_HT_CAP_RX_STBC_SHIFT
;
711 mi
->tx_flags
|= stbc
<< IEEE80211_TX_CTL_STBC_SHIFT
;
713 if (sta_cap
& IEEE80211_HT_CAP_LDPC_CODING
)
714 mi
->tx_flags
|= IEEE80211_TX_CTL_LDPC
;
716 if (oper_chan_type
!= NL80211_CHAN_HT40MINUS
&&
717 oper_chan_type
!= NL80211_CHAN_HT40PLUS
)
718 sta_cap
&= ~IEEE80211_HT_CAP_SUP_WIDTH_20_40
;
720 for (i
= 0; i
< ARRAY_SIZE(mi
->groups
); i
++) {
723 mi
->groups
[i
].supported
= 0;
724 if (minstrel_mcs_groups
[i
].flags
& IEEE80211_TX_RC_SHORT_GI
) {
725 if (minstrel_mcs_groups
[i
].flags
& IEEE80211_TX_RC_40_MHZ_WIDTH
)
726 req
|= IEEE80211_HT_CAP_SGI_40
;
728 req
|= IEEE80211_HT_CAP_SGI_20
;
731 if (minstrel_mcs_groups
[i
].flags
& IEEE80211_TX_RC_40_MHZ_WIDTH
)
732 req
|= IEEE80211_HT_CAP_SUP_WIDTH_20_40
;
734 if ((sta_cap
& req
) != req
)
737 mi
->groups
[i
].supported
=
738 mcs
->rx_mask
[minstrel_mcs_groups
[i
].streams
- 1];
740 if (mi
->groups
[i
].supported
)
751 memset(&msp
->legacy
, 0, sizeof(msp
->legacy
));
752 msp
->legacy
.r
= msp
->ratelist
;
753 msp
->legacy
.sample_table
= msp
->sample_table
;
754 return mac80211_minstrel
.rate_init(priv
, sband
, sta
, &msp
->legacy
);
758 minstrel_ht_rate_init(void *priv
, struct ieee80211_supported_band
*sband
,
759 struct ieee80211_sta
*sta
, void *priv_sta
)
761 struct minstrel_priv
*mp
= priv
;
763 minstrel_ht_update_caps(priv
, sband
, sta
, priv_sta
, mp
->hw
->conf
.channel_type
);
767 minstrel_ht_rate_update(void *priv
, struct ieee80211_supported_band
*sband
,
768 struct ieee80211_sta
*sta
, void *priv_sta
,
769 u32 changed
, enum nl80211_channel_type oper_chan_type
)
771 minstrel_ht_update_caps(priv
, sband
, sta
, priv_sta
, oper_chan_type
);
775 minstrel_ht_alloc_sta(void *priv
, struct ieee80211_sta
*sta
, gfp_t gfp
)
777 struct ieee80211_supported_band
*sband
;
778 struct minstrel_ht_sta_priv
*msp
;
779 struct minstrel_priv
*mp
= priv
;
780 struct ieee80211_hw
*hw
= mp
->hw
;
784 for (i
= 0; i
< IEEE80211_NUM_BANDS
; i
++) {
785 sband
= hw
->wiphy
->bands
[i
];
786 if (sband
&& sband
->n_bitrates
> max_rates
)
787 max_rates
= sband
->n_bitrates
;
790 msp
= kzalloc(sizeof(struct minstrel_ht_sta
), gfp
);
794 msp
->ratelist
= kzalloc(sizeof(struct minstrel_rate
) * max_rates
, gfp
);
798 msp
->sample_table
= kmalloc(SAMPLE_COLUMNS
* max_rates
, gfp
);
799 if (!msp
->sample_table
)
805 kfree(msp
->ratelist
);
812 minstrel_ht_free_sta(void *priv
, struct ieee80211_sta
*sta
, void *priv_sta
)
814 struct minstrel_ht_sta_priv
*msp
= priv_sta
;
816 kfree(msp
->sample_table
);
817 kfree(msp
->ratelist
);
822 minstrel_ht_alloc(struct ieee80211_hw
*hw
, struct dentry
*debugfsdir
)
824 return mac80211_minstrel
.alloc(hw
, debugfsdir
);
828 minstrel_ht_free(void *priv
)
830 mac80211_minstrel
.free(priv
);
833 static struct rate_control_ops mac80211_minstrel_ht
= {
834 .name
= "minstrel_ht",
835 .tx_status
= minstrel_ht_tx_status
,
836 .get_rate
= minstrel_ht_get_rate
,
837 .rate_init
= minstrel_ht_rate_init
,
838 .rate_update
= minstrel_ht_rate_update
,
839 .alloc_sta
= minstrel_ht_alloc_sta
,
840 .free_sta
= minstrel_ht_free_sta
,
841 .alloc
= minstrel_ht_alloc
,
842 .free
= minstrel_ht_free
,
843 #ifdef CONFIG_MAC80211_DEBUGFS
844 .add_sta_debugfs
= minstrel_ht_add_sta_debugfs
,
845 .remove_sta_debugfs
= minstrel_ht_remove_sta_debugfs
,
851 init_sample_table(void)
854 u8 rnd
[MCS_GROUP_RATES
];
856 memset(sample_table
, 0xff, sizeof(sample_table
));
857 for (col
= 0; col
< SAMPLE_COLUMNS
; col
++) {
858 for (i
= 0; i
< MCS_GROUP_RATES
; i
++) {
859 get_random_bytes(rnd
, sizeof(rnd
));
860 new_idx
= (i
+ rnd
[i
]) % MCS_GROUP_RATES
;
862 while (sample_table
[col
][new_idx
] != 0xff)
863 new_idx
= (new_idx
+ 1) % MCS_GROUP_RATES
;
865 sample_table
[col
][new_idx
] = i
;
871 rc80211_minstrel_ht_init(void)
874 return ieee80211_rate_control_register(&mac80211_minstrel_ht
);
878 rc80211_minstrel_ht_exit(void)
880 ieee80211_rate_control_unregister(&mac80211_minstrel_ht
);