From d76a86507530dd3d3a63a73523b4f48bd656aed9 Mon Sep 17 00:00:00 2001 From: Roman Yeryomin Date: Wed, 6 Feb 2013 02:59:31 +0200 Subject: Rebase files to rsdk 3.2 and refresh patches. Compilable (not by humans). Signed-off-by: Roman Yeryomin --- .../drivers/net/wireless/rtl8192cd/RateAdaptive.c | 571 +++++++++++++++++++++ 1 file changed, 571 insertions(+) create mode 100644 target/linux/realtek/files/drivers/net/wireless/rtl8192cd/RateAdaptive.c (limited to 'target/linux/realtek/files/drivers/net/wireless/rtl8192cd/RateAdaptive.c') diff --git a/target/linux/realtek/files/drivers/net/wireless/rtl8192cd/RateAdaptive.c b/target/linux/realtek/files/drivers/net/wireless/rtl8192cd/RateAdaptive.c new file mode 100644 index 000000000..d05b1a0c4 --- /dev/null +++ b/target/linux/realtek/files/drivers/net/wireless/rtl8192cd/RateAdaptive.c @@ -0,0 +1,571 @@ +/*++ +Copyright (c) Realtek Semiconductor Corp. All rights reserved. + +Module Name: + RateAdaptive.c + +Abstract: + Implement Rate Adaptive functions for common operations. + +Major Change History: + When Who What + ---------- --------------- ------------------------------- + 2011-08-12 Page Create. + +--*/ + +#ifdef CONFIG_RTL_88E_SUPPORT +#include "8192cd_cfg.h" + +#ifdef TXREPORT +#include "8192cd.h" +#include "8192cd_headers.h" +#include "8192cd_hw.h" +#include "8192cd_util.h" + +/* + * RateAdaptive.h - Start + */ +#define PERENTRY 23 +#define RETRYSIZE 5 +#define RATESIZE 28 +/* + * RateAdaptive.h - End + */ + + +static unsigned char RETRY_PENALTY[PERENTRY][RETRYSIZE+1] = {{5,4,3,2,0,3},//92 , idx=0 + {6,5,4,3,0,4},//86 , idx=1 + {6,5,4,2,0,4},//81 , idx=2 + {8,7,6,4,0,6},//75 , idx=3 + {10,9,8,6,0,8},//71 , idx=4 + {10,9,8,4,0,8},//66 , idx=5 + {10,9,8,2,0,8},//62 , idx=6 + {10,9,8,0,0,8},//59 , idx=7 + {18,17,16,8,0,16},//53 , idx=8 + {26,25,24,16,0,24},//50 , idx=9 + {34,33,32,24,0,32},//47 , idx=0x0a + //{34,33,32,16,0,32},//43 , idx=0x0b + //{34,33,32,8,0,32},//40 , idx=0x0c + //{34,33,28,8,0,32},//37 , idx=0x0d + //{34,33,20,8,0,32},//32 , idx=0x0e + //{34,32,24,8,0,32},//26 , idx=0x0f + //{49,48,32,16,0,48},//20 , idx=0x10 + //{49,48,24,0,0,48},//17 , idx=0x11 + //{49,47,16,16,0,48},//15 , idx=0x12 + //{49,44,16,16,0,48},//12 , idx=0x13 + //{49,40,16,0,0,48},//9 , idx=0x14 + {34,31,28,20,0,32},//43 , idx=0x0b + {34,31,27,18,0,32},//40 , idx=0x0c + {34,31,26,16,0,32},//37 , idx=0x0d + {34,30,22,16,0,32},//32 , idx=0x0e + {34,30,24,16,0,32},//26 , idx=0x0f + {49,46,40,16,0,48},//20 , idx=0x10 + {49,45,32,0,0,48},//17 , idx=0x11 + {49,45,22,18,0,48},//15 , idx=0x12 + {49,40,28,18,0,48},//12 , idx=0x13 + {49,34,20,16,0,48},//9 , idx=0x14 + {49,22,18,14,0,48},//6 , idx=0x15 + {49,16,16,0,0,48}};//3 //3, idx=0x16 + + +static unsigned char RETRY_PENALTY_UP[RETRYSIZE+1]={49,44,16,16,0,48}; // 12% for rate up + +static unsigned char PT_PENALTY[RETRYSIZE+1]={34,31,30,24,0,32}; + +#if 0 +static u1Byte RETRY_PENALTY_IDX[2][RATESIZE] = {{4,4,4,5,4,4,5,7,7,7,8,0x0a, // SS>TH + 4,4,4,4,6,0x0a,0x0b,0x0d, + 5,5,7,7,8,0x0b,0x0d,0x0f}, // 0329 R01 + {4,4,4,5,7,7,9,9,0x0c,0x0e,0x10,0x12, // SSTH + 4,4,4,4,6,0x0a,0x0b,0x0d, + 5,5,7,7,8,0x0b,0x0d,0x0f}, // 0329 R01 + {0x0a,0x0a,0x0a,0x0a,0x0c,0x0c,0x0e,0x10,0x11,0x12,0x12,0x13, // SSTH + 0x13,0x13,0x14,0x14,0x15,0x15,0x15,0x15, + 0x11,0x11,0x12,0x13,0x13,0x13,0x14,0x15}; + +/*static unsigned char RSSI_THRESHOLD[RATESIZE] = {0,0,0,0, + 0,0,0,0,0,0x24,0x26,0x2a, + 0x18,0x1a,0x1d,0x1f,0x21,0x27,0x29,0x2a, + 0,0,0,0x1f,0x23,0x28,0x2a,0x2c};*/ +static unsigned char RSSI_THRESHOLD[RATESIZE] = {0,0,0,0, + 0,0,0,0,0,0x24,0x26,0x2a, + 0x13,0x15,0x17,0x18,0x1a,0x1c,0x1d,0x1f, + 0,0,0,0x1f,0x23,0x28,0x2a,0x2c}; +static unsigned short N_THRESHOLD_HIGH[RATESIZE] = {4,4,8,16, + 24,36,48,72,96,144,192,216, + 60,80,100,160,240,400,560,640, + 300,320,480,720,1000,1200,1600,2000}; +static unsigned short N_THRESHOLD_LOW[RATESIZE] = {2,2,4,8, + 12,18,24,36,48,72,96,108, + 30,40,50,80,120,200,280,320, + 150,160,240,360,500,600,800,1000}; +static unsigned char TRYING_NECESSARY[RATESIZE] = {2,2,2,2, + 2,2,3,3,4,4,5,7, + 4,4,7,10,10,12,12,18, + 5,7,7,8,11,18,36,60}; // 0329 // 1207 +#if 0 +static u1Byte POOL_RETRY_TH[RATESIZE] = {30,30,30,30, + 30,30,25,25,20,15,15,10, + 30,25,25,20,15,10,10,10, + 30,25,25,20,15,10,10,10}; +#endif + +static unsigned char DROPING_NECESSARY[RATESIZE] = {1,1,1,1, + 1,2,3,4,5,6,7,8, + 1,2,3,4,5,6,7,8, + 5,6,7,8,9,10,11,12}; + + +static unsigned int INIT_RATE_FALLBACK_TABLE[16]={0x0f8ff015, // 0: 40M BGN mode + 0x0f8ff010, // 1: 40M GN mode + 0x0f8ff005, // 2: BN mode/ 40M BGN mode + 0x0f8ff000, // 3: N mode + 0x00000ff5, // 4: BG mode + 0x00000ff0, // 5: G mode + 0x0000000d, // 6: B mode + 0, // 7: + 0, // 8: + 0, // 9: + 0, // 10: + 0, // 11: + 0, // 12: + 0, // 13: + 0, // 14: + 0, // 15: + + }; +static unsigned char PendingForRateUpFail[5]={2,10,24,40,60}; + +static unsigned short DefaultTxRPTTiming=0x186a; //200ms +unsigned short DynamicTxRPTTiming[6]={0x186a, 0x30d4, 0x493e, 0x61a8, 0x7a12 ,0x927c}; // 200ms-1200ms +static unsigned short MinTxRPTTiming=0x186a; //200ms +unsigned char TxRPTTiming_idx=1; +unsigned char DynamicTxRPTTimingCounter=0; + + +// End Rate adaptive parameters +int RateAdaptiveInfoInit(PSTATION_RA_INFO pRaInfo) +{ + if(pRaInfo) + { +/* panic_printk("%s %d, aid %d\n", __FUNCTION__, __LINE__, pRaInfo->pstat->aid);*/ + pRaInfo->DecisionRate = 0x13; + pRaInfo->PreRate = 0x13; + pRaInfo->HighestRate=0x13; + pRaInfo->LowestRate=0; + pRaInfo->RateID=0; + pRaInfo->RateMask=0xffffffff; + pRaInfo->RssiStaRA=0; + pRaInfo->PreRssiStaRA=0; + pRaInfo->SGIEnable=0; + pRaInfo->RAUseRate=0xffffffff; + pRaInfo->NscDown=(N_THRESHOLD_HIGH[0x13]+N_THRESHOLD_LOW[0x13])/2; + pRaInfo->NscUp=(N_THRESHOLD_HIGH[0x13]+N_THRESHOLD_LOW[0x13])/2; + pRaInfo->RateSGI=0; + pRaInfo->Active=1; //Active is not used at present. by page, 110819 + pRaInfo->RptTime = 0x927c; + pRaInfo->DROP=0; + pRaInfo->RTY[0]=0; + pRaInfo->RTY[1]=0; + pRaInfo->RTY[2]=0; + pRaInfo->RTY[3]=0; + pRaInfo->RTY[4]=0; + pRaInfo->TOTAL=0; +#if 1 + pRaInfo->RAWaitingCounter=0; + pRaInfo->RAPendingCounter=0; +#endif +#if 0 + pRaInfo->TryingState=0; + pRaInfo->RateBeforeTrying=0x13; +#endif +#ifdef POWER_TRAINING_ACTIVE + pRaInfo->PTTryState=0; + pRaInfo->PTStage=0; + pRaInfo->PTStopCount=0; + pRaInfo->PTPreRate=0; + pRaInfo->PTPreRssi=0; + pRaInfo->PTModeSS=0; + pRaInfo->RAstage=0; +#endif + } + return 0; +} + +int ARFBRefresh(struct rtl8192cd_priv *priv, PSTATION_RA_INFO pRaInfo) +{ // Wilson 2011/10/26 + unsigned int MaskFromReg; + unsigned char i,j; + + // Test for Wilson + RTL_W16(REG_88E_TXRPT_TIM, DefaultTxRPTTiming); //200ms + RTL_W32(DARFRC, 0x04020100); + RTL_W32(DARFRC+4, 0x0a080706); + + switch(pRaInfo->RateID) { + case RATR_INX_WIRELESS_NGB: + pRaInfo->RAUseRate=(pRaInfo->RateMask)&0x0f8ff015; + break; + case RATR_INX_WIRELESS_NG: + pRaInfo->RAUseRate=(pRaInfo->RateMask)&0x0f8ff010; + break; + case RATR_INX_WIRELESS_NB: + pRaInfo->RAUseRate=(pRaInfo->RateMask)&0x0f8ff005; + break; + case RATR_INX_WIRELESS_N: + pRaInfo->RAUseRate=(pRaInfo->RateMask)&0x0f8ff000; + break; + case RATR_INX_WIRELESS_GB: + pRaInfo->RAUseRate=(pRaInfo->RateMask)&0x00000ff5; + break; + case RATR_INX_WIRELESS_G: + pRaInfo->RAUseRate=(pRaInfo->RateMask)&0x00000ff0; + break; + case RATR_INX_WIRELESS_B: + pRaInfo->RAUseRate=(pRaInfo->RateMask)&0x0000000d; + break; + case 12: + MaskFromReg=RTL_R32(ARFR0); + pRaInfo->RAUseRate=(pRaInfo->RateMask)&MaskFromReg; + break; + case 13: + MaskFromReg=RTL_R32(ARFR1); + pRaInfo->RAUseRate=(pRaInfo->RateMask)&MaskFromReg; + break; + case 14: + MaskFromReg=RTL_R32(ARFR2); + pRaInfo->RAUseRate=(pRaInfo->RateMask)&MaskFromReg; + break; + case 15: + MaskFromReg=RTL_R32(ARFR3); + pRaInfo->RAUseRate=(pRaInfo->RateMask)&MaskFromReg; + break; + default: + pRaInfo->RAUseRate=(pRaInfo->RateMask); + break; + } + // Highest rate + if (pRaInfo->RAUseRate) { + for (i=RATESIZE;i>=0;i--) { + if((pRaInfo->RAUseRate)&BIT(i)) { + pRaInfo->HighestRate=i; + break; + } + } + } else { + pRaInfo->HighestRate=0; + } + + // Lowest rate + if (pRaInfo->RAUseRate) { + for (i=0;iRAUseRate)&BIT(i)) { + pRaInfo->LowestRate=i; + break; + } + } + } else { + pRaInfo->LowestRate=0; + } +#if 0 + pRaInfo->RAWaitingCounter=0; + pRaInfo->RAExtendCounter=0; +#endif + +/* panic_printk("%s %d: RateID=%d RateMask=%8.8x RAUseRate=%8.8x HighestRate=%d\n", + __FUNCTION__, __LINE__, + pRaInfo->RateID, pRaInfo->RateMask, pRaInfo->RAUseRate, pRaInfo->HighestRate);*/ + return 0; +} + + +static int RateDown(struct rtl8192cd_priv *priv, PSTATION_RA_INFO pRaInfo) +{ + unsigned char RateID, LowestRate, HighestRate; + unsigned char i; + + if(NULL == pRaInfo) { + printk("%s %d: pRaInfo is NULL\n", __FUNCTION__, __LINE__); + return -1; + } + RateID = pRaInfo->PreRate; + LowestRate = pRaInfo->LowestRate; + HighestRate = pRaInfo->HighestRate; + +/* panic_printk("%s %d: RateID=%d LowestRate=%d HighestRate=%d RateSGI=%d\n", + __FUNCTION__, __LINE__, + RateID, LowestRate, HighestRate, pRaInfo->RateSGI);*/ + + if (RateID > HighestRate) { + RateID=HighestRate; + } else if(pRaInfo->RateSGI) { + pRaInfo->RateSGI=0; + } else if (RateID > LowestRate) { + if (RateID > 0) { + for (i=RateID-1; i>LowestRate;i--) { + if (pRaInfo->RAUseRate & BIT(i)) { + RateID=i; + goto RateDownFinish; + } + } + } + } else if (RateID <= LowestRate) { + RateID = LowestRate; + } + +RateDownFinish: +#if 1 + if (pRaInfo->RAWaitingCounter==1) { + pRaInfo->RAWaitingCounter+=1; + pRaInfo->RAPendingCounter+=1; + } + else if(pRaInfo->RAWaitingCounter==0){ + } else { + pRaInfo->RAWaitingCounter=0; + pRaInfo->RAPendingCounter=0; + } + + if(pRaInfo->RAPendingCounter>=4) + pRaInfo->RAPendingCounter=4; +#endif + + pRaInfo->DecisionRate=RateID; + RTL8188E_SetTxReportTimeByRA(priv, 2); + +/* panic_printk("=====> rate down %s %d: Rate down to RateID %d RateSGI %d\n", __FUNCTION__, __LINE__, RateID, pRaInfo->RateSGI);*/ + return 0; +} + + +static int RateUp(struct rtl8192cd_priv *priv, PSTATION_RA_INFO pRaInfo) +{ + unsigned char RateID, HighestRate; + unsigned char i; + + if(NULL == pRaInfo) { + printk("%s %d: pRaInfo is NULL\n", __FUNCTION__, __LINE__); + return -1; + } + RateID = pRaInfo->PreRate; +#if 0 + pRaInfo->RateBeforeTrying=RateID; +#endif + HighestRate = pRaInfo->HighestRate; +/* panic_printk("%s %d: RateID=%d HighestRate=%d\n", __FUNCTION__, __LINE__, RateID, HighestRate);*/ +#if 1 + if (pRaInfo->RAWaitingCounter==1) { + pRaInfo->RAWaitingCounter=0; + pRaInfo->RAPendingCounter=0; + } else if (pRaInfo->RAWaitingCounter>1) { + pRaInfo->PreRssiStaRA=pRaInfo->RssiStaRA; + goto RateUpfinish; + } + RTL8188E_SetTxReportTimeByRA(priv, 0); +/* panic_printk("%s %d, Decrease RPT Timing\n", __FUNCTION__, __LINE__);*/ +#endif + + if (RateID < HighestRate) { + for (i=RateID+1; i<=HighestRate; i++) { + if (pRaInfo->RAUseRate & BIT(i)) { + RateID=i; + goto RateUpfinish; + } + } + } else if(RateID == HighestRate) { + if (pRaInfo->SGIEnable && (pRaInfo->RateSGI != 1)) + pRaInfo->RateSGI = 1; + else if((pRaInfo->SGIEnable) !=1 ) + pRaInfo->RateSGI = 0; + } else /* if((sta_info_ra->Decision_rate) > (sta_info_ra->Highest_rate)) */ { + RateID = HighestRate; + } + +RateUpfinish: +#if 1 + //if(pRaInfo->RAWaitingCounter==10) + if(pRaInfo->RAWaitingCounter==(4+PendingForRateUpFail[pRaInfo->RAPendingCounter])) + pRaInfo->RAWaitingCounter=0; + else + pRaInfo->RAWaitingCounter++; +#endif + pRaInfo->DecisionRate=RateID; +#if 0 + pRaInfo->TryingState=1; + StartRateTrying(Adapter,pRaInfo); +#endif +/* panic_printk("%s %d: Rate up to RateID %d\n", __FUNCTION__, __LINE__, RateID);*/ + return 0; +} + + +static void ResetRaCounter(PSTATION_RA_INFO pRaInfo){ + unsigned char RateID; + RateID=pRaInfo->DecisionRate; + pRaInfo->NscUp=(N_THRESHOLD_HIGH[RateID]+N_THRESHOLD_LOW[RateID])>>1; + pRaInfo->NscDown=(N_THRESHOLD_HIGH[RateID]+N_THRESHOLD_LOW[RateID])>>1; +} + +#if 0 +void StartRateTrying(IN PADAPTER Adapter, IN PSTATION_RA_INFO pRaInfo) +{ + + // Test for Wilson + PlatformEFIOWrite2Byte(Adapter, REG_TX_RPT_TIME,0x0138); + RT_TRACE(COMP_RATE_ADAPTIVE, DBG_LOUD, + ("StartRateTrying(): ")); + // Need to Modify (Try bit?, Try timing) + + +} + +u1Byte EndRateTrying(IN PADAPTER Adapter, IN PSTATION_RA_INFO pRaInfo) +{ + + u1Byte TryResult=0; + u4Byte pool_retry; + pRaInfo->DecisionRate=(pRaInfo->DecisionRate)&0x7f; + PlatformEFIOWrite2Byte(Adapter, REG_TX_RPT_TIME,0x44A5); + pool_retry=pRaInfo->RTY[1]+pRaInfo->RTY[2]+pRaInfo->RTY[3]+pRaInfo->RTY[4]+pRaInfo->DROP; + if (pool_retry>2) + TryResult=0; + else + TryResult=1; + + return TryResult; + + +} +#endif + + +/* moved to 8188e_hw.c + +void SetTxRPTTiming(IN PADAPTER Adapter, int extend) +{ + u2Byte WriteTxRPTTiming; + u1Byte idx; + + idx=TxRPTTiming_idx; + if (extend==0) // back to default timing + idx=1; //400ms + else if (extend==1) {// increase the timing + idx+=1; + if (idx>5) + idx=5; + } + else if (extend==2) {// decrease the timing + if(idx!=0) + idx-=1; + } + WriteTxRPTTiming=DynamicTxRPTTiming[idx]; + TxRPTTiming_idx=idx; + PlatformEFIOWrite2Byte(Adapter, REG_TX_RPT_TIME, WriteTxRPTTiming); + +} +*/ + + +void RateDecision(struct rtl8192cd_priv *priv, PSTATION_RA_INFO pRaInfo) +{ + unsigned char i, RateID = 0, RtyPtID = 0, PenaltyID1 = 0, PenaltyID2 = 0; + unsigned int pool_retry; + unsigned char Try_Result=0; + + if (pRaInfo->Active && (pRaInfo->TOTAL > 0)) /* STA used and data packet exits */ { +#if 0 + if (pRaInfo->TryingState==1){ + + pRaInfo->TryingState=0; + Try_Result=EndRateTrying(Adapter,pRaInfo); + if (Try_Result==1) // Try good + pRaInfo->RateBeforeTrying=pRaInfo->DecisionRate; + else // Try bad + pRaInfo->DecisionRate=pRaInfo->RateBeforeTrying; + goto RateDecisionFinish; + } +#endif + if ((pRaInfo->RssiStaRA<(pRaInfo->PreRssiStaRA-3))|| (pRaInfo->RssiStaRA>(pRaInfo->PreRssiStaRA+3))) { + pRaInfo->RAWaitingCounter=0; + pRaInfo->RAPendingCounter=0; + } + // Start RA decision + if (pRaInfo->PreRate > pRaInfo->HighestRate) + RateID = pRaInfo->HighestRate; + else + RateID = pRaInfo->PreRate; + if (pRaInfo->RssiStaRA > RSSI_THRESHOLD[RateID]) + RtyPtID=0; + else + RtyPtID=1; + PenaltyID1 = RETRY_PENALTY_IDX[RtyPtID][RateID]; //TODO by page + +/* panic_printk("%s %d: NscDown init is %d\n", __FUNCTION__, __LINE__, pRaInfo->NscDown);*/ + //pool_retry=pRaInfo->RTY[2]+pRaInfo->RTY[3]+pRaInfo->RTY[4]+pRaInfo->DROP; + pRaInfo->NscDown += pRaInfo->RTY[0] * RETRY_PENALTY[PenaltyID1][0]; + pRaInfo->NscDown += pRaInfo->RTY[1] * RETRY_PENALTY[PenaltyID1][1]; + pRaInfo->NscDown += pRaInfo->RTY[2] * RETRY_PENALTY[PenaltyID1][2]; + pRaInfo->NscDown += pRaInfo->RTY[3] * RETRY_PENALTY[PenaltyID1][3]; + pRaInfo->NscDown += pRaInfo->RTY[4] * RETRY_PENALTY[PenaltyID1][4]; +/* panic_printk("%s %d: NscDown is %d, total*penalty[5] is %d\n", __FUNCTION__, __LINE__, + pRaInfo->NscDown, (pRaInfo->TOTAL * RETRY_PENALTY[PenaltyID1][5]));*/ + if (pRaInfo->NscDown > (pRaInfo->TOTAL * RETRY_PENALTY[PenaltyID1][5])) + pRaInfo->NscDown -= pRaInfo->TOTAL * RETRY_PENALTY[PenaltyID1][5]; + else + pRaInfo->NscDown=0; + + // rate up + PenaltyID2 = RETRY_PENALTY_UP_IDX[RateID]; +/* panic_printk("%s %d: NscUp init is %d\n", __FUNCTION__, __LINE__, pRaInfo->NscUp);*/ + pRaInfo->NscUp += pRaInfo->RTY[0] * RETRY_PENALTY[PenaltyID2][0]; + pRaInfo->NscUp += pRaInfo->RTY[1] * RETRY_PENALTY[PenaltyID2][1]; + pRaInfo->NscUp += pRaInfo->RTY[2] * RETRY_PENALTY[PenaltyID2][2]; + pRaInfo->NscUp += pRaInfo->RTY[3] * RETRY_PENALTY[PenaltyID2][3]; + pRaInfo->NscUp += pRaInfo->RTY[4] * RETRY_PENALTY[PenaltyID2][4]; +/* panic_printk("%s %d: NscUp is %d, total*up[5] is %d\n", __FUNCTION__, __LINE__, + pRaInfo->NscUp, (pRaInfo->TOTAL * RETRY_PENALTY[PenaltyID2][5]));*/ + if (pRaInfo->NscUp > (pRaInfo->TOTAL * RETRY_PENALTY[PenaltyID2][5])) + pRaInfo->NscUp -= pRaInfo->TOTAL * RETRY_PENALTY[PenaltyID2][5]; + else + pRaInfo->NscUp = 0; + /*printk("%s %d, RTY0 %d, RTY1 %d, RTY2 %d, RTY3 %d, RTY4 %d, userate 0x%08x\n", + __FUNCTION__, __LINE__, pRaInfo->RTY[0], pRaInfo->RTY[1], pRaInfo->RTY[2], pRaInfo->RTY[3], pRaInfo->RTY[4], pRaInfo->RAUseRate);*/ +/* panic_printk("%s %d: RssiStaRa= %d RtyPtID=%d PenaltyID1=0x%x PenaltyID2=0x%x RateID=%d NscDown=%d NscUp=%d\n", + __FUNCTION__, __LINE__, + pRaInfo->RssiStaRA,RtyPtID, PenaltyID1,PenaltyID2, RateID, pRaInfo->NscDown, pRaInfo->NscUp);*/ + if ((pRaInfo->NscDown < N_THRESHOLD_LOW[RateID]) ||(pRaInfo->DROP>DROPING_NECESSARY[RateID])) + RateDown(priv, pRaInfo); + //else if ((pRaInfo->NscUp > N_THRESHOLD_HIGH[RateID])&&(pool_retryNscUp > N_THRESHOLD_HIGH[RateID]) + RateUp(priv, pRaInfo); +#if 0 + RateDecisionFinish: +#endif + if ((pRaInfo->DecisionRate)==(pRaInfo->PreRate)) + DynamicTxRPTTimingCounter+=1; + else + DynamicTxRPTTimingCounter=0; + + if (DynamicTxRPTTimingCounter>=4) { + RTL8188E_SetTxReportTimeByRA(priv, 1); +/* panic_printk("%s %d, <=====Rate don't change 4 times, Extend RPT Timing\n", __FUNCTION__, __LINE__);*/ + DynamicTxRPTTimingCounter=0; + } + + pRaInfo->RptTime = DynamicTxRPTTiming[TxRPTTiming_idx]; + pRaInfo->PreRate = pRaInfo->DecisionRate; + + ResetRaCounter( pRaInfo); + } +} +#endif +#endif + -- cgit v1.2.3