Introduce TX aggregation and software TX queue management
for Atheros AR5416 and later wireless devices. This is a very large commit - the complete history can be found in the user/adrian/if_ath_tx branch. Legacy (ie, pre-AR5416) devices also use the per-software TXQ support and (in theory) can support non-aggregation ADDBA sessions. However, the net80211 stack doesn't currently support this. In summary: TX path: * queued frames normally go onto a per-TID, per-node queue * some special frames (eg ADDBA control frames) are thrown directly onto the relevant hardware queue so they can go out before any software queued frames are queued. * Add methods to create, suspend, resume and tear down an aggregation session. * Add in software retransmission of both normal and aggregate frames. * Add in completion handling of aggregate frames, including parsing the block ack bitmap provided by the hardware. * Write an aggregation function which can assemble frames into an aggregate based on the selected rate control and channel configuration. * The per-TID queues are locked based on their target hardware TX queue. This matches what ath9k/atheros does, and thus simplified porting over some of the aggregation logic. * When doing TX aggregation, stick the sequence number allocation in the TX path rather than net80211 TX path, and protect it by the TXQ lock. Rate control: * Delay rate control selection until the frame is about to be queued to the hardware, so retried frames can have their rate control choices changed. Frames with a static rate control selection have that applied before each TX, just to simplify the TX path (ie, not have "static" and "dynamic" rate control special cased.) * Teach ath_rate_sample about aggregates - both completion and errors. * Add an EWMA for tracking what the current "good" MCS rate is based on failure rates. Misc: * Introduce a bunch of dirty hacks and workarounds so TID mapping and net80211 frame inspection can be kept out of the net80211 layer. Because of the way this code works (and it's from Atheros and Linux ath9k), there is a consistent, 1:1 mapping between TID and AC. So we need to ensure that frames going to a specific TID will _always_ end up on the right AC, and vice versa, or the completion/locking will simply get very confused. I plan on addressing this mess in the future. Known issues: * There is no BAR frame transmission just yet. A whole lot of tidying up needs to occur before BAR frame TX can occur in the "correct" place - ie, once the TID TX queue has been drained. * Interface reset/purge/etc results in frames in the TX and RX queues being removed. This creates holes in the sequence numbers being assigned and the TX/RX AMPDU code (on either side) just hangs. * There's no filtered frame support at the present moment, so stations going into power saving mode will simply have a number of frames dropped - likely resulting in a traffic "hang". * Raw frame TX is going to just not function with 11n aggregation. Likely this needs to be modified to always override the sequence number if the frame is going into an aggregation session. However, general raw frame injection currently doesn't work in general in net80211, so let's just ignore this for now until this is sorted out. * HT protection is just not implemented and won't be until the above is sorted out. In addition, the AR5416 has issues RTS protecting large aggregates (anything >8k), so the work around needs to be ported and tested. Thus, this will be put on hold until the above work is complete. * The rate control module 'sample' is the only currently supported module; onoe/amrr haven't been tested and have likely bit rotted a little. I'll follow up with some commits to make them work again for non-11n rates, but they won't be updated to handle 11n and aggregation. If someone wishes to do so then they're welcome to send along patches. * .. and "sample" doesn't really do a good job of 11n TX. Specifically, the metrics used (packet TX time and failure/success rates) isn't as useful for 11n. It's likely that it should be extended to take into account the aggregate throughput possible and then choose a rate which maximises that. Ie, it may be acceptable for a higher MCS rate with a higher failure to be used if it gives a more acceptable throughput/latency then a lower MCS rate @ a lower error rate. Again, patches will be gratefully accepted. Because of this, ATH_ENABLE_11N is still not enabled by default. Sponsored by: Hobnob, Inc. Obtained from: Linux, Atheros
This commit is contained in:
parent
0d5f2f26fe
commit
eb6f0de09d
Notes:
svn2git
2020-12-20 02:59:44 +00:00
svn path=/head/; revision=227364
@ -122,19 +122,21 @@ ath_rate_findrate(struct ath_softc *sc, struct ath_node *an,
|
||||
*/
|
||||
void
|
||||
ath_rate_getxtxrates(struct ath_softc *sc, struct ath_node *an,
|
||||
uint8_t rix0, uint8_t *rix, uint8_t *try)
|
||||
uint8_t rix0, struct ath_rc_series *rc)
|
||||
{
|
||||
struct amrr_node *amn = ATH_NODE_AMRR(an);
|
||||
|
||||
/* rix[0] = amn->amn_tx_rate0; */
|
||||
rix[1] = amn->amn_tx_rate1;
|
||||
rix[2] = amn->amn_tx_rate2;
|
||||
rix[3] = amn->amn_tx_rate3;
|
||||
rc[0].flags = rc[1].flags = rc[2].flags = rc[3].flags = 0;
|
||||
|
||||
try[0] = amn->amn_tx_try0;
|
||||
try[1] = amn->amn_tx_try1;
|
||||
try[2] = amn->amn_tx_try2;
|
||||
try[3] = amn->amn_tx_try3;
|
||||
rc[0].rix = amn->amn_tx_rate0;
|
||||
rc[1].rix = amn->amn_tx_rate1;
|
||||
rc[2].rix = amn->amn_tx_rate2;
|
||||
rc[3].rix = amn->amn_tx_rate3;
|
||||
|
||||
rc[0].tries = amn->amn_tx_try0;
|
||||
rc[1].tries = amn->amn_tx_try1;
|
||||
rc[2].tries = amn->amn_tx_try2;
|
||||
rc[3].tries = amn->amn_tx_try3;
|
||||
}
|
||||
|
||||
|
||||
@ -153,10 +155,10 @@ ath_rate_setupxtxdesc(struct ath_softc *sc, struct ath_node *an,
|
||||
|
||||
void
|
||||
ath_rate_tx_complete(struct ath_softc *sc, struct ath_node *an,
|
||||
const struct ath_buf *bf)
|
||||
const struct ath_rc_series *rc, const struct ath_tx_status *ts,
|
||||
int frame_size, int nframes, int nbad)
|
||||
{
|
||||
struct amrr_node *amn = ATH_NODE_AMRR(an);
|
||||
const struct ath_tx_status *ts = &bf->bf_status.ds_txstat;
|
||||
int sr = ts->ts_shortretry;
|
||||
int lr = ts->ts_longretry;
|
||||
int retry_count = sr + lr;
|
||||
|
@ -130,19 +130,21 @@ ath_rate_findrate(struct ath_softc *sc, struct ath_node *an,
|
||||
*/
|
||||
void
|
||||
ath_rate_getxtxrates(struct ath_softc *sc, struct ath_node *an,
|
||||
uint8_t rix0, uint8_t *rix, uint8_t *try)
|
||||
uint8_t rix0, struct ath_rc_series *rc)
|
||||
{
|
||||
struct onoe_node *on = ATH_NODE_ONOE(an);
|
||||
|
||||
/* rix[0] = on->on_tx_rate0; */
|
||||
rix[1] = on->on_tx_rate1;
|
||||
rix[2] = on->on_tx_rate2;
|
||||
rix[3] = on->on_tx_rate3;
|
||||
rc[0].flags = rc[1].flags = rc[2].flags = rc[3].flags = 0;
|
||||
|
||||
try[0] = on->on_tx_try0;
|
||||
try[1] = 2;
|
||||
try[2] = 2;
|
||||
try[3] = 2;
|
||||
rc[0].rix = on->on_tx_rate0;
|
||||
rc[1].rix = on->on_tx_rate1;
|
||||
rc[2].rix = on->on_tx_rate2;
|
||||
rc[3].rix = on->on_tx_rate3;
|
||||
|
||||
rc[0].tries = on->on_tx_try0;
|
||||
rc[1].tries = 2;
|
||||
rc[2].tries = 2;
|
||||
rc[3].tries = 2;
|
||||
}
|
||||
|
||||
void
|
||||
@ -160,10 +162,10 @@ ath_rate_setupxtxdesc(struct ath_softc *sc, struct ath_node *an,
|
||||
|
||||
void
|
||||
ath_rate_tx_complete(struct ath_softc *sc, struct ath_node *an,
|
||||
const struct ath_buf *bf)
|
||||
const struct ath_rc_series *rc, const struct ath_tx_status *ts,
|
||||
int frame_size, int nframes, int nbad)
|
||||
{
|
||||
struct onoe_node *on = ATH_NODE_ONOE(an);
|
||||
const struct ath_tx_status *ts = &bf->bf_status.ds_txstat;
|
||||
|
||||
if (ts->ts_status == 0)
|
||||
on->on_tx_ok++;
|
||||
|
@ -170,12 +170,13 @@ pick_best_rate(struct ath_node *an, const HAL_RATE_TABLE *rt,
|
||||
int size_bin, int require_acked_before)
|
||||
{
|
||||
struct sample_node *sn = ATH_NODE_SAMPLE(an);
|
||||
int best_rate_rix, best_rate_tt;
|
||||
int best_rate_rix, best_rate_tt, best_rate_pct;
|
||||
uint32_t mask;
|
||||
int rix, tt;
|
||||
int rix, tt, pct;
|
||||
|
||||
best_rate_rix = 0;
|
||||
best_rate_tt = 0;
|
||||
best_rate_pct = 0;
|
||||
for (mask = sn->ratemask, rix = 0; mask != 0; mask >>= 1, rix++) {
|
||||
if ((mask & 1) == 0) /* not a supported rate */
|
||||
continue;
|
||||
@ -192,13 +193,54 @@ pick_best_rate(struct ath_node *an, const HAL_RATE_TABLE *rt,
|
||||
!sn->stats[size_bin][rix].packets_acked))
|
||||
continue;
|
||||
|
||||
/* Calculate percentage if possible */
|
||||
if (sn->stats[size_bin][rix].total_packets > 0) {
|
||||
pct = sn->stats[size_bin][rix].ewma_pct;
|
||||
} else {
|
||||
/* XXX for now, assume 95% ok */
|
||||
pct = 95;
|
||||
}
|
||||
|
||||
/* don't use a bit-rate that has been failing */
|
||||
if (sn->stats[size_bin][rix].successive_failures > 3)
|
||||
continue;
|
||||
|
||||
if (best_rate_tt == 0 || tt < best_rate_tt) {
|
||||
best_rate_tt = tt;
|
||||
best_rate_rix = rix;
|
||||
/*
|
||||
* For HT, Don't use a bit rate that is much more
|
||||
* lossy than the best.
|
||||
*
|
||||
* XXX this isn't optimal; it's just designed to
|
||||
* eliminate rates that are going to be obviously
|
||||
* worse.
|
||||
*/
|
||||
if (an->an_node.ni_flags & IEEE80211_NODE_HT) {
|
||||
if (best_rate_pct > (pct + 50))
|
||||
continue;
|
||||
}
|
||||
|
||||
/*
|
||||
* For non-MCS rates, use the current average txtime for
|
||||
* comparison.
|
||||
*/
|
||||
if (! (an->an_node.ni_flags & IEEE80211_NODE_HT)) {
|
||||
if (best_rate_tt == 0 || tt <= best_rate_tt) {
|
||||
best_rate_tt = tt;
|
||||
best_rate_rix = rix;
|
||||
best_rate_pct = pct;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Since 2 stream rates have slightly higher TX times,
|
||||
* allow a little bit of leeway. This should later
|
||||
* be abstracted out and properly handled.
|
||||
*/
|
||||
if (an->an_node.ni_flags & IEEE80211_NODE_HT) {
|
||||
if (best_rate_tt == 0 || (tt * 8 <= best_rate_tt * 10)) {
|
||||
best_rate_tt = tt;
|
||||
best_rate_rix = rix;
|
||||
best_rate_pct = pct;
|
||||
}
|
||||
}
|
||||
}
|
||||
return (best_rate_tt ? best_rate_rix : -1);
|
||||
@ -257,6 +299,28 @@ pick_sample_rate(struct sample_softc *ssc , struct ath_node *an,
|
||||
goto nextrate;
|
||||
}
|
||||
|
||||
/*
|
||||
* When doing aggregation, successive failures don't happen
|
||||
* as often, as sometimes some of the sub-frames get through.
|
||||
*
|
||||
* If the sample rix average tx time is greater than the
|
||||
* average tx time of the current rix, don't immediately use
|
||||
* the rate for sampling.
|
||||
*/
|
||||
if (an->an_node.ni_flags & IEEE80211_NODE_HT) {
|
||||
if ((sn->stats[size_bin][rix].average_tx_time * 10 >
|
||||
sn->stats[size_bin][current_rix].average_tx_time * 9) &&
|
||||
(ticks - sn->stats[size_bin][rix].last_tx < ssc->stale_failure_timeout)) {
|
||||
mask &= ~(1<<rix);
|
||||
goto nextrate;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* XXX TODO
|
||||
* For HT, limit sample somehow?
|
||||
*/
|
||||
|
||||
/* Don't sample more than 2 rates higher for rates > 11M for non-HT rates */
|
||||
if (! (an->an_node.ni_flags & IEEE80211_NODE_HT)) {
|
||||
if (DOT11RATE(rix) > 2*11 && rix > current_rix + 2) {
|
||||
@ -320,6 +384,96 @@ ath_rate_update_static_rix(struct ath_softc *sc, struct ieee80211_node *ni)
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Pick a non-HT rate to begin using.
|
||||
*/
|
||||
static int
|
||||
ath_rate_pick_seed_rate_legacy(struct ath_softc *sc, struct ath_node *an,
|
||||
int frameLen)
|
||||
{
|
||||
#define DOT11RATE(ix) (rt->info[ix].dot11Rate & IEEE80211_RATE_VAL)
|
||||
#define MCS(ix) (rt->info[ix].dot11Rate | IEEE80211_RATE_MCS)
|
||||
#define RATE(ix) (DOT11RATE(ix) / 2)
|
||||
int rix = -1;
|
||||
const HAL_RATE_TABLE *rt = sc->sc_currates;
|
||||
struct sample_node *sn = ATH_NODE_SAMPLE(an);
|
||||
const int size_bin = size_to_bin(frameLen);
|
||||
|
||||
/* no packet has been sent successfully yet */
|
||||
for (rix = rt->rateCount-1; rix > 0; rix--) {
|
||||
if ((sn->ratemask & (1<<rix)) == 0)
|
||||
continue;
|
||||
|
||||
/* Skip HT rates */
|
||||
if (rt->info[rix].phy == IEEE80211_T_HT)
|
||||
continue;
|
||||
|
||||
/*
|
||||
* Pick the highest rate <= 36 Mbps
|
||||
* that hasn't failed.
|
||||
*/
|
||||
if (DOT11RATE(rix) <= 72 &&
|
||||
sn->stats[size_bin][rix].successive_failures == 0) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
return rix;
|
||||
#undef RATE
|
||||
#undef MCS
|
||||
#undef DOT11RATE
|
||||
}
|
||||
|
||||
/*
|
||||
* Pick a HT rate to begin using.
|
||||
*
|
||||
* Don't use any non-HT rates; only consider HT rates.
|
||||
*/
|
||||
static int
|
||||
ath_rate_pick_seed_rate_ht(struct ath_softc *sc, struct ath_node *an,
|
||||
int frameLen)
|
||||
{
|
||||
#define DOT11RATE(ix) (rt->info[ix].dot11Rate & IEEE80211_RATE_VAL)
|
||||
#define MCS(ix) (rt->info[ix].dot11Rate | IEEE80211_RATE_MCS)
|
||||
#define RATE(ix) (DOT11RATE(ix) / 2)
|
||||
int rix = -1, ht_rix = -1;
|
||||
const HAL_RATE_TABLE *rt = sc->sc_currates;
|
||||
struct sample_node *sn = ATH_NODE_SAMPLE(an);
|
||||
const int size_bin = size_to_bin(frameLen);
|
||||
|
||||
/* no packet has been sent successfully yet */
|
||||
for (rix = rt->rateCount-1; rix > 0; rix--) {
|
||||
/* Skip rates we can't use */
|
||||
if ((sn->ratemask & (1<<rix)) == 0)
|
||||
continue;
|
||||
|
||||
/* Keep a copy of the last seen HT rate index */
|
||||
if (rt->info[rix].phy == IEEE80211_T_HT)
|
||||
ht_rix = rix;
|
||||
|
||||
/* Skip non-HT rates */
|
||||
if (rt->info[rix].phy != IEEE80211_T_HT)
|
||||
continue;
|
||||
|
||||
/*
|
||||
* Pick a medium-speed rate regardless of stream count
|
||||
* which has not seen any failures. Higher rates may fail;
|
||||
* we'll try them later.
|
||||
*/
|
||||
if (((MCS(rix) & 0x7) <= 4) &&
|
||||
sn->stats[size_bin][rix].successive_failures == 0) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* If all the MCS rates have successive failures, rix should be
|
||||
* > 0; otherwise use the lowest MCS rix (hopefully MCS 0.)
|
||||
*/
|
||||
return MAX(rix, ht_rix);
|
||||
#undef RATE
|
||||
#undef MCS
|
||||
#undef DOT11RATE
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
@ -363,9 +517,14 @@ ath_rate_findrate(struct ath_softc *sc, struct ath_node *an,
|
||||
if (sn->sample_tt[size_bin] < average_tx_time * (sn->packets_since_sample[size_bin]*ssc->sample_rate/100)) {
|
||||
rix = pick_sample_rate(ssc, an, rt, size_bin);
|
||||
IEEE80211_NOTE(an->an_node.ni_vap, IEEE80211_MSG_RATECTL,
|
||||
&an->an_node, "size %u sample rate %d current rate %d",
|
||||
bin_to_size(size_bin), RATE(rix),
|
||||
RATE(sn->current_rix[size_bin]));
|
||||
&an->an_node, "att %d sample_tt %d size %u sample rate %d %s current rate %d %s",
|
||||
average_tx_time,
|
||||
sn->sample_tt[size_bin],
|
||||
bin_to_size(size_bin),
|
||||
dot11rate(rt, rix),
|
||||
dot11rate_label(rt, rix),
|
||||
dot11rate(rt, sn->current_rix[size_bin]),
|
||||
dot11rate_label(rt, sn->current_rix[size_bin]));
|
||||
if (rix != sn->current_rix[size_bin]) {
|
||||
sn->current_sample_rix[size_bin] = rix;
|
||||
} else {
|
||||
@ -376,29 +535,58 @@ ath_rate_findrate(struct ath_softc *sc, struct ath_node *an,
|
||||
change_rates = 0;
|
||||
if (!sn->packets_sent[size_bin] || best_rix == -1) {
|
||||
/* no packet has been sent successfully yet */
|
||||
for (rix = rt->rateCount-1; rix > 0; rix--) {
|
||||
if ((sn->ratemask & (1<<rix)) == 0)
|
||||
continue;
|
||||
/*
|
||||
* Pick the highest rate <= 36 Mbps
|
||||
* that hasn't failed.
|
||||
*/
|
||||
if (DOT11RATE(rix) <= 72 &&
|
||||
sn->stats[size_bin][rix].successive_failures == 0) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
change_rates = 1;
|
||||
best_rix = rix;
|
||||
if (an->an_node.ni_flags & IEEE80211_NODE_HT)
|
||||
best_rix =
|
||||
ath_rate_pick_seed_rate_ht(sc, an, frameLen);
|
||||
else
|
||||
best_rix =
|
||||
ath_rate_pick_seed_rate_legacy(sc, an, frameLen);
|
||||
} else if (sn->packets_sent[size_bin] < 20) {
|
||||
/* let the bit-rate switch quickly during the first few packets */
|
||||
IEEE80211_NOTE(an->an_node.ni_vap,
|
||||
IEEE80211_MSG_RATECTL, &an->an_node,
|
||||
"%s: switching quickly..", __func__);
|
||||
change_rates = 1;
|
||||
} else if (ticks - ssc->min_switch > sn->ticks_since_switch[size_bin]) {
|
||||
/* min_switch seconds have gone by */
|
||||
IEEE80211_NOTE(an->an_node.ni_vap,
|
||||
IEEE80211_MSG_RATECTL, &an->an_node,
|
||||
"%s: min_switch %d > ticks_since_switch %d..",
|
||||
__func__, ticks - ssc->min_switch, sn->ticks_since_switch[size_bin]);
|
||||
change_rates = 1;
|
||||
} else if (2*average_tx_time < sn->stats[size_bin][sn->current_rix[size_bin]].average_tx_time) {
|
||||
} else if ((! (an->an_node.ni_flags & IEEE80211_NODE_HT)) &&
|
||||
(2*average_tx_time < sn->stats[size_bin][sn->current_rix[size_bin]].average_tx_time)) {
|
||||
/* the current bit-rate is twice as slow as the best one */
|
||||
IEEE80211_NOTE(an->an_node.ni_vap,
|
||||
IEEE80211_MSG_RATECTL, &an->an_node,
|
||||
"%s: 2x att (= %d) < cur_rix att %d",
|
||||
__func__,
|
||||
2 * average_tx_time, sn->stats[size_bin][sn->current_rix[size_bin]].average_tx_time);
|
||||
change_rates = 1;
|
||||
} else if ((an->an_node.ni_flags & IEEE80211_NODE_HT)) {
|
||||
int cur_rix = sn->current_rix[size_bin];
|
||||
int cur_att = sn->stats[size_bin][cur_rix].average_tx_time;
|
||||
/*
|
||||
* If the node is HT, upgrade it if the MCS rate is
|
||||
* higher and the average tx time is within 20% of
|
||||
* the current rate. It can fail a little.
|
||||
*
|
||||
* This is likely not optimal!
|
||||
*/
|
||||
#if 0
|
||||
printf("cur rix/att %x/%d, best rix/att %x/%d\n",
|
||||
MCS(cur_rix), cur_att, MCS(best_rix), average_tx_time);
|
||||
#endif
|
||||
if ((MCS(best_rix) > MCS(cur_rix)) &&
|
||||
(average_tx_time * 8) <= (cur_att * 10)) {
|
||||
IEEE80211_NOTE(an->an_node.ni_vap,
|
||||
IEEE80211_MSG_RATECTL, &an->an_node,
|
||||
"%s: HT: best_rix 0x%d > cur_rix 0x%x, average_tx_time %d, cur_att %d",
|
||||
__func__,
|
||||
MCS(best_rix), MCS(cur_rix), average_tx_time, cur_att);
|
||||
change_rates = 1;
|
||||
}
|
||||
}
|
||||
|
||||
sn->packets_since_sample[size_bin]++;
|
||||
@ -450,22 +638,24 @@ ath_rate_findrate(struct ath_softc *sc, struct ath_node *an,
|
||||
*/
|
||||
void
|
||||
ath_rate_getxtxrates(struct ath_softc *sc, struct ath_node *an,
|
||||
uint8_t rix0, uint8_t *rix, uint8_t *try)
|
||||
uint8_t rix0, struct ath_rc_series *rc)
|
||||
{
|
||||
struct sample_node *sn = ATH_NODE_SAMPLE(an);
|
||||
const struct txschedule *sched = &sn->sched[rix0];
|
||||
|
||||
KASSERT(rix0 == sched->r0, ("rix0 (%x) != sched->r0 (%x)!\n", rix0, sched->r0));
|
||||
|
||||
/* rix[0] = sched->r0; */
|
||||
rix[1] = sched->r1;
|
||||
rix[2] = sched->r2;
|
||||
rix[3] = sched->r3;
|
||||
rc[0].flags = rc[1].flags = rc[2].flags = rc[3].flags = 0;
|
||||
|
||||
try[0] = sched->t0;
|
||||
try[1] = sched->t1;
|
||||
try[2] = sched->t2;
|
||||
try[3] = sched->t3;
|
||||
rc[0].rix = sched->r0;
|
||||
rc[1].rix = sched->r1;
|
||||
rc[2].rix = sched->r2;
|
||||
rc[3].rix = sched->r3;
|
||||
|
||||
rc[0].tries = sched->t0;
|
||||
rc[1].tries = sched->t1;
|
||||
rc[2].tries = sched->t2;
|
||||
rc[3].tries = sched->t3;
|
||||
}
|
||||
|
||||
void
|
||||
@ -493,6 +683,71 @@ ath_rate_setupxtxdesc(struct ath_softc *sc, struct ath_node *an,
|
||||
s3code, sched->t3); /* series 3 */
|
||||
}
|
||||
|
||||
/*
|
||||
* Update the EWMA percentage.
|
||||
*
|
||||
* This is a simple hack to track an EWMA based on the current
|
||||
* rate scenario. For the rate codes which failed, this will
|
||||
* record a 0% against it. For the rate code which succeeded,
|
||||
* EWMA will record the nbad*100/nframes percentage against it.
|
||||
*/
|
||||
static void
|
||||
update_ewma_stats(struct ath_softc *sc, struct ath_node *an,
|
||||
int frame_size,
|
||||
int rix0, int tries0,
|
||||
int rix1, int tries1,
|
||||
int rix2, int tries2,
|
||||
int rix3, int tries3,
|
||||
int short_tries, int tries, int status,
|
||||
int nframes, int nbad)
|
||||
{
|
||||
struct sample_node *sn = ATH_NODE_SAMPLE(an);
|
||||
struct sample_softc *ssc = ATH_SOFTC_SAMPLE(sc);
|
||||
const int size_bin = size_to_bin(frame_size);
|
||||
int tries_so_far;
|
||||
int pct;
|
||||
int rix = rix0;
|
||||
|
||||
/* Calculate percentage based on current rate */
|
||||
if (nframes == 0)
|
||||
nframes = nbad = 1;
|
||||
pct = ((nframes - nbad) * 1000) / nframes;
|
||||
|
||||
/* Figure out which rate index succeeded */
|
||||
tries_so_far = tries0;
|
||||
|
||||
if (tries1 && tries_so_far < tries) {
|
||||
tries_so_far += tries1;
|
||||
rix = rix1;
|
||||
/* XXX bump ewma pct */
|
||||
}
|
||||
|
||||
if (tries2 && tries_so_far < tries) {
|
||||
tries_so_far += tries2;
|
||||
rix = rix2;
|
||||
/* XXX bump ewma pct */
|
||||
}
|
||||
|
||||
if (tries3 && tries_so_far < tries) {
|
||||
rix = rix3;
|
||||
/* XXX bump ewma pct */
|
||||
}
|
||||
|
||||
/* rix is the successful rate, update EWMA for final rix */
|
||||
if (sn->stats[size_bin][rix].total_packets <
|
||||
ssc->smoothing_minpackets) {
|
||||
/* just average the first few packets */
|
||||
int a_pct = (sn->stats[size_bin][rix].packets_acked * 1000) /
|
||||
(sn->stats[size_bin][rix].total_packets);
|
||||
sn->stats[size_bin][rix].ewma_pct = a_pct;
|
||||
} else {
|
||||
/* use a ewma */
|
||||
sn->stats[size_bin][rix].ewma_pct =
|
||||
((sn->stats[size_bin][rix].ewma_pct * ssc->smoothing_rate) +
|
||||
(pct * (100 - ssc->smoothing_rate))) / 100;
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
update_stats(struct ath_softc *sc, struct ath_node *an,
|
||||
int frame_size,
|
||||
@ -500,10 +755,12 @@ update_stats(struct ath_softc *sc, struct ath_node *an,
|
||||
int rix1, int tries1,
|
||||
int rix2, int tries2,
|
||||
int rix3, int tries3,
|
||||
int short_tries, int tries, int status)
|
||||
int short_tries, int tries, int status,
|
||||
int nframes, int nbad)
|
||||
{
|
||||
struct sample_node *sn = ATH_NODE_SAMPLE(an);
|
||||
struct sample_softc *ssc = ATH_SOFTC_SAMPLE(sc);
|
||||
const HAL_RATE_TABLE *rt = sc->sc_currates;
|
||||
const int size_bin = size_to_bin(frame_size);
|
||||
const int size = bin_to_size(size_bin);
|
||||
int tt, tries_so_far;
|
||||
@ -542,7 +799,7 @@ update_stats(struct ath_softc *sc, struct ath_node *an,
|
||||
/* just average the first few packets */
|
||||
int avg_tx = sn->stats[size_bin][rix0].average_tx_time;
|
||||
int packets = sn->stats[size_bin][rix0].total_packets;
|
||||
sn->stats[size_bin][rix0].average_tx_time = (tt+(avg_tx*packets))/(packets+1);
|
||||
sn->stats[size_bin][rix0].average_tx_time = (tt+(avg_tx*packets))/(packets+nframes);
|
||||
} else {
|
||||
/* use a ewma */
|
||||
sn->stats[size_bin][rix0].average_tx_time =
|
||||
@ -550,38 +807,50 @@ update_stats(struct ath_softc *sc, struct ath_node *an,
|
||||
(tt * (100 - ssc->smoothing_rate))) / 100;
|
||||
}
|
||||
|
||||
if (status != 0) {
|
||||
/*
|
||||
* XXX Don't mark the higher bit rates as also having failed; as this
|
||||
* unfortunately stops those rates from being tasted when trying to
|
||||
* TX. This happens with 11n aggregation.
|
||||
*/
|
||||
if (nframes == nbad) {
|
||||
#if 0
|
||||
int y;
|
||||
sn->stats[size_bin][rix0].successive_failures++;
|
||||
#endif
|
||||
sn->stats[size_bin][rix0].successive_failures += nbad;
|
||||
#if 0
|
||||
for (y = size_bin+1; y < NUM_PACKET_SIZE_BINS; y++) {
|
||||
/*
|
||||
* Also say larger packets failed since we
|
||||
* assume if a small packet fails at a
|
||||
* bit-rate then a larger one will also.
|
||||
*/
|
||||
sn->stats[y][rix0].successive_failures++;
|
||||
sn->stats[y][rix0].successive_failures += nbad;
|
||||
sn->stats[y][rix0].last_tx = ticks;
|
||||
sn->stats[y][rix0].tries += tries;
|
||||
sn->stats[y][rix0].total_packets++;
|
||||
sn->stats[y][rix0].total_packets += nframes;
|
||||
}
|
||||
#endif
|
||||
} else {
|
||||
sn->stats[size_bin][rix0].packets_acked++;
|
||||
sn->stats[size_bin][rix0].packets_acked += (nframes - nbad);
|
||||
sn->stats[size_bin][rix0].successive_failures = 0;
|
||||
}
|
||||
sn->stats[size_bin][rix0].tries += tries;
|
||||
sn->stats[size_bin][rix0].last_tx = ticks;
|
||||
sn->stats[size_bin][rix0].total_packets++;
|
||||
sn->stats[size_bin][rix0].total_packets += nframes;
|
||||
|
||||
if (rix0 == sn->current_sample_rix[size_bin]) {
|
||||
IEEE80211_NOTE(an->an_node.ni_vap, IEEE80211_MSG_RATECTL,
|
||||
&an->an_node,
|
||||
"%s: size %d %s sample rate %d tries (%d/%d) tt %d avg_tt (%d/%d)",
|
||||
"%s: size %d %s sample rate %d %s tries (%d/%d) tt %d avg_tt (%d/%d) nfrm %d nbad %d",
|
||||
__func__,
|
||||
size,
|
||||
status ? "FAIL" : "OK",
|
||||
rix0, short_tries, tries, tt,
|
||||
dot11rate(rt, rix0),
|
||||
dot11rate_label(rt, rix0),
|
||||
short_tries, tries, tt,
|
||||
sn->stats[size_bin][rix0].average_tx_time,
|
||||
sn->stats[size_bin][rix0].perfect_tx_time);
|
||||
sn->stats[size_bin][rix0].perfect_tx_time,
|
||||
nframes, nbad);
|
||||
sn->sample_tt[size_bin] = tt;
|
||||
sn->current_sample_rix[size_bin] = -1;
|
||||
}
|
||||
@ -596,21 +865,21 @@ badrate(struct ifnet *ifp, int series, int hwrate, int tries, int status)
|
||||
|
||||
void
|
||||
ath_rate_tx_complete(struct ath_softc *sc, struct ath_node *an,
|
||||
const struct ath_buf *bf)
|
||||
const struct ath_rc_series *rc, const struct ath_tx_status *ts,
|
||||
int frame_size, int nframes, int nbad)
|
||||
{
|
||||
struct ifnet *ifp = sc->sc_ifp;
|
||||
struct ieee80211com *ic = ifp->if_l2com;
|
||||
struct sample_node *sn = ATH_NODE_SAMPLE(an);
|
||||
const struct ath_tx_status *ts = &bf->bf_status.ds_txstat;
|
||||
const struct ath_desc *ds0 = &bf->bf_desc[0];
|
||||
int final_rix, short_tries, long_tries, frame_size;
|
||||
int final_rix, short_tries, long_tries;
|
||||
const HAL_RATE_TABLE *rt = sc->sc_currates;
|
||||
int status = ts->ts_status;
|
||||
int mrr;
|
||||
|
||||
final_rix = rt->rateCodeToIndex[ts->ts_rate];
|
||||
short_tries = ts->ts_shortretry;
|
||||
long_tries = ts->ts_longretry + 1;
|
||||
frame_size = ds0->ds_ctl0 & 0x0fff; /* low-order 12 bits of ds_ctl0 */
|
||||
|
||||
if (frame_size == 0) /* NB: should not happen */
|
||||
frame_size = 1500;
|
||||
|
||||
@ -620,63 +889,73 @@ ath_rate_tx_complete(struct ath_softc *sc, struct ath_node *an,
|
||||
"%s: size %d %s rate/try %d/%d no rates yet",
|
||||
__func__,
|
||||
bin_to_size(size_to_bin(frame_size)),
|
||||
ts->ts_status ? "FAIL" : "OK",
|
||||
status ? "FAIL" : "OK",
|
||||
short_tries, long_tries);
|
||||
return;
|
||||
}
|
||||
mrr = sc->sc_mrretry && !(ic->ic_flags & IEEE80211_F_USEPROT);
|
||||
if (!mrr || ts->ts_finaltsi == 0) {
|
||||
if (!IS_RATE_DEFINED(sn, final_rix)) {
|
||||
badrate(ifp, 0, ts->ts_rate, long_tries, ts->ts_status);
|
||||
badrate(ifp, 0, ts->ts_rate, long_tries, status);
|
||||
return;
|
||||
}
|
||||
/*
|
||||
* Only one rate was used; optimize work.
|
||||
*/
|
||||
IEEE80211_NOTE(an->an_node.ni_vap, IEEE80211_MSG_RATECTL,
|
||||
&an->an_node, "%s: size %d (%d bytes) %s rate/try %d %s/%d/%d",
|
||||
&an->an_node, "%s: size %d (%d bytes) %s rate/try %d %s/%d/%d nframes/nbad [%d/%d]",
|
||||
__func__,
|
||||
bin_to_size(size_to_bin(frame_size)),
|
||||
frame_size,
|
||||
ts->ts_status ? "FAIL" : "OK",
|
||||
dot11rate(rt, final_rix), dot11rate_label(rt, final_rix), short_tries, long_tries);
|
||||
status ? "FAIL" : "OK",
|
||||
dot11rate(rt, final_rix), dot11rate_label(rt, final_rix),
|
||||
short_tries, long_tries, nframes, nbad);
|
||||
update_stats(sc, an, frame_size,
|
||||
final_rix, long_tries,
|
||||
0, 0,
|
||||
0, 0,
|
||||
0, 0,
|
||||
short_tries, long_tries, ts->ts_status);
|
||||
short_tries, long_tries, status,
|
||||
nframes, nbad);
|
||||
update_ewma_stats(sc, an, frame_size,
|
||||
final_rix, long_tries,
|
||||
0, 0,
|
||||
0, 0,
|
||||
0, 0,
|
||||
short_tries, long_tries, status,
|
||||
nframes, nbad);
|
||||
|
||||
} else {
|
||||
int hwrates[4], tries[4], rix[4];
|
||||
int finalTSIdx = ts->ts_finaltsi;
|
||||
int i;
|
||||
|
||||
/*
|
||||
* Process intermediate rates that failed.
|
||||
*/
|
||||
ath_hal_gettxcompletionrates(sc->sc_ah, ds0, hwrates, tries);
|
||||
|
||||
for (i = 0; i < 4; i++) {
|
||||
rix[i] = rt->rateCodeToIndex[hwrates[i]];
|
||||
}
|
||||
|
||||
IEEE80211_NOTE(an->an_node.ni_vap, IEEE80211_MSG_RATECTL,
|
||||
&an->an_node,
|
||||
"%s: size %d (%d bytes) finaltsidx %d tries %d %s rate/try [%d %s/%d %d %s/%d %d %s/%d %d %s/%d]",
|
||||
"%s: size %d (%d bytes) finaltsidx %d tries %d %s rate/try [%d %s/%d %d %s/%d %d %s/%d %d %s/%d] nframes/nbad [%d/%d]",
|
||||
__func__,
|
||||
bin_to_size(size_to_bin(frame_size)),
|
||||
frame_size,
|
||||
finalTSIdx,
|
||||
long_tries,
|
||||
ts->ts_status ? "FAIL" : "OK",
|
||||
dot11rate(rt, rix[0]), dot11rate_label(rt, rix[0]), tries[0],
|
||||
dot11rate(rt, rix[1]), dot11rate_label(rt, rix[1]), tries[1],
|
||||
dot11rate(rt, rix[2]), dot11rate_label(rt, rix[2]), tries[2],
|
||||
dot11rate(rt, rix[3]), dot11rate_label(rt, rix[3]), tries[3]);
|
||||
long_tries,
|
||||
status ? "FAIL" : "OK",
|
||||
dot11rate(rt, rc[0].rix),
|
||||
dot11rate_label(rt, rc[0].rix), rc[0].tries,
|
||||
dot11rate(rt, rc[1].rix),
|
||||
dot11rate_label(rt, rc[1].rix), rc[1].tries,
|
||||
dot11rate(rt, rc[2].rix),
|
||||
dot11rate_label(rt, rc[2].rix), rc[2].tries,
|
||||
dot11rate(rt, rc[3].rix),
|
||||
dot11rate_label(rt, rc[3].rix), rc[3].tries,
|
||||
nframes, nbad);
|
||||
|
||||
for (i = 0; i < 4; i++) {
|
||||
if (tries[i] && !IS_RATE_DEFINED(sn, rix[i]))
|
||||
badrate(ifp, 0, hwrates[i], tries[i], ts->ts_status);
|
||||
if (rc[i].tries && !IS_RATE_DEFINED(sn, rc[i].rix))
|
||||
badrate(ifp, 0, rc[i].ratecode, rc[i].tries,
|
||||
status);
|
||||
}
|
||||
|
||||
/*
|
||||
@ -686,48 +965,62 @@ ath_rate_tx_complete(struct ath_softc *sc, struct ath_node *an,
|
||||
* sample higher rates 1 try at a time doing so
|
||||
* may unfairly penalize them.
|
||||
*/
|
||||
if (tries[0]) {
|
||||
update_stats(sc, an, frame_size,
|
||||
rix[0], tries[0],
|
||||
rix[1], tries[1],
|
||||
rix[2], tries[2],
|
||||
rix[3], tries[3],
|
||||
short_tries, long_tries,
|
||||
long_tries > tries[0]);
|
||||
long_tries -= tries[0];
|
||||
if (rc[0].tries) {
|
||||
update_stats(sc, an, frame_size,
|
||||
rc[0].rix, rc[0].tries,
|
||||
rc[1].rix, rc[1].tries,
|
||||
rc[2].rix, rc[2].tries,
|
||||
rc[3].rix, rc[3].tries,
|
||||
short_tries, long_tries,
|
||||
long_tries > rc[0].tries,
|
||||
nframes, nbad);
|
||||
long_tries -= rc[0].tries;
|
||||
}
|
||||
|
||||
if (tries[1] && finalTSIdx > 0) {
|
||||
update_stats(sc, an, frame_size,
|
||||
rix[1], tries[1],
|
||||
rix[2], tries[2],
|
||||
rix[3], tries[3],
|
||||
0, 0,
|
||||
short_tries, long_tries,
|
||||
ts->ts_status);
|
||||
long_tries -= tries[1];
|
||||
if (rc[1].tries && finalTSIdx > 0) {
|
||||
update_stats(sc, an, frame_size,
|
||||
rc[1].rix, rc[1].tries,
|
||||
rc[2].rix, rc[2].tries,
|
||||
rc[3].rix, rc[3].tries,
|
||||
0, 0,
|
||||
short_tries, long_tries,
|
||||
status,
|
||||
nframes, nbad);
|
||||
long_tries -= rc[1].tries;
|
||||
}
|
||||
|
||||
if (tries[2] && finalTSIdx > 1) {
|
||||
update_stats(sc, an, frame_size,
|
||||
rix[2], tries[2],
|
||||
rix[3], tries[3],
|
||||
if (rc[2].tries && finalTSIdx > 1) {
|
||||
update_stats(sc, an, frame_size,
|
||||
rc[2].rix, rc[2].tries,
|
||||
rc[3].rix, rc[3].tries,
|
||||
0, 0,
|
||||
0, 0,
|
||||
short_tries, long_tries,
|
||||
ts->ts_status);
|
||||
long_tries -= tries[2];
|
||||
short_tries, long_tries,
|
||||
status,
|
||||
nframes, nbad);
|
||||
long_tries -= rc[2].tries;
|
||||
}
|
||||
|
||||
if (tries[3] && finalTSIdx > 2) {
|
||||
update_stats(sc, an, frame_size,
|
||||
rix[3], tries[3],
|
||||
if (rc[3].tries && finalTSIdx > 2) {
|
||||
update_stats(sc, an, frame_size,
|
||||
rc[3].rix, rc[3].tries,
|
||||
0, 0,
|
||||
0, 0,
|
||||
0, 0,
|
||||
short_tries, long_tries,
|
||||
ts->ts_status);
|
||||
short_tries, long_tries,
|
||||
status,
|
||||
nframes, nbad);
|
||||
}
|
||||
|
||||
update_ewma_stats(sc, an, frame_size,
|
||||
rc[0].rix, rc[0].tries,
|
||||
rc[1].rix, rc[1].tries,
|
||||
rc[2].rix, rc[2].tries,
|
||||
rc[3].rix, rc[3].tries,
|
||||
short_tries, long_tries,
|
||||
long_tries > rc[0].tries,
|
||||
nframes, nbad);
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
@ -849,6 +1142,7 @@ ath_rate_ctl_reset(struct ath_softc *sc, struct ieee80211_node *ni)
|
||||
sn->stats[y][rix].total_packets = 0;
|
||||
sn->stats[y][rix].packets_acked = 0;
|
||||
sn->stats[y][rix].last_tx = 0;
|
||||
sn->stats[y][rix].ewma_pct = 0;
|
||||
|
||||
sn->stats[y][rix].perfect_tx_time =
|
||||
calc_usecs_unicast_packet(sc, size, rix, 0, 0,
|
||||
@ -886,18 +1180,24 @@ sample_stats(void *arg, struct ieee80211_node *ni)
|
||||
uint32_t mask;
|
||||
int rix, y;
|
||||
|
||||
printf("\n[%s] refcnt %d static_rix %d ratemask 0x%x\n",
|
||||
printf("\n[%s] refcnt %d static_rix (%d %s) ratemask 0x%x\n",
|
||||
ether_sprintf(ni->ni_macaddr), ieee80211_node_refcnt(ni),
|
||||
sn->static_rix, sn->ratemask);
|
||||
dot11rate(rt, sn->static_rix),
|
||||
dot11rate_label(rt, sn->static_rix),
|
||||
sn->ratemask);
|
||||
for (y = 0; y < NUM_PACKET_SIZE_BINS; y++) {
|
||||
printf("[%4u] cur rix %d (%d %s) since switch: packets %d ticks %u\n",
|
||||
bin_to_size(y), sn->current_rix[y],
|
||||
dot11rate(rt, sn->current_rix[y]),
|
||||
dot11rate_label(rt, sn->current_rix[y]),
|
||||
sn->packets_since_switch[y], sn->ticks_since_switch[y]);
|
||||
printf("[%4u] last sample %d cur sample %d packets sent %d\n",
|
||||
bin_to_size(y), sn->last_sample_rix[y],
|
||||
sn->current_sample_rix[y], sn->packets_sent[y]);
|
||||
printf("[%4u] last sample (%d %s) cur sample (%d %s) packets sent %d\n",
|
||||
bin_to_size(y),
|
||||
dot11rate(rt, sn->last_sample_rix[y]),
|
||||
dot11rate_label(rt, sn->last_sample_rix[y]),
|
||||
dot11rate(rt, sn->current_sample_rix[y]),
|
||||
dot11rate_label(rt, sn->current_sample_rix[y]),
|
||||
sn->packets_sent[y]);
|
||||
printf("[%4u] packets since sample %d sample tt %u\n",
|
||||
bin_to_size(y), sn->packets_since_sample[y],
|
||||
sn->sample_tt[y]);
|
||||
@ -908,13 +1208,15 @@ sample_stats(void *arg, struct ieee80211_node *ni)
|
||||
for (y = 0; y < NUM_PACKET_SIZE_BINS; y++) {
|
||||
if (sn->stats[y][rix].total_packets == 0)
|
||||
continue;
|
||||
printf("[%2u %s:%4u] %8ju:%-8ju (%3d%%) T %8ju F %4d avg %5u last %u\n",
|
||||
printf("[%2u %s:%4u] %8ju:%-8ju (%3d%%) (EWMA %3d.%1d%%) T %8ju F %4d avg %5u last %u\n",
|
||||
dot11rate(rt, rix), dot11rate_label(rt, rix),
|
||||
bin_to_size(y),
|
||||
(uintmax_t) sn->stats[y][rix].total_packets,
|
||||
(uintmax_t) sn->stats[y][rix].packets_acked,
|
||||
(int) ((sn->stats[y][rix].packets_acked * 100ULL) /
|
||||
sn->stats[y][rix].total_packets),
|
||||
sn->stats[y][rix].ewma_pct / 10,
|
||||
sn->stats[y][rix].ewma_pct % 10,
|
||||
(uintmax_t) sn->stats[y][rix].tries,
|
||||
sn->stats[y][rix].successive_failures,
|
||||
sn->stats[y][rix].average_tx_time,
|
||||
|
@ -51,6 +51,7 @@ struct sample_softc {
|
||||
int max_successive_failures;
|
||||
int stale_failure_timeout; /* how long to honor max_successive_failures */
|
||||
int min_switch; /* min time between rate changes */
|
||||
int min_good_pct; /* min good percentage for a rate to be considered */
|
||||
};
|
||||
#define ATH_SOFTC_SAMPLE(sc) ((struct sample_softc *)sc->sc_rc)
|
||||
|
||||
@ -60,6 +61,7 @@ struct rate_stats {
|
||||
uint64_t tries;
|
||||
uint64_t total_packets; /* pkts total since assoc */
|
||||
uint64_t packets_acked; /* pkts acked since assoc */
|
||||
int ewma_pct; /* EWMA percentage */
|
||||
unsigned perfect_tx_time; /* transmit time for 0 retries */
|
||||
int last_tx;
|
||||
};
|
||||
|
@ -723,6 +723,19 @@ ath_attach(u_int16_t devid, struct ath_softc *sc)
|
||||
ic->ic_scan_end = ath_scan_end;
|
||||
ic->ic_set_channel = ath_set_channel;
|
||||
|
||||
/* 802.11n specific - but just override anyway */
|
||||
sc->sc_addba_request = ic->ic_addba_request;
|
||||
sc->sc_addba_response = ic->ic_addba_response;
|
||||
sc->sc_addba_stop = ic->ic_addba_stop;
|
||||
sc->sc_bar_response = ic->ic_bar_response;
|
||||
sc->sc_addba_response_timeout = ic->ic_addba_response_timeout;
|
||||
|
||||
ic->ic_addba_request = ath_addba_request;
|
||||
ic->ic_addba_response = ath_addba_response;
|
||||
ic->ic_addba_response_timeout = ath_addba_response_timeout;
|
||||
ic->ic_addba_stop = ath_addba_stop;
|
||||
ic->ic_bar_response = ath_bar_response;
|
||||
|
||||
ieee80211_radiotap_attach(ic,
|
||||
&sc->sc_tx_th.wt_ihdr, sizeof(sc->sc_tx_th),
|
||||
ATH_TX_RADIOTAP_PRESENT,
|
||||
@ -3343,6 +3356,9 @@ ath_node_alloc(struct ieee80211vap *vap, const uint8_t mac[IEEE80211_ADDR_LEN])
|
||||
device_get_nameunit(sc->sc_dev), an);
|
||||
mtx_init(&an->an_mtx, an->an_name, NULL, MTX_DEF);
|
||||
|
||||
/* XXX setup ath_tid */
|
||||
ath_tx_tid_init(sc, an);
|
||||
|
||||
DPRINTF(sc, ATH_DEBUG_NODE, "%s: an %p\n", __func__, an);
|
||||
return &an->an_node;
|
||||
}
|
||||
@ -3354,6 +3370,7 @@ ath_node_cleanup(struct ieee80211_node *ni)
|
||||
struct ath_softc *sc = ic->ic_ifp->if_softc;
|
||||
|
||||
/* Cleanup ath_tid, free unused bufs, unlink bufs in TXQ */
|
||||
ath_tx_node_flush(sc, ATH_NODE(ni));
|
||||
ath_rate_node_cleanup(sc, ATH_NODE(ni));
|
||||
sc->sc_node_cleanup(ni);
|
||||
}
|
||||
@ -4363,6 +4380,29 @@ ath_tx_default_comp(struct ath_softc *sc, struct ath_buf *bf, int fail)
|
||||
ath_tx_freebuf(sc, bf, st);
|
||||
}
|
||||
|
||||
/*
|
||||
* Update rate control with the given completion status.
|
||||
*/
|
||||
void
|
||||
ath_tx_update_ratectrl(struct ath_softc *sc, struct ieee80211_node *ni,
|
||||
struct ath_rc_series *rc, struct ath_tx_status *ts, int frmlen,
|
||||
int nframes, int nbad)
|
||||
{
|
||||
struct ath_node *an;
|
||||
|
||||
/* Only for unicast frames */
|
||||
if (ni == NULL)
|
||||
return;
|
||||
|
||||
an = ATH_NODE(ni);
|
||||
|
||||
if ((ts->ts_status & HAL_TXERR_FILT) == 0) {
|
||||
ATH_NODE_LOCK(an);
|
||||
ath_rate_tx_complete(sc, an, rc, ts, frmlen, nframes, nbad);
|
||||
ATH_NODE_UNLOCK(an);
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Update the busy status of the last frame on the free list.
|
||||
* When doing TDMA, the busy flag tracks whether the hardware
|
||||
@ -4396,6 +4436,8 @@ ath_tx_update_busy(struct ath_softc *sc)
|
||||
|
||||
/*
|
||||
* Process completed xmit descriptors from the specified queue.
|
||||
* Kick the packet scheduler if needed. This can occur from this
|
||||
* particular task.
|
||||
*/
|
||||
static int
|
||||
ath_tx_processq(struct ath_softc *sc, struct ath_txq *txq, int dosched)
|
||||
@ -4405,6 +4447,7 @@ ath_tx_processq(struct ath_softc *sc, struct ath_txq *txq, int dosched)
|
||||
struct ath_desc *ds;
|
||||
struct ath_tx_status *ts;
|
||||
struct ieee80211_node *ni;
|
||||
struct ath_node *an;
|
||||
int nacked;
|
||||
HAL_STATUS status;
|
||||
|
||||
@ -4471,6 +4514,7 @@ ath_tx_processq(struct ath_softc *sc, struct ath_txq *txq, int dosched)
|
||||
|
||||
/* If unicast frame, update general statistics */
|
||||
if (ni != NULL) {
|
||||
an = ATH_NODE(ni);
|
||||
/* update statistics */
|
||||
ath_tx_update_stats(sc, ts, bf);
|
||||
}
|
||||
@ -4490,7 +4534,10 @@ ath_tx_processq(struct ath_softc *sc, struct ath_txq *txq, int dosched)
|
||||
* XXX assume this isn't an aggregate
|
||||
* frame.
|
||||
*/
|
||||
ath_rate_tx_complete(sc, ATH_NODE(ni), bf);
|
||||
ath_tx_update_ratectrl(sc, ni,
|
||||
bf->bf_state.bfs_rc, ts,
|
||||
bf->bf_state.bfs_pktlen, 1,
|
||||
(ts->ts_status == 0 ? 0 : 1));
|
||||
}
|
||||
ath_tx_default_comp(sc, bf, 0);
|
||||
} else
|
||||
@ -4503,6 +4550,14 @@ ath_tx_processq(struct ath_softc *sc, struct ath_txq *txq, int dosched)
|
||||
if (txq->axq_depth <= 1)
|
||||
ieee80211_ff_flush(ic, txq->axq_ac);
|
||||
#endif
|
||||
|
||||
/* Kick the TXQ scheduler */
|
||||
if (dosched) {
|
||||
ATH_TXQ_LOCK(txq);
|
||||
ath_txq_sched(sc, txq);
|
||||
ATH_TXQ_UNLOCK(txq);
|
||||
}
|
||||
|
||||
return nacked;
|
||||
}
|
||||
|
||||
@ -4736,6 +4791,11 @@ ath_tx_draintxq(struct ath_softc *sc, struct ath_txq *txq)
|
||||
ath_tx_default_comp(sc, bf, 1);
|
||||
}
|
||||
|
||||
/*
|
||||
* Drain software queued frames which are on
|
||||
* active TIDs.
|
||||
*/
|
||||
ath_tx_txq_drain(sc, txq);
|
||||
}
|
||||
|
||||
static void
|
||||
|
@ -60,6 +60,9 @@ extern int ath_reset(struct ifnet *, ATH_RESET_TYPE);
|
||||
extern void ath_tx_draintxq(struct ath_softc *sc, struct ath_txq *txq);
|
||||
extern void ath_tx_default_comp(struct ath_softc *sc, struct ath_buf *bf,
|
||||
int fail);
|
||||
extern void ath_tx_update_ratectrl(struct ath_softc *sc,
|
||||
struct ieee80211_node *ni, struct ath_rc_series *rc,
|
||||
struct ath_tx_status *ts, int frmlen, int nframes, int nbad);
|
||||
|
||||
extern void ath_tx_freebuf(struct ath_softc *sc, struct ath_buf *bf,
|
||||
int status);
|
||||
|
File diff suppressed because it is too large
Load Diff
@ -31,6 +31,18 @@
|
||||
#ifndef __IF_ATH_TX_H__
|
||||
#define __IF_ATH_TX_H__
|
||||
|
||||
/*
|
||||
* some general macros
|
||||
*/
|
||||
#define INCR(_l, _sz) (_l) ++; (_l) &= ((_sz) - 1)
|
||||
/*
|
||||
* return block-ack bitmap index given sequence and starting sequence
|
||||
*/
|
||||
#define ATH_BA_INDEX(_st, _seq) (((_seq) - (_st)) & (IEEE80211_SEQ_RANGE - 1))
|
||||
|
||||
#define WME_BA_BMP_SIZE 64
|
||||
#define WME_MAX_BA WME_BA_BMP_SIZE
|
||||
|
||||
/*
|
||||
* How 'busy' to try and keep the hardware txq
|
||||
*/
|
||||
@ -49,7 +61,28 @@
|
||||
#define ATH_AGGR_SCHED_HIGH 4
|
||||
#define ATH_AGGR_SCHED_LOW 2
|
||||
|
||||
/*
|
||||
* return whether a bit at index _n in bitmap _bm is set
|
||||
* _sz is the size of the bitmap
|
||||
*/
|
||||
#define ATH_BA_ISSET(_bm, _n) (((_n) < (WME_BA_BMP_SIZE)) && \
|
||||
((_bm)[(_n) >> 5] & (1 << ((_n) & 31))))
|
||||
|
||||
|
||||
/* extracting the seqno from buffer seqno */
|
||||
#define SEQNO(_a) ((_a) >> IEEE80211_SEQ_SEQ_SHIFT)
|
||||
|
||||
/*
|
||||
* Whether the current sequence number is within the
|
||||
* BAW.
|
||||
*/
|
||||
#define BAW_WITHIN(_start, _bawsz, _seqno) \
|
||||
((((_seqno) - (_start)) & 4095) < (_bawsz))
|
||||
|
||||
extern void ath_txq_restart_dma(struct ath_softc *sc, struct ath_txq *txq);
|
||||
extern void ath_freetx(struct mbuf *m);
|
||||
extern void ath_tx_node_flush(struct ath_softc *sc, struct ath_node *an);
|
||||
extern void ath_tx_txq_drain(struct ath_softc *sc, struct ath_txq *txq);
|
||||
extern void ath_txfrag_cleanup(struct ath_softc *sc, ath_bufhead *frags,
|
||||
struct ieee80211_node *ni);
|
||||
extern int ath_txfrag_setup(struct ath_softc *sc, ath_bufhead *frags,
|
||||
@ -59,4 +92,36 @@ extern int ath_tx_start(struct ath_softc *sc, struct ieee80211_node *ni,
|
||||
extern int ath_raw_xmit(struct ieee80211_node *ni, struct mbuf *m,
|
||||
const struct ieee80211_bpf_params *params);
|
||||
|
||||
/* software queue stuff */
|
||||
extern void ath_tx_swq(struct ath_softc *sc, struct ieee80211_node *ni,
|
||||
struct ath_txq *txq, struct ath_buf *bf);
|
||||
extern void ath_tx_tid_init(struct ath_softc *sc, struct ath_node *an);
|
||||
extern void ath_tx_tid_hw_queue_aggr(struct ath_softc *sc, struct ath_node *an,
|
||||
struct ath_tid *tid);
|
||||
extern void ath_tx_tid_hw_queue_norm(struct ath_softc *sc, struct ath_node *an,
|
||||
struct ath_tid *tid);
|
||||
extern void ath_txq_sched(struct ath_softc *sc, struct ath_txq *txq);
|
||||
extern void ath_tx_normal_comp(struct ath_softc *sc, struct ath_buf *bf,
|
||||
int fail);
|
||||
extern void ath_tx_aggr_comp(struct ath_softc *sc, struct ath_buf *bf,
|
||||
int fail);
|
||||
extern void ath_tx_addto_baw(struct ath_softc *sc, struct ath_node *an,
|
||||
struct ath_tid *tid, struct ath_buf *bf);
|
||||
extern struct ieee80211_tx_ampdu * ath_tx_get_tx_tid(struct ath_node *an,
|
||||
int tid);
|
||||
|
||||
/* TX addba handling */
|
||||
extern int ath_addba_request(struct ieee80211_node *ni,
|
||||
struct ieee80211_tx_ampdu *tap, int dialogtoken,
|
||||
int baparamset, int batimeout);
|
||||
extern int ath_addba_response(struct ieee80211_node *ni,
|
||||
struct ieee80211_tx_ampdu *tap, int dialogtoken,
|
||||
int code, int batimeout);
|
||||
extern void ath_addba_stop(struct ieee80211_node *ni,
|
||||
struct ieee80211_tx_ampdu *tap);
|
||||
extern void ath_bar_response(struct ieee80211_node *ni,
|
||||
struct ieee80211_tx_ampdu *tap, int status);
|
||||
extern void ath_addba_response_timeout(struct ieee80211_node *ni,
|
||||
struct ieee80211_tx_ampdu *tap);
|
||||
|
||||
#endif
|
||||
|
@ -86,17 +86,357 @@ __FBSDID("$FreeBSD$");
|
||||
#include <dev/ath/ath_tx99/ath_tx99.h>
|
||||
#endif
|
||||
|
||||
#include <dev/ath/if_ath_tx.h> /* XXX for some support functions */
|
||||
#include <dev/ath/if_ath_tx_ht.h>
|
||||
#include <dev/ath/if_athrate.h>
|
||||
#include <dev/ath/if_ath_debug.h>
|
||||
|
||||
/*
|
||||
* XXX net80211?
|
||||
*/
|
||||
#define IEEE80211_AMPDU_SUBFRAME_DEFAULT 32
|
||||
|
||||
#define ATH_AGGR_DELIM_SZ 4 /* delimiter size */
|
||||
#define ATH_AGGR_MINPLEN 256 /* in bytes, minimum packet length */
|
||||
#define ATH_AGGR_ENCRYPTDELIM 10 /* number of delimiters for encryption padding */
|
||||
|
||||
/*
|
||||
* returns delimiter padding required given the packet length
|
||||
*/
|
||||
#define ATH_AGGR_GET_NDELIM(_len) \
|
||||
(((((_len) + ATH_AGGR_DELIM_SZ) < ATH_AGGR_MINPLEN) ? \
|
||||
(ATH_AGGR_MINPLEN - (_len) - ATH_AGGR_DELIM_SZ) : 0) >> 2)
|
||||
|
||||
#define PADBYTES(_len) ((4 - ((_len) % 4)) % 4)
|
||||
|
||||
int ath_max_4ms_framelen[4][32] = {
|
||||
[MCS_HT20] = {
|
||||
3212, 6432, 9648, 12864, 19300, 25736, 28952, 32172,
|
||||
6424, 12852, 19280, 25708, 38568, 51424, 57852, 64280,
|
||||
9628, 19260, 28896, 38528, 57792, 65532, 65532, 65532,
|
||||
12828, 25656, 38488, 51320, 65532, 65532, 65532, 65532,
|
||||
},
|
||||
[MCS_HT20_SGI] = {
|
||||
3572, 7144, 10720, 14296, 21444, 28596, 32172, 35744,
|
||||
7140, 14284, 21428, 28568, 42856, 57144, 64288, 65532,
|
||||
10700, 21408, 32112, 42816, 64228, 65532, 65532, 65532,
|
||||
14256, 28516, 42780, 57040, 65532, 65532, 65532, 65532,
|
||||
},
|
||||
[MCS_HT40] = {
|
||||
6680, 13360, 20044, 26724, 40092, 53456, 60140, 65532,
|
||||
13348, 26700, 40052, 53400, 65532, 65532, 65532, 65532,
|
||||
20004, 40008, 60016, 65532, 65532, 65532, 65532, 65532,
|
||||
26644, 53292, 65532, 65532, 65532, 65532, 65532, 65532,
|
||||
},
|
||||
[MCS_HT40_SGI] = {
|
||||
7420, 14844, 22272, 29696, 44544, 59396, 65532, 65532,
|
||||
14832, 29668, 44504, 59340, 65532, 65532, 65532, 65532,
|
||||
22232, 44464, 65532, 65532, 65532, 65532, 65532, 65532,
|
||||
29616, 59232, 65532, 65532, 65532, 65532, 65532, 65532,
|
||||
}
|
||||
};
|
||||
|
||||
/*
|
||||
* XXX should be in net80211
|
||||
*/
|
||||
static int ieee80211_mpdudensity_map[] = {
|
||||
0, /* IEEE80211_HTCAP_MPDUDENSITY_NA */
|
||||
25, /* IEEE80211_HTCAP_MPDUDENSITY_025 */
|
||||
50, /* IEEE80211_HTCAP_MPDUDENSITY_05 */
|
||||
100, /* IEEE80211_HTCAP_MPDUDENSITY_1 */
|
||||
200, /* IEEE80211_HTCAP_MPDUDENSITY_2 */
|
||||
400, /* IEEE80211_HTCAP_MPDUDENSITY_4 */
|
||||
800, /* IEEE80211_HTCAP_MPDUDENSITY_8 */
|
||||
1600, /* IEEE80211_HTCAP_MPDUDENSITY_16 */
|
||||
};
|
||||
|
||||
/*
|
||||
* XXX should be in the HAL/net80211 ?
|
||||
*/
|
||||
#define BITS_PER_BYTE 8
|
||||
#define OFDM_PLCP_BITS 22
|
||||
#define HT_RC_2_MCS(_rc) ((_rc) & 0x7f)
|
||||
#define HT_RC_2_STREAMS(_rc) ((((_rc) & 0x78) >> 3) + 1)
|
||||
#define L_STF 8
|
||||
#define L_LTF 8
|
||||
#define L_SIG 4
|
||||
#define HT_SIG 8
|
||||
#define HT_STF 4
|
||||
#define HT_LTF(_ns) (4 * (_ns))
|
||||
#define SYMBOL_TIME(_ns) ((_ns) << 2) // ns * 4 us
|
||||
#define SYMBOL_TIME_HALFGI(_ns) (((_ns) * 18 + 4) / 5) // ns * 3.6 us
|
||||
#define NUM_SYMBOLS_PER_USEC(_usec) (_usec >> 2)
|
||||
#define NUM_SYMBOLS_PER_USEC_HALFGI(_usec) (((_usec*5)-4)/18)
|
||||
#define IS_HT_RATE(_rate) ((_rate) & 0x80)
|
||||
|
||||
const uint32_t bits_per_symbol[][2] = {
|
||||
/* 20MHz 40MHz */
|
||||
{ 26, 54 }, // 0: BPSK
|
||||
{ 52, 108 }, // 1: QPSK 1/2
|
||||
{ 78, 162 }, // 2: QPSK 3/4
|
||||
{ 104, 216 }, // 3: 16-QAM 1/2
|
||||
{ 156, 324 }, // 4: 16-QAM 3/4
|
||||
{ 208, 432 }, // 5: 64-QAM 2/3
|
||||
{ 234, 486 }, // 6: 64-QAM 3/4
|
||||
{ 260, 540 }, // 7: 64-QAM 5/6
|
||||
{ 52, 108 }, // 8: BPSK
|
||||
{ 104, 216 }, // 9: QPSK 1/2
|
||||
{ 156, 324 }, // 10: QPSK 3/4
|
||||
{ 208, 432 }, // 11: 16-QAM 1/2
|
||||
{ 312, 648 }, // 12: 16-QAM 3/4
|
||||
{ 416, 864 }, // 13: 64-QAM 2/3
|
||||
{ 468, 972 }, // 14: 64-QAM 3/4
|
||||
{ 520, 1080 }, // 15: 64-QAM 5/6
|
||||
{ 78, 162 }, // 16: BPSK
|
||||
{ 156, 324 }, // 17: QPSK 1/2
|
||||
{ 234, 486 }, // 18: QPSK 3/4
|
||||
{ 312, 648 }, // 19: 16-QAM 1/2
|
||||
{ 468, 972 }, // 20: 16-QAM 3/4
|
||||
{ 624, 1296 }, // 21: 64-QAM 2/3
|
||||
{ 702, 1458 }, // 22: 64-QAM 3/4
|
||||
{ 780, 1620 }, // 23: 64-QAM 5/6
|
||||
{ 104, 216 }, // 24: BPSK
|
||||
{ 208, 432 }, // 25: QPSK 1/2
|
||||
{ 312, 648 }, // 26: QPSK 3/4
|
||||
{ 416, 864 }, // 27: 16-QAM 1/2
|
||||
{ 624, 1296 }, // 28: 16-QAM 3/4
|
||||
{ 832, 1728 }, // 29: 64-QAM 2/3
|
||||
{ 936, 1944 }, // 30: 64-QAM 3/4
|
||||
{ 1040, 2160 }, // 31: 64-QAM 5/6
|
||||
};
|
||||
|
||||
/*
|
||||
* Fill in the rate array information based on the current
|
||||
* node configuration and the choices made by the rate
|
||||
* selection code and ath_buf setup code.
|
||||
*
|
||||
* Later on, this may end up also being made by the
|
||||
* rate control code, but for now it can live here.
|
||||
*
|
||||
* This needs to be called just before the packet is
|
||||
* queued to the software queue or hardware queue,
|
||||
* so all of the needed fields in bf_state are setup.
|
||||
*/
|
||||
void
|
||||
ath_tx_rate_fill_rcflags(struct ath_softc *sc, struct ath_buf *bf)
|
||||
{
|
||||
struct ieee80211_node *ni = bf->bf_node;
|
||||
struct ieee80211com *ic = ni->ni_ic;
|
||||
const HAL_RATE_TABLE *rt = sc->sc_currates;
|
||||
struct ath_rc_series *rc = bf->bf_state.bfs_rc;
|
||||
uint8_t rate;
|
||||
int i;
|
||||
|
||||
for (i = 0; i < ATH_RC_NUM; i++) {
|
||||
rc[i].flags = 0;
|
||||
if (rc[i].tries == 0)
|
||||
continue;
|
||||
|
||||
rate = rt->info[rc[i].rix].rateCode;
|
||||
|
||||
/*
|
||||
* XXX only do this for legacy rates?
|
||||
*/
|
||||
if (bf->bf_state.bfs_shpream)
|
||||
rate |= rt->info[rc[i].rix].shortPreamble;
|
||||
|
||||
/*
|
||||
* Save this, used by the TX and completion code
|
||||
*/
|
||||
rc[i].ratecode = rate;
|
||||
|
||||
if (bf->bf_state.bfs_flags &
|
||||
(HAL_TXDESC_RTSENA | HAL_TXDESC_CTSENA))
|
||||
rc[i].flags |= ATH_RC_RTSCTS_FLAG;
|
||||
|
||||
/* Only enable shortgi, 2040, dual-stream if HT is set */
|
||||
if (IS_HT_RATE(rate)) {
|
||||
rc[i].flags |= ATH_RC_HT_FLAG;
|
||||
|
||||
if (ni->ni_chw == 40)
|
||||
rc[i].flags |= ATH_RC_CW40_FLAG;
|
||||
|
||||
if (ni->ni_chw == 40 &&
|
||||
ic->ic_htcaps & IEEE80211_HTCAP_SHORTGI40 &&
|
||||
ni->ni_htcap & IEEE80211_HTCAP_SHORTGI40)
|
||||
rc[i].flags |= ATH_RC_SGI_FLAG;
|
||||
|
||||
if (ni->ni_chw == 20 &&
|
||||
ic->ic_htcaps & IEEE80211_HTCAP_SHORTGI20 &&
|
||||
ni->ni_htcap & IEEE80211_HTCAP_SHORTGI20)
|
||||
rc[i].flags |= ATH_RC_SGI_FLAG;
|
||||
|
||||
/* XXX dual stream? and 3-stream? */
|
||||
}
|
||||
|
||||
/*
|
||||
* Calculate the maximum 4ms frame length based
|
||||
* on the MCS rate, SGI and channel width flags.
|
||||
*/
|
||||
if ((rc[i].flags & ATH_RC_HT_FLAG) &&
|
||||
(HT_RC_2_MCS(rate) < 32)) {
|
||||
int j;
|
||||
if (rc[i].flags & ATH_RC_CW40_FLAG) {
|
||||
if (rc[i].flags & ATH_RC_SGI_FLAG)
|
||||
j = MCS_HT40_SGI;
|
||||
else
|
||||
j = MCS_HT40;
|
||||
} else {
|
||||
if (rc[i].flags & ATH_RC_SGI_FLAG)
|
||||
j = MCS_HT20_SGI;
|
||||
else
|
||||
j = MCS_HT20;
|
||||
}
|
||||
rc[i].max4msframelen =
|
||||
ath_max_4ms_framelen[j][HT_RC_2_MCS(rate)];
|
||||
} else
|
||||
rc[i].max4msframelen = 0;
|
||||
DPRINTF(sc, ATH_DEBUG_SW_TX_AGGR,
|
||||
"%s: i=%d, rate=0x%x, flags=0x%x, max4ms=%d\n",
|
||||
__func__, i, rate, rc[i].flags, rc[i].max4msframelen);
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Return the number of delimiters to be added to
|
||||
* meet the minimum required mpdudensity.
|
||||
*
|
||||
* Caller should make sure that the rate is HT.
|
||||
*
|
||||
* TODO: is this delimiter calculation supposed to be the
|
||||
* total frame length, the hdr length, the data length (including
|
||||
* delimiters, padding, CRC, etc) or ?
|
||||
*
|
||||
* TODO: this should ensure that the rate control information
|
||||
* HAS been setup for the first rate.
|
||||
*
|
||||
* TODO: ensure this is only called for MCS rates.
|
||||
*
|
||||
* TODO: enforce MCS < 31
|
||||
*/
|
||||
static int
|
||||
ath_compute_num_delims(struct ath_softc *sc, struct ath_buf *first_bf,
|
||||
uint16_t pktlen)
|
||||
{
|
||||
const HAL_RATE_TABLE *rt = sc->sc_currates;
|
||||
struct ieee80211_node *ni = first_bf->bf_node;
|
||||
struct ieee80211vap *vap = ni->ni_vap;
|
||||
int ndelim, mindelim = 0;
|
||||
int mpdudensity; /* in 1/100'th of a microsecond */
|
||||
uint8_t rc, rix, flags;
|
||||
int width, half_gi;
|
||||
uint32_t nsymbits, nsymbols;
|
||||
uint16_t minlen;
|
||||
|
||||
/*
|
||||
* vap->iv_ampdu_density is a value, rather than the actual
|
||||
* density.
|
||||
*/
|
||||
if (vap->iv_ampdu_density > IEEE80211_HTCAP_MPDUDENSITY_16)
|
||||
mpdudensity = 1600; /* maximum density */
|
||||
else
|
||||
mpdudensity = ieee80211_mpdudensity_map[vap->iv_ampdu_density];
|
||||
|
||||
/* Select standard number of delimiters based on frame length */
|
||||
ndelim = ATH_AGGR_GET_NDELIM(pktlen);
|
||||
|
||||
/*
|
||||
* If encryption is enabled, add extra delimiters to let the
|
||||
* crypto hardware catch up. This could be tuned per-MAC and
|
||||
* per-rate, but for now we'll simply assume encryption is
|
||||
* always enabled.
|
||||
*/
|
||||
ndelim += ATH_AGGR_ENCRYPTDELIM;
|
||||
|
||||
DPRINTF(sc, ATH_DEBUG_SW_TX_AGGR,
|
||||
"%s: pktlen=%d, ndelim=%d, mpdudensity=%d\n",
|
||||
__func__, pktlen, ndelim, mpdudensity);
|
||||
|
||||
/*
|
||||
* If the MPDU density is 0, we can return here.
|
||||
* Otherwise, we need to convert the desired mpdudensity
|
||||
* into a byte length, based on the rate in the subframe.
|
||||
*/
|
||||
if (mpdudensity == 0)
|
||||
return ndelim;
|
||||
|
||||
/*
|
||||
* Convert desired mpdu density from microeconds to bytes based
|
||||
* on highest rate in rate series (i.e. first rate) to determine
|
||||
* required minimum length for subframe. Take into account
|
||||
* whether high rate is 20 or 40Mhz and half or full GI.
|
||||
*/
|
||||
rix = first_bf->bf_state.bfs_rc[0].rix;
|
||||
rc = rt->info[rix].rateCode;
|
||||
flags = first_bf->bf_state.bfs_rc[0].flags;
|
||||
width = !! (flags & ATH_RC_CW40_FLAG);
|
||||
half_gi = !! (flags & ATH_RC_SGI_FLAG);
|
||||
|
||||
/*
|
||||
* mpdudensity is in 1/100th of a usec, so divide by 100
|
||||
*/
|
||||
if (half_gi)
|
||||
nsymbols = NUM_SYMBOLS_PER_USEC_HALFGI(mpdudensity);
|
||||
else
|
||||
nsymbols = NUM_SYMBOLS_PER_USEC(mpdudensity);
|
||||
nsymbols /= 100;
|
||||
|
||||
if (nsymbols == 0)
|
||||
nsymbols = 1;
|
||||
|
||||
nsymbits = bits_per_symbol[HT_RC_2_MCS(rc)][width];
|
||||
minlen = (nsymbols * nsymbits) / BITS_PER_BYTE;
|
||||
|
||||
/*
|
||||
* Min length is the minimum frame length for the
|
||||
* required MPDU density.
|
||||
*/
|
||||
if (pktlen < minlen) {
|
||||
mindelim = (minlen - pktlen) / ATH_AGGR_DELIM_SZ;
|
||||
ndelim = MAX(mindelim, ndelim);
|
||||
}
|
||||
|
||||
DPRINTF(sc, ATH_DEBUG_SW_TX_AGGR,
|
||||
"%s: pktlen=%d, minlen=%d, rix=%x, rc=%x, width=%d, hgi=%d, ndelim=%d\n",
|
||||
__func__, pktlen, minlen, rix, rc, width, half_gi, ndelim);
|
||||
|
||||
return ndelim;
|
||||
}
|
||||
|
||||
/*
|
||||
* Fetch the aggregation limit.
|
||||
*
|
||||
* It's the lowest of the four rate series 4ms frame length.
|
||||
*/
|
||||
static int
|
||||
ath_get_aggr_limit(struct ath_softc *sc, struct ath_buf *bf)
|
||||
{
|
||||
int amin = 65530;
|
||||
int i;
|
||||
|
||||
for (i = 0; i < 4; i++) {
|
||||
if (bf->bf_state.bfs_rc[i].tries == 0)
|
||||
continue;
|
||||
amin = MIN(amin, bf->bf_state.bfs_rc[i].max4msframelen);
|
||||
}
|
||||
|
||||
DPRINTF(sc, ATH_DEBUG_SW_TX_AGGR, "%s: max frame len= %d\n",
|
||||
__func__, amin);
|
||||
|
||||
return amin;
|
||||
}
|
||||
|
||||
/*
|
||||
* Setup a 11n rate series structure
|
||||
*
|
||||
* This should be called for both legacy and MCS rates.
|
||||
*
|
||||
* It, along with ath_buf_set_rate, must be called -after- a burst
|
||||
* or aggregate is setup.
|
||||
*/
|
||||
static void
|
||||
ath_rateseries_setup(struct ath_softc *sc, struct ieee80211_node *ni,
|
||||
HAL_11N_RATE_SERIES *series, unsigned int pktlen, uint8_t *rix,
|
||||
uint8_t *try, int flags)
|
||||
struct ath_buf *bf, HAL_11N_RATE_SERIES *series)
|
||||
{
|
||||
#define HT_RC_2_STREAMS(_rc) ((((_rc) & 0x78) >> 3) + 1)
|
||||
struct ieee80211com *ic = ni->ni_ic;
|
||||
@ -104,18 +444,34 @@ ath_rateseries_setup(struct ath_softc *sc, struct ieee80211_node *ni,
|
||||
HAL_BOOL shortPreamble = AH_FALSE;
|
||||
const HAL_RATE_TABLE *rt = sc->sc_currates;
|
||||
int i;
|
||||
int pktlen;
|
||||
int flags = bf->bf_state.bfs_flags;
|
||||
struct ath_rc_series *rc = bf->bf_state.bfs_rc;
|
||||
|
||||
if ((ic->ic_flags & IEEE80211_F_SHPREAMBLE) &&
|
||||
(ni->ni_capinfo & IEEE80211_CAPINFO_SHORT_PREAMBLE))
|
||||
shortPreamble = AH_TRUE;
|
||||
|
||||
/*
|
||||
* If this is the first frame in an aggregate series,
|
||||
* use the aggregate length.
|
||||
*/
|
||||
if (bf->bf_state.bfs_aggr)
|
||||
pktlen = bf->bf_state.bfs_al;
|
||||
else
|
||||
pktlen = bf->bf_state.bfs_pktlen;
|
||||
|
||||
/*
|
||||
* XXX TODO: modify this routine to use the bfs_rc[x].flags
|
||||
* XXX fields.
|
||||
*/
|
||||
memset(series, 0, sizeof(HAL_11N_RATE_SERIES) * 4);
|
||||
for (i = 0; i < 4; i++) {
|
||||
/* Only set flags for actual TX attempts */
|
||||
if (try[i] == 0)
|
||||
if (rc[i].tries == 0)
|
||||
continue;
|
||||
|
||||
series[i].Tries = try[i];
|
||||
series[i].Tries = rc[i].tries;
|
||||
|
||||
/*
|
||||
* XXX this isn't strictly correct - sc_txchainmask
|
||||
@ -154,7 +510,7 @@ ath_rateseries_setup(struct ath_softc *sc, struct ieee80211_node *ni,
|
||||
ni->ni_htcap & IEEE80211_HTCAP_SHORTGI20)
|
||||
series[i].RateFlags |= HAL_RATESERIES_HALFGI;
|
||||
|
||||
series[i].Rate = rt->info[rix[i]].rateCode;
|
||||
series[i].Rate = rt->info[rc[i].rix].rateCode;
|
||||
|
||||
/* PktDuration doesn't include slot, ACK, RTS, etc timing - it's just the packet duration */
|
||||
if (series[i].Rate & IEEE80211_RATE_MCS) {
|
||||
@ -166,9 +522,10 @@ ath_rateseries_setup(struct ath_softc *sc, struct ieee80211_node *ni,
|
||||
, series[i].RateFlags & HAL_RATESERIES_HALFGI);
|
||||
} else {
|
||||
if (shortPreamble)
|
||||
series[i].Rate |= rt->info[rix[i]].shortPreamble;
|
||||
series[i].Rate |=
|
||||
rt->info[rc[i].rix].shortPreamble;
|
||||
series[i].PktDuration = ath_hal_computetxtime(ah,
|
||||
rt, pktlen, rix[i], shortPreamble);
|
||||
rt, pktlen, rc[i].rix, shortPreamble);
|
||||
}
|
||||
}
|
||||
#undef HT_RC_2_STREAMS
|
||||
@ -200,25 +557,28 @@ ath_rateseries_print(HAL_11N_RATE_SERIES *series)
|
||||
*/
|
||||
|
||||
void
|
||||
ath_buf_set_rate(struct ath_softc *sc, struct ieee80211_node *ni, struct ath_buf *bf,
|
||||
int pktlen, int flags, uint8_t ctsrate, int is_pspoll, uint8_t *rix, uint8_t *try)
|
||||
ath_buf_set_rate(struct ath_softc *sc, struct ieee80211_node *ni,
|
||||
struct ath_buf *bf)
|
||||
{
|
||||
HAL_11N_RATE_SERIES series[4];
|
||||
struct ath_desc *ds = bf->bf_desc;
|
||||
struct ath_desc *lastds = NULL;
|
||||
struct ath_hal *ah = sc->sc_ah;
|
||||
int is_pspoll = (bf->bf_state.bfs_atype == HAL_PKT_TYPE_PSPOLL);
|
||||
int ctsrate = bf->bf_state.bfs_ctsrate;
|
||||
int flags = bf->bf_state.bfs_flags;
|
||||
|
||||
/* Setup rate scenario */
|
||||
memset(&series, 0, sizeof(series));
|
||||
|
||||
ath_rateseries_setup(sc, ni, series, pktlen, rix, try, flags);
|
||||
ath_rateseries_setup(sc, ni, bf, series);
|
||||
|
||||
/* Enforce AR5416 aggregate limit - can't do RTS w/ an agg frame > 8k */
|
||||
|
||||
/* Enforce RTS and CTS are mutually exclusive */
|
||||
|
||||
/* Get a pointer to the last tx descriptor in the list */
|
||||
lastds = &bf->bf_desc[bf->bf_nseg - 1];
|
||||
lastds = bf->bf_lastds;
|
||||
|
||||
#if 0
|
||||
printf("pktlen: %d; flags 0x%x\n", pktlen, flags);
|
||||
@ -238,6 +598,238 @@ ath_buf_set_rate(struct ath_softc *sc, struct ieee80211_node *ni, struct ath_buf
|
||||
ath_hal_setuplasttxdesc(ah, lastds, ds);
|
||||
|
||||
/* Set burst duration */
|
||||
/* This should only be done if aggregate protection is enabled */
|
||||
/*
|
||||
* This is only required when doing 11n burst, not aggregation
|
||||
* ie, if there's a second frame in a RIFS or A-MPDU burst
|
||||
* w/ >1 A-MPDU frame bursting back to back.
|
||||
* Normal A-MPDU doesn't do bursting -between- aggregates.
|
||||
*
|
||||
* .. and it's highly likely this won't ever be implemented
|
||||
*/
|
||||
//ath_hal_set11nburstduration(ah, ds, 8192);
|
||||
}
|
||||
|
||||
/*
|
||||
* Form an aggregate packet list.
|
||||
*
|
||||
* This function enforces the aggregate restrictions/requirements.
|
||||
*
|
||||
* These are:
|
||||
*
|
||||
* + The aggregate size maximum (64k for AR9160 and later, 8K for
|
||||
* AR5416 when doing RTS frame protection.)
|
||||
* + Maximum number of sub-frames for an aggregate
|
||||
* + The aggregate delimiter size, giving MACs time to do whatever is
|
||||
* needed before each frame
|
||||
* + Enforce the BAW limit
|
||||
*
|
||||
* Each descriptor queued should have the DMA setup.
|
||||
* The rate series, descriptor setup, linking, etc is all done
|
||||
* externally. This routine simply chains them together.
|
||||
* ath_tx_setds_11n() will take care of configuring the per-
|
||||
* descriptor setup, and ath_buf_set_rate() will configure the
|
||||
* rate control.
|
||||
*
|
||||
* Note that the TID lock is only grabbed when dequeuing packets from
|
||||
* the TID queue. If some code in another thread adds to the head of this
|
||||
* list, very strange behaviour will occur. Since retransmission is the
|
||||
* only reason this will occur, and this routine is designed to be called
|
||||
* from within the scheduler task, it won't ever clash with the completion
|
||||
* task.
|
||||
*
|
||||
* So if you want to call this from an upper layer context (eg, to direct-
|
||||
* dispatch aggregate frames to the hardware), please keep this in mind.
|
||||
*/
|
||||
ATH_AGGR_STATUS
|
||||
ath_tx_form_aggr(struct ath_softc *sc, struct ath_node *an, struct ath_tid *tid,
|
||||
ath_bufhead *bf_q)
|
||||
{
|
||||
//struct ieee80211_node *ni = &an->an_node;
|
||||
struct ath_buf *bf, *bf_first = NULL, *bf_prev = NULL;
|
||||
int nframes = 0;
|
||||
uint16_t aggr_limit = 0, al = 0, bpad = 0, al_delta, h_baw;
|
||||
struct ieee80211_tx_ampdu *tap;
|
||||
int status = ATH_AGGR_DONE;
|
||||
int prev_frames = 0; /* XXX for AR5416 burst, not done here */
|
||||
int prev_al = 0; /* XXX also for AR5416 burst */
|
||||
|
||||
ATH_TXQ_LOCK_ASSERT(sc->sc_ac2q[tid->ac]);
|
||||
|
||||
tap = ath_tx_get_tx_tid(an, tid->tid);
|
||||
if (tap == NULL) {
|
||||
status = ATH_AGGR_ERROR;
|
||||
goto finish;
|
||||
}
|
||||
|
||||
h_baw = tap->txa_wnd / 2;
|
||||
|
||||
for (;;) {
|
||||
bf = TAILQ_FIRST(&tid->axq_q);
|
||||
if (bf_first == NULL)
|
||||
bf_first = bf;
|
||||
if (bf == NULL) {
|
||||
status = ATH_AGGR_DONE;
|
||||
break;
|
||||
} else {
|
||||
/*
|
||||
* It's the first frame;
|
||||
* set the aggregation limit based on the
|
||||
* rate control decision that has been made.
|
||||
*/
|
||||
aggr_limit = ath_get_aggr_limit(sc, bf_first);
|
||||
}
|
||||
|
||||
/* Set this early just so things don't get confused */
|
||||
bf->bf_next = NULL;
|
||||
|
||||
/*
|
||||
* Don't unlock the tid lock until we're sure we are going
|
||||
* to queue this frame.
|
||||
*/
|
||||
|
||||
/*
|
||||
* If the frame doesn't have a sequence number that we're
|
||||
* tracking in the BAW (eg NULL QOS data frame), we can't
|
||||
* aggregate it. Stop the aggregation process; the sender
|
||||
* can then TX what's in the list thus far and then
|
||||
* TX the frame individually.
|
||||
*/
|
||||
if (! bf->bf_state.bfs_dobaw) {
|
||||
status = ATH_AGGR_NONAGGR;
|
||||
break;
|
||||
}
|
||||
|
||||
/*
|
||||
* If any of the rates are non-HT, this packet
|
||||
* can't be aggregated.
|
||||
* XXX TODO: add a bf_state flag which gets marked
|
||||
* if any active rate is non-HT.
|
||||
*/
|
||||
|
||||
/*
|
||||
* If the packet has a sequence number, do not
|
||||
* step outside of the block-ack window.
|
||||
*/
|
||||
if (! BAW_WITHIN(tap->txa_start, tap->txa_wnd,
|
||||
SEQNO(bf->bf_state.bfs_seqno))) {
|
||||
status = ATH_AGGR_BAW_CLOSED;
|
||||
break;
|
||||
}
|
||||
|
||||
/*
|
||||
* XXX TODO: AR5416 has an 8K aggregation size limit
|
||||
* when RTS is enabled, and RTS is required for dual-stream
|
||||
* rates.
|
||||
*
|
||||
* For now, limit all aggregates for the AR5416 to be 8K.
|
||||
*/
|
||||
|
||||
/*
|
||||
* do not exceed aggregation limit
|
||||
*/
|
||||
al_delta = ATH_AGGR_DELIM_SZ + bf->bf_state.bfs_pktlen;
|
||||
if (nframes &&
|
||||
(aggr_limit < (al + bpad + al_delta + prev_al))) {
|
||||
status = ATH_AGGR_LIMITED;
|
||||
break;
|
||||
}
|
||||
|
||||
/*
|
||||
* Do not exceed subframe limit.
|
||||
*/
|
||||
if ((nframes + prev_frames) >= MIN((h_baw),
|
||||
IEEE80211_AMPDU_SUBFRAME_DEFAULT)) {
|
||||
status = ATH_AGGR_LIMITED;
|
||||
break;
|
||||
}
|
||||
|
||||
/*
|
||||
* this packet is part of an aggregate.
|
||||
*/
|
||||
ATH_TXQ_REMOVE(tid, bf, bf_list);
|
||||
|
||||
/* The TID lock is required for the BAW update */
|
||||
ath_tx_addto_baw(sc, an, tid, bf);
|
||||
bf->bf_state.bfs_addedbaw = 1;
|
||||
|
||||
/*
|
||||
* XXX TODO: If any frame in the aggregate requires RTS/CTS,
|
||||
* set the first frame.
|
||||
*/
|
||||
|
||||
/*
|
||||
* XXX enforce ACK for aggregate frames (this needs to be
|
||||
* XXX handled more gracefully?
|
||||
*/
|
||||
if (bf->bf_state.bfs_flags & HAL_TXDESC_NOACK) {
|
||||
device_printf(sc->sc_dev,
|
||||
"%s: HAL_TXDESC_NOACK set for an aggregate frame?\n",
|
||||
__func__);
|
||||
bf->bf_state.bfs_flags &= (~HAL_TXDESC_NOACK);
|
||||
}
|
||||
|
||||
/*
|
||||
* Add the now owned buffer (which isn't
|
||||
* on the software TXQ any longer) to our
|
||||
* aggregate frame list.
|
||||
*/
|
||||
TAILQ_INSERT_TAIL(bf_q, bf, bf_list);
|
||||
nframes ++;
|
||||
|
||||
/* Completion handler */
|
||||
bf->bf_comp = ath_tx_aggr_comp;
|
||||
|
||||
/*
|
||||
* add padding for previous frame to aggregation length
|
||||
*/
|
||||
al += bpad + al_delta;
|
||||
|
||||
/*
|
||||
* Calculate delimiters needed for the current frame
|
||||
*/
|
||||
bf->bf_state.bfs_ndelim =
|
||||
ath_compute_num_delims(sc, bf_first,
|
||||
bf->bf_state.bfs_pktlen);
|
||||
|
||||
/*
|
||||
* Calculate the padding needed from this set of delimiters,
|
||||
* used when calculating if the next frame will fit in
|
||||
* the aggregate.
|
||||
*/
|
||||
bpad = PADBYTES(al_delta) + (bf->bf_state.bfs_ndelim << 2);
|
||||
|
||||
/*
|
||||
* Chain the buffers together
|
||||
*/
|
||||
if (bf_prev)
|
||||
bf_prev->bf_next = bf;
|
||||
bf_prev = bf;
|
||||
|
||||
/*
|
||||
* XXX TODO: if any sub-frames have RTS/CTS enabled;
|
||||
* enable it for the entire aggregate.
|
||||
*/
|
||||
|
||||
#if 0
|
||||
/*
|
||||
* terminate aggregation on a small packet boundary
|
||||
*/
|
||||
if (bf->bf_state.bfs_pktlen < ATH_AGGR_MINPLEN) {
|
||||
status = ATH_AGGR_SHORTPKT;
|
||||
break;
|
||||
}
|
||||
#endif
|
||||
|
||||
}
|
||||
|
||||
finish:
|
||||
/*
|
||||
* Just in case the list was empty when we tried to
|
||||
* dequeue a packet ..
|
||||
*/
|
||||
if (bf_first) {
|
||||
bf_first->bf_state.bfs_al = al;
|
||||
bf_first->bf_state.bfs_nframes = nframes;
|
||||
}
|
||||
return status;
|
||||
}
|
||||
|
@ -31,9 +31,32 @@
|
||||
#ifndef __IF_ATH_TX_HT_H__
|
||||
#define __IF_ATH_TX_HT_H__
|
||||
|
||||
enum {
|
||||
MCS_HT20,
|
||||
MCS_HT20_SGI,
|
||||
MCS_HT40,
|
||||
MCS_HT40_SGI,
|
||||
};
|
||||
|
||||
typedef enum {
|
||||
ATH_AGGR_DONE,
|
||||
ATH_AGGR_BAW_CLOSED,
|
||||
ATH_AGGR_LIMITED,
|
||||
ATH_AGGR_SHORTPKT,
|
||||
ATH_AGGR_8K_LIMITED,
|
||||
ATH_AGGR_ERROR,
|
||||
ATH_AGGR_NONAGGR,
|
||||
} ATH_AGGR_STATUS;
|
||||
|
||||
extern int ath_max_4ms_framelen[4][32];
|
||||
|
||||
extern void ath_tx_rate_fill_rcflags(struct ath_softc *sc, struct ath_buf *bf);
|
||||
|
||||
extern void ath_buf_set_rate(struct ath_softc *sc,
|
||||
struct ieee80211_node *ni, struct ath_buf *bf,
|
||||
int pktlen, int flags, uint8_t ctsrate, int is_pspoll,
|
||||
uint8_t *rix, uint8_t *try);
|
||||
struct ieee80211_node *ni, struct ath_buf *bf);
|
||||
|
||||
extern ATH_AGGR_STATUS
|
||||
ath_tx_form_aggr(struct ath_softc *sc, struct ath_node *an,
|
||||
struct ath_tid *tid, ath_bufhead *bf_q);
|
||||
|
||||
#endif
|
||||
|
@ -120,7 +120,7 @@ void ath_rate_newassoc(struct ath_softc *, struct ath_node *,
|
||||
* Return the four TX rate index and try counts for the current data packet.
|
||||
*/
|
||||
void ath_rate_getxtxrates(struct ath_softc *sc, struct ath_node *an,
|
||||
uint8_t rix0, uint8_t *rix, uint8_t *try);
|
||||
uint8_t rix0, struct ath_rc_series *rc);
|
||||
|
||||
/*
|
||||
* Return the transmit info for a data packet. If multi-rate state
|
||||
@ -142,8 +142,12 @@ void ath_rate_setupxtxdesc(struct ath_softc *, struct ath_node *,
|
||||
* supplied transmit descriptor. The routine is invoked both
|
||||
* for packets that were successfully sent and for those that
|
||||
* failed (consult the descriptor for details).
|
||||
*
|
||||
* For A-MPDU frames, nframes and nbad indicate how many frames
|
||||
* were in the aggregate, and how many failed.
|
||||
*/
|
||||
struct ath_buf;
|
||||
void ath_rate_tx_complete(struct ath_softc *, struct ath_node *,
|
||||
const struct ath_buf *);
|
||||
const struct ath_rc_series *, const struct ath_tx_status *,
|
||||
int pktlen, int nframes, int nbad);
|
||||
#endif /* _ATH_RATECTRL_H_ */
|
||||
|
Loading…
Reference in New Issue
Block a user