Changeset 36334


Ignore:
Timestamp:
2013-04-15T15:54:42+02:00 (5 years ago)
Author:
nbd
Message:

mac80211: merge upstream legacy minstrel improvements

Signed-off-by: Felix Fietkau <nbd@…>

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/package/mac80211/patches/300-pending_work.patch

    r36311 r36334  
    635635--- a/net/mac80211/rc80211_minstrel_ht.c 
    636636+++ b/net/mac80211/rc80211_minstrel_ht.c 
    637 @@ -26,11 +26,11 @@ 
     637@@ -17,8 +17,6 @@ 
     638 #include "rc80211_minstrel_ht.h" 
     639  
     640 #define AVG_PKT_SIZE   1200 
     641-#define SAMPLE_COLUMNS 10 
     642-#define EWMA_LEVEL             75 
     643  
     644 /* Number of bits for an average sized packet */ 
     645 #define MCS_NBITS (AVG_PKT_SIZE << 3) 
     646@@ -26,11 +24,11 @@ 
    638647 /* Number of symbols for a packet with (bps) bits per symbol */ 
    639648 #define MCS_NSYMS(bps) ((MCS_NBITS + (bps) - 1) / (bps)) 
     
    650659  
    651660 /* Transmit duration for the raw data part of an average sized packet */ 
    652 @@ -64,9 +64,9 @@ 
     661@@ -64,9 +62,9 @@ 
    653662 } 
    654663  
     
    662671 #define CCK_ACK_DURATION(_bitrate, _short)                     \ 
    663672        (CCK_DURATION((_bitrate > 10 ? 20 : 10), false, 60) +   \ 
    664 @@ -211,20 +211,32 @@ static void 
     673@@ -129,15 +127,6 @@ const struct mcs_group minstrel_mcs_grou 
     674 static u8 sample_table[SAMPLE_COLUMNS][MCS_GROUP_RATES]; 
     675  
     676 /* 
     677- * Perform EWMA (Exponentially Weighted Moving Average) calculation 
     678- */ 
     679-static int 
     680-minstrel_ewma(int old, int new, int weight) 
     681-{ 
     682-       return (new * (100 - weight) + old * weight) / 100; 
     683-} 
     684- 
     685-/* 
     686  * Look up an MCS group index based on mac80211 rate information 
     687  */ 
     688 static int 
     689@@ -211,20 +200,32 @@ static void 
    665690 minstrel_ht_calc_tp(struct minstrel_ht_sta *mi, int group, int rate) 
    666691 { 
     
    690715-               usecs = mi->overhead / MINSTREL_TRUNC(mi->avg_ampdu_len); 
    691716+               nsecs = 1000 * mi->overhead / MINSTREL_TRUNC(mi->avg_ampdu_len); 
     717+ 
     718+       nsecs += minstrel_mcs_groups[group].duration[rate]; 
     719+       tp = 1000000 * ((mr->probability * 1000) / nsecs); 
    692720  
    693721-       usecs += minstrel_mcs_groups[group].duration[rate]; 
    694722-       mr->cur_tp = MINSTREL_TRUNC((1000000 / usecs) * mr->probability); 
    695 +       nsecs += minstrel_mcs_groups[group].duration[rate]; 
    696 +       tp = 1000000 * ((mr->probability * 1000) / nsecs); 
    697 + 
    698723+       mr->cur_tp = MINSTREL_TRUNC(tp); 
    699724 } 
    700725  
    701726 /* 
    702 @@ -308,8 +320,8 @@ minstrel_ht_update_stats(struct minstrel 
     727@@ -308,8 +309,8 @@ minstrel_ht_update_stats(struct minstrel 
    703728                } 
    704729        } 
     
    711736        cur_prob = 0; 
    712737        cur_prob_tp = 0; 
    713 @@ -320,20 +332,13 @@ minstrel_ht_update_stats(struct minstrel 
     738@@ -320,20 +321,13 @@ minstrel_ht_update_stats(struct minstrel 
    714739                if (!mg->supported) 
    715740                        continue; 
     
    733758  
    734759                mr = minstrel_get_ratestats(mi, mg->max_tp_rate2); 
    735 @@ -343,6 +348,23 @@ minstrel_ht_update_stats(struct minstrel 
     760@@ -343,6 +337,23 @@ minstrel_ht_update_stats(struct minstrel 
    736761                } 
    737762        } 
     
    757782 } 
    758783  
    759 @@ -467,7 +489,7 @@ minstrel_ht_tx_status(void *priv, struct 
     784@@ -467,7 +478,7 @@ minstrel_ht_tx_status(void *priv, struct 
    760785  
    761786        if (!mi->sample_wait && !mi->sample_tries && mi->sample_count > 0) { 
     
    766791        } 
    767792  
    768 @@ -536,7 +558,7 @@ minstrel_calc_retransmit(struct minstrel 
     793@@ -536,7 +547,7 @@ minstrel_calc_retransmit(struct minstrel 
    769794        mr->retry_updated = true; 
    770795  
     
    775800        /* Contention time for first 2 tries */ 
    776801        ctime = (t_slot * cw) >> 1; 
    777 @@ -616,6 +638,7 @@ minstrel_get_sample_rate(struct minstrel 
     802@@ -616,6 +627,7 @@ minstrel_get_sample_rate(struct minstrel 
    778803 { 
    779804        struct minstrel_rate_stats *mr; 
     
    783808  
    784809        if (mi->sample_wait > 0) { 
    785 @@ -626,39 +649,46 @@ minstrel_get_sample_rate(struct minstrel 
     810@@ -626,39 +638,46 @@ minstrel_get_sample_rate(struct minstrel 
    786811        if (!mi->sample_tries) 
    787812                return -1; 
     
    841866--- a/net/mac80211/rc80211_minstrel_ht.h 
    842867+++ b/net/mac80211/rc80211_minstrel_ht.h 
    843 @@ -85,6 +85,7 @@ struct minstrel_ht_sta { 
     868@@ -16,11 +16,6 @@ 
     869 #define MINSTREL_MAX_STREAMS   3 
     870 #define MINSTREL_STREAM_GROUPS 4 
     871  
     872-/* scaled fraction values */ 
     873-#define MINSTREL_SCALE 16 
     874-#define MINSTREL_FRAC(val, div) (((val) << MINSTREL_SCALE) / div) 
     875-#define MINSTREL_TRUNC(val) ((val) >> MINSTREL_SCALE) 
     876- 
     877 #define MCS_GROUP_RATES        8 
     878  
     879 struct mcs_group { 
     880@@ -85,6 +80,7 @@ struct minstrel_ht_sta { 
    844881  
    845882        /* best probability rate */ 
     
    11621199        if (ifmgd->auth_data && !ifmgd->auth_data->done) { 
    11631200                err = -EBUSY; 
     1201--- a/net/mac80211/rc80211_minstrel.c 
     1202+++ b/net/mac80211/rc80211_minstrel.c 
     1203@@ -55,7 +55,6 @@ 
     1204 #include "rate.h" 
     1205 #include "rc80211_minstrel.h" 
     1206  
     1207-#define SAMPLE_COLUMNS 10 
     1208 #define SAMPLE_TBL(_mi, _idx, _col) \ 
     1209                _mi->sample_table[(_idx * SAMPLE_COLUMNS) + _col] 
     1210  
     1211@@ -70,16 +69,31 @@ rix_to_ndx(struct minstrel_sta_info *mi, 
     1212        return i; 
     1213 } 
     1214  
     1215+/* find & sort topmost throughput rates */ 
     1216+static inline void 
     1217+minstrel_sort_best_tp_rates(struct minstrel_sta_info *mi, int i, u8 *tp_list) 
     1218+{ 
     1219+       int j = MAX_THR_RATES; 
     1220+ 
     1221+       while (j > 0 && mi->r[i].cur_tp > mi->r[tp_list[j - 1]].cur_tp) 
     1222+               j--; 
     1223+       if (j < MAX_THR_RATES - 1) 
     1224+               memmove(&tp_list[j + 1], &tp_list[j], MAX_THR_RATES - (j + 1)); 
     1225+       if (j < MAX_THR_RATES) 
     1226+               tp_list[j] = i; 
     1227+} 
     1228+ 
     1229 static void 
     1230 minstrel_update_stats(struct minstrel_priv *mp, struct minstrel_sta_info *mi) 
     1231 { 
     1232-       u32 max_tp = 0, index_max_tp = 0, index_max_tp2 = 0; 
     1233-       u32 max_prob = 0, index_max_prob = 0; 
     1234+       u8 tmp_tp_rate[MAX_THR_RATES]; 
     1235+       u8 tmp_prob_rate = 0; 
     1236        u32 usecs; 
     1237-       u32 p; 
     1238        int i; 
     1239  
     1240-       mi->stats_update = jiffies; 
     1241+       for (i=0; i < MAX_THR_RATES; i++) 
     1242+           tmp_tp_rate[i] = 0; 
     1243+ 
     1244        for (i = 0; i < mi->n_rates; i++) { 
     1245                struct minstrel_rate *mr = &mi->r[i]; 
     1246  
     1247@@ -87,27 +101,32 @@ minstrel_update_stats(struct minstrel_pr 
     1248                if (!usecs) 
     1249                        usecs = 1000000; 
     1250  
     1251-               /* To avoid rounding issues, probabilities scale from 0 (0%) 
     1252-                * to 18000 (100%) */ 
     1253-               if (mr->attempts) { 
     1254-                       p = (mr->success * 18000) / mr->attempts; 
     1255+               if (unlikely(mr->attempts > 0)) { 
     1256+                       mr->sample_skipped = 0; 
     1257+                       mr->cur_prob = MINSTREL_FRAC(mr->success, mr->attempts); 
     1258                        mr->succ_hist += mr->success; 
     1259                        mr->att_hist += mr->attempts; 
     1260-                       mr->cur_prob = p; 
     1261-                       p = ((p * (100 - mp->ewma_level)) + (mr->probability * 
     1262-                               mp->ewma_level)) / 100; 
     1263-                       mr->probability = p; 
     1264-                       mr->cur_tp = p * (1000000 / usecs); 
     1265-               } 
     1266+                       mr->probability = minstrel_ewma(mr->probability, 
     1267+                                                       mr->cur_prob, 
     1268+                                                       EWMA_LEVEL); 
     1269+               } else 
     1270+                       mr->sample_skipped++; 
     1271  
     1272                mr->last_success = mr->success; 
     1273                mr->last_attempts = mr->attempts; 
     1274                mr->success = 0; 
     1275                mr->attempts = 0; 
     1276  
     1277+               /* Update throughput per rate, reset thr. below 10% success */ 
     1278+               if (mr->probability < MINSTREL_FRAC(10, 100)) 
     1279+                       mr->cur_tp = 0; 
     1280+               else 
     1281+                       mr->cur_tp = mr->probability * (1000000 / usecs); 
     1282+ 
     1283                /* Sample less often below the 10% chance of success. 
     1284                 * Sample less often above the 95% chance of success. */ 
     1285-               if ((mr->probability > 17100) || (mr->probability < 1800)) { 
     1286+               if (mr->probability > MINSTREL_FRAC(95, 100) || 
     1287+                   mr->probability < MINSTREL_FRAC(10, 100)) { 
     1288                        mr->adjusted_retry_count = mr->retry_count >> 1; 
     1289                        if (mr->adjusted_retry_count > 2) 
     1290                                mr->adjusted_retry_count = 2; 
     1291@@ -118,35 +137,30 @@ minstrel_update_stats(struct minstrel_pr 
     1292                } 
     1293                if (!mr->adjusted_retry_count) 
     1294                        mr->adjusted_retry_count = 2; 
     1295-       } 
     1296  
     1297-       for (i = 0; i < mi->n_rates; i++) { 
     1298-               struct minstrel_rate *mr = &mi->r[i]; 
     1299-               if (max_tp < mr->cur_tp) { 
     1300-                       index_max_tp = i; 
     1301-                       max_tp = mr->cur_tp; 
     1302-               } 
     1303-               if (max_prob < mr->probability) { 
     1304-                       index_max_prob = i; 
     1305-                       max_prob = mr->probability; 
     1306+               minstrel_sort_best_tp_rates(mi, i, tmp_tp_rate); 
     1307+ 
     1308+               /* To determine the most robust rate (max_prob_rate) used at 
     1309+                * 3rd mmr stage we distinct between two cases: 
     1310+                * (1) if any success probabilitiy >= 95%, out of those rates 
     1311+                * choose the maximum throughput rate as max_prob_rate 
     1312+                * (2) if all success probabilities < 95%, the rate with 
     1313+                * highest success probability is choosen as max_prob_rate */ 
     1314+               if (mr->probability >= MINSTREL_FRAC(95,100)) { 
     1315+                       if (mr->cur_tp >= mi->r[tmp_prob_rate].cur_tp) 
     1316+                               tmp_prob_rate = i; 
     1317+               } else { 
     1318+                       if (mr->probability >= mi->r[tmp_prob_rate].probability) 
     1319+                               tmp_prob_rate = i; 
     1320                } 
     1321        } 
     1322  
     1323-       max_tp = 0; 
     1324-       for (i = 0; i < mi->n_rates; i++) { 
     1325-               struct minstrel_rate *mr = &mi->r[i]; 
     1326- 
     1327-               if (i == index_max_tp) 
     1328-                       continue; 
     1329+       /* Assign the new rate set */ 
     1330+       memcpy(mi->max_tp_rate, tmp_tp_rate, sizeof(mi->max_tp_rate)); 
     1331+       mi->max_prob_rate = tmp_prob_rate; 
     1332  
     1333-               if (max_tp < mr->cur_tp) { 
     1334-                       index_max_tp2 = i; 
     1335-                       max_tp = mr->cur_tp; 
     1336-               } 
     1337-       } 
     1338-       mi->max_tp_rate = index_max_tp; 
     1339-       mi->max_tp_rate2 = index_max_tp2; 
     1340-       mi->max_prob_rate = index_max_prob; 
     1341+       /* Reset update timer */ 
     1342+       mi->stats_update = jiffies; 
     1343 } 
     1344  
     1345 static void 
     1346@@ -207,10 +221,10 @@ static int 
     1347 minstrel_get_next_sample(struct minstrel_sta_info *mi) 
     1348 { 
     1349        unsigned int sample_ndx; 
     1350-       sample_ndx = SAMPLE_TBL(mi, mi->sample_idx, mi->sample_column); 
     1351-       mi->sample_idx++; 
     1352-       if ((int) mi->sample_idx > (mi->n_rates - 2)) { 
     1353-               mi->sample_idx = 0; 
     1354+       sample_ndx = SAMPLE_TBL(mi, mi->sample_row, mi->sample_column); 
     1355+       mi->sample_row++; 
     1356+       if ((int) mi->sample_row >= mi->n_rates) { 
     1357+               mi->sample_row = 0; 
     1358                mi->sample_column++; 
     1359                if (mi->sample_column >= SAMPLE_COLUMNS) 
     1360                        mi->sample_column = 0; 
     1361@@ -228,31 +242,37 @@ minstrel_get_rate(void *priv, struct iee 
     1362        struct minstrel_priv *mp = priv; 
     1363        struct ieee80211_tx_rate *ar = info->control.rates; 
     1364        unsigned int ndx, sample_ndx = 0; 
     1365-       bool mrr; 
     1366-       bool sample_slower = false; 
     1367-       bool sample = false; 
     1368+       bool mrr_capable; 
     1369+       bool indirect_rate_sampling = false; 
     1370+       bool rate_sampling = false; 
     1371        int i, delta; 
     1372        int mrr_ndx[3]; 
     1373-       int sample_rate; 
     1374+       int sampling_ratio; 
     1375  
     1376+       /* management/no-ack frames do not use rate control */ 
     1377        if (rate_control_send_low(sta, priv_sta, txrc)) 
     1378                return; 
     1379  
     1380-       mrr = mp->has_mrr && !txrc->rts && !txrc->bss_conf->use_cts_prot; 
     1381- 
     1382-       ndx = mi->max_tp_rate; 
     1383- 
     1384-       if (mrr) 
     1385-               sample_rate = mp->lookaround_rate_mrr; 
     1386+       /* check multi-rate-retry capabilities & adjust lookaround_rate */ 
     1387+       mrr_capable = mp->has_mrr && 
     1388+                     !txrc->rts && 
     1389+                     !txrc->bss_conf->use_cts_prot; 
     1390+       if (mrr_capable) 
     1391+               sampling_ratio = mp->lookaround_rate_mrr; 
     1392        else 
     1393-               sample_rate = mp->lookaround_rate; 
     1394+               sampling_ratio = mp->lookaround_rate; 
     1395+ 
     1396+       /* init rateindex [ndx] with max throughput rate */ 
     1397+       ndx = mi->max_tp_rate[0]; 
     1398  
     1399+       /* increase sum packet counter */ 
     1400        mi->packet_count++; 
     1401-       delta = (mi->packet_count * sample_rate / 100) - 
     1402+ 
     1403+       delta = (mi->packet_count * sampling_ratio / 100) - 
     1404                        (mi->sample_count + mi->sample_deferred / 2); 
     1405  
     1406        /* delta > 0: sampling required */ 
     1407-       if ((delta > 0) && (mrr || !mi->prev_sample)) { 
     1408+       if ((delta > 0) && (mrr_capable || !mi->prev_sample)) { 
     1409                struct minstrel_rate *msr; 
     1410                if (mi->packet_count >= 10000) { 
     1411                        mi->sample_deferred = 0; 
     1412@@ -271,21 +291,28 @@ minstrel_get_rate(void *priv, struct iee 
     1413                        mi->sample_count += (delta - mi->n_rates * 2); 
     1414                } 
     1415  
     1416+               /* get next random rate sample */ 
     1417                sample_ndx = minstrel_get_next_sample(mi); 
     1418                msr = &mi->r[sample_ndx]; 
     1419-               sample = true; 
     1420-               sample_slower = mrr && (msr->perfect_tx_time > 
     1421-                       mi->r[ndx].perfect_tx_time); 
     1422+               rate_sampling = true; 
     1423  
     1424-               if (!sample_slower) { 
     1425+               /* Decide if direct ( 1st mrr stage) or indirect (2nd mrr stage) 
     1426+                * rate sampling method should be used. 
     1427+                * Respect such rates that are not sampled for 20 interations. 
     1428+                */ 
     1429+               if (mrr_capable && 
     1430+                   msr->perfect_tx_time > mi->r[ndx].perfect_tx_time && 
     1431+                   msr->sample_skipped < 20) 
     1432+                               indirect_rate_sampling = true; 
     1433+ 
     1434+               if (!indirect_rate_sampling) { 
     1435                        if (msr->sample_limit != 0) { 
     1436                                ndx = sample_ndx; 
     1437                                mi->sample_count++; 
     1438                                if (msr->sample_limit > 0) 
     1439                                        msr->sample_limit--; 
     1440-                       } else { 
     1441-                               sample = false; 
     1442-                       } 
     1443+                       } else 
     1444+                               rate_sampling = false; 
     1445                } else { 
     1446                        /* Only use IEEE80211_TX_CTL_RATE_CTRL_PROBE to mark 
     1447                         * packets that have the sampling rate deferred to the 
     1448@@ -297,34 +324,39 @@ minstrel_get_rate(void *priv, struct iee 
     1449                        mi->sample_deferred++; 
     1450                } 
     1451        } 
     1452-       mi->prev_sample = sample; 
     1453+       mi->prev_sample = rate_sampling; 
     1454  
     1455        /* If we're not using MRR and the sampling rate already 
     1456         * has a probability of >95%, we shouldn't be attempting 
     1457         * to use it, as this only wastes precious airtime */ 
     1458-       if (!mrr && sample && (mi->r[ndx].probability > 17100)) 
     1459-               ndx = mi->max_tp_rate; 
     1460+       if (!mrr_capable && rate_sampling && 
     1461+          (mi->r[ndx].probability > MINSTREL_FRAC(95, 100))) 
     1462+               ndx = mi->max_tp_rate[0]; 
     1463  
     1464+       /* mrr setup for 1st stage */ 
     1465        ar[0].idx = mi->r[ndx].rix; 
     1466        ar[0].count = minstrel_get_retry_count(&mi->r[ndx], info); 
     1467  
     1468-       if (!mrr) { 
     1469-               if (!sample) 
     1470+       /* non mrr setup for 2nd stage */ 
     1471+       if (!mrr_capable) { 
     1472+               if (!rate_sampling) 
     1473                        ar[0].count = mp->max_retry; 
     1474                ar[1].idx = mi->lowest_rix; 
     1475                ar[1].count = mp->max_retry; 
     1476                return; 
     1477        } 
     1478  
     1479-       /* MRR setup */ 
     1480-       if (sample) { 
     1481-               if (sample_slower) 
     1482+       /* mrr setup for 2nd stage */ 
     1483+       if (rate_sampling) { 
     1484+               if (indirect_rate_sampling) 
     1485                        mrr_ndx[0] = sample_ndx; 
     1486                else 
     1487-                       mrr_ndx[0] = mi->max_tp_rate; 
     1488+                       mrr_ndx[0] = mi->max_tp_rate[0]; 
     1489        } else { 
     1490-               mrr_ndx[0] = mi->max_tp_rate2; 
     1491+               mrr_ndx[0] = mi->max_tp_rate[1]; 
     1492        } 
     1493+ 
     1494+       /* mrr setup for 3rd & 4th stage */ 
     1495        mrr_ndx[1] = mi->max_prob_rate; 
     1496        mrr_ndx[2] = 0; 
     1497        for (i = 1; i < 4; i++) { 
     1498@@ -351,26 +383,21 @@ static void 
     1499 init_sample_table(struct minstrel_sta_info *mi) 
     1500 { 
     1501        unsigned int i, col, new_idx; 
     1502-       unsigned int n_srates = mi->n_rates - 1; 
     1503        u8 rnd[8]; 
     1504  
     1505        mi->sample_column = 0; 
     1506-       mi->sample_idx = 0; 
     1507-       memset(mi->sample_table, 0, SAMPLE_COLUMNS * mi->n_rates); 
     1508+       mi->sample_row = 0; 
     1509+       memset(mi->sample_table, 0xff, SAMPLE_COLUMNS * mi->n_rates); 
     1510  
     1511        for (col = 0; col < SAMPLE_COLUMNS; col++) { 
     1512-               for (i = 0; i < n_srates; i++) { 
     1513+               for (i = 0; i < mi->n_rates; i++) { 
     1514                        get_random_bytes(rnd, sizeof(rnd)); 
     1515-                       new_idx = (i + rnd[i & 7]) % n_srates; 
     1516+                       new_idx = (i + rnd[i & 7]) % mi->n_rates; 
     1517  
     1518-                       while (SAMPLE_TBL(mi, new_idx, col) != 0) 
     1519-                               new_idx = (new_idx + 1) % n_srates; 
     1520+                       while (SAMPLE_TBL(mi, new_idx, col) != 0xff) 
     1521+                               new_idx = (new_idx + 1) % mi->n_rates; 
     1522  
     1523-                       /* Don't sample the slowest rate (i.e. slowest base 
     1524-                        * rate). We must presume that the slowest rate works 
     1525-                        * fine, or else other management frames will also be 
     1526-                        * failing and the link will break */ 
     1527-                       SAMPLE_TBL(mi, new_idx, col) = i + 1; 
     1528+                       SAMPLE_TBL(mi, new_idx, col) = i; 
     1529                } 
     1530        } 
     1531 } 
     1532@@ -542,9 +569,6 @@ minstrel_alloc(struct ieee80211_hw *hw,  
     1533        mp->lookaround_rate = 5; 
     1534        mp->lookaround_rate_mrr = 10; 
     1535  
     1536-       /* moving average weight for EWMA */ 
     1537-       mp->ewma_level = 75; 
     1538- 
     1539        /* maximum time that the hw is allowed to stay in one MRR segment */ 
     1540        mp->segment_size = 6000; 
     1541  
     1542--- a/net/mac80211/rc80211_minstrel.h 
     1543+++ b/net/mac80211/rc80211_minstrel.h 
     1544@@ -9,6 +9,28 @@ 
     1545 #ifndef __RC_MINSTREL_H 
     1546 #define __RC_MINSTREL_H 
     1547  
     1548+#define EWMA_LEVEL     75      /* ewma weighting factor [%] */ 
     1549+#define SAMPLE_COLUMNS 10      /* number of columns in sample table */ 
     1550+ 
     1551+ 
     1552+/* scaled fraction values */ 
     1553+#define MINSTREL_SCALE  16 
     1554+#define MINSTREL_FRAC(val, div) (((val) << MINSTREL_SCALE) / div) 
     1555+#define MINSTREL_TRUNC(val) ((val) >> MINSTREL_SCALE) 
     1556+ 
     1557+/* number of highest throughput rates to consider*/ 
     1558+#define MAX_THR_RATES 4 
     1559+ 
     1560+/* 
     1561+ * Perform EWMA (Exponentially Weighted Moving Average) calculation 
     1562+  */ 
     1563+static inline int 
     1564+minstrel_ewma(int old, int new, int weight) 
     1565+{ 
     1566+       return (new * (100 - weight) + old * weight) / 100; 
     1567+} 
     1568+ 
     1569+ 
     1570 struct minstrel_rate { 
     1571        int bitrate; 
     1572        int rix; 
     1573@@ -26,6 +48,7 @@ struct minstrel_rate { 
     1574        u32 attempts; 
     1575        u32 last_attempts; 
     1576        u32 last_success; 
     1577+       u8 sample_skipped; 
     1578  
     1579        /* parts per thousand */ 
     1580        u32 cur_prob; 
     1581@@ -45,14 +68,13 @@ struct minstrel_sta_info { 
     1582  
     1583        unsigned int lowest_rix; 
     1584  
     1585-       unsigned int max_tp_rate; 
     1586-       unsigned int max_tp_rate2; 
     1587-       unsigned int max_prob_rate; 
     1588+       u8 max_tp_rate[MAX_THR_RATES]; 
     1589+       u8 max_prob_rate; 
     1590        unsigned int packet_count; 
     1591        unsigned int sample_count; 
     1592        int sample_deferred; 
     1593  
     1594-       unsigned int sample_idx; 
     1595+       unsigned int sample_row; 
     1596        unsigned int sample_column; 
     1597  
     1598        int n_rates; 
     1599@@ -73,7 +95,6 @@ struct minstrel_priv { 
     1600        unsigned int cw_min; 
     1601        unsigned int cw_max; 
     1602        unsigned int max_retry; 
     1603-       unsigned int ewma_level; 
     1604        unsigned int segment_size; 
     1605        unsigned int update_interval; 
     1606        unsigned int lookaround_rate; 
     1607--- a/net/mac80211/rc80211_minstrel_debugfs.c 
     1608+++ b/net/mac80211/rc80211_minstrel_debugfs.c 
     1609@@ -73,15 +73,17 @@ minstrel_stats_open(struct inode *inode, 
     1610        for (i = 0; i < mi->n_rates; i++) { 
     1611                struct minstrel_rate *mr = &mi->r[i]; 
     1612  
     1613-               *(p++) = (i == mi->max_tp_rate) ? 'T' : ' '; 
     1614-               *(p++) = (i == mi->max_tp_rate2) ? 't' : ' '; 
     1615+               *(p++) = (i == mi->max_tp_rate[0]) ? 'A' : ' '; 
     1616+               *(p++) = (i == mi->max_tp_rate[1]) ? 'B' : ' '; 
     1617+               *(p++) = (i == mi->max_tp_rate[2]) ? 'C' : ' '; 
     1618+               *(p++) = (i == mi->max_tp_rate[3]) ? 'D' : ' '; 
     1619                *(p++) = (i == mi->max_prob_rate) ? 'P' : ' '; 
     1620                p += sprintf(p, "%3u%s", mr->bitrate / 2, 
     1621                                (mr->bitrate & 1 ? ".5" : "  ")); 
     1622  
     1623-               tp = mr->cur_tp / ((18000 << 10) / 96); 
     1624-               prob = mr->cur_prob / 18; 
     1625-               eprob = mr->probability / 18; 
     1626+               tp = MINSTREL_TRUNC(mr->cur_tp / 10); 
     1627+               prob = MINSTREL_TRUNC(mr->cur_prob * 1000); 
     1628+               eprob = MINSTREL_TRUNC(mr->probability * 1000); 
     1629  
     1630                p += sprintf(p, "  %6u.%1u   %6u.%1u   %6u.%1u        " 
     1631                                "%3u(%3u)   %8llu    %8llu\n", 
Note: See TracChangeset for help on using the changeset viewer.