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 availble 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 ieee80211_start_tx_ba_session(pubsta
, tid
);
378 minstrel_ht_tx_status(void *priv
, struct ieee80211_supported_band
*sband
,
379 struct ieee80211_sta
*sta
, void *priv_sta
,
382 struct minstrel_ht_sta_priv
*msp
= priv_sta
;
383 struct minstrel_ht_sta
*mi
= &msp
->ht
;
384 struct ieee80211_tx_info
*info
= IEEE80211_SKB_CB(skb
);
385 struct ieee80211_tx_rate
*ar
= info
->status
.rates
;
386 struct minstrel_rate_stats
*rate
, *rate2
;
387 struct minstrel_priv
*mp
= priv
;
393 return mac80211_minstrel
.tx_status(priv
, sband
, sta
, &msp
->legacy
, skb
);
395 /* This packet was aggregated but doesn't carry status info */
396 if ((info
->flags
& IEEE80211_TX_CTL_AMPDU
) &&
397 !(info
->flags
& IEEE80211_TX_STAT_AMPDU
))
400 if (!(info
->flags
& IEEE80211_TX_STAT_AMPDU
)) {
401 info
->status
.ampdu_ack_len
=
402 (info
->flags
& IEEE80211_TX_STAT_ACK
? 1 : 0);
403 info
->status
.ampdu_len
= 1;
407 mi
->ampdu_len
+= info
->status
.ampdu_len
;
409 if (!mi
->sample_wait
&& !mi
->sample_tries
&& mi
->sample_count
> 0) {
410 mi
->sample_wait
= 4 + 2 * MINSTREL_TRUNC(mi
->avg_ampdu_len
);
411 mi
->sample_tries
= 3;
415 if (info
->flags
& IEEE80211_TX_CTL_RATE_CTRL_PROBE
) {
416 mi
->sample_packets
+= info
->status
.ampdu_len
;
417 minstrel_next_sample_idx(mi
);
420 for (i
= 0; !last
; i
++) {
421 last
= (i
== IEEE80211_TX_MAX_RATES
- 1) ||
422 !minstrel_ht_txstat_valid(&ar
[i
+ 1]);
424 if (!minstrel_ht_txstat_valid(&ar
[i
]))
427 group
= minstrel_ht_get_group_idx(&ar
[i
]);
428 rate
= &mi
->groups
[group
].rates
[ar
[i
].idx
% 8];
431 rate
->success
+= info
->status
.ampdu_ack_len
;
433 rate
->attempts
+= ar
[i
].count
* info
->status
.ampdu_len
;
437 * check for sudden death of spatial multiplexing,
438 * downgrade to a lower number of streams if necessary.
440 rate
= minstrel_get_ratestats(mi
, mi
->max_tp_rate
);
441 if (rate
->attempts
> 30 &&
442 MINSTREL_FRAC(rate
->success
, rate
->attempts
) <
443 MINSTREL_FRAC(20, 100))
444 minstrel_downgrade_rate(mi
, &mi
->max_tp_rate
, true);
446 rate2
= minstrel_get_ratestats(mi
, mi
->max_tp_rate2
);
447 if (rate2
->attempts
> 30 &&
448 MINSTREL_FRAC(rate2
->success
, rate2
->attempts
) <
449 MINSTREL_FRAC(20, 100))
450 minstrel_downgrade_rate(mi
, &mi
->max_tp_rate2
, false);
452 if (time_after(jiffies
, mi
->stats_update
+ (mp
->update_interval
/ 2 * HZ
) / 1000)) {
453 minstrel_ht_update_stats(mp
, mi
);
454 minstrel_aggr_check(mp
, sta
, skb
);
459 minstrel_calc_retransmit(struct minstrel_priv
*mp
, struct minstrel_ht_sta
*mi
,
462 struct minstrel_rate_stats
*mr
;
463 const struct mcs_group
*group
;
464 unsigned int tx_time
, tx_time_rtscts
, tx_time_data
;
465 unsigned int cw
= mp
->cw_min
;
466 unsigned int t_slot
= 9; /* FIXME */
467 unsigned int ampdu_len
= MINSTREL_TRUNC(mi
->avg_ampdu_len
);
469 mr
= minstrel_get_ratestats(mi
, index
);
470 if (mr
->probability
< MINSTREL_FRAC(1, 10)) {
472 mr
->retry_count_rtscts
= 1;
477 mr
->retry_count_rtscts
= 2;
478 mr
->retry_updated
= true;
480 group
= &minstrel_mcs_groups
[index
/ MCS_GROUP_RATES
];
481 tx_time_data
= group
->duration
[index
% MCS_GROUP_RATES
] * ampdu_len
;
482 tx_time
= 2 * (t_slot
+ mi
->overhead
+ tx_time_data
);
483 tx_time_rtscts
= 2 * (t_slot
+ mi
->overhead_rtscts
+ tx_time_data
);
486 cw
= min(cw
, mp
->cw_max
);
487 tx_time
+= cw
+ t_slot
+ mi
->overhead
;
488 tx_time_rtscts
+= cw
+ t_slot
+ mi
->overhead_rtscts
;
489 if (tx_time_rtscts
< mp
->segment_size
)
490 mr
->retry_count_rtscts
++;
491 } while ((tx_time
< mp
->segment_size
) &&
492 (++mr
->retry_count
< mp
->max_retry
));
497 minstrel_ht_set_rate(struct minstrel_priv
*mp
, struct minstrel_ht_sta
*mi
,
498 struct ieee80211_tx_rate
*rate
, int index
,
499 struct ieee80211_tx_rate_control
*txrc
,
500 bool sample
, bool rtscts
)
502 const struct mcs_group
*group
= &minstrel_mcs_groups
[index
/ MCS_GROUP_RATES
];
503 struct minstrel_rate_stats
*mr
;
505 mr
= minstrel_get_ratestats(mi
, index
);
506 if (!mr
->retry_updated
)
507 minstrel_calc_retransmit(mp
, mi
, index
);
509 if (mr
->probability
< MINSTREL_FRAC(20, 100))
512 rate
->count
= mr
->retry_count_rtscts
;
514 rate
->count
= mr
->retry_count
;
516 rate
->flags
= IEEE80211_TX_RC_MCS
| group
->flags
;
517 if (txrc
->short_preamble
)
518 rate
->flags
|= IEEE80211_TX_RC_USE_SHORT_PREAMBLE
;
519 if (txrc
->rts
|| rtscts
)
520 rate
->flags
|= IEEE80211_TX_RC_USE_RTS_CTS
;
521 rate
->idx
= index
% MCS_GROUP_RATES
+ (group
->streams
- 1) * MCS_GROUP_RATES
;
525 minstrel_get_duration(int index
)
527 const struct mcs_group
*group
= &minstrel_mcs_groups
[index
/ MCS_GROUP_RATES
];
528 return group
->duration
[index
% MCS_GROUP_RATES
];
532 minstrel_get_sample_rate(struct minstrel_priv
*mp
, struct minstrel_ht_sta
*mi
)
534 struct minstrel_rate_stats
*mr
;
535 struct minstrel_mcs_group_data
*mg
;
538 if (mi
->sample_wait
> 0) {
543 if (!mi
->sample_tries
)
547 mg
= &mi
->groups
[mi
->sample_group
];
548 sample_idx
= sample_table
[mg
->column
][mg
->index
];
549 mr
= &mg
->rates
[sample_idx
];
550 sample_idx
+= mi
->sample_group
* MCS_GROUP_RATES
;
553 * When not using MRR, do not sample if the probability is already
554 * higher than 95% to avoid wasting airtime
556 if (!mp
->has_mrr
&& (mr
->probability
> MINSTREL_FRAC(95, 100)))
560 * Make sure that lower rates get sampled only occasionally,
561 * if the link is working perfectly.
563 if (minstrel_get_duration(sample_idx
) >
564 minstrel_get_duration(mi
->max_tp_rate
)) {
565 if (mr
->sample_skipped
< 10)
568 if (mi
->sample_slow
++ > 2)
575 minstrel_next_sample_idx(mi
);
580 minstrel_ht_get_rate(void *priv
, struct ieee80211_sta
*sta
, void *priv_sta
,
581 struct ieee80211_tx_rate_control
*txrc
)
583 struct ieee80211_tx_info
*info
= IEEE80211_SKB_CB(txrc
->skb
);
584 struct ieee80211_tx_rate
*ar
= info
->status
.rates
;
585 struct minstrel_ht_sta_priv
*msp
= priv_sta
;
586 struct minstrel_ht_sta
*mi
= &msp
->ht
;
587 struct minstrel_priv
*mp
= priv
;
590 if (rate_control_send_low(sta
, priv_sta
, txrc
))
594 return mac80211_minstrel
.get_rate(priv
, sta
, &msp
->legacy
, txrc
);
596 info
->flags
|= mi
->tx_flags
;
597 sample_idx
= minstrel_get_sample_rate(mp
, mi
);
598 if (sample_idx
>= 0) {
599 minstrel_ht_set_rate(mp
, mi
, &ar
[0], sample_idx
,
601 minstrel_ht_set_rate(mp
, mi
, &ar
[1], mi
->max_tp_rate
,
603 info
->flags
|= IEEE80211_TX_CTL_RATE_CTRL_PROBE
;
605 minstrel_ht_set_rate(mp
, mi
, &ar
[0], mi
->max_tp_rate
,
607 minstrel_ht_set_rate(mp
, mi
, &ar
[1], mi
->max_tp_rate2
,
610 minstrel_ht_set_rate(mp
, mi
, &ar
[2], mi
->max_prob_rate
, txrc
, false, true);
618 if (mi
->total_packets
== ~0) {
619 mi
->total_packets
= 0;
620 mi
->sample_packets
= 0;
625 minstrel_ht_update_caps(void *priv
, struct ieee80211_supported_band
*sband
,
626 struct ieee80211_sta
*sta
, void *priv_sta
,
627 enum nl80211_channel_type oper_chan_type
)
629 struct minstrel_priv
*mp
= priv
;
630 struct minstrel_ht_sta_priv
*msp
= priv_sta
;
631 struct minstrel_ht_sta
*mi
= &msp
->ht
;
632 struct ieee80211_mcs_info
*mcs
= &sta
->ht_cap
.mcs
;
633 struct ieee80211_local
*local
= hw_to_local(mp
->hw
);
634 u16 sta_cap
= sta
->ht_cap
.cap
;
639 /* fall back to the old minstrel for legacy stations */
640 if (!sta
->ht_cap
.ht_supported
) {
642 memset(&msp
->legacy
, 0, sizeof(msp
->legacy
));
643 msp
->legacy
.r
= msp
->ratelist
;
644 msp
->legacy
.sample_table
= msp
->sample_table
;
645 return mac80211_minstrel
.rate_init(priv
, sband
, sta
, &msp
->legacy
);
648 BUILD_BUG_ON(ARRAY_SIZE(minstrel_mcs_groups
) !=
649 MINSTREL_MAX_STREAMS
* MINSTREL_STREAM_GROUPS
);
652 memset(mi
, 0, sizeof(*mi
));
653 mi
->stats_update
= jiffies
;
655 ack_dur
= ieee80211_frame_duration(local
, 10, 60, 1, 1);
656 mi
->overhead
= ieee80211_frame_duration(local
, 0, 60, 1, 1) + ack_dur
;
657 mi
->overhead_rtscts
= mi
->overhead
+ 2 * ack_dur
;
659 mi
->avg_ampdu_len
= MINSTREL_FRAC(1, 1);
661 /* When using MRR, sample more on the first attempt, without delay */
663 mi
->sample_count
= 16;
666 mi
->sample_count
= 8;
669 mi
->sample_tries
= 4;
671 stbc
= (sta_cap
& IEEE80211_HT_CAP_RX_STBC
) >>
672 IEEE80211_HT_CAP_RX_STBC_SHIFT
;
673 mi
->tx_flags
|= stbc
<< IEEE80211_TX_CTL_STBC_SHIFT
;
675 if (sta_cap
& IEEE80211_HT_CAP_LDPC_CODING
)
676 mi
->tx_flags
|= IEEE80211_TX_CTL_LDPC
;
678 if (oper_chan_type
!= NL80211_CHAN_HT40MINUS
&&
679 oper_chan_type
!= NL80211_CHAN_HT40PLUS
)
680 sta_cap
&= ~IEEE80211_HT_CAP_SUP_WIDTH_20_40
;
682 for (i
= 0; i
< ARRAY_SIZE(mi
->groups
); i
++) {
685 mi
->groups
[i
].supported
= 0;
686 if (minstrel_mcs_groups
[i
].flags
& IEEE80211_TX_RC_SHORT_GI
) {
687 if (minstrel_mcs_groups
[i
].flags
& IEEE80211_TX_RC_40_MHZ_WIDTH
)
688 req
|= IEEE80211_HT_CAP_SGI_40
;
690 req
|= IEEE80211_HT_CAP_SGI_20
;
693 if (minstrel_mcs_groups
[i
].flags
& IEEE80211_TX_RC_40_MHZ_WIDTH
)
694 req
|= IEEE80211_HT_CAP_SUP_WIDTH_20_40
;
696 if ((sta_cap
& req
) != req
)
699 mi
->groups
[i
].supported
=
700 mcs
->rx_mask
[minstrel_mcs_groups
[i
].streams
- 1];
705 minstrel_ht_rate_init(void *priv
, struct ieee80211_supported_band
*sband
,
706 struct ieee80211_sta
*sta
, void *priv_sta
)
708 struct minstrel_priv
*mp
= priv
;
710 minstrel_ht_update_caps(priv
, sband
, sta
, priv_sta
, mp
->hw
->conf
.channel_type
);
714 minstrel_ht_rate_update(void *priv
, struct ieee80211_supported_band
*sband
,
715 struct ieee80211_sta
*sta
, void *priv_sta
,
716 u32 changed
, enum nl80211_channel_type oper_chan_type
)
718 minstrel_ht_update_caps(priv
, sband
, sta
, priv_sta
, oper_chan_type
);
722 minstrel_ht_alloc_sta(void *priv
, struct ieee80211_sta
*sta
, gfp_t gfp
)
724 struct ieee80211_supported_band
*sband
;
725 struct minstrel_ht_sta_priv
*msp
;
726 struct minstrel_priv
*mp
= priv
;
727 struct ieee80211_hw
*hw
= mp
->hw
;
731 for (i
= 0; i
< IEEE80211_NUM_BANDS
; i
++) {
732 sband
= hw
->wiphy
->bands
[i
];
733 if (sband
&& sband
->n_bitrates
> max_rates
)
734 max_rates
= sband
->n_bitrates
;
737 msp
= kzalloc(sizeof(struct minstrel_ht_sta
), gfp
);
741 msp
->ratelist
= kzalloc(sizeof(struct minstrel_rate
) * max_rates
, gfp
);
745 msp
->sample_table
= kmalloc(SAMPLE_COLUMNS
* max_rates
, gfp
);
746 if (!msp
->sample_table
)
752 kfree(msp
->ratelist
);
759 minstrel_ht_free_sta(void *priv
, struct ieee80211_sta
*sta
, void *priv_sta
)
761 struct minstrel_ht_sta_priv
*msp
= priv_sta
;
763 kfree(msp
->sample_table
);
764 kfree(msp
->ratelist
);
769 minstrel_ht_alloc(struct ieee80211_hw
*hw
, struct dentry
*debugfsdir
)
771 return mac80211_minstrel
.alloc(hw
, debugfsdir
);
775 minstrel_ht_free(void *priv
)
777 mac80211_minstrel
.free(priv
);
780 static struct rate_control_ops mac80211_minstrel_ht
= {
781 .name
= "minstrel_ht",
782 .tx_status
= minstrel_ht_tx_status
,
783 .get_rate
= minstrel_ht_get_rate
,
784 .rate_init
= minstrel_ht_rate_init
,
785 .rate_update
= minstrel_ht_rate_update
,
786 .alloc_sta
= minstrel_ht_alloc_sta
,
787 .free_sta
= minstrel_ht_free_sta
,
788 .alloc
= minstrel_ht_alloc
,
789 .free
= minstrel_ht_free
,
790 #ifdef CONFIG_MAC80211_DEBUGFS
791 .add_sta_debugfs
= minstrel_ht_add_sta_debugfs
,
792 .remove_sta_debugfs
= minstrel_ht_remove_sta_debugfs
,
798 init_sample_table(void)
801 u8 rnd
[MCS_GROUP_RATES
];
803 memset(sample_table
, 0xff, sizeof(sample_table
));
804 for (col
= 0; col
< SAMPLE_COLUMNS
; col
++) {
805 for (i
= 0; i
< MCS_GROUP_RATES
; i
++) {
806 get_random_bytes(rnd
, sizeof(rnd
));
807 new_idx
= (i
+ rnd
[i
]) % MCS_GROUP_RATES
;
809 while (sample_table
[col
][new_idx
] != 0xff)
810 new_idx
= (new_idx
+ 1) % MCS_GROUP_RATES
;
812 sample_table
[col
][new_idx
] = i
;
818 rc80211_minstrel_ht_init(void)
821 return ieee80211_rate_control_register(&mac80211_minstrel_ht
);
825 rc80211_minstrel_ht_exit(void)
827 ieee80211_rate_control_unregister(&mac80211_minstrel_ht
);