mac80211: merge upstream legacy minstrel improvements

Signed-off-by: Felix Fietkau <nbd@openwrt.org>

git-svn-id: svn://svn.openwrt.org/openwrt/trunk@36334 3c298f89-4303-0410-b956-a3cf2f4a3e73

1 files changed, 482 insertions, 14 deletions

diff --git a/package/mac80211/patches/300-pending_work.patch b/package/mac80211/patches/300-pending_work.patch
index a609c9a5e..a4bfb99b4 100644
--- a/package/mac80211/patches/300-pending_work.patch
+++ b/package/mac80211/patches/300-pending_work.patch
@@ -634,7 +634,16 @@
  	rt2x00dev->hw->wiphy->flags |= WIPHY_FLAG_IBSS_RSN;
 --- a/net/mac80211/rc80211_minstrel_ht.c
 +++ b/net/mac80211/rc80211_minstrel_ht.c
-@@ -26,11 +26,11 @@
+@@ -17,8 +17,6 @@
+ #include "rc80211_minstrel_ht.h"
+ 
+ #define AVG_PKT_SIZE	1200
+-#define SAMPLE_COLUMNS	10
+-#define EWMA_LEVEL		75
+ 
+ /* Number of bits for an average sized packet */
+ #define MCS_NBITS (AVG_PKT_SIZE << 3)
+@@ -26,11 +24,11 @@
  /* Number of symbols for a packet with (bps) bits per symbol */
  #define MCS_NSYMS(bps) ((MCS_NBITS + (bps) - 1) / (bps))
  
@@ -649,7 +658,7 @@
  	)
  
  /* Transmit duration for the raw data part of an average sized packet */
-@@ -64,9 +64,9 @@
+@@ -64,9 +62,9 @@
  }
  
  #define CCK_DURATION(_bitrate, _short, _len)		\
@@ -661,7 +670,23 @@
  
  #define CCK_ACK_DURATION(_bitrate, _short)			\
  	(CCK_DURATION((_bitrate > 10 ? 20 : 10), false, 60) +	\
-@@ -211,20 +211,32 @@ static void
+@@ -129,15 +127,6 @@ const struct mcs_group minstrel_mcs_grou
+ static u8 sample_table[SAMPLE_COLUMNS][MCS_GROUP_RATES];
+ 
+ /*
+- * Perform EWMA (Exponentially Weighted Moving Average) calculation
+- */
+-static int
+-minstrel_ewma(int old, int new, int weight)
+-{
+-	return (new * (100 - weight) + old * weight) / 100;
+-}
+-
+-/*
+  * Look up an MCS group index based on mac80211 rate information
+  */
+ static int
+@@ -211,20 +200,32 @@ static void
  minstrel_ht_calc_tp(struct minstrel_ht_sta *mi, int group, int rate)
  {
  	struct minstrel_rate_stats *mr;
@@ -689,17 +714,17 @@
  	if (group != MINSTREL_CCK_GROUP)
 -		usecs = mi->overhead / MINSTREL_TRUNC(mi->avg_ampdu_len);
 +		nsecs = 1000 * mi->overhead / MINSTREL_TRUNC(mi->avg_ampdu_len);
++
++	nsecs += minstrel_mcs_groups[group].duration[rate];
++	tp = 1000000 * ((mr->probability * 1000) / nsecs);
  
 -	usecs += minstrel_mcs_groups[group].duration[rate];
 -	mr->cur_tp = MINSTREL_TRUNC((1000000 / usecs) * mr->probability);
-+	nsecs += minstrel_mcs_groups[group].duration[rate];
-+	tp = 1000000 * ((mr->probability * 1000) / nsecs);
-+
 +	mr->cur_tp = MINSTREL_TRUNC(tp);
  }
  
  /*
-@@ -308,8 +320,8 @@ minstrel_ht_update_stats(struct minstrel
+@@ -308,8 +309,8 @@ minstrel_ht_update_stats(struct minstrel
  		}
  	}
  
@@ -710,7 +735,7 @@
  
  	cur_prob = 0;
  	cur_prob_tp = 0;
-@@ -320,20 +332,13 @@ minstrel_ht_update_stats(struct minstrel
+@@ -320,20 +321,13 @@ minstrel_ht_update_stats(struct minstrel
  		if (!mg->supported)
  			continue;
  
@@ -732,7 +757,7 @@
  		}
  
  		mr = minstrel_get_ratestats(mi, mg->max_tp_rate2);
-@@ -343,6 +348,23 @@ minstrel_ht_update_stats(struct minstrel
+@@ -343,6 +337,23 @@ minstrel_ht_update_stats(struct minstrel
  		}
  	}
  
@@ -756,7 +781,7 @@
  	mi->stats_update = jiffies;
  }
  
-@@ -467,7 +489,7 @@ minstrel_ht_tx_status(void *priv, struct
+@@ -467,7 +478,7 @@ minstrel_ht_tx_status(void *priv, struct
  
  	if (!mi->sample_wait && !mi->sample_tries && mi->sample_count > 0) {
  		mi->sample_wait = 16 + 2 * MINSTREL_TRUNC(mi->avg_ampdu_len);
@@ -765,7 +790,7 @@
  		mi->sample_count--;
  	}
  
-@@ -536,7 +558,7 @@ minstrel_calc_retransmit(struct minstrel
+@@ -536,7 +547,7 @@ minstrel_calc_retransmit(struct minstrel
  	mr->retry_updated = true;
  
  	group = &minstrel_mcs_groups[index / MCS_GROUP_RATES];
@@ -774,7 +799,7 @@
  
  	/* Contention time for first 2 tries */
  	ctime = (t_slot * cw) >> 1;
-@@ -616,6 +638,7 @@ minstrel_get_sample_rate(struct minstrel
+@@ -616,6 +627,7 @@ minstrel_get_sample_rate(struct minstrel
  {
  	struct minstrel_rate_stats *mr;
  	struct minstrel_mcs_group_data *mg;
@@ -782,7 +807,7 @@
  	int sample_idx = 0;
  
  	if (mi->sample_wait > 0) {
-@@ -626,39 +649,46 @@ minstrel_get_sample_rate(struct minstrel
+@@ -626,39 +638,46 @@ minstrel_get_sample_rate(struct minstrel
  	if (!mi->sample_tries)
  		return -1;
  
@@ -840,7 +865,19 @@
  }
 --- a/net/mac80211/rc80211_minstrel_ht.h
 +++ b/net/mac80211/rc80211_minstrel_ht.h
-@@ -85,6 +85,7 @@ struct minstrel_ht_sta {
+@@ -16,11 +16,6 @@
+ #define MINSTREL_MAX_STREAMS	3
+ #define MINSTREL_STREAM_GROUPS	4
+ 
+-/* scaled fraction values */
+-#define MINSTREL_SCALE	16
+-#define MINSTREL_FRAC(val, div) (((val) << MINSTREL_SCALE) / div)
+-#define MINSTREL_TRUNC(val) ((val) >> MINSTREL_SCALE)
+-
+ #define MCS_GROUP_RATES	8
+ 
+ struct mcs_group {
+@@ -85,6 +80,7 @@ struct minstrel_ht_sta {
  
  	/* best probability rate */
  	unsigned int max_prob_rate;
@@ -1161,3 +1198,434 @@
  
  	if (ifmgd->auth_data && !ifmgd->auth_data->done) {
  		err = -EBUSY;
+--- a/net/mac80211/rc80211_minstrel.c
++++ b/net/mac80211/rc80211_minstrel.c
+@@ -55,7 +55,6 @@
+ #include "rate.h"
+ #include "rc80211_minstrel.h"
+ 
+-#define SAMPLE_COLUMNS	10
+ #define SAMPLE_TBL(_mi, _idx, _col) \
+ 		_mi->sample_table[(_idx * SAMPLE_COLUMNS) + _col]
+ 
+@@ -70,16 +69,31 @@ rix_to_ndx(struct minstrel_sta_info *mi,
+ 	return i;
+ }
+ 
++/* find & sort topmost throughput rates */
++static inline void
++minstrel_sort_best_tp_rates(struct minstrel_sta_info *mi, int i, u8 *tp_list)
++{
++	int j = MAX_THR_RATES;
++
++	while (j > 0 && mi->r[i].cur_tp > mi->r[tp_list[j - 1]].cur_tp)
++		j--;
++	if (j < MAX_THR_RATES - 1)
++		memmove(&tp_list[j + 1], &tp_list[j], MAX_THR_RATES - (j + 1));
++	if (j < MAX_THR_RATES)
++		tp_list[j] = i;
++}
++
+ static void
+ minstrel_update_stats(struct minstrel_priv *mp, struct minstrel_sta_info *mi)
+ {
+-	u32 max_tp = 0, index_max_tp = 0, index_max_tp2 = 0;
+-	u32 max_prob = 0, index_max_prob = 0;
++	u8 tmp_tp_rate[MAX_THR_RATES];
++	u8 tmp_prob_rate = 0;
+ 	u32 usecs;
+-	u32 p;
+ 	int i;
+ 
+-	mi->stats_update = jiffies;
++	for (i=0; i < MAX_THR_RATES; i++)
++	    tmp_tp_rate[i] = 0;
++
+ 	for (i = 0; i < mi->n_rates; i++) {
+ 		struct minstrel_rate *mr = &mi->r[i];
+ 
+@@ -87,27 +101,32 @@ minstrel_update_stats(struct minstrel_pr
+ 		if (!usecs)
+ 			usecs = 1000000;
+ 
+-		/* To avoid rounding issues, probabilities scale from 0 (0%)
+-		 * to 18000 (100%) */
+-		if (mr->attempts) {
+-			p = (mr->success * 18000) / mr->attempts;
++		if (unlikely(mr->attempts > 0)) {
++			mr->sample_skipped = 0;
++			mr->cur_prob = MINSTREL_FRAC(mr->success, mr->attempts);
+ 			mr->succ_hist += mr->success;
+ 			mr->att_hist += mr->attempts;
+-			mr->cur_prob = p;
+-			p = ((p * (100 - mp->ewma_level)) + (mr->probability *
+-				mp->ewma_level)) / 100;
+-			mr->probability = p;
+-			mr->cur_tp = p * (1000000 / usecs);
+-		}
++			mr->probability = minstrel_ewma(mr->probability,
++							mr->cur_prob,
++							EWMA_LEVEL);
++		} else
++			mr->sample_skipped++;
+ 
+ 		mr->last_success = mr->success;
+ 		mr->last_attempts = mr->attempts;
+ 		mr->success = 0;
+ 		mr->attempts = 0;
+ 
++		/* Update throughput per rate, reset thr. below 10% success */
++		if (mr->probability < MINSTREL_FRAC(10, 100))
++			mr->cur_tp = 0;
++		else
++			mr->cur_tp = mr->probability * (1000000 / usecs);
++
+ 		/* Sample less often below the 10% chance of success.
+ 		 * Sample less often above the 95% chance of success. */
+-		if ((mr->probability > 17100) || (mr->probability < 1800)) {
++		if (mr->probability > MINSTREL_FRAC(95, 100) ||
++		    mr->probability < MINSTREL_FRAC(10, 100)) {
+ 			mr->adjusted_retry_count = mr->retry_count >> 1;
+ 			if (mr->adjusted_retry_count > 2)
+ 				mr->adjusted_retry_count = 2;
+@@ -118,35 +137,30 @@ minstrel_update_stats(struct minstrel_pr
+ 		}
+ 		if (!mr->adjusted_retry_count)
+ 			mr->adjusted_retry_count = 2;
+-	}
+ 
+-	for (i = 0; i < mi->n_rates; i++) {
+-		struct minstrel_rate *mr = &mi->r[i];
+-		if (max_tp < mr->cur_tp) {
+-			index_max_tp = i;
+-			max_tp = mr->cur_tp;
+-		}
+-		if (max_prob < mr->probability) {
+-			index_max_prob = i;
+-			max_prob = mr->probability;
++		minstrel_sort_best_tp_rates(mi, i, tmp_tp_rate);
++
++		/* To determine the most robust rate (max_prob_rate) used at
++		 * 3rd mmr stage we distinct between two cases:
++		 * (1) if any success probabilitiy >= 95%, out of those rates
++		 * choose the maximum throughput rate as max_prob_rate
++		 * (2) if all success probabilities < 95%, the rate with
++		 * highest success probability is choosen as max_prob_rate */
++		if (mr->probability >= MINSTREL_FRAC(95,100)) {
++			if (mr->cur_tp >= mi->r[tmp_prob_rate].cur_tp)
++				tmp_prob_rate = i;
++		} else {
++			if (mr->probability >= mi->r[tmp_prob_rate].probability)
++				tmp_prob_rate = i;
+ 		}
+ 	}
+ 
+-	max_tp = 0;
+-	for (i = 0; i < mi->n_rates; i++) {
+-		struct minstrel_rate *mr = &mi->r[i];
+-
+-		if (i == index_max_tp)
+-			continue;
++	/* Assign the new rate set */
++	memcpy(mi->max_tp_rate, tmp_tp_rate, sizeof(mi->max_tp_rate));
++	mi->max_prob_rate = tmp_prob_rate;
+ 
+-		if (max_tp < mr->cur_tp) {
+-			index_max_tp2 = i;
+-			max_tp = mr->cur_tp;
+-		}
+-	}
+-	mi->max_tp_rate = index_max_tp;
+-	mi->max_tp_rate2 = index_max_tp2;
+-	mi->max_prob_rate = index_max_prob;
++	/* Reset update timer */
++	mi->stats_update = jiffies;
+ }
+ 
+ static void
+@@ -207,10 +221,10 @@ static int
+ minstrel_get_next_sample(struct minstrel_sta_info *mi)
+ {
+ 	unsigned int sample_ndx;
+-	sample_ndx = SAMPLE_TBL(mi, mi->sample_idx, mi->sample_column);
+-	mi->sample_idx++;
+-	if ((int) mi->sample_idx > (mi->n_rates - 2)) {
+-		mi->sample_idx = 0;
++	sample_ndx = SAMPLE_TBL(mi, mi->sample_row, mi->sample_column);
++	mi->sample_row++;
++	if ((int) mi->sample_row >= mi->n_rates) {
++		mi->sample_row = 0;
+ 		mi->sample_column++;
+ 		if (mi->sample_column >= SAMPLE_COLUMNS)
+ 			mi->sample_column = 0;
+@@ -228,31 +242,37 @@ minstrel_get_rate(void *priv, struct iee
+ 	struct minstrel_priv *mp = priv;
+ 	struct ieee80211_tx_rate *ar = info->control.rates;
+ 	unsigned int ndx, sample_ndx = 0;
+-	bool mrr;
+-	bool sample_slower = false;
+-	bool sample = false;
++	bool mrr_capable;
++	bool indirect_rate_sampling = false;
++	bool rate_sampling = false;
+ 	int i, delta;
+ 	int mrr_ndx[3];
+-	int sample_rate;
++	int sampling_ratio;
+ 
++	/* management/no-ack frames do not use rate control */
+ 	if (rate_control_send_low(sta, priv_sta, txrc))
+ 		return;
+ 
+-	mrr = mp->has_mrr && !txrc->rts && !txrc->bss_conf->use_cts_prot;
+-
+-	ndx = mi->max_tp_rate;
+-
+-	if (mrr)
+-		sample_rate = mp->lookaround_rate_mrr;
++	/* check multi-rate-retry capabilities & adjust lookaround_rate */
++	mrr_capable = mp->has_mrr &&
++		      !txrc->rts &&
++		      !txrc->bss_conf->use_cts_prot;
++	if (mrr_capable)
++		sampling_ratio = mp->lookaround_rate_mrr;
+ 	else
+-		sample_rate = mp->lookaround_rate;
++		sampling_ratio = mp->lookaround_rate;
++
++	/* init rateindex [ndx] with max throughput rate */
++	ndx = mi->max_tp_rate[0];
+ 
++	/* increase sum packet counter */
+ 	mi->packet_count++;
+-	delta = (mi->packet_count * sample_rate / 100) -
++
++	delta = (mi->packet_count * sampling_ratio / 100) -
+ 			(mi->sample_count + mi->sample_deferred / 2);
+ 
+ 	/* delta > 0: sampling required */
+-	if ((delta > 0) && (mrr || !mi->prev_sample)) {
++	if ((delta > 0) && (mrr_capable || !mi->prev_sample)) {
+ 		struct minstrel_rate *msr;
+ 		if (mi->packet_count >= 10000) {
+ 			mi->sample_deferred = 0;
+@@ -271,21 +291,28 @@ minstrel_get_rate(void *priv, struct iee
+ 			mi->sample_count += (delta - mi->n_rates * 2);
+ 		}
+ 
++		/* get next random rate sample */
+ 		sample_ndx = minstrel_get_next_sample(mi);
+ 		msr = &mi->r[sample_ndx];
+-		sample = true;
+-		sample_slower = mrr && (msr->perfect_tx_time >
+-			mi->r[ndx].perfect_tx_time);
++		rate_sampling = true;
+ 
+-		if (!sample_slower) {
++		/* Decide if direct ( 1st mrr stage) or indirect (2nd mrr stage)
++		 * rate sampling method should be used.
++		 * Respect such rates that are not sampled for 20 interations.
++		 */
++		if (mrr_capable &&
++		    msr->perfect_tx_time > mi->r[ndx].perfect_tx_time &&
++		    msr->sample_skipped < 20)
++				indirect_rate_sampling = true;
++
++		if (!indirect_rate_sampling) {
+ 			if (msr->sample_limit != 0) {
+ 				ndx = sample_ndx;
+ 				mi->sample_count++;
+ 				if (msr->sample_limit > 0)
+ 					msr->sample_limit--;
+-			} else {
+-				sample = false;
+-			}
++			} else
++				rate_sampling = false;
+ 		} else {
+ 			/* Only use IEEE80211_TX_CTL_RATE_CTRL_PROBE to mark
+ 			 * packets that have the sampling rate deferred to the
+@@ -297,34 +324,39 @@ minstrel_get_rate(void *priv, struct iee
+ 			mi->sample_deferred++;
+ 		}
+ 	}
+-	mi->prev_sample = sample;
++	mi->prev_sample = rate_sampling;
+ 
+ 	/* If we're not using MRR and the sampling rate already
+ 	 * has a probability of >95%, we shouldn't be attempting
+ 	 * to use it, as this only wastes precious airtime */
+-	if (!mrr && sample && (mi->r[ndx].probability > 17100))
+-		ndx = mi->max_tp_rate;
++	if (!mrr_capable && rate_sampling &&
++	   (mi->r[ndx].probability > MINSTREL_FRAC(95, 100)))
++		ndx = mi->max_tp_rate[0];
+ 
++	/* mrr setup for 1st stage */
+ 	ar[0].idx = mi->r[ndx].rix;
+ 	ar[0].count = minstrel_get_retry_count(&mi->r[ndx], info);
+ 
+-	if (!mrr) {
+-		if (!sample)
++	/* non mrr setup for 2nd stage */
++	if (!mrr_capable) {
++		if (!rate_sampling)
+ 			ar[0].count = mp->max_retry;
+ 		ar[1].idx = mi->lowest_rix;
+ 		ar[1].count = mp->max_retry;
+ 		return;
+ 	}
+ 
+-	/* MRR setup */
+-	if (sample) {
+-		if (sample_slower)
++	/* mrr setup for 2nd stage */
++	if (rate_sampling) {
++		if (indirect_rate_sampling)
+ 			mrr_ndx[0] = sample_ndx;
+ 		else
+-			mrr_ndx[0] = mi->max_tp_rate;
++			mrr_ndx[0] = mi->max_tp_rate[0];
+ 	} else {
+-		mrr_ndx[0] = mi->max_tp_rate2;
++		mrr_ndx[0] = mi->max_tp_rate[1];
+ 	}
++
++	/* mrr setup for 3rd & 4th stage */
+ 	mrr_ndx[1] = mi->max_prob_rate;
+ 	mrr_ndx[2] = 0;
+ 	for (i = 1; i < 4; i++) {
+@@ -351,26 +383,21 @@ static void
+ init_sample_table(struct minstrel_sta_info *mi)
+ {
+ 	unsigned int i, col, new_idx;
+-	unsigned int n_srates = mi->n_rates - 1;
+ 	u8 rnd[8];
+ 
+ 	mi->sample_column = 0;
+-	mi->sample_idx = 0;
+-	memset(mi->sample_table, 0, SAMPLE_COLUMNS * mi->n_rates);
++	mi->sample_row = 0;
++	memset(mi->sample_table, 0xff, SAMPLE_COLUMNS * mi->n_rates);
+ 
+ 	for (col = 0; col < SAMPLE_COLUMNS; col++) {
+-		for (i = 0; i < n_srates; i++) {
++		for (i = 0; i < mi->n_rates; i++) {
+ 			get_random_bytes(rnd, sizeof(rnd));
+-			new_idx = (i + rnd[i & 7]) % n_srates;
++			new_idx = (i + rnd[i & 7]) % mi->n_rates;
+ 
+-			while (SAMPLE_TBL(mi, new_idx, col) != 0)
+-				new_idx = (new_idx + 1) % n_srates;
++			while (SAMPLE_TBL(mi, new_idx, col) != 0xff)
++				new_idx = (new_idx + 1) % mi->n_rates;
+ 
+-			/* Don't sample the slowest rate (i.e. slowest base
+-			 * rate). We must presume that the slowest rate works
+-			 * fine, or else other management frames will also be
+-			 * failing and the link will break */
+-			SAMPLE_TBL(mi, new_idx, col) = i + 1;
++			SAMPLE_TBL(mi, new_idx, col) = i;
+ 		}
+ 	}
+ }
+@@ -542,9 +569,6 @@ minstrel_alloc(struct ieee80211_hw *hw, 
+ 	mp->lookaround_rate = 5;
+ 	mp->lookaround_rate_mrr = 10;
+ 
+-	/* moving average weight for EWMA */
+-	mp->ewma_level = 75;
+-
+ 	/* maximum time that the hw is allowed to stay in one MRR segment */
+ 	mp->segment_size = 6000;
+ 
+--- a/net/mac80211/rc80211_minstrel.h
++++ b/net/mac80211/rc80211_minstrel.h
+@@ -9,6 +9,28 @@
+ #ifndef __RC_MINSTREL_H
+ #define __RC_MINSTREL_H
+ 
++#define EWMA_LEVEL	75	/* ewma weighting factor [%] */
++#define SAMPLE_COLUMNS	10	/* number of columns in sample table */
++
++
++/* scaled fraction values */
++#define MINSTREL_SCALE  16
++#define MINSTREL_FRAC(val, div) (((val) << MINSTREL_SCALE) / div)
++#define MINSTREL_TRUNC(val) ((val) >> MINSTREL_SCALE)
++
++/* number of highest throughput rates to consider*/
++#define MAX_THR_RATES 4
++
++/*
++ * Perform EWMA (Exponentially Weighted Moving Average) calculation
++  */
++static inline int
++minstrel_ewma(int old, int new, int weight)
++{
++	return (new * (100 - weight) + old * weight) / 100;
++}
++
++
+ struct minstrel_rate {
+ 	int bitrate;
+ 	int rix;
+@@ -26,6 +48,7 @@ struct minstrel_rate {
+ 	u32 attempts;
+ 	u32 last_attempts;
+ 	u32 last_success;
++	u8 sample_skipped;
+ 
+ 	/* parts per thousand */
+ 	u32 cur_prob;
+@@ -45,14 +68,13 @@ struct minstrel_sta_info {
+ 
+ 	unsigned int lowest_rix;
+ 
+-	unsigned int max_tp_rate;
+-	unsigned int max_tp_rate2;
+-	unsigned int max_prob_rate;
++	u8 max_tp_rate[MAX_THR_RATES];
++	u8 max_prob_rate;
+ 	unsigned int packet_count;
+ 	unsigned int sample_count;
+ 	int sample_deferred;
+ 
+-	unsigned int sample_idx;
++	unsigned int sample_row;
+ 	unsigned int sample_column;
+ 
+ 	int n_rates;
+@@ -73,7 +95,6 @@ struct minstrel_priv {
+ 	unsigned int cw_min;
+ 	unsigned int cw_max;
+ 	unsigned int max_retry;
+-	unsigned int ewma_level;
+ 	unsigned int segment_size;
+ 	unsigned int update_interval;
+ 	unsigned int lookaround_rate;
+--- a/net/mac80211/rc80211_minstrel_debugfs.c
++++ b/net/mac80211/rc80211_minstrel_debugfs.c
+@@ -73,15 +73,17 @@ minstrel_stats_open(struct inode *inode,
+ 	for (i = 0; i < mi->n_rates; i++) {
+ 		struct minstrel_rate *mr = &mi->r[i];
+ 
+-		*(p++) = (i == mi->max_tp_rate) ? 'T' : ' ';
+-		*(p++) = (i == mi->max_tp_rate2) ? 't' : ' ';
++		*(p++) = (i == mi->max_tp_rate[0]) ? 'A' : ' ';
++		*(p++) = (i == mi->max_tp_rate[1]) ? 'B' : ' ';
++		*(p++) = (i == mi->max_tp_rate[2]) ? 'C' : ' ';
++		*(p++) = (i == mi->max_tp_rate[3]) ? 'D' : ' ';
+ 		*(p++) = (i == mi->max_prob_rate) ? 'P' : ' ';
+ 		p += sprintf(p, "%3u%s", mr->bitrate / 2,
+ 				(mr->bitrate & 1 ? ".5" : "  "));
+ 
+-		tp = mr->cur_tp / ((18000 << 10) / 96);
+-		prob = mr->cur_prob / 18;
+-		eprob = mr->probability / 18;
++		tp = MINSTREL_TRUNC(mr->cur_tp / 10);
++		prob = MINSTREL_TRUNC(mr->cur_prob * 1000);
++		eprob = MINSTREL_TRUNC(mr->probability * 1000);
+ 
+ 		p += sprintf(p, "  %6u.%1u   %6u.%1u   %6u.%1u        "
+ 				"%3u(%3u)   %8llu    %8llu\n",