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_AMPDU_SIZE 16
21 #define AVG_PKT_SIZE 1200
23 /* Number of bits for an average sized packet */
24 #define MCS_NBITS ((AVG_PKT_SIZE * AVG_AMPDU_SIZE) << 3)
26 /* Number of symbols for a packet with (bps) bits per symbol */
27 #define MCS_NSYMS(bps) DIV_ROUND_UP(MCS_NBITS, (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) \
38 (MCS_SYMBOL_TIME(sgi, MCS_NSYMS((streams) * (bps))) / AVG_AMPDU_SIZE)
45 * Define group sort order: HT40 -> SGI -> #streams
47 #define GROUP_IDX(_streams, _sgi, _ht40) \
48 MINSTREL_HT_GROUP_0 + \
49 MINSTREL_MAX_STREAMS * 2 * _ht40 + \
50 MINSTREL_MAX_STREAMS * _sgi + \
53 /* MCS rate information for an MCS group */
54 #define MCS_GROUP(_streams, _sgi, _ht40) \
55 [GROUP_IDX(_streams, _sgi, _ht40)] = { \
56 .streams = _streams, \
58 IEEE80211_TX_RC_MCS | \
59 (_sgi ? IEEE80211_TX_RC_SHORT_GI : 0) | \
60 (_ht40 ? IEEE80211_TX_RC_40_MHZ_WIDTH : 0), \
62 MCS_DURATION(_streams, _sgi, _ht40 ? 54 : 26), \
63 MCS_DURATION(_streams, _sgi, _ht40 ? 108 : 52), \
64 MCS_DURATION(_streams, _sgi, _ht40 ? 162 : 78), \
65 MCS_DURATION(_streams, _sgi, _ht40 ? 216 : 104), \
66 MCS_DURATION(_streams, _sgi, _ht40 ? 324 : 156), \
67 MCS_DURATION(_streams, _sgi, _ht40 ? 432 : 208), \
68 MCS_DURATION(_streams, _sgi, _ht40 ? 486 : 234), \
69 MCS_DURATION(_streams, _sgi, _ht40 ? 540 : 260) \
73 #define VHT_GROUP_IDX(_streams, _sgi, _bw) \
74 (MINSTREL_VHT_GROUP_0 + \
75 MINSTREL_MAX_STREAMS * 2 * (_bw) + \
76 MINSTREL_MAX_STREAMS * (_sgi) + \
79 #define BW2VBPS(_bw, r3, r2, r1) \
80 (_bw == BW_80 ? r3 : _bw == BW_40 ? r2 : r1)
82 #define VHT_GROUP(_streams, _sgi, _bw) \
83 [VHT_GROUP_IDX(_streams, _sgi, _bw)] = { \
84 .streams = _streams, \
86 IEEE80211_TX_RC_VHT_MCS | \
87 (_sgi ? IEEE80211_TX_RC_SHORT_GI : 0) | \
88 (_bw == BW_80 ? IEEE80211_TX_RC_80_MHZ_WIDTH : \
89 _bw == BW_40 ? IEEE80211_TX_RC_40_MHZ_WIDTH : 0), \
91 MCS_DURATION(_streams, _sgi, \
92 BW2VBPS(_bw, 117, 54, 26)), \
93 MCS_DURATION(_streams, _sgi, \
94 BW2VBPS(_bw, 234, 108, 52)), \
95 MCS_DURATION(_streams, _sgi, \
96 BW2VBPS(_bw, 351, 162, 78)), \
97 MCS_DURATION(_streams, _sgi, \
98 BW2VBPS(_bw, 468, 216, 104)), \
99 MCS_DURATION(_streams, _sgi, \
100 BW2VBPS(_bw, 702, 324, 156)), \
101 MCS_DURATION(_streams, _sgi, \
102 BW2VBPS(_bw, 936, 432, 208)), \
103 MCS_DURATION(_streams, _sgi, \
104 BW2VBPS(_bw, 1053, 486, 234)), \
105 MCS_DURATION(_streams, _sgi, \
106 BW2VBPS(_bw, 1170, 540, 260)), \
107 MCS_DURATION(_streams, _sgi, \
108 BW2VBPS(_bw, 1404, 648, 312)), \
109 MCS_DURATION(_streams, _sgi, \
110 BW2VBPS(_bw, 1560, 720, 346)) \
114 #define CCK_DURATION(_bitrate, _short, _len) \
115 (1000 * (10 /* SIFS */ + \
116 (_short ? 72 + 24 : 144 + 48) + \
117 (8 * (_len + 4) * 10) / (_bitrate)))
119 #define CCK_ACK_DURATION(_bitrate, _short) \
120 (CCK_DURATION((_bitrate > 10 ? 20 : 10), false, 60) + \
121 CCK_DURATION(_bitrate, _short, AVG_PKT_SIZE))
123 #define CCK_DURATION_LIST(_short) \
124 CCK_ACK_DURATION(10, _short), \
125 CCK_ACK_DURATION(20, _short), \
126 CCK_ACK_DURATION(55, _short), \
127 CCK_ACK_DURATION(110, _short)
130 [MINSTREL_CCK_GROUP] = { \
134 CCK_DURATION_LIST(false), \
135 CCK_DURATION_LIST(true) \
139 #ifdef CONFIG_MAC80211_RC_MINSTREL_VHT
140 static bool minstrel_vht_only
= true;
141 module_param(minstrel_vht_only
, bool, 0644);
142 MODULE_PARM_DESC(minstrel_vht_only
,
143 "Use only VHT rates when VHT is supported by sta.");
147 * To enable sufficiently targeted rate sampling, MCS rates are divided into
148 * groups, based on the number of streams and flags (HT40, SGI) that they
151 * Sortorder has to be fixed for GROUP_IDX macro to be applicable:
152 * BW -> SGI -> #streams
154 const struct mcs_group minstrel_mcs_groups
[] = {
155 MCS_GROUP(1, 0, BW_20
),
156 MCS_GROUP(2, 0, BW_20
),
157 #if MINSTREL_MAX_STREAMS >= 3
158 MCS_GROUP(3, 0, BW_20
),
161 MCS_GROUP(1, 1, BW_20
),
162 MCS_GROUP(2, 1, BW_20
),
163 #if MINSTREL_MAX_STREAMS >= 3
164 MCS_GROUP(3, 1, BW_20
),
167 MCS_GROUP(1, 0, BW_40
),
168 MCS_GROUP(2, 0, BW_40
),
169 #if MINSTREL_MAX_STREAMS >= 3
170 MCS_GROUP(3, 0, BW_40
),
173 MCS_GROUP(1, 1, BW_40
),
174 MCS_GROUP(2, 1, BW_40
),
175 #if MINSTREL_MAX_STREAMS >= 3
176 MCS_GROUP(3, 1, BW_40
),
181 #ifdef CONFIG_MAC80211_RC_MINSTREL_VHT
182 VHT_GROUP(1, 0, BW_20
),
183 VHT_GROUP(2, 0, BW_20
),
184 #if MINSTREL_MAX_STREAMS >= 3
185 VHT_GROUP(3, 0, BW_20
),
188 VHT_GROUP(1, 1, BW_20
),
189 VHT_GROUP(2, 1, BW_20
),
190 #if MINSTREL_MAX_STREAMS >= 3
191 VHT_GROUP(3, 1, BW_20
),
194 VHT_GROUP(1, 0, BW_40
),
195 VHT_GROUP(2, 0, BW_40
),
196 #if MINSTREL_MAX_STREAMS >= 3
197 VHT_GROUP(3, 0, BW_40
),
200 VHT_GROUP(1, 1, BW_40
),
201 VHT_GROUP(2, 1, BW_40
),
202 #if MINSTREL_MAX_STREAMS >= 3
203 VHT_GROUP(3, 1, BW_40
),
206 VHT_GROUP(1, 0, BW_80
),
207 VHT_GROUP(2, 0, BW_80
),
208 #if MINSTREL_MAX_STREAMS >= 3
209 VHT_GROUP(3, 0, BW_80
),
212 VHT_GROUP(1, 1, BW_80
),
213 VHT_GROUP(2, 1, BW_80
),
214 #if MINSTREL_MAX_STREAMS >= 3
215 VHT_GROUP(3, 1, BW_80
),
220 static u8 sample_table
[SAMPLE_COLUMNS
][MCS_GROUP_RATES
] __read_mostly
;
223 minstrel_ht_update_rates(struct minstrel_priv
*mp
, struct minstrel_ht_sta
*mi
);
226 * Some VHT MCSes are invalid (when Ndbps / Nes is not an integer)
227 * e.g for MCS9@20MHzx1Nss: Ndbps=8x52*(5/6) Nes=1
229 * Returns the valid mcs map for struct minstrel_mcs_group_data.supported
232 minstrel_get_valid_vht_rates(int bw
, int nss
, __le16 mcs_map
)
237 if (nss
!= 3 && nss
!= 6)
239 } else if (bw
== BW_80
) {
240 if (nss
== 3 || nss
== 7)
245 WARN_ON(bw
!= BW_40
);
248 switch ((le16_to_cpu(mcs_map
) >> (2 * (nss
- 1))) & 3) {
249 case IEEE80211_VHT_MCS_SUPPORT_0_7
:
252 case IEEE80211_VHT_MCS_SUPPORT_0_8
:
255 case IEEE80211_VHT_MCS_SUPPORT_0_9
:
261 return 0x3ff & ~mask
;
265 * Look up an MCS group index based on mac80211 rate information
268 minstrel_ht_get_group_idx(struct ieee80211_tx_rate
*rate
)
270 return GROUP_IDX((rate
->idx
/ 8) + 1,
271 !!(rate
->flags
& IEEE80211_TX_RC_SHORT_GI
),
272 !!(rate
->flags
& IEEE80211_TX_RC_40_MHZ_WIDTH
));
276 minstrel_vht_get_group_idx(struct ieee80211_tx_rate
*rate
)
278 return VHT_GROUP_IDX(ieee80211_rate_get_vht_nss(rate
),
279 !!(rate
->flags
& IEEE80211_TX_RC_SHORT_GI
),
280 !!(rate
->flags
& IEEE80211_TX_RC_40_MHZ_WIDTH
) +
281 2*!!(rate
->flags
& IEEE80211_TX_RC_80_MHZ_WIDTH
));
284 static struct minstrel_rate_stats
*
285 minstrel_ht_get_stats(struct minstrel_priv
*mp
, struct minstrel_ht_sta
*mi
,
286 struct ieee80211_tx_rate
*rate
)
290 if (rate
->flags
& IEEE80211_TX_RC_MCS
) {
291 group
= minstrel_ht_get_group_idx(rate
);
293 } else if (rate
->flags
& IEEE80211_TX_RC_VHT_MCS
) {
294 group
= minstrel_vht_get_group_idx(rate
);
295 idx
= ieee80211_rate_get_vht_mcs(rate
);
297 group
= MINSTREL_CCK_GROUP
;
299 for (idx
= 0; idx
< ARRAY_SIZE(mp
->cck_rates
); idx
++)
300 if (rate
->idx
== mp
->cck_rates
[idx
])
304 if (!(mi
->groups
[group
].supported
& BIT(idx
)))
307 return &mi
->groups
[group
].rates
[idx
];
310 static inline struct minstrel_rate_stats
*
311 minstrel_get_ratestats(struct minstrel_ht_sta
*mi
, int index
)
313 return &mi
->groups
[index
/ MCS_GROUP_RATES
].rates
[index
% MCS_GROUP_RATES
];
318 * Recalculate success probabilities and counters for a rate using EWMA
321 minstrel_calc_rate_ewma(struct minstrel_rate_stats
*mr
)
323 if (unlikely(mr
->attempts
> 0)) {
324 mr
->sample_skipped
= 0;
325 mr
->cur_prob
= MINSTREL_FRAC(mr
->success
, mr
->attempts
);
327 mr
->probability
= mr
->cur_prob
;
329 mr
->probability
= minstrel_ewma(mr
->probability
,
330 mr
->cur_prob
, EWMA_LEVEL
);
331 mr
->att_hist
+= mr
->attempts
;
332 mr
->succ_hist
+= mr
->success
;
334 mr
->sample_skipped
++;
336 mr
->last_success
= mr
->success
;
337 mr
->last_attempts
= mr
->attempts
;
343 * Calculate throughput based on the average A-MPDU length, taking into account
344 * the expected number of retransmissions and their expected length
347 minstrel_ht_calc_tp(struct minstrel_ht_sta
*mi
, int group
, int rate
)
349 struct minstrel_rate_stats
*mr
;
350 unsigned int nsecs
= 0;
354 mr
= &mi
->groups
[group
].rates
[rate
];
355 prob
= mr
->probability
;
357 if (prob
< MINSTREL_FRAC(1, 10)) {
363 * For the throughput calculation, limit the probability value to 90% to
364 * account for collision related packet error rate fluctuation
366 if (prob
> MINSTREL_FRAC(9, 10))
367 prob
= MINSTREL_FRAC(9, 10);
369 if (group
!= MINSTREL_CCK_GROUP
)
370 nsecs
= 1000 * mi
->overhead
/ MINSTREL_TRUNC(mi
->avg_ampdu_len
);
372 nsecs
+= minstrel_mcs_groups
[group
].duration
[rate
];
374 /* prob is scaled - see MINSTREL_FRAC above */
375 tp
= 1000000 * ((prob
* 1000) / nsecs
);
376 mr
->cur_tp
= MINSTREL_TRUNC(tp
);
380 * Find & sort topmost throughput rates
382 * If multiple rates provide equal throughput the sorting is based on their
383 * current success probability. Higher success probability is preferred among
384 * MCS groups, CCK rates do not provide aggregation and are therefore at last.
387 minstrel_ht_sort_best_tp_rates(struct minstrel_ht_sta
*mi
, u16 index
,
390 int cur_group
, cur_idx
, cur_thr
, cur_prob
;
391 int tmp_group
, tmp_idx
, tmp_thr
, tmp_prob
;
392 int j
= MAX_THR_RATES
;
394 cur_group
= index
/ MCS_GROUP_RATES
;
395 cur_idx
= index
% MCS_GROUP_RATES
;
396 cur_thr
= mi
->groups
[cur_group
].rates
[cur_idx
].cur_tp
;
397 cur_prob
= mi
->groups
[cur_group
].rates
[cur_idx
].probability
;
400 tmp_group
= tp_list
[j
- 1] / MCS_GROUP_RATES
;
401 tmp_idx
= tp_list
[j
- 1] % MCS_GROUP_RATES
;
402 tmp_thr
= mi
->groups
[tmp_group
].rates
[tmp_idx
].cur_tp
;
403 tmp_prob
= mi
->groups
[tmp_group
].rates
[tmp_idx
].probability
;
404 if (cur_thr
< tmp_thr
||
405 (cur_thr
== tmp_thr
&& cur_prob
<= tmp_prob
))
410 if (j
< MAX_THR_RATES
- 1) {
411 memmove(&tp_list
[j
+ 1], &tp_list
[j
], (sizeof(*tp_list
) *
412 (MAX_THR_RATES
- (j
+ 1))));
414 if (j
< MAX_THR_RATES
)
419 * Find and set the topmost probability rate per sta and per group
422 minstrel_ht_set_best_prob_rate(struct minstrel_ht_sta
*mi
, u16 index
)
424 struct minstrel_mcs_group_data
*mg
;
425 struct minstrel_rate_stats
*mr
;
426 int tmp_group
, tmp_idx
, tmp_tp
, tmp_prob
, max_tp_group
;
428 mg
= &mi
->groups
[index
/ MCS_GROUP_RATES
];
429 mr
= &mg
->rates
[index
% MCS_GROUP_RATES
];
431 tmp_group
= mi
->max_prob_rate
/ MCS_GROUP_RATES
;
432 tmp_idx
= mi
->max_prob_rate
% MCS_GROUP_RATES
;
433 tmp_tp
= mi
->groups
[tmp_group
].rates
[tmp_idx
].cur_tp
;
434 tmp_prob
= mi
->groups
[tmp_group
].rates
[tmp_idx
].probability
;
436 /* if max_tp_rate[0] is from MCS_GROUP max_prob_rate get selected from
437 * MCS_GROUP as well as CCK_GROUP rates do not allow aggregation */
438 max_tp_group
= mi
->max_tp_rate
[0] / MCS_GROUP_RATES
;
439 if((index
/ MCS_GROUP_RATES
== MINSTREL_CCK_GROUP
) &&
440 (max_tp_group
!= MINSTREL_CCK_GROUP
))
443 if (mr
->probability
> MINSTREL_FRAC(75, 100)) {
444 if (mr
->cur_tp
> tmp_tp
)
445 mi
->max_prob_rate
= index
;
446 if (mr
->cur_tp
> mg
->rates
[mg
->max_group_prob_rate
].cur_tp
)
447 mg
->max_group_prob_rate
= index
;
449 if (mr
->probability
> tmp_prob
)
450 mi
->max_prob_rate
= index
;
451 if (mr
->probability
> mg
->rates
[mg
->max_group_prob_rate
].probability
)
452 mg
->max_group_prob_rate
= index
;
458 * Assign new rate set per sta and use CCK rates only if the fastest
459 * rate (max_tp_rate[0]) is from CCK group. This prohibits such sorted
460 * rate sets where MCS and CCK rates are mixed, because CCK rates can
461 * not use aggregation.
464 minstrel_ht_assign_best_tp_rates(struct minstrel_ht_sta
*mi
,
465 u16 tmp_mcs_tp_rate
[MAX_THR_RATES
],
466 u16 tmp_cck_tp_rate
[MAX_THR_RATES
])
468 unsigned int tmp_group
, tmp_idx
, tmp_cck_tp
, tmp_mcs_tp
;
471 tmp_group
= tmp_cck_tp_rate
[0] / MCS_GROUP_RATES
;
472 tmp_idx
= tmp_cck_tp_rate
[0] % MCS_GROUP_RATES
;
473 tmp_cck_tp
= mi
->groups
[tmp_group
].rates
[tmp_idx
].cur_tp
;
475 tmp_group
= tmp_mcs_tp_rate
[0] / MCS_GROUP_RATES
;
476 tmp_idx
= tmp_mcs_tp_rate
[0] % MCS_GROUP_RATES
;
477 tmp_mcs_tp
= mi
->groups
[tmp_group
].rates
[tmp_idx
].cur_tp
;
479 if (tmp_cck_tp
> tmp_mcs_tp
) {
480 for(i
= 0; i
< MAX_THR_RATES
; i
++) {
481 minstrel_ht_sort_best_tp_rates(mi
, tmp_cck_tp_rate
[i
],
489 * Try to increase robustness of max_prob rate by decrease number of
490 * streams if possible.
493 minstrel_ht_prob_rate_reduce_streams(struct minstrel_ht_sta
*mi
)
495 struct minstrel_mcs_group_data
*mg
;
496 struct minstrel_rate_stats
*mr
;
497 int tmp_max_streams
, group
;
500 tmp_max_streams
= minstrel_mcs_groups
[mi
->max_tp_rate
[0] /
501 MCS_GROUP_RATES
].streams
;
502 for (group
= 0; group
< ARRAY_SIZE(minstrel_mcs_groups
); group
++) {
503 mg
= &mi
->groups
[group
];
504 if (!mg
->supported
|| group
== MINSTREL_CCK_GROUP
)
506 mr
= minstrel_get_ratestats(mi
, mg
->max_group_prob_rate
);
507 if (tmp_tp
< mr
->cur_tp
&&
508 (minstrel_mcs_groups
[group
].streams
< tmp_max_streams
)) {
509 mi
->max_prob_rate
= mg
->max_group_prob_rate
;
516 * Update rate statistics and select new primary rates
518 * Rules for rate selection:
519 * - max_prob_rate must use only one stream, as a tradeoff between delivery
520 * probability and throughput during strong fluctuations
521 * - as long as the max prob rate has a probability of more than 75%, pick
522 * higher throughput rates, even if the probablity is a bit lower
525 minstrel_ht_update_stats(struct minstrel_priv
*mp
, struct minstrel_ht_sta
*mi
)
527 struct minstrel_mcs_group_data
*mg
;
528 struct minstrel_rate_stats
*mr
;
530 u16 tmp_mcs_tp_rate
[MAX_THR_RATES
], tmp_group_tp_rate
[MAX_THR_RATES
];
531 u16 tmp_cck_tp_rate
[MAX_THR_RATES
], index
;
533 if (mi
->ampdu_packets
> 0) {
534 mi
->avg_ampdu_len
= minstrel_ewma(mi
->avg_ampdu_len
,
535 MINSTREL_FRAC(mi
->ampdu_len
, mi
->ampdu_packets
), EWMA_LEVEL
);
537 mi
->ampdu_packets
= 0;
541 mi
->sample_count
= 0;
543 /* Initialize global rate indexes */
544 for(j
= 0; j
< MAX_THR_RATES
; j
++){
545 tmp_mcs_tp_rate
[j
] = 0;
546 tmp_cck_tp_rate
[j
] = 0;
549 /* Find best rate sets within all MCS groups*/
550 for (group
= 0; group
< ARRAY_SIZE(minstrel_mcs_groups
); group
++) {
552 mg
= &mi
->groups
[group
];
558 /* (re)Initialize group rate indexes */
559 for(j
= 0; j
< MAX_THR_RATES
; j
++)
560 tmp_group_tp_rate
[j
] = group
;
562 for (i
= 0; i
< MCS_GROUP_RATES
; i
++) {
563 if (!(mg
->supported
& BIT(i
)))
566 index
= MCS_GROUP_RATES
* group
+ i
;
569 mr
->retry_updated
= false;
570 minstrel_calc_rate_ewma(mr
);
571 minstrel_ht_calc_tp(mi
, group
, i
);
576 /* Find max throughput rate set */
577 if (group
!= MINSTREL_CCK_GROUP
) {
578 minstrel_ht_sort_best_tp_rates(mi
, index
,
580 } else if (group
== MINSTREL_CCK_GROUP
) {
581 minstrel_ht_sort_best_tp_rates(mi
, index
,
585 /* Find max throughput rate set within a group */
586 minstrel_ht_sort_best_tp_rates(mi
, index
,
589 /* Find max probability rate per group and global */
590 minstrel_ht_set_best_prob_rate(mi
, index
);
593 memcpy(mg
->max_group_tp_rate
, tmp_group_tp_rate
,
594 sizeof(mg
->max_group_tp_rate
));
597 /* Assign new rate set per sta */
598 minstrel_ht_assign_best_tp_rates(mi
, tmp_mcs_tp_rate
, tmp_cck_tp_rate
);
599 memcpy(mi
->max_tp_rate
, tmp_mcs_tp_rate
, sizeof(mi
->max_tp_rate
));
601 /* Try to increase robustness of max_prob_rate*/
602 minstrel_ht_prob_rate_reduce_streams(mi
);
604 /* try to sample all available rates during each interval */
605 mi
->sample_count
*= 8;
607 #ifdef CONFIG_MAC80211_DEBUGFS
608 /* use fixed index if set */
609 if (mp
->fixed_rate_idx
!= -1) {
610 for (i
= 0; i
< 4; i
++)
611 mi
->max_tp_rate
[i
] = mp
->fixed_rate_idx
;
612 mi
->max_prob_rate
= mp
->fixed_rate_idx
;
616 /* Reset update timer */
617 mi
->stats_update
= jiffies
;
621 minstrel_ht_txstat_valid(struct minstrel_priv
*mp
, struct ieee80211_tx_rate
*rate
)
629 if (rate
->flags
& IEEE80211_TX_RC_MCS
||
630 rate
->flags
& IEEE80211_TX_RC_VHT_MCS
)
633 return rate
->idx
== mp
->cck_rates
[0] ||
634 rate
->idx
== mp
->cck_rates
[1] ||
635 rate
->idx
== mp
->cck_rates
[2] ||
636 rate
->idx
== mp
->cck_rates
[3];
640 minstrel_next_sample_idx(struct minstrel_ht_sta
*mi
)
642 struct minstrel_mcs_group_data
*mg
;
646 mi
->sample_group
%= ARRAY_SIZE(minstrel_mcs_groups
);
647 mg
= &mi
->groups
[mi
->sample_group
];
652 if (++mg
->index
>= MCS_GROUP_RATES
) {
654 if (++mg
->column
>= ARRAY_SIZE(sample_table
))
662 minstrel_downgrade_rate(struct minstrel_ht_sta
*mi
, u16
*idx
, bool primary
)
664 int group
, orig_group
;
666 orig_group
= group
= *idx
/ MCS_GROUP_RATES
;
670 if (!mi
->groups
[group
].supported
)
673 if (minstrel_mcs_groups
[group
].streams
>
674 minstrel_mcs_groups
[orig_group
].streams
)
678 *idx
= mi
->groups
[group
].max_group_tp_rate
[0];
680 *idx
= mi
->groups
[group
].max_group_tp_rate
[1];
686 minstrel_aggr_check(struct ieee80211_sta
*pubsta
, struct sk_buff
*skb
)
688 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*) skb
->data
;
689 struct sta_info
*sta
= container_of(pubsta
, struct sta_info
, sta
);
692 if (skb_get_queue_mapping(skb
) == IEEE80211_AC_VO
)
695 if (unlikely(!ieee80211_is_data_qos(hdr
->frame_control
)))
698 if (unlikely(skb
->protocol
== cpu_to_be16(ETH_P_PAE
)))
701 tid
= *ieee80211_get_qos_ctl(hdr
) & IEEE80211_QOS_CTL_TID_MASK
;
702 if (likely(sta
->ampdu_mlme
.tid_tx
[tid
]))
705 ieee80211_start_tx_ba_session(pubsta
, tid
, 5000);
709 minstrel_ht_tx_status(void *priv
, struct ieee80211_supported_band
*sband
,
710 struct ieee80211_sta
*sta
, void *priv_sta
,
711 struct ieee80211_tx_info
*info
)
713 struct minstrel_ht_sta_priv
*msp
= priv_sta
;
714 struct minstrel_ht_sta
*mi
= &msp
->ht
;
715 struct ieee80211_tx_rate
*ar
= info
->status
.rates
;
716 struct minstrel_rate_stats
*rate
, *rate2
;
717 struct minstrel_priv
*mp
= priv
;
718 bool last
, update
= false;
722 return mac80211_minstrel
.tx_status_noskb(priv
, sband
, sta
,
725 /* This packet was aggregated but doesn't carry status info */
726 if ((info
->flags
& IEEE80211_TX_CTL_AMPDU
) &&
727 !(info
->flags
& IEEE80211_TX_STAT_AMPDU
))
730 if (!(info
->flags
& IEEE80211_TX_STAT_AMPDU
)) {
731 info
->status
.ampdu_ack_len
=
732 (info
->flags
& IEEE80211_TX_STAT_ACK
? 1 : 0);
733 info
->status
.ampdu_len
= 1;
737 mi
->ampdu_len
+= info
->status
.ampdu_len
;
739 if (!mi
->sample_wait
&& !mi
->sample_tries
&& mi
->sample_count
> 0) {
740 mi
->sample_wait
= 16 + 2 * MINSTREL_TRUNC(mi
->avg_ampdu_len
);
741 mi
->sample_tries
= 1;
745 if (info
->flags
& IEEE80211_TX_CTL_RATE_CTRL_PROBE
)
746 mi
->sample_packets
+= info
->status
.ampdu_len
;
748 last
= !minstrel_ht_txstat_valid(mp
, &ar
[0]);
749 for (i
= 0; !last
; i
++) {
750 last
= (i
== IEEE80211_TX_MAX_RATES
- 1) ||
751 !minstrel_ht_txstat_valid(mp
, &ar
[i
+ 1]);
753 rate
= minstrel_ht_get_stats(mp
, mi
, &ar
[i
]);
756 rate
->success
+= info
->status
.ampdu_ack_len
;
758 rate
->attempts
+= ar
[i
].count
* info
->status
.ampdu_len
;
762 * check for sudden death of spatial multiplexing,
763 * downgrade to a lower number of streams if necessary.
765 rate
= minstrel_get_ratestats(mi
, mi
->max_tp_rate
[0]);
766 if (rate
->attempts
> 30 &&
767 MINSTREL_FRAC(rate
->success
, rate
->attempts
) <
768 MINSTREL_FRAC(20, 100)) {
769 minstrel_downgrade_rate(mi
, &mi
->max_tp_rate
[0], true);
773 rate2
= minstrel_get_ratestats(mi
, mi
->max_tp_rate
[1]);
774 if (rate2
->attempts
> 30 &&
775 MINSTREL_FRAC(rate2
->success
, rate2
->attempts
) <
776 MINSTREL_FRAC(20, 100)) {
777 minstrel_downgrade_rate(mi
, &mi
->max_tp_rate
[1], false);
781 if (time_after(jiffies
, mi
->stats_update
+ (mp
->update_interval
/ 2 * HZ
) / 1000)) {
783 minstrel_ht_update_stats(mp
, mi
);
787 minstrel_ht_update_rates(mp
, mi
);
791 minstrel_calc_retransmit(struct minstrel_priv
*mp
, struct minstrel_ht_sta
*mi
,
794 struct minstrel_rate_stats
*mr
;
795 const struct mcs_group
*group
;
796 unsigned int tx_time
, tx_time_rtscts
, tx_time_data
;
797 unsigned int cw
= mp
->cw_min
;
798 unsigned int ctime
= 0;
799 unsigned int t_slot
= 9; /* FIXME */
800 unsigned int ampdu_len
= MINSTREL_TRUNC(mi
->avg_ampdu_len
);
801 unsigned int overhead
= 0, overhead_rtscts
= 0;
803 mr
= minstrel_get_ratestats(mi
, index
);
804 if (mr
->probability
< MINSTREL_FRAC(1, 10)) {
806 mr
->retry_count_rtscts
= 1;
811 mr
->retry_count_rtscts
= 2;
812 mr
->retry_updated
= true;
814 group
= &minstrel_mcs_groups
[index
/ MCS_GROUP_RATES
];
815 tx_time_data
= group
->duration
[index
% MCS_GROUP_RATES
] * ampdu_len
/ 1000;
817 /* Contention time for first 2 tries */
818 ctime
= (t_slot
* cw
) >> 1;
819 cw
= min((cw
<< 1) | 1, mp
->cw_max
);
820 ctime
+= (t_slot
* cw
) >> 1;
821 cw
= min((cw
<< 1) | 1, mp
->cw_max
);
823 if (index
/ MCS_GROUP_RATES
!= MINSTREL_CCK_GROUP
) {
824 overhead
= mi
->overhead
;
825 overhead_rtscts
= mi
->overhead_rtscts
;
828 /* Total TX time for data and Contention after first 2 tries */
829 tx_time
= ctime
+ 2 * (overhead
+ tx_time_data
);
830 tx_time_rtscts
= ctime
+ 2 * (overhead_rtscts
+ tx_time_data
);
832 /* See how many more tries we can fit inside segment size */
834 /* Contention time for this try */
835 ctime
= (t_slot
* cw
) >> 1;
836 cw
= min((cw
<< 1) | 1, mp
->cw_max
);
838 /* Total TX time after this try */
839 tx_time
+= ctime
+ overhead
+ tx_time_data
;
840 tx_time_rtscts
+= ctime
+ overhead_rtscts
+ tx_time_data
;
842 if (tx_time_rtscts
< mp
->segment_size
)
843 mr
->retry_count_rtscts
++;
844 } while ((tx_time
< mp
->segment_size
) &&
845 (++mr
->retry_count
< mp
->max_retry
));
850 minstrel_ht_set_rate(struct minstrel_priv
*mp
, struct minstrel_ht_sta
*mi
,
851 struct ieee80211_sta_rates
*ratetbl
, int offset
, int index
)
853 const struct mcs_group
*group
= &minstrel_mcs_groups
[index
/ MCS_GROUP_RATES
];
854 struct minstrel_rate_stats
*mr
;
856 u16 flags
= group
->flags
;
858 mr
= minstrel_get_ratestats(mi
, index
);
859 if (!mr
->retry_updated
)
860 minstrel_calc_retransmit(mp
, mi
, index
);
862 if (mr
->probability
< MINSTREL_FRAC(20, 100) || !mr
->retry_count
) {
863 ratetbl
->rate
[offset
].count
= 2;
864 ratetbl
->rate
[offset
].count_rts
= 2;
865 ratetbl
->rate
[offset
].count_cts
= 2;
867 ratetbl
->rate
[offset
].count
= mr
->retry_count
;
868 ratetbl
->rate
[offset
].count_cts
= mr
->retry_count
;
869 ratetbl
->rate
[offset
].count_rts
= mr
->retry_count_rtscts
;
872 if (index
/ MCS_GROUP_RATES
== MINSTREL_CCK_GROUP
)
873 idx
= mp
->cck_rates
[index
% ARRAY_SIZE(mp
->cck_rates
)];
874 else if (flags
& IEEE80211_TX_RC_VHT_MCS
)
875 idx
= ((group
->streams
- 1) << 4) |
876 ((index
% MCS_GROUP_RATES
) & 0xF);
878 idx
= index
% MCS_GROUP_RATES
+ (group
->streams
- 1) * 8;
881 ratetbl
->rate
[offset
].count
= ratetbl
->rate
[offset
].count_rts
;
882 flags
|= IEEE80211_TX_RC_USE_RTS_CTS
;
885 ratetbl
->rate
[offset
].idx
= idx
;
886 ratetbl
->rate
[offset
].flags
= flags
;
890 minstrel_ht_update_rates(struct minstrel_priv
*mp
, struct minstrel_ht_sta
*mi
)
892 struct ieee80211_sta_rates
*rates
;
895 rates
= kzalloc(sizeof(*rates
), GFP_ATOMIC
);
899 /* Start with max_tp_rate[0] */
900 minstrel_ht_set_rate(mp
, mi
, rates
, i
++, mi
->max_tp_rate
[0]);
902 if (mp
->hw
->max_rates
>= 3) {
903 /* At least 3 tx rates supported, use max_tp_rate[1] next */
904 minstrel_ht_set_rate(mp
, mi
, rates
, i
++, mi
->max_tp_rate
[1]);
907 if (mp
->hw
->max_rates
>= 2) {
909 * At least 2 tx rates supported, use max_prob_rate next */
910 minstrel_ht_set_rate(mp
, mi
, rates
, i
++, mi
->max_prob_rate
);
913 rates
->rate
[i
].idx
= -1;
914 rate_control_set_rates(mp
->hw
, mi
->sta
, rates
);
918 minstrel_get_duration(int index
)
920 const struct mcs_group
*group
= &minstrel_mcs_groups
[index
/ MCS_GROUP_RATES
];
921 return group
->duration
[index
% MCS_GROUP_RATES
];
925 minstrel_get_sample_rate(struct minstrel_priv
*mp
, struct minstrel_ht_sta
*mi
)
927 struct minstrel_rate_stats
*mr
;
928 struct minstrel_mcs_group_data
*mg
;
929 unsigned int sample_dur
, sample_group
, cur_max_tp_streams
;
932 if (mi
->sample_wait
> 0) {
937 if (!mi
->sample_tries
)
940 sample_group
= mi
->sample_group
;
941 mg
= &mi
->groups
[sample_group
];
942 sample_idx
= sample_table
[mg
->column
][mg
->index
];
943 minstrel_next_sample_idx(mi
);
945 if (!(mg
->supported
& BIT(sample_idx
)))
948 mr
= &mg
->rates
[sample_idx
];
949 sample_idx
+= sample_group
* MCS_GROUP_RATES
;
952 * Sampling might add some overhead (RTS, no aggregation)
953 * to the frame. Hence, don't use sampling for the currently
956 if (sample_idx
== mi
->max_tp_rate
[0] ||
957 sample_idx
== mi
->max_tp_rate
[1] ||
958 sample_idx
== mi
->max_prob_rate
)
962 * Do not sample if the probability is already higher than 95%
963 * to avoid wasting airtime.
965 if (mr
->probability
> MINSTREL_FRAC(95, 100))
969 * Make sure that lower rates get sampled only occasionally,
970 * if the link is working perfectly.
973 cur_max_tp_streams
= minstrel_mcs_groups
[mi
->max_tp_rate
[0] /
974 MCS_GROUP_RATES
].streams
;
975 sample_dur
= minstrel_get_duration(sample_idx
);
976 if (sample_dur
>= minstrel_get_duration(mi
->max_tp_rate
[1]) &&
977 (cur_max_tp_streams
- 1 <
978 minstrel_mcs_groups
[sample_group
].streams
||
979 sample_dur
>= minstrel_get_duration(mi
->max_prob_rate
))) {
980 if (mr
->sample_skipped
< 20)
983 if (mi
->sample_slow
++ > 2)
992 minstrel_ht_check_cck_shortpreamble(struct minstrel_priv
*mp
,
993 struct minstrel_ht_sta
*mi
, bool val
)
995 u8 supported
= mi
->groups
[MINSTREL_CCK_GROUP
].supported
;
997 if (!supported
|| !mi
->cck_supported_short
)
1000 if (supported
& (mi
->cck_supported_short
<< (val
* 4)))
1003 supported
^= mi
->cck_supported_short
| (mi
->cck_supported_short
<< 4);
1004 mi
->groups
[MINSTREL_CCK_GROUP
].supported
= supported
;
1008 minstrel_ht_get_rate(void *priv
, struct ieee80211_sta
*sta
, void *priv_sta
,
1009 struct ieee80211_tx_rate_control
*txrc
)
1011 const struct mcs_group
*sample_group
;
1012 struct ieee80211_tx_info
*info
= IEEE80211_SKB_CB(txrc
->skb
);
1013 struct ieee80211_tx_rate
*rate
= &info
->status
.rates
[0];
1014 struct minstrel_ht_sta_priv
*msp
= priv_sta
;
1015 struct minstrel_ht_sta
*mi
= &msp
->ht
;
1016 struct minstrel_priv
*mp
= priv
;
1019 if (rate_control_send_low(sta
, priv_sta
, txrc
))
1023 return mac80211_minstrel
.get_rate(priv
, sta
, &msp
->legacy
, txrc
);
1025 if (!(info
->flags
& IEEE80211_TX_CTL_AMPDU
) &&
1026 mi
->max_prob_rate
/ MCS_GROUP_RATES
!= MINSTREL_CCK_GROUP
)
1027 minstrel_aggr_check(sta
, txrc
->skb
);
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_noskb
= 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
);