Lines Matching refs:mi
278 minstrel_ht_update_rates(struct minstrel_priv *mp, struct minstrel_ht_sta *mi);
370 minstrel_ht_get_stats(struct minstrel_priv *mp, struct minstrel_ht_sta *mi,
389 if (!(mi->supported[group] & BIT(idx)))
396 if ((mi->supported[group] & BIT(idx + 4)) &&
404 if (rate->idx == mp->ofdm_rates[mi->band][idx])
409 return &mi->groups[group].rates[idx];
416 minstrel_ht_ri_get_stats(struct minstrel_priv *mp, struct minstrel_ht_sta *mi,
440 if ((mi->supported[group] & BIT(idx + 4)) &&
441 mi->use_short_preamble)
448 if (rate->legacy == minstrel_ofdm_bitrates[ mp->ofdm_rates[mi->band][idx] ])
453 return &mi->groups[group].rates[idx];
457 minstrel_get_ratestats(struct minstrel_ht_sta *mi, int index)
459 return &mi->groups[MI_RATE_GROUP(index)].rates[MI_RATE_IDX(index)];
471 minstrel_ht_avg_ampdu_len(struct minstrel_ht_sta *mi)
475 if (mi->avg_ampdu_len)
476 return MINSTREL_TRUNC(mi->avg_ampdu_len);
478 if (minstrel_ht_is_legacy_group(MI_RATE_GROUP(mi->max_tp_rate[0])))
481 duration = minstrel_get_duration(mi->max_tp_rate[0]);
500 minstrel_ht_get_tp_avg(struct minstrel_ht_sta *mi, int group, int rate,
503 unsigned int nsecs = 0, overhead = mi->overhead;
511 overhead = mi->overhead_legacy;
513 ampdu_len = minstrel_ht_avg_ampdu_len(mi);
538 minstrel_ht_sort_best_tp_rates(struct minstrel_ht_sta *mi, u16 index,
547 cur_prob = mi->groups[cur_group].rates[cur_idx].prob_avg;
548 cur_tp_avg = minstrel_ht_get_tp_avg(mi, cur_group, cur_idx, cur_prob);
553 tmp_prob = mi->groups[tmp_group].rates[tmp_idx].prob_avg;
554 tmp_tp_avg = minstrel_ht_get_tp_avg(mi, tmp_group, tmp_idx,
574 minstrel_ht_set_best_prob_rate(struct minstrel_ht_sta *mi, u16 *dest, u16 index)
586 mg = &mi->groups[cur_group];
591 tmp_prob = mi->groups[tmp_group].rates[tmp_idx].prob_avg;
592 tmp_tp_avg = minstrel_ht_get_tp_avg(mi, tmp_group, tmp_idx, tmp_prob);
596 max_tp_group = MI_RATE_GROUP(mi->max_tp_rate[0]);
597 max_tp_idx = MI_RATE_IDX(mi->max_tp_rate[0]);
598 max_tp_prob = mi->groups[max_tp_group].rates[max_tp_idx].prob_avg;
605 if (minstrel_get_duration(mi->max_tp_rate[0]) > minstrel_get_duration(index) &&
611 max_gpr_prob = mi->groups[max_gpr_group].rates[max_gpr_idx].prob_avg;
614 cur_tp_avg = minstrel_ht_get_tp_avg(mi, cur_group, cur_idx,
619 max_gpr_tp_avg = minstrel_ht_get_tp_avg(mi, max_gpr_group,
640 minstrel_ht_assign_best_tp_rates(struct minstrel_ht_sta *mi,
649 tmp_prob = mi->groups[tmp_group].rates[tmp_idx].prob_avg;
650 tmp_cck_tp = minstrel_ht_get_tp_avg(mi, tmp_group, tmp_idx, tmp_prob);
654 tmp_prob = mi->groups[tmp_group].rates[tmp_idx].prob_avg;
655 tmp_mcs_tp = minstrel_ht_get_tp_avg(mi, tmp_group, tmp_idx, tmp_prob);
659 minstrel_ht_sort_best_tp_rates(mi, tmp_legacy_tp_rate[i],
671 minstrel_ht_prob_rate_reduce_streams(struct minstrel_ht_sta *mi)
677 if (!mi->sta->deflink.ht_cap.ht_supported)
680 group = MI_RATE_GROUP(mi->max_tp_rate[0]);
683 mg = &mi->groups[group];
684 if (!mi->supported[group] || group == MINSTREL_CCK_GROUP)
688 tmp_prob = mi->groups[group].rates[tmp_idx].prob_avg;
690 if (tmp_tp < minstrel_ht_get_tp_avg(mi, group, tmp_idx, tmp_prob) &&
692 mi->max_prob_rate = mg->max_group_prob_rate;
693 tmp_tp = minstrel_ht_get_tp_avg(mi, group,
701 __minstrel_ht_get_sample_rate(struct minstrel_ht_sta *mi,
704 u16 *rates = mi->sample[type].sample_rates;
786 minstrel_ht_find_sample_rate(struct minstrel_ht_sta *mi, int type, int idx)
791 u16 cur = mi->sample[type].sample_rates[i];
804 minstrel_ht_move_sample_rates(struct minstrel_ht_sta *mi, int type,
807 u16 *rates = mi->sample[type].sample_rates;
850 minstrel_ht_group_min_rate_offset(struct minstrel_ht_sta *mi, int group,
853 u16 supported = mi->supported[group];
875 minstrel_ht_next_inc_rate(struct minstrel_ht_sta *mi, u32 fast_rate_dur)
881 group = mi->sample[type].sample_group;
885 index = minstrel_ht_group_min_rate_offset(mi, group,
891 if (!minstrel_ht_find_sample_rate(mi, type, index))
897 mi->sample[type].sample_group = group;
903 minstrel_ht_next_group_sample_rate(struct minstrel_ht_sta *mi, int group,
906 struct minstrel_mcs_group_data *mg = &mi->groups[group];
937 minstrel_ht_next_jump_rate(struct minstrel_ht_sta *mi, u32 fast_rate_dur,
951 slow_rates = mi->sample[MINSTREL_SAMPLE_TYPE_SLOW].sample_rates;
952 group = mi->sample[MINSTREL_SAMPLE_TYPE_JUMP].sample_group;
958 supported = mi->supported[group];
962 offset = minstrel_ht_group_min_rate_offset(mi, group,
967 index = minstrel_ht_next_group_sample_rate(mi, group, supported,
978 if (minstrel_ht_find_sample_rate(mi, type, index))
991 mrs = minstrel_get_ratestats(mi, index);
1002 mi->sample[MINSTREL_SAMPLE_TYPE_JUMP].sample_group = group;
1008 minstrel_ht_refill_sample_rates(struct minstrel_ht_sta *mi)
1010 u32 prob_dur = minstrel_get_duration(mi->max_prob_rate);
1011 u32 tp_dur = minstrel_get_duration(mi->max_tp_rate[0]);
1012 u32 tp2_dur = minstrel_get_duration(mi->max_tp_rate[1]);
1018 rates = mi->sample[MINSTREL_SAMPLE_TYPE_INC].sample_rates;
1019 i = minstrel_ht_move_sample_rates(mi, MINSTREL_SAMPLE_TYPE_INC,
1022 rates[i] = minstrel_ht_next_inc_rate(mi, tp_dur);
1029 rates = mi->sample[MINSTREL_SAMPLE_TYPE_JUMP].sample_rates;
1030 i = minstrel_ht_move_sample_rates(mi, MINSTREL_SAMPLE_TYPE_JUMP,
1032 j = minstrel_ht_move_sample_rates(mi, MINSTREL_SAMPLE_TYPE_SLOW,
1035 rates[i] = minstrel_ht_next_jump_rate(mi, fast_rate_dur,
1043 for (i = 0; i < ARRAY_SIZE(mi->sample); i++)
1044 memcpy(mi->sample[i].cur_sample_rates, mi->sample[i].sample_rates,
1045 sizeof(mi->sample[i].cur_sample_rates));
1059 minstrel_ht_update_stats(struct minstrel_priv *mp, struct minstrel_ht_sta *mi)
1067 bool ht_supported = mi->sta->deflink.ht_cap.ht_supported;
1069 if (mi->ampdu_packets > 0) {
1071 mi->avg_ampdu_len = minstrel_ewma(mi->avg_ampdu_len,
1072 MINSTREL_FRAC(mi->ampdu_len, mi->ampdu_packets),
1075 mi->avg_ampdu_len = 0;
1076 mi->ampdu_len = 0;
1077 mi->ampdu_packets = 0;
1080 if (mi->supported[MINSTREL_CCK_GROUP])
1082 else if (mi->supported[MINSTREL_OFDM_GROUP])
1091 if (mi->supported[MINSTREL_VHT_GROUP_0])
1095 else if (mi->supported[MINSTREL_CCK_GROUP])
1110 mg = &mi->groups[group];
1111 if (!mi->supported[group])
1122 if (!(mi->supported[group] & BIT(i)))
1137 if (minstrel_ht_get_tp_avg(mi, group, i, cur_prob) == 0)
1141 minstrel_ht_sort_best_tp_rates(mi, index, tp_rate);
1144 minstrel_ht_sort_best_tp_rates(mi, index,
1153 minstrel_ht_assign_best_tp_rates(mi, tmp_mcs_tp_rate,
1155 memcpy(mi->max_tp_rate, tmp_mcs_tp_rate, sizeof(mi->max_tp_rate));
1158 if (!mi->supported[group])
1161 mg = &mi->groups[group];
1165 if (!(mi->supported[group] & BIT(i)))
1171 minstrel_ht_set_best_prob_rate(mi, &tmp_max_prob_rate,
1176 mi->max_prob_rate = tmp_max_prob_rate;
1179 minstrel_ht_prob_rate_reduce_streams(mi);
1180 minstrel_ht_refill_sample_rates(mi);
1186 mi->max_tp_rate[i] = mp->fixed_rate_idx;
1187 mi->max_prob_rate = mp->fixed_rate_idx;
1192 mi->last_stats_update = jiffies;
1193 mi->sample_time = jiffies;
1197 minstrel_ht_txstat_valid(struct minstrel_priv *mp, struct minstrel_ht_sta *mi,
1217 if (rate->idx == mp->ofdm_rates[mi->band][i])
1228 struct minstrel_ht_sta *mi,
1250 minstrel_ofdm_bitrates[ mp->ofdm_rates[mi->band][i] ])
1258 minstrel_downgrade_rate(struct minstrel_ht_sta *mi, u16 *idx, bool primary)
1266 if (!mi->supported[group])
1274 *idx = mi->groups[group].max_group_tp_rate[0];
1276 *idx = mi->groups[group].max_group_tp_rate[1];
1286 struct minstrel_ht_sta *mi = priv_sta;
1310 if (mi->total_packets >= ~0 - info->status.ampdu_len) {
1311 mi->total_packets = 0;
1312 mi->sample_packets = 0;
1315 mi->total_packets += info->status.ampdu_len;
1317 mi->sample_packets += info->status.ampdu_len;
1319 mi->ampdu_packets++;
1320 mi->ampdu_len += info->status.ampdu_len;
1323 last = !minstrel_ht_ri_txstat_valid(mp, mi, &(st->rates[0]));
1326 !minstrel_ht_ri_txstat_valid(mp, mi,
1329 rate = minstrel_ht_ri_get_stats(mp, mi,
1339 last = !minstrel_ht_txstat_valid(mp, mi, &ar[0]);
1342 !minstrel_ht_txstat_valid(mp, mi, &ar[i + 1]);
1344 rate = minstrel_ht_get_stats(mp, mi, &ar[i]);
1357 rate = minstrel_get_ratestats(mi, mi->max_tp_rate[0]);
1360 minstrel_downgrade_rate(mi, &mi->max_tp_rate[0], true);
1364 rate2 = minstrel_get_ratestats(mi, mi->max_tp_rate[1]);
1367 minstrel_downgrade_rate(mi, &mi->max_tp_rate[1], false);
1372 if (time_after(jiffies, mi->last_stats_update + update_interval)) {
1374 minstrel_ht_update_stats(mp, mi);
1378 minstrel_ht_update_rates(mp, mi);
1382 minstrel_calc_retransmit(struct minstrel_priv *mp, struct minstrel_ht_sta *mi,
1390 unsigned int ampdu_len = minstrel_ht_avg_ampdu_len(mi);
1393 mrs = minstrel_get_ratestats(mi, index);
1413 overhead = mi->overhead_legacy;
1414 overhead_rtscts = mi->overhead_legacy_rtscts;
1416 overhead = mi->overhead;
1417 overhead_rtscts = mi->overhead_rtscts;
1442 minstrel_ht_set_rate(struct minstrel_priv *mp, struct minstrel_ht_sta *mi,
1451 mrs = minstrel_get_ratestats(mi, index);
1453 minstrel_calc_retransmit(mp, mi, index);
1469 idx = mp->ofdm_rates[mi->band][index %
1482 (mi->sta->deflink.smps_mode == IEEE80211_SMPS_DYNAMIC &&
1493 minstrel_ht_get_prob_avg(struct minstrel_ht_sta *mi, int rate)
1497 return mi->groups[group].rates[rate].prob_avg;
1501 minstrel_ht_get_max_amsdu_len(struct minstrel_ht_sta *mi)
1503 int group = MI_RATE_GROUP(mi->max_prob_rate);
1505 int rate = MI_RATE_IDX(mi->max_prob_rate);
1509 if (mi->groups[group].rates[rate].prob_avg < MINSTREL_FRAC(50, 100))
1532 (minstrel_ht_get_prob_avg(mi, mi->max_tp_rate[0]) <
1542 if (!mi->sta->deflink.vht_cap.vht_supported)
1550 minstrel_ht_update_rates(struct minstrel_priv *mp, struct minstrel_ht_sta *mi)
1561 minstrel_ht_set_rate(mp, mi, rates, i++, mi->max_tp_rate[0]);
1565 minstrel_ht_set_rate(mp, mi, rates, i, mi->max_tp_rate[i]);
1568 minstrel_ht_set_rate(mp, mi, rates, i++, mi->max_prob_rate);
1573 mi->sta->deflink.agg.max_rc_amsdu_len = minstrel_ht_get_max_amsdu_len(mi);
1574 ieee80211_sta_recalc_aggregates(mi->sta);
1575 rate_control_set_rates(mp->hw, mi->sta, rates);
1579 minstrel_ht_get_sample_rate(struct minstrel_priv *mp, struct minstrel_ht_sta *mi)
1584 seq = mi->sample_seq;
1585 mi->sample_seq = (seq + 1) % ARRAY_SIZE(minstrel_sample_seq);
1591 return __minstrel_ht_get_sample_rate(mi, seq);
1601 struct minstrel_ht_sta *mi = priv_sta;
1605 info->flags |= mi->tx_flags;
1617 if (time_is_after_jiffies(mi->sample_time))
1620 mi->sample_time = jiffies + MINSTREL_SAMPLE_INTERVAL;
1621 sample_idx = minstrel_ht_get_sample_rate(mp, mi);
1640 rate->idx = mp->ofdm_rates[mi->band][idx];
1652 minstrel_ht_update_cck(struct minstrel_priv *mp, struct minstrel_ht_sta *mi,
1670 mi->supported[MINSTREL_CCK_GROUP] |= BIT(i);
1672 mi->supported[MINSTREL_CCK_GROUP] |= BIT(i + 4);
1677 minstrel_ht_update_ofdm(struct minstrel_priv *mp, struct minstrel_ht_sta *mi,
1693 mi->supported[MINSTREL_OFDM_GROUP] |= BIT(i);
1703 struct minstrel_ht_sta *mi = priv_sta;
1722 memset(mi, 0, sizeof(*mi));
1724 mi->sta = sta;
1725 mi->band = sband->band;
1726 mi->last_stats_update = jiffies;
1729 mi->overhead = ieee80211_frame_duration(sband->band, 0, 60, 1, 1, 0);
1730 mi->overhead += ack_dur;
1731 mi->overhead_rtscts = mi->overhead + 2 * ack_dur;
1738 mi->overhead_legacy = ack_dur;
1739 mi->overhead_legacy_rtscts = mi->overhead_legacy + 2 * ack_dur;
1741 mi->avg_ampdu_len = MINSTREL_FRAC(1, 1);
1755 mi->tx_flags |= stbc << IEEE80211_TX_CTL_STBC_SHIFT;
1757 mi->tx_flags |= IEEE80211_TX_CTL_LDPC;
1759 for (i = 0; i < ARRAY_SIZE(mi->groups); i++) {
1763 mi->supported[i] = 0;
1792 mi->supported[i] = mcs->rx_mask[nss - 1];
1817 mi->supported[i] = minstrel_get_valid_vht_rates(bw, nss,
1822 mi->use_short_preamble = test_sta_flag(sta_info, WLAN_STA_SHORT_PREAMBLE) &&
1825 minstrel_ht_update_cck(mp, mi, sband, sta);
1826 minstrel_ht_update_ofdm(mp, mi, sband, sta);
1829 minstrel_ht_update_stats(mp, mi);
1830 minstrel_ht_update_rates(mp, mi);
1854 struct minstrel_ht_sta *mi;
1866 return kzalloc(sizeof(*mi), gfp);
1990 struct minstrel_ht_sta *mi = priv_sta;
1993 i = MI_RATE_GROUP(mi->max_tp_rate[0]);
1994 j = MI_RATE_IDX(mi->max_tp_rate[0]);
1995 prob = mi->groups[i].rates[j].prob_avg;
1998 tp_avg = minstrel_ht_get_tp_avg(mi, i, j, prob) * 10;