2 * Copyright (C) 2008 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.
9 * Copyright (C) 2005-2007 Derek Smithies <derek@indranet.co.nz>
10 * Sponsored by Indranet Technologies Ltd
13 * Copyright (c) 2005 John Bicket
14 * All rights reserved.
16 * Redistribution and use in source and binary forms, with or without
17 * modification, are permitted provided that the following conditions
19 * 1. Redistributions of source code must retain the above copyright
20 * notice, this list of conditions and the following disclaimer,
21 * without modification.
22 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
23 * similar to the "NO WARRANTY" disclaimer below ("Disclaimer") and any
24 * redistribution must be conditioned upon including a substantially
25 * similar Disclaimer requirement for further binary redistribution.
26 * 3. Neither the names of the above-listed copyright holders nor the names
27 * of any contributors may be used to endorse or promote products derived
28 * from this software without specific prior written permission.
30 * Alternatively, this software may be distributed under the terms of the
31 * GNU General Public License ("GPL") version 2 as published by the Free
32 * Software Foundation.
35 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
36 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
37 * LIMITED TO, THE IMPLIED WARRANTIES OF NONINFRINGEMENT, MERCHANTIBILITY
38 * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
39 * THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY,
40 * OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
41 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
42 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
43 * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
44 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
45 * THE POSSIBILITY OF SUCH DAMAGES.
47 #include <linux/netdevice.h>
48 #include <linux/types.h>
49 #include <linux/skbuff.h>
50 #include <linux/debugfs.h>
51 #include <linux/random.h>
52 #include <linux/ieee80211.h>
53 #include <linux/slab.h>
54 #include <net/mac80211.h>
56 #include "rc80211_minstrel.h"
58 #define SAMPLE_TBL(_mi, _idx, _col) \
59 _mi->sample_table[(_idx * SAMPLE_COLUMNS) + _col]
61 /* convert mac80211 rate index to local array index */
63 rix_to_ndx(struct minstrel_sta_info
*mi
, int rix
)
66 for (i
= rix
; i
>= 0; i
--)
67 if (mi
->r
[i
].rix
== rix
)
72 /* return current EMWA throughput */
73 int minstrel_get_tp_avg(struct minstrel_rate
*mr
, int prob_ewma
)
77 usecs
= mr
->perfect_tx_time
;
81 /* reset thr. below 10% success */
82 if (mr
->stats
.prob_ewma
< MINSTREL_FRAC(10, 100))
85 if (prob_ewma
> MINSTREL_FRAC(90, 100))
86 return MINSTREL_TRUNC(100000 * (MINSTREL_FRAC(90, 100) / usecs
));
88 return MINSTREL_TRUNC(100000 * (prob_ewma
/ usecs
));
91 /* find & sort topmost throughput rates */
93 minstrel_sort_best_tp_rates(struct minstrel_sta_info
*mi
, int i
, u8
*tp_list
)
95 int j
= MAX_THR_RATES
;
96 struct minstrel_rate_stats
*tmp_mrs
= &mi
->r
[j
- 1].stats
;
97 struct minstrel_rate_stats
*cur_mrs
= &mi
->r
[i
].stats
;
99 while (j
> 0 && (minstrel_get_tp_avg(&mi
->r
[i
], cur_mrs
->prob_ewma
) >
100 minstrel_get_tp_avg(&mi
->r
[tp_list
[j
- 1]], tmp_mrs
->prob_ewma
))) {
102 tmp_mrs
= &mi
->r
[tp_list
[j
- 1]].stats
;
105 if (j
< MAX_THR_RATES
- 1)
106 memmove(&tp_list
[j
+ 1], &tp_list
[j
], MAX_THR_RATES
- (j
+ 1));
107 if (j
< MAX_THR_RATES
)
112 minstrel_set_rate(struct minstrel_sta_info
*mi
, struct ieee80211_sta_rates
*ratetbl
,
115 struct minstrel_rate
*r
= &mi
->r
[idx
];
117 ratetbl
->rate
[offset
].idx
= r
->rix
;
118 ratetbl
->rate
[offset
].count
= r
->adjusted_retry_count
;
119 ratetbl
->rate
[offset
].count_cts
= r
->retry_count_cts
;
120 ratetbl
->rate
[offset
].count_rts
= r
->stats
.retry_count_rtscts
;
124 minstrel_update_rates(struct minstrel_priv
*mp
, struct minstrel_sta_info
*mi
)
126 struct ieee80211_sta_rates
*ratetbl
;
129 ratetbl
= kzalloc(sizeof(*ratetbl
), GFP_ATOMIC
);
133 /* Start with max_tp_rate */
134 minstrel_set_rate(mi
, ratetbl
, i
++, mi
->max_tp_rate
[0]);
136 if (mp
->hw
->max_rates
>= 3) {
137 /* At least 3 tx rates supported, use max_tp_rate2 next */
138 minstrel_set_rate(mi
, ratetbl
, i
++, mi
->max_tp_rate
[1]);
141 if (mp
->hw
->max_rates
>= 2) {
142 /* At least 2 tx rates supported, use max_prob_rate next */
143 minstrel_set_rate(mi
, ratetbl
, i
++, mi
->max_prob_rate
);
146 /* Use lowest rate last */
147 ratetbl
->rate
[i
].idx
= mi
->lowest_rix
;
148 ratetbl
->rate
[i
].count
= mp
->max_retry
;
149 ratetbl
->rate
[i
].count_cts
= mp
->max_retry
;
150 ratetbl
->rate
[i
].count_rts
= mp
->max_retry
;
152 rate_control_set_rates(mp
->hw
, mi
->sta
, ratetbl
);
156 * Recalculate statistics and counters of a given rate
159 minstrel_calc_rate_stats(struct minstrel_rate_stats
*mrs
)
161 if (unlikely(mrs
->attempts
> 0)) {
162 mrs
->sample_skipped
= 0;
163 mrs
->cur_prob
= MINSTREL_FRAC(mrs
->success
, mrs
->attempts
);
164 if (unlikely(!mrs
->att_hist
)) {
165 mrs
->prob_ewma
= mrs
->cur_prob
;
167 /* update exponential weighted moving variance */
168 mrs
->prob_ewmsd
= minstrel_ewmsd(mrs
->prob_ewmsd
,
173 /*update exponential weighted moving avarage */
174 mrs
->prob_ewma
= minstrel_ewma(mrs
->prob_ewma
,
178 mrs
->att_hist
+= mrs
->attempts
;
179 mrs
->succ_hist
+= mrs
->success
;
181 mrs
->sample_skipped
++;
184 mrs
->last_success
= mrs
->success
;
185 mrs
->last_attempts
= mrs
->attempts
;
191 minstrel_update_stats(struct minstrel_priv
*mp
, struct minstrel_sta_info
*mi
)
193 u8 tmp_tp_rate
[MAX_THR_RATES
];
194 u8 tmp_prob_rate
= 0;
195 int i
, tmp_cur_tp
, tmp_prob_tp
;
197 for (i
= 0; i
< MAX_THR_RATES
; i
++)
200 for (i
= 0; i
< mi
->n_rates
; i
++) {
201 struct minstrel_rate
*mr
= &mi
->r
[i
];
202 struct minstrel_rate_stats
*mrs
= &mi
->r
[i
].stats
;
203 struct minstrel_rate_stats
*tmp_mrs
= &mi
->r
[tmp_prob_rate
].stats
;
205 /* Update statistics of success probability per rate */
206 minstrel_calc_rate_stats(mrs
);
208 /* Sample less often below the 10% chance of success.
209 * Sample less often above the 95% chance of success. */
210 if (mrs
->prob_ewma
> MINSTREL_FRAC(95, 100) ||
211 mrs
->prob_ewma
< MINSTREL_FRAC(10, 100)) {
212 mr
->adjusted_retry_count
= mrs
->retry_count
>> 1;
213 if (mr
->adjusted_retry_count
> 2)
214 mr
->adjusted_retry_count
= 2;
215 mr
->sample_limit
= 4;
217 mr
->sample_limit
= -1;
218 mr
->adjusted_retry_count
= mrs
->retry_count
;
220 if (!mr
->adjusted_retry_count
)
221 mr
->adjusted_retry_count
= 2;
223 minstrel_sort_best_tp_rates(mi
, i
, tmp_tp_rate
);
225 /* To determine the most robust rate (max_prob_rate) used at
226 * 3rd mmr stage we distinct between two cases:
227 * (1) if any success probabilitiy >= 95%, out of those rates
228 * choose the maximum throughput rate as max_prob_rate
229 * (2) if all success probabilities < 95%, the rate with
230 * highest success probability is chosen as max_prob_rate */
231 if (mrs
->prob_ewma
>= MINSTREL_FRAC(95, 100)) {
232 tmp_cur_tp
= minstrel_get_tp_avg(mr
, mrs
->prob_ewma
);
233 tmp_prob_tp
= minstrel_get_tp_avg(&mi
->r
[tmp_prob_rate
],
235 if (tmp_cur_tp
>= tmp_prob_tp
)
238 if (mrs
->prob_ewma
>= tmp_mrs
->prob_ewma
)
243 /* Assign the new rate set */
244 memcpy(mi
->max_tp_rate
, tmp_tp_rate
, sizeof(mi
->max_tp_rate
));
245 mi
->max_prob_rate
= tmp_prob_rate
;
247 #ifdef CONFIG_MAC80211_DEBUGFS
248 /* use fixed index if set */
249 if (mp
->fixed_rate_idx
!= -1) {
250 mi
->max_tp_rate
[0] = mp
->fixed_rate_idx
;
251 mi
->max_tp_rate
[1] = mp
->fixed_rate_idx
;
252 mi
->max_prob_rate
= mp
->fixed_rate_idx
;
256 /* Reset update timer */
257 mi
->last_stats_update
= jiffies
;
259 minstrel_update_rates(mp
, mi
);
263 minstrel_tx_status(void *priv
, struct ieee80211_supported_band
*sband
,
264 struct ieee80211_sta
*sta
, void *priv_sta
,
265 struct ieee80211_tx_info
*info
)
267 struct minstrel_priv
*mp
= priv
;
268 struct minstrel_sta_info
*mi
= priv_sta
;
269 struct ieee80211_tx_rate
*ar
= info
->status
.rates
;
273 success
= !!(info
->flags
& IEEE80211_TX_STAT_ACK
);
275 for (i
= 0; i
< IEEE80211_TX_MAX_RATES
; i
++) {
279 ndx
= rix_to_ndx(mi
, ar
[i
].idx
);
283 mi
->r
[ndx
].stats
.attempts
+= ar
[i
].count
;
285 if ((i
!= IEEE80211_TX_MAX_RATES
- 1) && (ar
[i
+ 1].idx
< 0))
286 mi
->r
[ndx
].stats
.success
+= success
;
289 if ((info
->flags
& IEEE80211_TX_CTL_RATE_CTRL_PROBE
) && (i
>= 0))
290 mi
->sample_packets
++;
292 if (mi
->sample_deferred
> 0)
293 mi
->sample_deferred
--;
295 if (time_after(jiffies
, mi
->last_stats_update
+
296 (mp
->update_interval
* HZ
) / 1000))
297 minstrel_update_stats(mp
, mi
);
301 static inline unsigned int
302 minstrel_get_retry_count(struct minstrel_rate
*mr
,
303 struct ieee80211_tx_info
*info
)
305 u8 retry
= mr
->adjusted_retry_count
;
307 if (info
->control
.use_rts
)
308 retry
= max_t(u8
, 2, min(mr
->stats
.retry_count_rtscts
, retry
));
309 else if (info
->control
.use_cts_prot
)
310 retry
= max_t(u8
, 2, min(mr
->retry_count_cts
, retry
));
316 minstrel_get_next_sample(struct minstrel_sta_info
*mi
)
318 unsigned int sample_ndx
;
319 sample_ndx
= SAMPLE_TBL(mi
, mi
->sample_row
, mi
->sample_column
);
321 if ((int) mi
->sample_row
>= mi
->n_rates
) {
324 if (mi
->sample_column
>= SAMPLE_COLUMNS
)
325 mi
->sample_column
= 0;
331 minstrel_get_rate(void *priv
, struct ieee80211_sta
*sta
,
332 void *priv_sta
, struct ieee80211_tx_rate_control
*txrc
)
334 struct sk_buff
*skb
= txrc
->skb
;
335 struct ieee80211_tx_info
*info
= IEEE80211_SKB_CB(skb
);
336 struct minstrel_sta_info
*mi
= priv_sta
;
337 struct minstrel_priv
*mp
= priv
;
338 struct ieee80211_tx_rate
*rate
= &info
->control
.rates
[0];
339 struct minstrel_rate
*msr
, *mr
;
346 /* management/no-ack frames do not use rate control */
347 if (rate_control_send_low(sta
, priv_sta
, txrc
))
350 /* check multi-rate-retry capabilities & adjust lookaround_rate */
351 mrr_capable
= mp
->has_mrr
&&
353 !txrc
->bss_conf
->use_cts_prot
;
355 sampling_ratio
= mp
->lookaround_rate_mrr
;
357 sampling_ratio
= mp
->lookaround_rate
;
359 /* increase sum packet counter */
362 #ifdef CONFIG_MAC80211_DEBUGFS
363 if (mp
->fixed_rate_idx
!= -1)
367 delta
= (mi
->total_packets
* sampling_ratio
/ 100) -
368 (mi
->sample_packets
+ mi
->sample_deferred
/ 2);
370 /* delta < 0: no sampling required */
371 prev_sample
= mi
->prev_sample
;
372 mi
->prev_sample
= false;
373 if (delta
< 0 || (!mrr_capable
&& prev_sample
))
376 if (mi
->total_packets
>= 10000) {
377 mi
->sample_deferred
= 0;
378 mi
->sample_packets
= 0;
379 mi
->total_packets
= 0;
380 } else if (delta
> mi
->n_rates
* 2) {
381 /* With multi-rate retry, not every planned sample
382 * attempt actually gets used, due to the way the retry
383 * chain is set up - [max_tp,sample,prob,lowest] for
384 * sample_rate < max_tp.
386 * If there's too much sampling backlog and the link
387 * starts getting worse, minstrel would start bursting
388 * out lots of sampling frames, which would result
389 * in a large throughput loss. */
390 mi
->sample_packets
+= (delta
- mi
->n_rates
* 2);
393 /* get next random rate sample */
394 ndx
= minstrel_get_next_sample(mi
);
396 mr
= &mi
->r
[mi
->max_tp_rate
[0]];
398 /* Decide if direct ( 1st mrr stage) or indirect (2nd mrr stage)
399 * rate sampling method should be used.
400 * Respect such rates that are not sampled for 20 interations.
403 msr
->perfect_tx_time
> mr
->perfect_tx_time
&&
404 msr
->stats
.sample_skipped
< 20) {
405 /* Only use IEEE80211_TX_CTL_RATE_CTRL_PROBE to mark
406 * packets that have the sampling rate deferred to the
407 * second MRR stage. Increase the sample counter only
408 * if the deferred sample rate was actually used.
409 * Use the sample_deferred counter to make sure that
410 * the sampling is not done in large bursts */
411 info
->flags
|= IEEE80211_TX_CTL_RATE_CTRL_PROBE
;
413 mi
->sample_deferred
++;
415 if (!msr
->sample_limit
)
418 mi
->sample_packets
++;
419 if (msr
->sample_limit
> 0)
423 /* If we're not using MRR and the sampling rate already
424 * has a probability of >95%, we shouldn't be attempting
425 * to use it, as this only wastes precious airtime */
427 (mi
->r
[ndx
].stats
.prob_ewma
> MINSTREL_FRAC(95, 100)))
430 mi
->prev_sample
= true;
432 rate
->idx
= mi
->r
[ndx
].rix
;
433 rate
->count
= minstrel_get_retry_count(&mi
->r
[ndx
], info
);
438 calc_rate_durations(enum ieee80211_band band
,
439 struct minstrel_rate
*d
,
440 struct ieee80211_rate
*rate
,
441 struct cfg80211_chan_def
*chandef
)
443 int erp
= !!(rate
->flags
& IEEE80211_RATE_ERP_G
);
444 int shift
= ieee80211_chandef_get_shift(chandef
);
446 d
->perfect_tx_time
= ieee80211_frame_duration(band
, 1200,
447 DIV_ROUND_UP(rate
->bitrate
, 1 << shift
), erp
, 1,
449 d
->ack_time
= ieee80211_frame_duration(band
, 10,
450 DIV_ROUND_UP(rate
->bitrate
, 1 << shift
), erp
, 1,
455 init_sample_table(struct minstrel_sta_info
*mi
)
457 unsigned int i
, col
, new_idx
;
460 mi
->sample_column
= 0;
462 memset(mi
->sample_table
, 0xff, SAMPLE_COLUMNS
* mi
->n_rates
);
464 for (col
= 0; col
< SAMPLE_COLUMNS
; col
++) {
465 prandom_bytes(rnd
, sizeof(rnd
));
466 for (i
= 0; i
< mi
->n_rates
; i
++) {
467 new_idx
= (i
+ rnd
[i
& 7]) % mi
->n_rates
;
468 while (SAMPLE_TBL(mi
, new_idx
, col
) != 0xff)
469 new_idx
= (new_idx
+ 1) % mi
->n_rates
;
471 SAMPLE_TBL(mi
, new_idx
, col
) = i
;
477 minstrel_rate_init(void *priv
, struct ieee80211_supported_band
*sband
,
478 struct cfg80211_chan_def
*chandef
,
479 struct ieee80211_sta
*sta
, void *priv_sta
)
481 struct minstrel_sta_info
*mi
= priv_sta
;
482 struct minstrel_priv
*mp
= priv
;
483 struct ieee80211_rate
*ctl_rate
;
484 unsigned int i
, n
= 0;
485 unsigned int t_slot
= 9; /* FIXME: get real slot time */
489 mi
->lowest_rix
= rate_lowest_index(sband
, sta
);
490 ctl_rate
= &sband
->bitrates
[mi
->lowest_rix
];
491 mi
->sp_ack_dur
= ieee80211_frame_duration(sband
->band
, 10,
493 !!(ctl_rate
->flags
& IEEE80211_RATE_ERP_G
), 1,
494 ieee80211_chandef_get_shift(chandef
));
496 rate_flags
= ieee80211_chandef_rate_flags(&mp
->hw
->conf
.chandef
);
497 memset(mi
->max_tp_rate
, 0, sizeof(mi
->max_tp_rate
));
498 mi
->max_prob_rate
= 0;
500 for (i
= 0; i
< sband
->n_bitrates
; i
++) {
501 struct minstrel_rate
*mr
= &mi
->r
[n
];
502 struct minstrel_rate_stats
*mrs
= &mi
->r
[n
].stats
;
503 unsigned int tx_time
= 0, tx_time_cts
= 0, tx_time_rtscts
= 0;
504 unsigned int tx_time_single
;
505 unsigned int cw
= mp
->cw_min
;
508 if (!rate_supported(sta
, sband
->band
, i
))
510 if ((rate_flags
& sband
->bitrates
[i
].flags
) != rate_flags
)
514 memset(mr
, 0, sizeof(*mr
));
515 memset(mrs
, 0, sizeof(*mrs
));
518 shift
= ieee80211_chandef_get_shift(chandef
);
519 mr
->bitrate
= DIV_ROUND_UP(sband
->bitrates
[i
].bitrate
,
521 calc_rate_durations(sband
->band
, mr
, &sband
->bitrates
[i
],
524 /* calculate maximum number of retransmissions before
525 * fallback (based on maximum segment size) */
526 mr
->sample_limit
= -1;
527 mrs
->retry_count
= 1;
528 mr
->retry_count_cts
= 1;
529 mrs
->retry_count_rtscts
= 1;
530 tx_time
= mr
->perfect_tx_time
+ mi
->sp_ack_dur
;
532 /* add one retransmission */
533 tx_time_single
= mr
->ack_time
+ mr
->perfect_tx_time
;
535 /* contention window */
536 tx_time_single
+= (t_slot
* cw
) >> 1;
537 cw
= min((cw
<< 1) | 1, mp
->cw_max
);
539 tx_time
+= tx_time_single
;
540 tx_time_cts
+= tx_time_single
+ mi
->sp_ack_dur
;
541 tx_time_rtscts
+= tx_time_single
+ 2 * mi
->sp_ack_dur
;
542 if ((tx_time_cts
< mp
->segment_size
) &&
543 (mr
->retry_count_cts
< mp
->max_retry
))
544 mr
->retry_count_cts
++;
545 if ((tx_time_rtscts
< mp
->segment_size
) &&
546 (mrs
->retry_count_rtscts
< mp
->max_retry
))
547 mrs
->retry_count_rtscts
++;
548 } while ((tx_time
< mp
->segment_size
) &&
549 (++mr
->stats
.retry_count
< mp
->max_retry
));
550 mr
->adjusted_retry_count
= mrs
->retry_count
;
551 if (!(sband
->bitrates
[i
].flags
& IEEE80211_RATE_ERP_G
))
552 mr
->retry_count_cts
= mrs
->retry_count
;
555 for (i
= n
; i
< sband
->n_bitrates
; i
++) {
556 struct minstrel_rate
*mr
= &mi
->r
[i
];
561 mi
->last_stats_update
= jiffies
;
563 init_sample_table(mi
);
564 minstrel_update_rates(mp
, mi
);
568 minstrel_alloc_sta(void *priv
, struct ieee80211_sta
*sta
, gfp_t gfp
)
570 struct ieee80211_supported_band
*sband
;
571 struct minstrel_sta_info
*mi
;
572 struct minstrel_priv
*mp
= priv
;
573 struct ieee80211_hw
*hw
= mp
->hw
;
577 mi
= kzalloc(sizeof(struct minstrel_sta_info
), gfp
);
581 for (i
= 0; i
< IEEE80211_NUM_BANDS
; i
++) {
582 sband
= hw
->wiphy
->bands
[i
];
583 if (sband
&& sband
->n_bitrates
> max_rates
)
584 max_rates
= sband
->n_bitrates
;
587 mi
->r
= kzalloc(sizeof(struct minstrel_rate
) * max_rates
, gfp
);
591 mi
->sample_table
= kmalloc(SAMPLE_COLUMNS
* max_rates
, gfp
);
592 if (!mi
->sample_table
)
595 mi
->last_stats_update
= jiffies
;
606 minstrel_free_sta(void *priv
, struct ieee80211_sta
*sta
, void *priv_sta
)
608 struct minstrel_sta_info
*mi
= priv_sta
;
610 kfree(mi
->sample_table
);
616 minstrel_init_cck_rates(struct minstrel_priv
*mp
)
618 static const int bitrates
[4] = { 10, 20, 55, 110 };
619 struct ieee80211_supported_band
*sband
;
620 u32 rate_flags
= ieee80211_chandef_rate_flags(&mp
->hw
->conf
.chandef
);
623 sband
= mp
->hw
->wiphy
->bands
[IEEE80211_BAND_2GHZ
];
627 for (i
= 0, j
= 0; i
< sband
->n_bitrates
; i
++) {
628 struct ieee80211_rate
*rate
= &sband
->bitrates
[i
];
630 if (rate
->flags
& IEEE80211_RATE_ERP_G
)
633 if ((rate_flags
& sband
->bitrates
[i
].flags
) != rate_flags
)
636 for (j
= 0; j
< ARRAY_SIZE(bitrates
); j
++) {
637 if (rate
->bitrate
!= bitrates
[j
])
640 mp
->cck_rates
[j
] = i
;
647 minstrel_alloc(struct ieee80211_hw
*hw
, struct dentry
*debugfsdir
)
649 struct minstrel_priv
*mp
;
651 mp
= kzalloc(sizeof(struct minstrel_priv
), GFP_ATOMIC
);
655 /* contention window settings
656 * Just an approximation. Using the per-queue values would complicate
657 * the calculations and is probably unnecessary */
661 /* number of packets (in %) to use for sampling other rates
662 * sample less often for non-mrr packets, because the overhead
663 * is much higher than with mrr */
664 mp
->lookaround_rate
= 5;
665 mp
->lookaround_rate_mrr
= 10;
667 /* maximum time that the hw is allowed to stay in one MRR segment */
668 mp
->segment_size
= 6000;
670 if (hw
->max_rate_tries
> 0)
671 mp
->max_retry
= hw
->max_rate_tries
;
673 /* safe default, does not necessarily have to match hw properties */
676 if (hw
->max_rates
>= 4)
680 mp
->update_interval
= 100;
682 #ifdef CONFIG_MAC80211_DEBUGFS
683 mp
->fixed_rate_idx
= (u32
) -1;
684 mp
->dbg_fixed_rate
= debugfs_create_u32("fixed_rate_idx",
685 S_IRUGO
| S_IWUGO
, debugfsdir
, &mp
->fixed_rate_idx
);
688 minstrel_init_cck_rates(mp
);
694 minstrel_free(void *priv
)
696 #ifdef CONFIG_MAC80211_DEBUGFS
697 debugfs_remove(((struct minstrel_priv
*)priv
)->dbg_fixed_rate
);
702 static u32
minstrel_get_expected_throughput(void *priv_sta
)
704 struct minstrel_sta_info
*mi
= priv_sta
;
705 struct minstrel_rate_stats
*tmp_mrs
;
706 int idx
= mi
->max_tp_rate
[0];
709 /* convert pkt per sec in kbps (1200 is the average pkt size used for
712 tmp_mrs
= &mi
->r
[idx
].stats
;
713 tmp_cur_tp
= minstrel_get_tp_avg(&mi
->r
[idx
], tmp_mrs
->prob_ewma
);
714 tmp_cur_tp
= tmp_cur_tp
* 1200 * 8 / 1024;
719 const struct rate_control_ops mac80211_minstrel
= {
721 .tx_status_noskb
= minstrel_tx_status
,
722 .get_rate
= minstrel_get_rate
,
723 .rate_init
= minstrel_rate_init
,
724 .alloc
= minstrel_alloc
,
725 .free
= minstrel_free
,
726 .alloc_sta
= minstrel_alloc_sta
,
727 .free_sta
= minstrel_free_sta
,
728 #ifdef CONFIG_MAC80211_DEBUGFS
729 .add_sta_debugfs
= minstrel_add_sta_debugfs
,
730 .remove_sta_debugfs
= minstrel_remove_sta_debugfs
,
732 .get_expected_throughput
= minstrel_get_expected_throughput
,
736 rc80211_minstrel_init(void)
738 return ieee80211_rate_control_register(&mac80211_minstrel
);
742 rc80211_minstrel_exit(void)
744 ieee80211_rate_control_unregister(&mac80211_minstrel
);