/*
 * Copyright (c) 2007-2008 Atheros Communications Inc.
 *
 * Permission to use, copy, modify, and/or distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include "cprecomp.h"
#include "ratectrl.h"

const u32_t zcRateToPhyCtrl[] =
    {
        /* 1M,        2M,         5M,        11M ,  0  1  2  3*/
        0x00000,    0x10000,    0x20000,    0x30000,
        /* 6M         9M          12M        18M ,  4  5  6  7*/
        0xb0001,    0xf0001,    0xa0001,    0xe0001,
        /* 24M         36M        48M        54M ,  8  9  10 11*/
        0x90001,    0xd0001,    0x80001,    0xc0001,
        /* MCS0      MCS1        MCS2        MCS3,  12 13 14 15*/
        0x00002,    0x10002,    0x20002,    0x30002,
        /* MCS4      MCS5        MCS6        MCS7,  16 17 18 19*/
        0x40002,    0x50002,    0x60002,    0x70002,
        /* MCS8      MCS9        MCS10       MCS11, 20 21 22 23*/
        0x80002,    0x90002,    0xa0002,    0xb0002,
        /* MCS12     MCS13       MCS14       MCS15, 24 25 26 27*/
        0xc0002,    0xd0002,    0xe0002,    0xf0002,
        /* MCS14SG,  MCS15SG     MCS7SG           , 28 29, 30*/
        0x800e0002, 0x800f0002, 0x80070002
    };


const u8_t zcHtRateTable[15][4] =
    { /*[5G 20MHz]  [5G 40MHz] [2.4G 20MHz]  [2.4G 40MHz]*/
        {  4,          4,          0,          0},   /*OFDM6M OFDM6M  CCK1M  CCK1M  */
        {  5,          5,          1,          1},   /*OFDM9M OFDM9M  CCK2M  CCK2M  */
        {  13,         12,         2,          2},   /*MCS1   MCS0    CCK5M  CCK5M  */
        {  14,         13,         3,          3},   /*MCS2   MCS1    CCK11M CCK11M */
        {  15,         14,         13,         12},  /*MCS3   MCS2    MCS1   MCS0   */
        {  16,         15,         14,         13},  /*MCS4   MCS3    MCS2   MCS1   */
        {  23,         16,         15,         14},  /*MCS11  MCS4    MCS3   MCS2   */
        {  24,         23,         16,         15},  /*MCS12  MCS11   MCS4   MCS3   */
        {  25,         24,         23,         16},  /*MCS13  MCS12   MCS11  MCS4   */
        {  26,         25,         24,         23},  /*MCS14  MCS13   MCS12  MCS11  */
        {  27,         26,         25,         24},  /*MCS15  MCS14   MCS13  MCS12  */
        {  0,          27,         26,         25},  /*0      MCS15   MCS14  MCS13  */
        {  0,          29,         27,         26},  /*0      MCS15SG MCS15  MCS14  */
        {  0,          0,          0,          28},  /*0      0       0      MCS14SG*/
        {  0,          0,          0,          29}   /*0      0       0      MCS15SG*/
    };

const u8_t zcHtOneTxStreamRateTable[15][4] =
    { /*[5G 20MHz]  [5G 40MHz] [2.4G 20MHz]  [2.4G 40MHz]*/
        {  4,          4,          0,          0},   /*OFDM6M OFDM6M  CCK1M  CCK1M  */
        {  5,          5,          1,          1},   /*OFDM9M OFDM9M  CCK2M  CCK2M  */
        {  13,         12,         2,          2},   /*MCS1   MCS0    CCK5M  CCK5M  */
        {  14,         13,         3,          3},   /*MCS2   MCS1    CCK11M CCK11M */
        {  15,         14,         13,         12},  /*MCS3   MCS2    MCS1   MCS0   */
        {  16,         15,         14,         13},  /*MCS4   MCS3    MCS2   MCS1   */
        {  17,         16,         15,         14},  /*MCS5   MCS4    MCS3   MCS2   */
        {  18,         17,         16,         15},  /*MCS6   MCS5    MCS4   MCS3   */
        {  19,         18,         17,         16},  /*MCS7   MCS6    MCS5   MCS4   */
        {  0,          19,         18,         17},  /*0      MCS7    MCS6   MCS5   */
        {  0,          30,         19,         18},  /*0      MCS7SG  MCS7   MCS6   */
        {  0,          0,          0,          19},  /*0      0       0      MCS7   */
        {  0,          0,          0,          30},  /*0      0       0      MCS7SG */
        {  0,          0,          0,          0 },  /*0      0       0      0      */
        {  0,          0,          0,          0 }   /*0      0       0      0      */
    };

const u16_t zcRate[] =
    {
        1, 2, 5, 11,                  /* 1M, 2M, 5M, 11M          ,  0  1  2  3*/
        6, 9, 12, 18,                 /* 6M  9M  12M  18M         ,  4  5  6  7*/
        24, 36, 48, 54,               /* 24M  36M  48M  54M       ,  8  9 10 11*/
        13, 27, 40, 54,               /* MCS0 MCS1 MCS2 MCS3      , 12 13 14 15*/
        81, 108, 121, 135,            /* MCS4 MCS5 MCS6 MCS7      , 16 17 18 19*/
        27, 54, 81, 108,              /* MCS8 MCS9 MCS10 MCS11    , 20 21 22 23*/
        162, 216, 243, 270,           /* MCS12 MCS13 MCS14 MCS15  , 24 25 26 27*/
        270, 300, 150                 /* MCS14SG, MCS15SG, MCS7SG , 28 29 30*/
    };

const u16_t PERThreshold[] =
    {
        100, 50, 50, 50,    /* 1M, 2M, 5M, 11M          ,  0  1  2  3*/
        50, 50, 30, 30,     /* 6M  9M  12M  18M         ,  4  5  6  7*/
        25, 25, 25, 20,     /* 24M  36M  48M  54M       ,  8  9 10 11*/
        50, 50, 50, 40,    /* MCS0 MCS1 MCS2 MCS3      , 12 13 14 15*/
        30, 30, 30, 30,    /* MCS4 MCS5 MCS6 MCS7      , 16 17 18 19*/
        30, 30, 25, 25,    /* MCS8 MCS9 MCS10 MCS11    , 20 21 22 23*/
        25, 25, 15, 15,     /* MCS12 MCS13 MCS14 MCS15  , 24 25 26 27*/
        15, 15, 10          /* MCS14SG, MCS15SG         , 28 29*/
    };

const u16_t FailDiff[] =
    {
        40, 46, 40, 0,          /* 1M, 2M, 5M, 11M          ,  0  1  2  3*/
        24, 17, 22, 16,         /* 6M  9M  12M  18M         ,  4  5  6  7*/
        19, 13, 5, 0,           /* 24M  36M  48M  54M       ,  8  9 10 11*/
        36, 22, 15, 19,         /* MCS0 MCS1 MCS2 MCS3      , 12 13 14 15*/
        12, 5, 4, 7,            /* MCS4 MCS5 MCS6 MCS7      , 16 17 18 19*/
        0, 0, 0, 0,             /* MCS8 MCS9 MCS10 MCS11    , 20 21 22 23*/
        9, 4, 3, 3,             /* MCS12 MCS13 MCS14 MCS15  , 24 25 26 27*/
        3, 0, 0                 /* MCS14SG, MCS15SG         , 28 29*/
    };


#ifdef ZM_ENABLE_BA_RATECTRL
u32_t TxMPDU[29];
u32_t BAFail[29];
u32_t BAPER[29];
const u16_t BADiff[] =
    {
        0, 0, 0, 0,
        0, 0, 0, 0,
        0, 0, 0, 0,
        361, 220, 151, 187,
        122, 48, 41, 65,
        0, 0, 0, 0,
        88, 33, 27, 25,
        0
    };
#endif

/************************************************************************/
/*                                                                      */
/*    FUNCTION DESCRIPTION                  zfRateCtrlInitCell          */
/*      Initialize rate control cell.                                   */
/*                                                                      */
/*    INPUTS                                                            */
/*      dev : device pointer                                            */
/*      type : 0=>11b, 1=>11a/g, 2=>11n, 3=>11n one Tx stream           */
/*      gBand : 1=>2.4G, 0=>5G                                          */
/*                                                                      */
/*    OUTPUTS                                                           */
/*      None                                                            */
/*                                                                      */
/*    AUTHOR                                                            */
/*      Stephen Chen        Atheros Communications, INC.    2007.2      */
/*                                                                      */
/************************************************************************/
void zfRateCtrlInitCell(zdev_t* dev, struct zsRcCell* rcCell, u8_t type,
        u8_t gBand, u8_t SG40)
{
    u8_t i;
    u8_t maxrate;
    zmw_get_wlan_dev(dev);

    if (SG40) SG40 = 1;

    if (gBand != 0)
    {
        if (type == 1) //11g
        {
            for (i=0; i<4; i++) //1M 2M 5M 11M
            {
                rcCell->operationRateSet[i] = (u8_t)i;
            }
            for (i=4; i<10; i++) //12M 18M 24M 36M 48M 54M
            {
                rcCell->operationRateSet[i] = 2+i;
            }
            rcCell->operationRateCount = 10;
            rcCell->currentRateIndex = 5; //18M
        }
        else if (type == 2) //11ng
        {
            if (wd->wlanMode == ZM_MODE_AP) //AP 11ng 40M
            {
                for (i=0; i<15; i++)
                {
                    rcCell->operationRateSet[i] = zcHtRateTable[i][3];
                }
                if(!SG40) rcCell->operationRateSet[13] = 27;
                rcCell->operationRateCount = 14+SG40;
                rcCell->currentRateIndex = 10;
            }
            else //STA
            {
                if (wd->sta.htCtrlBandwidth == ZM_BANDWIDTH_40MHZ) //11ng 40M
                {
                    for (i=0; i<15; i++)
                    {
                        rcCell->operationRateSet[i] = zcHtRateTable[i][3];
                    }
                    if(!SG40) rcCell->operationRateSet[13] = 27;
                    rcCell->operationRateCount = 14+SG40;
                    rcCell->currentRateIndex = 10;
                }
                else    //11ng 20M
                {
                    for (i=0; i<13; i++)
                    {
                        rcCell->operationRateSet[i] = zcHtRateTable[i][2];
                    }
                    rcCell->operationRateCount = 13;
                    rcCell->currentRateIndex = 9;
                }
            }
        }
        else if (type == 3) //11ng one Tx stream
        {
                if (wd->sta.htCtrlBandwidth == ZM_BANDWIDTH_40MHZ) //11ng 40M one Tx stream
                {
                    if(SG40 != 0)
                    {
                        maxrate = 13;
                    }
                    else
                    {
                        maxrate = 12;
                    }
                    for (i=0; i<maxrate; i++)
                    {
                        rcCell->operationRateSet[i] = zcHtOneTxStreamRateTable[i][3];
                    }
                    rcCell->operationRateCount = i;
                    rcCell->currentRateIndex = ((i+1)*3)/4;
                }
                else    //11ng 20M
                {
                    for (i=0; i<11; i++)
                    {
                        rcCell->operationRateSet[i] = zcHtOneTxStreamRateTable[i][2];
                    }
                    rcCell->operationRateCount = i;
                    rcCell->currentRateIndex = ((i+1)*3)/4;
                }
        }
        else //if (type == 0) //11b
        {
            for (i=0; i<4; i++)
            {
                rcCell->operationRateSet[i] = (u8_t)i;
            }
            rcCell->operationRateCount = 4;
            rcCell->currentRateIndex = rcCell->operationRateCount-1;
        }
    }
    else
    {
        if (type == 2) //11na
        {
            if (wd->wlanMode == ZM_MODE_AP) //AP 11na 40M
            {
                for (i=0; i<(12+SG40); i++)
                {
                    rcCell->operationRateSet[i] = zcHtRateTable[i][1];
                }
                rcCell->operationRateCount = 12+SG40;
                rcCell->currentRateIndex = 8;
            }
            else //STA
            {
                if (wd->sta.htCtrlBandwidth == ZM_BANDWIDTH_40MHZ) //11na 40M
                {
                    for (i=0; i<(12+SG40); i++)
                    {
                        rcCell->operationRateSet[i] = zcHtRateTable[i][1];
                    }
                    rcCell->operationRateCount = 12+SG40;
                    rcCell->currentRateIndex = 8;
                }
                else    //11na 20M
                {
                    for (i=0; i<11; i++)
                    {
                        rcCell->operationRateSet[i] = zcHtRateTable[i][0];
                    }
                    rcCell->operationRateCount = 11;
                    rcCell->currentRateIndex = 7;
                }
            }
        }
        else if (type == 3) //11na one Tx stream
        {
                if (wd->sta.htCtrlBandwidth == ZM_BANDWIDTH_40MHZ) //11na 40M one Tx stream
                {
                    if(SG40 != 0)
                    {
                        maxrate = 11;
                    }
                    else
                    {
                        maxrate = 10;
                    }
                    for (i=0; i<maxrate; i++)
                    {
                        rcCell->operationRateSet[i] = zcHtOneTxStreamRateTable[i][1];
                    }
                    rcCell->operationRateCount = i;
                    rcCell->currentRateIndex = ((i+1)*3)/4;
                }
                else    //11ng 20M
                {
                    for (i=0; i<9; i++)
                    {
                        rcCell->operationRateSet[i] = zcHtOneTxStreamRateTable[i][0];
                    }
                    rcCell->operationRateCount = i;
                    rcCell->currentRateIndex = ((i+1)*3)/4;
                }
        }
        else //if (type == 1) //11a
        {
            for (i=0; i<8; i++) //6M 9M 12M 18M 24M 36M 48M 54M
            {
                rcCell->operationRateSet[i] = i+4;
            }
            rcCell->operationRateCount = 8;
            rcCell->currentRateIndex = 4;  //24M
        }
    }

    rcCell->flag = 0;
    rcCell->txCount = 0;
    rcCell->failCount = 0;
    rcCell->currentRate = rcCell->operationRateSet[rcCell->currentRateIndex];
    rcCell->lasttxCount = 0;
    rcCell->lastTime    = wd->tick;
    rcCell->probingTime = wd->tick;
    for (i=0; i<ZM_RATE_TABLE_SIZE; i++) {
        wd->PER[i] = 0;
        wd->txMPDU[i] = wd->txFail[i] = 0;
    }
    wd->probeCount = 0;
    wd->probeInterval = 0;
#ifdef ZM_ENABLE_BA_RATECTRL
    for (i=0; i<29; i++) {
        TxMPDU[i]=0;
        BAFail[i]=0;
        BAPER[i]=0;
    }
#endif
    return;
}


/************************************************************************/
/*                                                                      */
/*    FUNCTION DESCRIPTION                  zfRateCtrlGetHigherRate     */
/*      Get a higher rate.                                              */
/*                                                                      */
/*    INPUTS                                                            */
/*      rcCell : rate control cell                                      */
/*                                                                      */
/*    OUTPUTS                                                           */
/*      rate                                                            */
/*                                                                      */
/*    AUTHOR                                                            */
/*      Stephen Chen        Atheros Communications, INC.    2007.2      */
/*                                                                      */
/************************************************************************/
u8_t zfRateCtrlGetHigherRate(struct zsRcCell* rcCell)
{
    u8_t rateIndex;

    rateIndex = rcCell->currentRateIndex
            + (((rcCell->currentRateIndex+1) < rcCell->operationRateCount)?1:0);
    return rcCell->operationRateSet[rateIndex];
}


/************************************************************************/
/*                                                                      */
/*    FUNCTION DESCRIPTION                  zfRateCtrlNextLowerRate     */
/*      Get a lower rate.                                               */
/*                                                                      */
/*    INPUTS                                                            */
/*      rcCell : rate control cell                                      */
/*                                                                      */
/*    OUTPUTS                                                           */
/*      rate                                                            */
/*                                                                      */
/*    AUTHOR                                                            */
/*      Stephen Chen        Atheros Communications, INC.    2007.2      */
/*                                                                      */
/************************************************************************/
u8_t zfRateCtrlNextLowerRate(zdev_t* dev, struct zsRcCell* rcCell)
{
    zmw_get_wlan_dev(dev);
    if (rcCell->currentRateIndex > 0)
    {
        rcCell->currentRateIndex--;
        rcCell->currentRate = rcCell->operationRateSet[rcCell->currentRateIndex];
    }
    zm_msg1_tx(ZM_LV_0, "Lower Tx Rate=", rcCell->currentRate);
    //DbgPrint("Lower Tx Rate=%d", rcCell->currentRate);
    rcCell->failCount = rcCell->txCount = 0;
    rcCell->lasttxCount = 0;
    rcCell->lastTime  = wd->tick;
    return rcCell->currentRate;
}


/************************************************************************/
/*                                                                      */
/*    FUNCTION DESCRIPTION                  zfRateCtrlRateDiff          */
/*      Rate difference.                                                */
/*                                                                      */
/*    INPUTS                                                            */
/*      rcCell : rate control cell                                      */
/*      retryRate : retry rate                                          */
/*                                                                      */
/*    OUTPUTS                                                           */
/*      rate difference                                                 */
/*                                                                      */
/*    AUTHOR                                                            */
/*      Stephen Chen        Atheros Communications, INC.    2007.2      */
/*                                                                      */
/************************************************************************/
u8_t zfRateCtrlRateDiff(struct zsRcCell* rcCell, u8_t retryRate)
{
    u16_t i;

    /* Find retryRate in operationRateSet[] */
    for (i=0; i<rcCell->operationRateCount; i++)
    {
        if (retryRate == rcCell->operationRateSet[i])
        {
            if (i < rcCell->currentRateIndex)
            {
                return ((rcCell->currentRateIndex - i)+1)>>1;
            }
            else if (i == rcCell->currentRateIndex == 0)
            {
                return 1;
            }
            else
            {
                return 0;
            }
        }
    }
    /* TODO : retry rate not in operation rate set */
    zm_msg1_tx(ZM_LV_0, "Not in operation rate set:", retryRate);
    return 1;

}

u32_t zfRateCtrlUDPTP(zdev_t* dev, u16_t Rate, u32_t PER) {
    if ((PER < 100) && (Rate > 0) && PER)
        return 1168000/(((12304/Rate)+197)*(100+100*PER/(100-PER)));
    else
        return 0;
}

u8_t zfRateCtrlFindMaxUDPTP(zdev_t* dev, struct zsRcCell* rcCell) {
    u8_t i, maxIndex=0, rateIndex;
    u32_t max=0, UDPThroughput;

    zmw_get_wlan_dev(dev);

    rateIndex = zm_agg_min(rcCell->currentRateIndex+3, rcCell->operationRateCount-1);
    for (i=rcCell->currentRateIndex; i < rateIndex; i++) {
        UDPThroughput = zfRateCtrlUDPTP(dev, zcRate[rcCell->operationRateSet[i]],
            wd->PER[rcCell->operationRateSet[i]]);
        if (max < UDPThroughput) {
            max = UDPThroughput;
            maxIndex = i;
        }
    }

    return rcCell->operationRateSet[maxIndex];
}
/************************************************************************/
/*                                                                      */
/*    FUNCTION DESCRIPTION                  zfRateCtrlGetTxRate         */
/*      Get transmission rate.                                          */
/*                                                                      */
/*    INPUTS                                                            */
/*      dev : device pointer                                            */
/*      rcCell : rate control cell                                      */
/*      probing : rate probing flag                                     */
/*                                                                      */
/*    OUTPUTS                                                           */
/*      Tx rate                                                         */
/*                                                                      */
/*    AUTHOR                                                            */
/*      Stephen Chen        Atheros Communications, INC.    2007.2      */
/*                                                                      */
/************************************************************************/
u16_t zfRateCtrlGetTxRate(zdev_t* dev, struct zsRcCell* rcCell, u16_t* probing)
{
    u8_t newRate, highRate;
    zmw_get_wlan_dev(dev);

    zm_msg1_tx(ZM_LV_3, "txCount=", rcCell->txCount);
    zm_msg1_tx(ZM_LV_3, "probingTime=", rcCell->probingTime);
    zm_msg1_tx(ZM_LV_3, "tick=", wd->tick);
    *probing = 0;
    newRate = rcCell->currentRate;

    if (wd->probeCount && (wd->probeCount < wd->success_probing))
    {
        if (wd->probeInterval < 50)
        {
            wd->probeInterval++;
        }
        else
        {
            wd->probeInterval++;
            if (wd->probeInterval > 52) //probe 51, 52, 53 three packets every 50 packets
            {
                wd->probeInterval = 0;
            }
            newRate=zfRateCtrlGetHigherRate(rcCell);
            *probing = 1;
            wd->probeCount++;
            rcCell->probingTime = wd->tick;
        }
    }
    /* Accumulate at least 1000ms and 8 packets or Accumulate over 1K packets */
    else if ((((wd->tick - rcCell->probingTime) > (ZM_RATE_CTRL_PROBING_INTERVAL_MS/ZM_MS_PER_TICK))
                && (rcCell->txCount >= ZM_RATE_CTRL_MIN_PROBING_PACKET))
        || (rcCell->txCount >= 1000))
    {
#ifndef ZM_DISABLE_RATE_CTRL
        /* PER = fail/total */
        wd->probeCount = 0;
        wd->probeSuccessCount = 0;
        if (wd->txMPDU[rcCell->currentRate] != 0) {
            wd->PER[rcCell->currentRate] = zm_agg_min(100,
                (wd->txFail[rcCell->currentRate]*100)/wd->txMPDU[rcCell->currentRate]);
            if (!wd->PER[rcCell->currentRate]) wd->PER[rcCell->currentRate] ++;
        }

        /* if PER < threshold, do rate probing, return probing rate */
        if ((wd->PER[rcCell->currentRate] <= (ZM_RATE_PROBING_THRESHOLD+15)) ||
            ((rcCell->currentRate <= 16) &&
            ((wd->PER[rcCell->currentRate]/2) <= ZM_RATE_PROBING_THRESHOLD)))
        {
            newRate = zfRateCtrlGetHigherRate(rcCell);
            if (newRate != rcCell->currentRate)
            {
                *probing = 1;
                wd->probeCount++;
                wd->probeInterval = 0;
                wd->success_probing =
                    (rcCell->currentRate <= 16)? (ZM_RATE_SUCCESS_PROBING/2) : ZM_RATE_SUCCESS_PROBING;
                //DbgPrint("Start Probing");
                zm_msg1_tx(ZM_LV_0, "Probing Rate=", newRate);
            }
        }
#endif

        zm_msg0_tx(ZM_LV_1, "Diminish counter");
        rcCell->failCount = rcCell->failCount>>1;
        rcCell->txCount = rcCell->txCount>>1;
        wd->txFail[rcCell->currentRate] = wd->txFail[rcCell->currentRate] >> 1;
        wd->txMPDU[rcCell->currentRate] = wd->txMPDU[rcCell->currentRate] >> 1;


        if (rcCell->currentRate > 15) {
            highRate = zfRateCtrlGetHigherRate(rcCell);
            if ((highRate != rcCell->currentRate) && wd->PER[highRate] &&
                ((wd->PER[rcCell->currentRate] + FailDiff[rcCell->currentRate]) >
                wd->PER[highRate])) {
                //DbgPrint("PER compare force raise rate to %d", highRate);
                wd->probeSuccessCount = wd->probeCount = ZM_RATE_SUCCESS_PROBING;
                zfRateCtrlTxSuccessEvent(dev, rcCell, highRate);
            }
        }
        else {
            highRate = zfRateCtrlFindMaxUDPTP(dev, rcCell);
            if (rcCell->currentRate < highRate) {
                //DbgPrint("UDP Throughput compare force raise rate to %d", highRate);
                wd->probeSuccessCount = wd->probeCount = ZM_RATE_SUCCESS_PROBING;
                zfRateCtrlTxSuccessEvent(dev, rcCell, highRate);
            }
        }
        rcCell->probingTime = wd->tick;
    }

    if( (wd->tick > 1000)
        && ((wd->tick - rcCell->lastTime) > 3840) )
    {
        if (rcCell->lasttxCount < 70)
        {
            rcCell->failCount = rcCell->failCount>>1;
            rcCell->txCount = rcCell->txCount>>1;
            wd->txFail[rcCell->currentRate] = wd->txFail[rcCell->currentRate] >> 1;
            wd->txMPDU[rcCell->currentRate] = wd->txMPDU[rcCell->currentRate] >> 1;

            rcCell->failCount = (rcCell->failCount < rcCell->txCount)?
                                rcCell->failCount : rcCell->txCount;
            wd->txFail[rcCell->currentRate] = (wd->txFail[rcCell->currentRate] < wd->txMPDU[rcCell->currentRate])?
                                              wd->txFail[rcCell->currentRate] : wd->txMPDU[rcCell->currentRate];
        }

        rcCell->lastTime    = wd->tick;
        rcCell->lasttxCount = 0;
    }

    rcCell->txCount++;
    rcCell->lasttxCount++;
    wd->txMPDU[rcCell->currentRate]++;
    zm_msg1_tx(ZM_LV_1, "Get Tx Rate=", newRate);
    return newRate;
}


/************************************************************************/
/*                                                                      */
/*    FUNCTION DESCRIPTION                  zfRateCtrlTxFailEvent       */
/*      Tx fail event. Calculate PER and lower Tx rate if under         */
/*      PER under threshold.                                            */
/*                                                                      */
/*    INPUTS                                                            */
/*      rcCell : rate control cell                                      */
/*      retryRate : retry rate                                          */
/*                                                                      */
/*    OUTPUTS                                                           */
/*      None                                                            */
/*                                                                      */
/*    AUTHOR                                                            */
/*      Stephen Chen        Atheros Communications, INC.    2007.2      */
/*                                                                      */
/************************************************************************/
void zfRateCtrlTxFailEvent(zdev_t* dev, struct zsRcCell* rcCell, u8_t aggRate, u32_t retryRate)
{
    zmw_get_wlan_dev(dev);

    zmw_declare_for_critical_section();

#ifndef ZM_DISABLE_RATE_CTRL
    //DbgPrint("aggRate=%d, retryRate=%d", aggRate, retryRate);
    if (aggRate && (aggRate != rcCell->currentRate)) {
        wd->txFail[aggRate] += retryRate;
        return;
    }

    if (!aggRate) {
        retryRate = (zfRateCtrlRateDiff(rcCell, (u8_t)retryRate)+1)>>1;
        if (rcCell->currentRate <12) //legacy rate
        {
            retryRate*=2;
        }
    }
    rcCell->failCount += retryRate;
    wd->txFail[rcCell->currentRate] += retryRate;

    //DbgPrint("failCount=%d", rcCell->failCount);
    if (rcCell->failCount > ZM_MIN_RATE_FAIL_COUNT)
    {
        if (wd->txMPDU[rcCell->currentRate] != 0) {
            wd->PER[rcCell->currentRate] = zm_agg_min(100,
                (wd->txFail[rcCell->currentRate]*100)/wd->txMPDU[rcCell->currentRate]);
            if (!wd->PER[rcCell->currentRate]) wd->PER[rcCell->currentRate] ++;
        }
        //zm_msg1_tx(ZM_LV_1, "PER=", per);
        //DbgPrint("PER=%d, txFail=%d, txMPDU=%d", wd->PER[rcCell->currentRate], wd->txFail[rcCell->currentRate], wd->txMPDU[rcCell->currentRate]);
        if (wd->PER[rcCell->currentRate] > PERThreshold[rcCell->currentRate])
        {
            /* Lower Tx Rate if PER < THRESHOLD */
            zfRateCtrlNextLowerRate(dev, rcCell);
            rcCell->flag |= ZM_RC_TRAINED_BIT;

            // Resolve compatibility problem with Marvell
            if(rcCell->currentRate == 15)
            {
                zmw_leave_critical_section(dev);
                zfHpSetAggPktNum(dev, 8);
                zmw_enter_critical_section(dev);
            }

            wd->txFail[rcCell->currentRate] = wd->txFail[rcCell->currentRate] >> 1;
            wd->txMPDU[rcCell->currentRate] = wd->txMPDU[rcCell->currentRate] >> 1;

            wd->probeCount = wd->probeSuccessCount = 0;
        }
    }

#endif
    return;
}


/************************************************************************/
/*                                                                      */
/*    FUNCTION DESCRIPTION                  zfRateCtrlTxSuccessEvent    */
/*      Tx success event. Raise Tx rate because rate probing success.   */
/*                                                                      */
/*    INPUTS                                                            */
/*      rcCell : rate control cell                                      */
/*      successRate : success rate                                      */
/*                                                                      */
/*    OUTPUTS                                                           */
/*      None                                                            */
/*                                                                      */
/*    AUTHOR                                                            */
/*      Stephen Chen        Atheros Communications, INC.    2007.2      */
/*                                                                      */
/************************************************************************/
void zfRateCtrlTxSuccessEvent(zdev_t* dev, struct zsRcCell* rcCell, u8_t successRate)
{
    /* Raise Tx Rate */
    u16_t i, PERProbe;
    u16_t pcount;
    zmw_get_wlan_dev(dev);

    zmw_declare_for_critical_section();

    //DbgPrint("Probing successRate=%d", successRate);
    /* Find successRate in operationRateSet[] */
    wd->probeSuccessCount++;
    if (wd->probeCount < wd->success_probing)
    {
        return;
    }

    pcount = wd->probeCount;
    if (pcount != 0)
    {
        PERProbe = wd->probeSuccessCount * 100 / pcount;
    }
    else
    {
        PERProbe = 1;
    }

    if (PERProbe < ((rcCell->currentRate < 16)? 80:100))
    {
        return;
    }
    //DbgPrint("wd->probeCount=%d, wd->probeSuccessCount=%d", wd->probeCount, wd->probeSuccessCount);
    wd->probeCount = wd->probeSuccessCount = 0;
    for (i=0; i<rcCell->operationRateCount; i++)
    {
        if (successRate == rcCell->operationRateSet[i])
        {
            if (i > rcCell->currentRateIndex)
            {
                /* Raise current Tx rate */
                zm_msg1_tx(ZM_LV_0, "Raise Tx Rate=", successRate);
                //DbgPrint("Raise Tx Rate=%d", successRate);

                // Resolve compatibility problem with Marvell
                if((rcCell->currentRate <= 15) && (successRate > 15))
                {
                    zmw_leave_critical_section(dev);
                    zfHpSetAggPktNum(dev, 16);
                    zmw_enter_critical_section(dev);
                }

                rcCell->currentRate = successRate;
                rcCell->currentRateIndex = (u8_t)i;
                rcCell->failCount = rcCell->txCount = 0;
                rcCell->lasttxCount = 0;
                rcCell->lastTime  = wd->tick;
                wd->txFail[rcCell->currentRate] = wd->txFail[rcCell->currentRate] >> 1;
                wd->txMPDU[rcCell->currentRate] = wd->txMPDU[rcCell->currentRate] >> 1;
            }
        }
    }

    return;
}


/************************************************************************/
/*                                                                      */
/*    FUNCTION DESCRIPTION                  zfRateCtrlRxRssiEvent       */
/*      Rx RSSI event. Calculate RSSI moving average, accelarate        */
/*      rate probing if RSSI variation over threshold.                  */
/*                                                                      */
/*    INPUTS                                                            */
/*      rcCell : rate control cell                                      */
/*      successRate : success rate                                      */
/*                                                                      */
/*    OUTPUTS                                                           */
/*      None                                                            */
/*                                                                      */
/*    AUTHOR                                                            */
/*      Stephen Chen        Atheros Communications, INC.    2007.2      */
/*                                                                      */
/************************************************************************/
void zfRateCtrlRxRssiEvent(struct zsRcCell* rcCell, u16_t rxRssi)
{
    /* if delta(rcCell->rxRssi, rxRssi) > ZM_RATE_CTRL_RSSI_VARIATION */
    if ((rcCell->rxRssi - rxRssi) > ZM_RATE_CTRL_RSSI_VARIATION)
    {
        /* Accelerate rate probing via decreaing rcCell->probingTime */
        rcCell->probingTime -= ZM_RATE_CTRL_PROBING_INTERVAL_MS/ZM_MS_PER_TICK;
    }

    /* Update RSSI moving average */
    rcCell->rxRssi = (((rcCell->rxRssi*7) + rxRssi)+4) >> 3;
    return;
}


#ifdef ZM_ENABLE_BA_RATECTRL
u8_t HigherRate(u8_t Rate) {
    if (Rate < 28) Rate++; //28=MCS15SG, 27=MCS15, 26=MCS14, 25=MCS13
    if (Rate > 28) Rate = 28;
    while ((Rate >= 20) && (Rate <= 23)) {
        Rate ++;
    }
    return Rate;
}

u8_t LowerRate(u8_t Rate) {
    if (Rate > 1) Rate--;
    while ((Rate >= 20) && (Rate <= 23)) {
        Rate --;
    }
    return Rate;
}

u8_t RateMapToRateIndex(u8_t Rate, struct zsRcCell* rcCell) {
    u8_t i;
    for (i=0; i<rcCell->operationRateCount; i++) {
        if (Rate == rcCell->operationRateSet[i]) {
            return i;
        }
    }
    return 0;
}

void zfRateCtrlAggrSta(zdev_t* dev) {
    u8_t RateIndex, Rate;
    u8_t HRate;
    u8_t LRate;
    u32_t RateCtrlTxMPDU, RateCtrlBAFail;
    zmw_get_wlan_dev(dev);

    RateIndex = wd->sta.oppositeInfo[0].rcCell.currentRateIndex;
    Rate = wd->sta.oppositeInfo[0].rcCell.operationRateSet[RateIndex];

    TxMPDU[Rate] = (TxMPDU[Rate] / 5) + (wd->commTally.RateCtrlTxMPDU * 4 / 5);
    BAFail[Rate] = (BAFail[Rate] / 5) + (wd->commTally.RateCtrlBAFail * 4 / 5);
    RateCtrlTxMPDU = wd->commTally.RateCtrlTxMPDU;
    RateCtrlBAFail = wd->commTally.RateCtrlBAFail;
    wd->commTally.RateCtrlTxMPDU = 0;
    wd->commTally.RateCtrlBAFail = 0;
    if (TxMPDU[Rate] > 0) {
        BAPER[Rate] = BAFail[Rate] * 1000 / TxMPDU[Rate]; //PER*1000
        BAPER[Rate] = (BAPER[Rate]>0)? BAPER[Rate]:1;
    }
    else {
        return;
    }

    HRate = HigherRate(Rate);
    LRate = LowerRate(Rate);
    if (BAPER[Rate]>200) {
        if ((RateCtrlTxMPDU > 100) && (BAPER[Rate]<300) && (HRate != Rate) && BAPER[HRate] &&
            (BAPER[HRate] < BAPER[Rate] + BADiff[Rate])) {
            Rate = HRate;
            //DbgPrint("Rate improved to %d", Rate);
        }
        else {
            Rate = LRate;
            //DbgPrint("Rate decreased to %d", Rate);
        }
    }
    else if (BAPER[Rate] && BAPER[Rate]<100) {
        if (RateCtrlTxMPDU > 100) {
            Rate = HRate;
            //DbgPrint("Rate improved to %d", Rate);
        }
    }
    wd->sta.oppositeInfo[0].rcCell.currentRate = Rate;
    wd->sta.oppositeInfo[0].rcCell.currentRateIndex = RateMapToRateIndex(Rate, &wd->sta.oppositeInfo[0].rcCell);
}
#endif