/*
 * Copyright (c) 2015 South Silicon Valley Microelectronics Inc.
 * Copyright (c) 2015 iComm Corporation
 *
 * This program is free software: you can redistribute it and/or modify 
 * it under the terms of the GNU General Public License as published by 
 * the Free Software Foundation, either version 3 of the License, or 
 * (at your option) any later version.
 * This program is distributed in the hope that it will be useful, but 
 * WITHOUT ANY WARRANTY; without even the implied warranty of 
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
 * See the GNU General Public License for more details.
 * You should have received a copy of the GNU General Public License 
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */

#include <linux/version.h>
#include <ssv6200.h>
#include "dev.h"
#include "ssv_ht_rc.h"
#include "ssv_rc.h"
#define SAMPLE_COUNT 4
#define HT_CW_MIN 15
#define HT_SEGMENT_SIZE 6000
#define AVG_PKT_SIZE 12000
#define SAMPLE_COLUMNS 10
#define EWMA_LEVEL 75
#define MCS_NBITS (AVG_PKT_SIZE << 3)
#define MCS_NSYMS(bps) ((MCS_NBITS + (bps) - 1) / (bps))
#define MCS_SYMBOL_TIME(sgi,syms) \
    (sgi ? \
      ((syms) * 18 + 4) / 5 : \
      (syms) << 2 \
    )
#define MCS_DURATION(streams,sgi,bps) MCS_SYMBOL_TIME(sgi, MCS_NSYMS((streams) * (bps)))
#define MCS_GROUP(_streams,_sgi,_ht40) { \
    .duration = { \
        MCS_DURATION(_streams, _sgi, _ht40 ? 54 : 26), \
        MCS_DURATION(_streams, _sgi, _ht40 ? 108 : 52), \
        MCS_DURATION(_streams, _sgi, _ht40 ? 162 : 78), \
        MCS_DURATION(_streams, _sgi, _ht40 ? 216 : 104), \
        MCS_DURATION(_streams, _sgi, _ht40 ? 324 : 156), \
        MCS_DURATION(_streams, _sgi, _ht40 ? 432 : 208), \
        MCS_DURATION(_streams, _sgi, _ht40 ? 486 : 234), \
        MCS_DURATION(_streams, _sgi, _ht40 ? 540 : 260) \
    } \
}
const struct mcs_group minstrel_mcs_groups_ssv[] = {
    MCS_GROUP(1, 0, 0),
    MCS_GROUP(1, 1, 0),
};
const u16 ampdu_max_transmit_length[RATE_TABLE_SIZE] =
{
    0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0,
    4600, 9200, 13800, 18500, 27700, 37000, 41600, 46200,
    5100, 10200, 15400, 20500, 30800, 41100, 46200, 51300,
    4600, 9200, 13800, 18500, 27700, 37000, 41600, 46200
};
static u8 sample_table[SAMPLE_COLUMNS][MCS_GROUP_RATES];
static int minstrel_ewma(int old, int new, int weight)
{
    return (new * (100 - weight) + old * weight) / 100;
}
static inline struct minstrel_rate_stats *minstrel_get_ratestats(struct ssv62xx_ht *mi, int index)
{
    return &mi->groups.rates[index % MCS_GROUP_RATES];
}
static void minstrel_calc_rate_ewma(struct minstrel_rate_stats *mr)
{
    if (unlikely(mr->attempts > 0)) {
        mr->sample_skipped = 0;
        mr->cur_prob = MINSTREL_FRAC(mr->success, mr->attempts);
        if (!mr->att_hist)
            mr->probability = mr->cur_prob;
        else
            mr->probability = minstrel_ewma(mr->probability,
                mr->cur_prob, EWMA_LEVEL);
        mr->att_hist += mr->attempts;
        mr->succ_hist += mr->success;
    } else {
        mr->sample_skipped++;
    }
    mr->last_success = mr->success;
    mr->last_attempts = mr->attempts;
    mr->success = 0;
    mr->attempts = 0;
}
static void minstrel_ht_calc_tp(struct ssv62xx_ht *mi, struct ssv_sta_rc_info *rc_sta, int rate)
{
    struct minstrel_rate_stats *mr;
    unsigned int usecs,group_id;
    if(rc_sta->ht_rc_type == RC_TYPE_HT_LGI_20)
        group_id = 0;
    else
        group_id = 1;
    mr = &mi->groups.rates[rate];
    if (mr->probability < MINSTREL_FRAC(1, 10)) {
        mr->cur_tp = 0;
        return;
    }
    usecs = mi->overhead / MINSTREL_TRUNC(mi->avg_ampdu_len);
    usecs += minstrel_mcs_groups_ssv[group_id].duration[rate];
    mr->cur_tp = MINSTREL_TRUNC((1000000 / usecs) * mr->probability);
}
static void rate_control_ht_sample(struct ssv62xx_ht *mi,struct ssv_sta_rc_info *rc_sta)
{
    struct minstrel_mcs_group_data *mg;
    struct minstrel_rate_stats *mr;
    int cur_prob, cur_prob_tp, cur_tp, cur_tp2;
    int i, index;
    if (mi->ampdu_packets > 0) {
        mi->avg_ampdu_len = minstrel_ewma(mi->avg_ampdu_len,
            MINSTREL_FRAC(mi->ampdu_len, mi->ampdu_packets), EWMA_LEVEL);
        mi->ampdu_len = 0;
        mi->ampdu_packets = 0;
    }
    else
        return;
    mi->sample_slow = 0;
    mi->sample_count = 0;
    {
        cur_prob = 0;
        cur_prob_tp = 0;
        cur_tp = 0;
        cur_tp2 = 0;
        mg = &mi->groups;
        mg->max_tp_rate = 0;
        mg->max_tp_rate2 = 0;
        mg->max_prob_rate = 0;
        for (i = 0; i < MCS_GROUP_RATES; i++) {
            if (!(rc_sta->ht_supp_rates & BIT(i)))
                continue;
            mr = &mg->rates[i];
            index = i;
            minstrel_calc_rate_ewma(mr);
            minstrel_ht_calc_tp(mi, rc_sta, i);
#ifdef RATE_CONTROL_HT_PARAMETER_DEBUG
            if(mr->cur_prob)
                printk("rate[%d]probability[%08d]cur_prob[%08d]TP[%04d]\n",i,mr->probability,mr->cur_prob,mr->cur_tp);
#endif
#ifdef RATE_CONTROL_HT_STUPID_DEBUG
            printk("HT sample result max_tp_rate[%d]max_tp_rate2[%d]max_prob_rate[%d]\n",mg->max_tp_rate,mg->max_tp_rate2,mg->max_prob_rate);
            printk("rate[%d]probability[%08d]TP[%d]\n",i,mr->probability,mr->cur_tp);
#endif
            if (!mr->cur_tp)
                continue;
#ifdef RATE_CONTROL_HT_STUPID_DEBUG
            printk("HT--1 mr->cur_tp[%d]cur_prob_tp[%d]\n",mr->cur_tp,cur_prob_tp);
#endif
            if ((mr->cur_tp > cur_prob_tp && mr->probability >
                 MINSTREL_FRAC(3, 4)) || mr->probability > cur_prob) {
                mg->max_prob_rate = index;
                cur_prob = mr->probability;
                cur_prob_tp = mr->cur_tp;
            }
#ifdef RATE_CONTROL_HT_STUPID_DEBUG
            printk("HT--2 mr->cur_tp[%d]cur_tp[%d]\n",mr->cur_tp,cur_tp);
#endif
            if (mr->cur_tp > cur_tp) {
                swap(index, mg->max_tp_rate);
                cur_tp = mr->cur_tp;
                mr = minstrel_get_ratestats(mi, index);
            }
#ifdef RATE_CONTROL_HT_STUPID_DEBUG
            if(index != i)
                printk("HT--3 index[%d]i[%d]mg->max_tp_rate[%d]\n",index,i,mg->max_tp_rate);
#endif
            if (index >= mg->max_tp_rate)
                continue;
#ifdef RATE_CONTROL_HT_STUPID_DEBUG
            if(index != i)
                printk("HT--4 mr->cur_tp[%d]cur_tp2[%d]\n",mr->cur_tp,cur_tp2);
#endif
            if (mr->cur_tp > cur_tp2) {
                mg->max_tp_rate2 = index;
                cur_tp2 = mr->cur_tp;
            }
        }
    }
    mi->sample_count = SAMPLE_COUNT;
#if 0
    cur_prob = 0;
    cur_prob_tp = 0;
    cur_tp = 0;
    cur_tp2 = 0;
    {
        mg = &mi->groups;
        mr = minstrel_get_ratestats(mi, mg->max_prob_rate);
        if (cur_prob_tp < mr->cur_tp) {
            mi->max_prob_rate = mg->max_prob_rate;
            cur_prob = mr->cur_prob;
            cur_prob_tp = mr->cur_tp;
        }
        mr = minstrel_get_ratestats(mi, mg->max_tp_rate);
        if (cur_tp < mr->cur_tp) {
            mi->max_tp_rate2 = mi->max_tp_rate;
            cur_tp2 = cur_tp;
            mi->max_tp_rate = mg->max_tp_rate;
            cur_tp = mr->cur_tp;
        }
        mr = minstrel_get_ratestats(mi, mg->max_tp_rate2);
        if (cur_tp2 < mr->cur_tp) {
            mi->max_tp_rate2 = mg->max_tp_rate2;
            cur_tp2 = mr->cur_tp;
        }
    }
#else
    mi->max_tp_rate = mg->max_tp_rate;
    mi->max_tp_rate2 = mg->max_tp_rate2;
    mi->max_prob_rate = mg->max_prob_rate;
#endif
#ifdef RATE_CONTROL_HT_STUPID_DEBUG
        printk("HT sample result max_tp_rate[%d]max_tp_rate2[%d]max_prob_rate[%d]\n",mi->max_tp_rate,mi->max_tp_rate2,mi->max_prob_rate);
#endif
    mi->stats_update = jiffies;
}
#if 0
static void minstrel_calc_retransmit(struct ssv62xx_ht *mi,int index, struct ssv_sta_rc_info *rc_sta)
{
    struct minstrel_rate_stats *mr;
    const struct mcs_group *group;
    unsigned int tx_time, tx_time_rtscts, tx_time_data;
    unsigned int cw = HT_CW_MIN;
    unsigned int cw_max = 1023;
    unsigned int ctime = 0;
    unsigned int t_slot = 9;
    unsigned int ampdu_len = MINSTREL_TRUNC(mi->avg_ampdu_len);
    unsigned int group_id;
    if(rc_sta->ht_rc_type == RC_TYPE_HT_LGI_20)
        group_id = 0;
    else
        group_id = 1;
    mr = minstrel_get_ratestats(mi, index);
    if (mr->probability < MINSTREL_FRAC(1, 10)) {
        mr->retry_count = 1;
        mr->retry_count_rtscts = 1;
        return;
    }
    mr->retry_count = 2;
    mr->retry_count_rtscts = 2;
    mr->retry_updated = true;
    group = &minstrel_mcs_groups_ssv[group_id];
    tx_time_data = group->duration[index % MCS_GROUP_RATES] * ampdu_len;
    ctime = (t_slot * cw) >> 1;
    cw = min((cw << 1) | 1, cw_max);
    ctime += (t_slot * cw) >> 1;
    cw = min((cw << 1) | 1, cw_max);
    tx_time = ctime + 2 * (mi->overhead + tx_time_data);
    tx_time_rtscts = ctime + 2 * (mi->overhead_rtscts + tx_time_data);
    do {
        ctime = (t_slot * cw) >> 1;
        cw = min((cw << 1) | 1, cw_max);
        tx_time += ctime + mi->overhead + tx_time_data;
        tx_time_rtscts += ctime + mi->overhead_rtscts + tx_time_data;
        if (tx_time_rtscts < HT_SEGMENT_SIZE)
            mr->retry_count_rtscts++;
    } while ((tx_time < HT_SEGMENT_SIZE) &&
             (++mr->retry_count < HW_MAX_RATE_TRIES));
}
#endif
static void minstrel_ht_set_rate(struct ssv62xx_ht *mi,
                     struct fw_rc_retry_params *rate, int index,
                     bool sample, bool rtscts, struct ssv_sta_rc_info *rc_sta,
                     struct ssv_rate_ctrl *ssv_rc)
{
    struct minstrel_rate_stats *mr;
    mr = minstrel_get_ratestats(mi, index);
#if 0
    if (!mr->retry_updated)
        minstrel_calc_retransmit(mi, index, rc_sta);
    if (sample)
        rate->count = 1;
    else if (mr->probability < MINSTREL_FRAC(20, 100))
        rate->count = 2;
    else if (rtscts)
        rate->count = mr->retry_count_rtscts;
    else
        rate->count = mr->retry_count;
#endif
    rate->drate = ssv_rc->rc_table[mr->rc_index].hw_rate_idx;
    rate->crate = ssv_rc->rc_table[mr->rc_index].ctrl_rate_idx;
}
static inline int minstrel_get_duration(int index, struct ssv_sta_rc_info *rc_sta)
{
    unsigned int group_id;
    const struct mcs_group *group;
    if(rc_sta->ht_rc_type == RC_TYPE_HT_LGI_20)
        group_id = 0;
    else
        group_id = 1;
    group = &minstrel_mcs_groups_ssv[group_id];
    return group->duration[index % MCS_GROUP_RATES];
}
static void minstrel_next_sample_idx(struct ssv62xx_ht *mi)
{
    struct minstrel_mcs_group_data *mg;
    for (;;) {
        mg = &mi->groups;
        if (++mg->index >= MCS_GROUP_RATES) {
            mg->index = 0;
            if (++mg->column >= ARRAY_SIZE(sample_table))
                mg->column = 0;
        }
        break;
    }
}
static int minstrel_get_sample_rate(struct ssv62xx_ht *mi, struct ssv_sta_rc_info *rc_sta)
{
    struct minstrel_rate_stats *mr;
    struct minstrel_mcs_group_data *mg;
    int sample_idx = 0;
    if (mi->sample_wait > 0) {
        mi->sample_wait--;
        return -1;
    }
    if (!mi->sample_tries)
        return -1;
    mi->sample_tries--;
    mg = &mi->groups;
    sample_idx = sample_table[mg->column][mg->index];
    mr = &mg->rates[sample_idx];
    minstrel_next_sample_idx(mi);
    if (minstrel_get_duration(sample_idx, rc_sta) >
        minstrel_get_duration(mi->max_tp_rate, rc_sta)) {
        if (mr->sample_skipped < 20)
        {
            return -1;
        }
        if (mi->sample_slow++ > 2)
        {
            return -1;
        }
    }
    return sample_idx;
}
static void _fill_txinfo_rates (struct ssv_rate_ctrl *ssv_rc, struct sk_buff *skb, struct fw_rc_retry_params *ar)
{
    struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
    info->control.rates[0].idx = ssv_rc->rc_table[ar[0].drate].dot11_rate_idx;
    info->control.rates[0].count = 1;
    info->control.rates[SSV_DRATE_IDX].count = ar[0].drate;
    info->control.rates[SSV_CRATE_IDX].count = ar[0].crate;
}
extern const u16 ssv6xxx_rc_rate_set[RC_TYPE_MAX][13];
s32 ssv62xx_ht_rate_update(struct sk_buff *skb, struct ssv_softc *sc, struct fw_rc_retry_params *ar)
{
    struct ssv_rate_ctrl *ssv_rc = sc->rc;
    struct SKB_info_st *skb_info = (struct SKB_info_st *)skb->head;
    struct ieee80211_sta *sta = skb_info->sta;
    struct ssv62xx_ht *mi = NULL;
    int sample_idx;
    bool sample = false;
    struct ssv_sta_rc_info *rc_sta;
    struct ssv_sta_priv_data *sta_priv;
    struct rc_pid_sta_info *spinfo;
    int ret = 0;
    if (sc->sc_flags & SC_OP_FIXED_RATE)
    {
        ar[0].count = 3;
        ar[0].drate = ssv_rc->rc_table[sc->max_rate_idx].hw_rate_idx;
        ar[0].crate = ssv_rc->rc_table[sc->max_rate_idx].ctrl_rate_idx;
        ar[1].count = 2;
        ar[1].drate = ssv_rc->rc_table[sc->max_rate_idx].hw_rate_idx;
        ar[1].crate = ssv_rc->rc_table[sc->max_rate_idx].ctrl_rate_idx;
        ar[2].count = 2;
        ar[2].drate = ssv_rc->rc_table[sc->max_rate_idx].hw_rate_idx;
        ar[2].crate = ssv_rc->rc_table[sc->max_rate_idx].ctrl_rate_idx;
        _fill_txinfo_rates(ssv_rc, skb, ar);
        return ssv_rc->rc_table[sc->max_rate_idx].hw_rate_idx;
    }
    if(sta == NULL)
    {
        printk("@Q@...station NULL\n");
        BUG_ON(1);
    }
    sta_priv = (struct ssv_sta_priv_data *)sta->drv_priv;
    rc_sta = &ssv_rc->sta_rc_info[sta_priv->rc_idx];
    spinfo= &rc_sta->spinfo;
    if ((rc_sta->rc_wsid >= SSV_RC_MAX_HARDWARE_SUPPORT) || (rc_sta->rc_wsid < 0))
    {
        struct ssv_sta_priv_data *ssv_sta_priv;
        int rateidx=99;
        ssv_sta_priv = (struct ssv_sta_priv_data *)sta->drv_priv;
        {
            if ((rc_sta->ht_rc_type >= RC_TYPE_HT_SGI_20) &&
                (ssv_sta_priv->rx_data_rate < SSV62XX_RATE_MCS_INDEX))
            {
                if(ssv6xxx_rc_rate_set[rc_sta->ht_rc_type][0] == 12)
                    rateidx = (int)rc_sta->pinfo.rinfo[4].rc_index;
                else
                    rateidx = (int)rc_sta->pinfo.rinfo[0].rc_index;
        #if 0
                printk("RC %d rx %d tx %d\n", ssv_sta_priv->sta_idx,
                       ssv_sta_priv->rx_data_rate, rateidx);
        #endif
            }
            else
            {
                rateidx = (int)ssv_sta_priv->rx_data_rate;
                rateidx -= SSV62XX_RATE_MCS_INDEX;
                rateidx %= 8;
                if(rc_sta->ht_rc_type == RC_TYPE_HT_SGI_20)
                    rateidx += SSV62XX_RATE_MCS_SGI_INDEX;
                else if(rc_sta->ht_rc_type == RC_TYPE_HT_LGI_20)
                    rateidx += SSV62XX_RATE_MCS_LGI_INDEX;
                else
                    rateidx += SSV62XX_RATE_MCS_GREENFIELD_INDEX;
            }
        }
        ar[0].count = 3;
        ar[2].drate = ar[1].drate = ar[0].drate = ssv_rc->rc_table[rateidx].hw_rate_idx;
        ar[2].crate = ar[1].crate = ar[0].crate = ssv_rc->rc_table[rateidx].ctrl_rate_idx;
        ar[1].count = 2;
        ar[2].count = 2;
        _fill_txinfo_rates(ssv_rc, skb, ar);
        return rateidx;
    }
    mi = &rc_sta->ht;
    sample_idx = minstrel_get_sample_rate(mi, rc_sta);
    if (sample_idx >= 0) {
        sample = true;
        minstrel_ht_set_rate(mi, &ar[0], sample_idx,
            true, false, rc_sta, ssv_rc);
    } else {
        minstrel_ht_set_rate(mi, &ar[0], mi->max_tp_rate,
            false, false, rc_sta, ssv_rc);
    }
    ar[0].count = mi->first_try_count;
    ret = ar[0].drate;
    {
        if (sample_idx >= 0)
            minstrel_ht_set_rate(mi, &ar[1], mi->max_tp_rate,
                false, false, rc_sta, ssv_rc);
        else
            minstrel_ht_set_rate(mi, &ar[1], mi->max_tp_rate2,
                false, true, rc_sta, ssv_rc);
        ar[1].count = mi->second_try_count;
        if(ret > ar[1].drate)
            ret = ar[1].drate;
        minstrel_ht_set_rate(mi, &ar[2], mi->max_prob_rate,
                     false, !sample, rc_sta, ssv_rc);
        ar[2].count = mi->other_try_count;
        if(ret > ar[2].drate)
            ret = ar[2].drate;
    }
    mi->total_packets++;
    if (mi->total_packets == ~0) {
        mi->total_packets = 0;
        mi->sample_packets = 0;
    }
    if(spinfo->real_hw_index < SSV62XX_RATE_MCS_INDEX)
        return spinfo->real_hw_index;
    _fill_txinfo_rates(ssv_rc, skb, ar);
    return ret;
}
static void init_sample_table(void)
{
    int col, i, new_idx;
    u8 rnd[MCS_GROUP_RATES];
    memset(sample_table, 0xff, sizeof(sample_table));
    for (col = 0; col < SAMPLE_COLUMNS; col++) {
        for (i = 0; i < MCS_GROUP_RATES; i++) {
            get_random_bytes(rnd, sizeof(rnd));
            new_idx = (i + rnd[i]) % MCS_GROUP_RATES;
            while (sample_table[col][new_idx] != 0xff)
                new_idx = (new_idx + 1) % MCS_GROUP_RATES;
            sample_table[col][new_idx] = i;
        }
    }
}
void ssv62xx_ht_rc_caps(const u16 ssv6xxx_rc_rate_set[RC_TYPE_MAX][13],struct ssv_sta_rc_info *rc_sta)
{
    struct ssv62xx_ht *mi = &rc_sta->ht;
    int ack_dur;
    int i;
#if 1
    unsigned int group_id;
    if(rc_sta->ht_rc_type == RC_TYPE_HT_LGI_20)
        group_id = 0;
    else
        group_id = 1;
    for (i = 0; i < MCS_GROUP_RATES; i++) {
            printk("[RC]HT duration[%d][%d]\n",i,minstrel_mcs_groups_ssv[group_id].duration[i]);
    }
#endif
    init_sample_table();
    memset(mi, 0, sizeof(*mi));
    mi->stats_update = jiffies;
    ack_dur = pide_frame_duration( 10, 60, 0, 0);
    mi->overhead = pide_frame_duration( 0, 60, 0, 0) + ack_dur;
    mi->overhead_rtscts = mi->overhead + 2 * ack_dur;
    mi->avg_ampdu_len = MINSTREL_FRAC(1, 1);
    mi->sample_count = 16;
    mi->sample_wait = 0;
    mi->sample_tries = 4;
#ifdef DISABLE_RATE_CONTROL_SAMPLE
    mi->max_tp_rate = MCS_GROUP_RATES - 1;
    mi->max_tp_rate2 = MCS_GROUP_RATES - 1;
    mi->max_prob_rate = MCS_GROUP_RATES - 1;
#endif
#if (HW_MAX_RATE_TRIES == 7)
    {
        mi->first_try_count = 3;
        mi->second_try_count = 2;
        mi->other_try_count = 2;
    }
#else
    {
        mi->first_try_count = 2;
        mi->second_try_count = 1;
        mi->other_try_count = 1;
    }
#endif
    for (i = 0; i < MCS_GROUP_RATES; i++) {
        mi->groups.rates[i].rc_index = ssv6xxx_rc_rate_set[rc_sta->ht_rc_type][i+1];
    }
}
static bool minstrel_ht_txstat_valid(struct ssv62xx_tx_rate *rate)
{
    if (!rate->count)
        return false;
    if (rate->data_rate < 0)
        return false;
    return true;
}
void ssv6xxx_ht_report_handler(struct ssv_softc *sc,struct sk_buff *skb,struct ssv_sta_rc_info *rc_sta)
{
    struct cfg_host_event *host_event;
    struct firmware_rate_control_report_data *report_data;
    struct ssv62xx_ht *mi;
    struct minstrel_rate_stats *rate;
    bool last = false;
    int i = 0;
    u16 report_ampdu_packets = 0;
    unsigned long period;
    host_event = (struct cfg_host_event *)skb->data;
    report_data = (struct firmware_rate_control_report_data *)&host_event->dat[0];
    if(host_event->h_event == SOC_EVT_RC_AMPDU_REPORT) {
#if 0
        printk("SC HT AMPDU wsid[%d]ampdu_len[%d]ampdu_ack_len[%d]\n",report_data->wsid,report_data->ampdu_len,report_data->ampdu_ack_len);
        for (i = 0; i < SSV62XX_TX_MAX_RATES ; i++) {
            if(report_data->rates[i].data_rate == -1)
                break;
            if(report_data->rates[i].count == 0) {
                    printk("*********************************\n");
                    printk("       Illegal HT report         \n");
                    printk("*********************************\n");
            }
            printk("        i=[%d] rate[%d] count[%d]\n",i,report_data->rates[i].data_rate,report_data->rates[i].count);
        }
#endif
        report_ampdu_packets = 1;
    }
    else if(host_event->h_event == SOC_EVT_RC_MPDU_REPORT) {
        report_data->ampdu_len = 1;
        report_ampdu_packets = report_data->ampdu_len;
#if 0
        printk("SC MPDU wsid[%d]ampdu_len[%d]ampdu_ack_len[%d]\n",report_data->wsid,report_data->ampdu_len,report_data->ampdu_ack_len);
        for (i = 0; i < SSV62XX_TX_MAX_RATES ; i++) {
            if(report_data->rates[i].data_rate == -1)
                break;
            if(report_data->rates[i].count == 0) {
                    printk("*********************************\n");
                    printk("       Illegal MPDU report       \n");
                    printk("*********************************\n");
            }
            printk("        i=[%d] rate[%d] count[%d]\n",i,report_data->rates[i].data_rate,report_data->rates[i].count);
        }
#endif
    }
    else
    {
        printk("RC work get garbage!!\n");
        return;
    }
    mi = &rc_sta->ht;
    mi->ampdu_packets += report_ampdu_packets;
    mi->ampdu_len += report_data->ampdu_len;
    if (!mi->sample_wait && !mi->sample_tries && mi->sample_count > 0) {
        mi->sample_wait = 16 + 2 * MINSTREL_TRUNC(mi->avg_ampdu_len);
        mi->sample_tries = 2;
        mi->sample_count--;
    }
    for (i = 0; !last; i++) {
        last = (i == SSV62XX_TX_MAX_RATES - 1) ||
               !minstrel_ht_txstat_valid(&report_data->rates[i+1]);
        if (!minstrel_ht_txstat_valid(&report_data->rates[i]))
            break;
#ifdef RATE_CONTROL_DEBUG
        if((report_data->rates[i].data_rate < SSV62XX_RATE_MCS_INDEX) || (report_data->rates[i].data_rate >= SSV62XX_RATE_MCS_GREENFIELD_INDEX)) {
            printk("[RC]ssv6xxx_ht_report_handler get error report rate[%d]\n",report_data->rates[i].data_rate);
            break;
        }
#endif
        rate = &mi->groups.rates[(report_data->rates[i].data_rate - SSV62XX_RATE_MCS_INDEX) % MCS_GROUP_RATES];
        if (last)
            rate->success += report_data->ampdu_ack_len;
        rate->attempts += report_data->rates[i].count * report_data->ampdu_len;
    }
#if 0
    rate = minstrel_get_ratestats(mi, mi->max_tp_rate);
    if (rate->attempts > 30 &&
        MINSTREL_FRAC(rate->success, rate->attempts) <
        MINSTREL_FRAC(20, 100))
        minstrel_downgrade_rate(mi, &mi->max_tp_rate, true);
    rate2 = minstrel_get_ratestats(mi, mi->max_tp_rate2);
    if (rate2->attempts > 30 &&
        MINSTREL_FRAC(rate2->success, rate2->attempts) <
        MINSTREL_FRAC(20, 100))
        minstrel_downgrade_rate(mi, &mi->max_tp_rate2, false);
#endif
    period = msecs_to_jiffies(SSV_RC_HT_INTERVAL/2);
    if (time_after(jiffies, mi->stats_update + period)) {
        rate_control_ht_sample(mi,rc_sta);
    }
#if 0
    period = msecs_to_jiffies(HT_RC_UPDATE_INTERVAL);
    if (time_after(jiffies, mi->stats_update + period)) {
        struct rc_pid_sta_info *spinfo;
        spinfo = &rc_sta->spinfo;
#if 1
        printk("AMPDU rate update time!!\n");
#endif
        if(rc_sta->rc_num_rate == 12)
        {
            if(spinfo->txrate_idx >= 4)
                rc_sta->ht.max_tp_rate = spinfo->txrate_idx - 4;
            else
                rc_sta->ht.max_tp_rate = 0;
        }
        else
            rc_sta->ht.max_tp_rate = spinfo->txrate_idx;
        mi->stats_update = jiffies;
    }
#endif
}