ubuntu/rtl8192se/rtllib/rtl819x_HTProc.c

   1 /******************************************************************************
   2  * Copyright(c) 2008 - 2010 Realtek Corporation. All rights reserved.
   3  *
   4  * This program is distributed in the hope that it will be useful, but WITHOUT
   5  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   6  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
   7  * more details.
   8  *
   9  * You should have received a copy of the GNU General Public License along with
  10  * this program; if not, write to the Free Software Foundation, Inc.,
  11  * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
  12  *
  13  * The full GNU General Public License is included in this distribution in the
  14  * file called LICENSE.
  15  *
  16  * Contact Information:
  17  * wlanfae <wlanfae@realtek.com>
  18 ******************************************************************************/
  19 #include "rtllib.h"
  20 #include "rtl819x_HT.h"
  21 u8 MCS_FILTER_ALL[16] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
  22
  23 u8 MCS_FILTER_1SS[16] = {0xff, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
  24
  25 u16 MCS_DATA_RATE[2][2][77] =
  26         {       {       {13, 26, 39, 52, 78, 104, 117, 130, 26, 52, 78 ,104, 156, 208, 234, 260,
  27                         39, 78, 117, 234, 312, 351, 390, 52, 104, 156, 208, 312, 416, 468, 520,
  28                         0, 78, 104, 130, 117, 156, 195, 104, 130, 130, 156, 182, 182, 208, 156, 195,
  29                         195, 234, 273, 273, 312, 130, 156, 181, 156, 181, 208, 234, 208, 234, 260, 260,
  30                         286, 195, 234, 273, 234, 273, 312, 351, 312, 351, 390, 390, 429},
  31                         {14, 29, 43, 58, 87, 116, 130, 144, 29, 58, 87, 116, 173, 231, 260, 289,
  32                         43, 87, 130, 173, 260, 347, 390, 433, 58, 116, 173, 231, 347, 462, 520, 578,
  33                         0, 87, 116, 144, 130, 173, 217, 116, 144, 144, 173, 202, 202, 231, 173, 217,
  34                         217, 260, 303, 303, 347, 144, 173, 202, 173, 202, 231, 260, 231, 260, 289, 289,
  35                         318, 217, 260, 303, 260, 303, 347, 390, 347, 390, 433, 433, 477}        },
  36                 {       {27, 54, 81, 108, 162, 216, 243, 270, 54, 108, 162, 216, 324, 432, 486, 540,
  37                         81, 162, 243, 324, 486, 648, 729, 810, 108, 216, 324, 432, 648, 864, 972, 1080,
  38                         12, 162, 216, 270, 243, 324, 405, 216, 270, 270, 324, 378, 378, 432, 324, 405,
  39                         405, 486, 567, 567, 648, 270, 324, 378, 324, 378, 432, 486, 432, 486, 540, 540,
  40                         594, 405, 486, 567, 486, 567, 648, 729, 648, 729, 810, 810, 891},
  41                         {30, 60, 90, 120, 180, 240, 270, 300, 60, 120, 180, 240, 360, 480, 540, 600,
  42                         90, 180, 270, 360, 540, 720, 810, 900, 120, 240, 360, 480, 720, 960, 1080, 1200,
  43                         13, 180, 240, 300, 270, 360, 450, 240, 300, 300, 360, 420, 420, 480, 360, 450,
  44                         450, 540, 630, 630, 720, 300, 360, 420, 360, 420, 480, 540, 480, 540, 600, 600,
  45                         660, 450, 540, 630, 540, 630, 720, 810, 720, 810, 900, 900, 990}        }
  46         };
  47
  48 static u8 UNKNOWN_BORADCOM[3] = {0x00, 0x14, 0xbf};
  49 static u8 LINKSYSWRT330_LINKSYSWRT300_BROADCOM[3] = {0x00, 0x1a, 0x70};
  50 static u8 LINKSYSWRT350_LINKSYSWRT150_BROADCOM[3] = {0x00, 0x1d, 0x7e};
  51 static u8 BELKINF5D8233V1_RALINK[3] = {0x00, 0x17, 0x3f};
  52 static u8 BELKINF5D82334V3_RALINK[3] = {0x00, 0x1c, 0xdf};
  53 static u8 PCI_RALINK[3] = {0x00, 0x90, 0xcc};
  54 static u8 EDIMAX_RALINK[3] = {0x00, 0x0e, 0x2e};
  55 static u8 AIRLINK_RALINK[3] = {0x00, 0x18, 0x02};
  56 static u8 DLINK_ATHEROS_1[3] = {0x00, 0x1c, 0xf0};
  57 static u8 DLINK_ATHEROS_2[3] = {0x00, 0x21, 0x91};
  58 static u8 CISCO_BROADCOM[3] = {0x00, 0x17, 0x94};
  59 #if defined(RTL8192SU)
  60 static u8 NETGEAR_BROADCOM[3] = {0x00, 0x1f, 0x33};
  61 #endif
  62 static u8 LINKSYS_MARVELL_4400N[3] = {0x00, 0x14, 0xa4};
  63 void HTUpdateDefaultSetting(struct rtllib_device* ieee)
  64 {
  65         PRT_HIGH_THROUGHPUT     pHTInfo = ieee->pHTInfo;
  66
  67 #ifdef RTL8192CE
  68         pHTInfo->bRDGEnable = 0;
  69 #endif
  70
  71         pHTInfo->bRegShortGI20MHz= 1;
  72         pHTInfo->bRegShortGI40MHz= 1;
  73
  74         pHTInfo->bRegBW40MHz = 1;
  75
  76         if(pHTInfo->bRegBW40MHz)
  77                 pHTInfo->bRegSuppCCK = 1;
  78         else
  79                 pHTInfo->bRegSuppCCK = true;
  80
  81         pHTInfo->nAMSDU_MaxSize = 7935UL;
  82         pHTInfo->bAMSDU_Support = 0;
  83
  84         pHTInfo->bAMPDUEnable = 1;
  85         pHTInfo->AMPDU_Factor = 2;
  86         pHTInfo->MPDU_Density = 0;
  87
  88         pHTInfo->SelfMimoPs = 3;
  89         if(pHTInfo->SelfMimoPs == 2)
  90                 pHTInfo->SelfMimoPs = 3;
  91         ieee->bTxDisableRateFallBack = 0;
  92         ieee->bTxUseDriverAssingedRate = 0;
  93
  94         ieee->bTxEnableFwCalcDur = 1;
  95
  96         pHTInfo->bRegRT2RTAggregation = 1;
  97
  98         pHTInfo->bRegRxReorderEnable = 1;
  99         pHTInfo->RxReorderWinSize = 64;
 100         pHTInfo->RxReorderPendingTime = 30;
 101
 102 #ifdef USB_TX_DRIVER_AGGREGATION_ENABLE
 103         pHTInfo->UsbTxAggrNum = 4;
 104 #endif
 105 #ifdef USB_RX_AGGREGATION_SUPPORT
 106 #ifdef RTL8192SU
 107         pHTInfo->UsbRxFwAggrEn = 1;
 108         pHTInfo->UsbRxFwAggrPageNum = 48;
 109         pHTInfo->UsbRxFwAggrPacketNum = 8;
 110         pHTInfo->UsbRxFwAggrTimeout = 4;
 111         pHTInfo->UsbRxPageSize= 128;
 112 #else
 113         pHTInfo->UsbRxFwAggrEn = 1;
 114         pHTInfo->UsbRxFwAggrPageNum = 24;
 115         pHTInfo->UsbRxFwAggrPacketNum = 8;
 116         pHTInfo->UsbRxFwAggrTimeout = 8;
 117 #endif
 118 #endif
 119
 120
 121 }
 122 void HTDebugHTCapability(u8* CapIE, u8* TitleString )
 123 {
 124
 125         static u8       EWC11NHTCap[] = {0x00, 0x90, 0x4c, 0x33};
 126         PHT_CAPABILITY_ELE              pCapELE;
 127
 128         if(!memcmp(CapIE, EWC11NHTCap, sizeof(EWC11NHTCap)))
 129         {
 130                 RTLLIB_DEBUG(RTLLIB_DL_HT, "EWC IE in %s()\n", __FUNCTION__);
 131                 pCapELE = (PHT_CAPABILITY_ELE)(&CapIE[4]);
 132         }else
 133                 pCapELE = (PHT_CAPABILITY_ELE)(&CapIE[0]);
 134
 135         RTLLIB_DEBUG(RTLLIB_DL_HT, "<Log HT Capability>. Called by %s\n", TitleString );
 136
 137         RTLLIB_DEBUG(RTLLIB_DL_HT,  "\tSupported Channel Width = %s\n", (pCapELE->ChlWidth)?"20MHz": "20/40MHz");
 138         RTLLIB_DEBUG(RTLLIB_DL_HT,  "\tSupport Short GI for 20M = %s\n", (pCapELE->ShortGI20Mhz)?"YES": "NO");
 139         RTLLIB_DEBUG(RTLLIB_DL_HT,  "\tSupport Short GI for 40M = %s\n", (pCapELE->ShortGI40Mhz)?"YES": "NO");
 140         RTLLIB_DEBUG(RTLLIB_DL_HT,  "\tSupport TX STBC = %s\n", (pCapELE->TxSTBC)?"YES": "NO");
 141         RTLLIB_DEBUG(RTLLIB_DL_HT,  "\tMax AMSDU Size = %s\n", (pCapELE->MaxAMSDUSize)?"3839": "7935");
 142         RTLLIB_DEBUG(RTLLIB_DL_HT,  "\tSupport CCK in 20/40 mode = %s\n", (pCapELE->DssCCk)?"YES": "NO");
 143         RTLLIB_DEBUG(RTLLIB_DL_HT,  "\tMax AMPDU Factor = %d\n", pCapELE->MaxRxAMPDUFactor);
 144         RTLLIB_DEBUG(RTLLIB_DL_HT,  "\tMPDU Density = %d\n", pCapELE->MPDUDensity);
 145         RTLLIB_DEBUG(RTLLIB_DL_HT,  "\tMCS Rate Set = [%x][%x][%x][%x][%x]\n", pCapELE->MCS[0],\
 146                                 pCapELE->MCS[1], pCapELE->MCS[2], pCapELE->MCS[3], pCapELE->MCS[4]);
 147         return;
 148
 149 }
 150 void HTDebugHTInfo(u8*  InfoIE, u8* TitleString)
 151 {
 152
 153         static u8       EWC11NHTInfo[] = {0x00, 0x90, 0x4c, 0x34};
 154         PHT_INFORMATION_ELE             pHTInfoEle;
 155
 156         if(!memcmp(InfoIE, EWC11NHTInfo, sizeof(EWC11NHTInfo)))
 157         {
 158                 RTLLIB_DEBUG(RTLLIB_DL_HT, "EWC IE in %s()\n", __FUNCTION__);
 159                 pHTInfoEle = (PHT_INFORMATION_ELE)(&InfoIE[4]);
 160         }else
 161                 pHTInfoEle = (PHT_INFORMATION_ELE)(&InfoIE[0]);
 162
 163
 164         RTLLIB_DEBUG(RTLLIB_DL_HT, "<Log HT Information Element>. Called by %s\n", TitleString);
 165
 166         RTLLIB_DEBUG(RTLLIB_DL_HT, "\tPrimary channel = %d\n", pHTInfoEle->ControlChl);
 167         RTLLIB_DEBUG(RTLLIB_DL_HT, "\tSenondary channel =");
 168         switch(pHTInfoEle->ExtChlOffset)
 169         {
 170                 case 0:
 171                         RTLLIB_DEBUG(RTLLIB_DL_HT, "Not Present\n");
 172                         break;
 173                 case 1:
 174                         RTLLIB_DEBUG(RTLLIB_DL_HT, "Upper channel\n");
 175                         break;
 176                 case 2:
 177                         RTLLIB_DEBUG(RTLLIB_DL_HT, "Reserved. Eooro!!!\n");
 178                         break;
 179                 case 3:
 180                         RTLLIB_DEBUG(RTLLIB_DL_HT, "Lower Channel\n");
 181                         break;
 182         }
 183         RTLLIB_DEBUG(RTLLIB_DL_HT, "\tRecommended channel width = %s\n", (pHTInfoEle->RecommemdedTxWidth)?"20Mhz": "40Mhz");
 184
 185         RTLLIB_DEBUG(RTLLIB_DL_HT, "\tOperation mode for protection = ");
 186         switch(pHTInfoEle->OptMode)
 187         {
 188                 case 0:
 189                         RTLLIB_DEBUG(RTLLIB_DL_HT, "No Protection\n");
 190                         break;
 191                 case 1:
 192                         RTLLIB_DEBUG(RTLLIB_DL_HT, "HT non-member protection mode\n");
 193                         break;
 194                 case 2:
 195                         RTLLIB_DEBUG(RTLLIB_DL_HT, "Suggest to open protection\n");
 196                         break;
 197                 case 3:
 198                         RTLLIB_DEBUG(RTLLIB_DL_HT, "HT mixed mode\n");
 199                         break;
 200         }
 201
 202         RTLLIB_DEBUG(RTLLIB_DL_HT, "\tBasic MCS Rate Set = [%x][%x][%x][%x][%x]\n", pHTInfoEle->BasicMSC[0],\
 203                                 pHTInfoEle->BasicMSC[1], pHTInfoEle->BasicMSC[2], pHTInfoEle->BasicMSC[3], pHTInfoEle->BasicMSC[4]);
 204         return;
 205 }
 206
 207 bool IsHTHalfNmode40Bandwidth(struct rtllib_device* ieee)
 208 {
 209         bool                    retValue = false;
 210         PRT_HIGH_THROUGHPUT      pHTInfo = ieee->pHTInfo;
 211
 212         if(pHTInfo->bCurrentHTSupport == false )
 213                 retValue = false;
 214         else if(pHTInfo->bRegBW40MHz == false)
 215                 retValue = false;
 216         else if(!ieee->GetHalfNmodeSupportByAPsHandler(ieee->dev))
 217                 retValue = false;
 218         else if(((PHT_CAPABILITY_ELE)(pHTInfo->PeerHTCapBuf))->ChlWidth)
 219                 retValue = true;
 220         else
 221                 retValue = false;
 222
 223         return retValue;
 224 }
 225
 226 bool IsHTHalfNmodeSGI(struct rtllib_device* ieee, bool is40MHz)
 227 {
 228         bool                    retValue = false;
 229         PRT_HIGH_THROUGHPUT      pHTInfo = ieee->pHTInfo;
 230
 231         if(pHTInfo->bCurrentHTSupport == false )
 232                 retValue = false;
 233         else if(!ieee->GetHalfNmodeSupportByAPsHandler(ieee->dev))
 234                 retValue = false;
 235         else if(is40MHz)
 236         {
 237                 if(((PHT_CAPABILITY_ELE)(pHTInfo->PeerHTCapBuf))->ShortGI40Mhz)
 238                         retValue = true;
 239                 else
 240                         retValue = false;
 241         }
 242         else
 243         {
 244                 if(((PHT_CAPABILITY_ELE)(pHTInfo->PeerHTCapBuf))->ShortGI20Mhz)
 245                         retValue = true;
 246                 else
 247                         retValue = false;
 248         }
 249
 250         return retValue;
 251 }
 252
 253 u16 HTHalfMcsToDataRate(struct rtllib_device* ieee,     u8      nMcsRate)
 254 {
 255
 256         u8      is40MHz;
 257         u8      isShortGI;
 258
 259         is40MHz  =  (IsHTHalfNmode40Bandwidth(ieee))?1:0;
 260         isShortGI = (IsHTHalfNmodeSGI(ieee, is40MHz))? 1:0;
 261
 262         return MCS_DATA_RATE[is40MHz][isShortGI][(nMcsRate&0x7f)];
 263 }
 264
 265
 266 u16 HTMcsToDataRate( struct rtllib_device* ieee, u8 nMcsRate)
 267 {
 268         PRT_HIGH_THROUGHPUT     pHTInfo = ieee->pHTInfo;
 269
 270         u8      is40MHz = (pHTInfo->bCurBW40MHz)?1:0;
 271         u8      isShortGI = (pHTInfo->bCurBW40MHz)?
 272                                                 ((pHTInfo->bCurShortGI40MHz)?1:0):
 273                                                 ((pHTInfo->bCurShortGI20MHz)?1:0);
 274         return MCS_DATA_RATE[is40MHz][isShortGI][(nMcsRate&0x7f)];
 275 }
 276
 277 u16  TxCountToDataRate( struct rtllib_device* ieee, u8 nDataRate)
 278 {
 279         u16             CCKOFDMRate[12] = {0x02 , 0x04 , 0x0b , 0x16 , 0x0c , 0x12 , 0x18 , 0x24 , 0x30 , 0x48 , 0x60 , 0x6c};
 280         u8      is40MHz = 0;
 281         u8      isShortGI = 0;
 282
 283         if(nDataRate < 12)
 284         {
 285                 return CCKOFDMRate[nDataRate];
 286         }
 287         else
 288         {
 289                 if (nDataRate >= 0x10 && nDataRate <= 0x1f)
 290                 {
 291                         is40MHz = 0;
 292                         isShortGI = 0;
 293
 294                 }
 295                 else if(nDataRate >=0x20  && nDataRate <= 0x2f )
 296                 {
 297                         is40MHz = 1;
 298                         isShortGI = 0;
 299
 300                 }
 301                 else if(nDataRate >= 0x30  && nDataRate <= 0x3f )
 302                 {
 303                         is40MHz = 0;
 304                         isShortGI = 1;
 305
 306                 }
 307                 else if(nDataRate >= 0x40  && nDataRate <= 0x4f )
 308                 {
 309                         is40MHz = 1;
 310                         isShortGI = 1;
 311
 312                 }
 313                 return MCS_DATA_RATE[is40MHz][isShortGI][nDataRate&0xf];
 314         }
 315 }
 316
 317
 318
 319 bool IsHTHalfNmodeAPs(struct rtllib_device* ieee)
 320 {
 321         bool                    retValue = false;
 322         struct rtllib_network* net = &ieee->current_network;
 323 #if 0
 324         if(ieee->bHalfNMode == false)
 325                 retValue = false;
 326         else
 327 #endif
 328         if((memcmp(net->bssid, BELKINF5D8233V1_RALINK, 3)==0) ||
 329                      (memcmp(net->bssid, BELKINF5D82334V3_RALINK, 3)==0) ||
 330                      (memcmp(net->bssid, PCI_RALINK, 3)==0) ||
 331                      (memcmp(net->bssid, EDIMAX_RALINK, 3)==0) ||
 332                      (memcmp(net->bssid, AIRLINK_RALINK, 3)==0) ||
 333                      (net->ralink_cap_exist))
 334                 retValue = true;
 335         else if((memcmp(net->bssid, UNKNOWN_BORADCOM, 3)==0) ||
 336                     (memcmp(net->bssid, LINKSYSWRT330_LINKSYSWRT300_BROADCOM, 3)==0)||
 337                     (memcmp(net->bssid, LINKSYSWRT350_LINKSYSWRT150_BROADCOM, 3)==0)||
 338                     (net->broadcom_cap_exist))
 339                   retValue = true;
 340         else if(net->bssht.bdRT2RTAggregation)
 341                 retValue = true;
 342         else
 343                 retValue = false;
 344
 345         return retValue;
 346 }
 347
 348 void HTIOTPeerDetermine(struct rtllib_device* ieee)
 349 {
 350         PRT_HIGH_THROUGHPUT     pHTInfo = ieee->pHTInfo;
 351         struct rtllib_network* net = &ieee->current_network;
 352         if(net->bssht.bdRT2RTAggregation){
 353                 pHTInfo->IOTPeer = HT_IOT_PEER_REALTEK;
 354                 if(net->bssht.RT2RT_HT_Mode & RT_HT_CAP_USE_92SE){
 355                         pHTInfo->IOTPeer = HT_IOT_PEER_REALTEK_92SE;
 356                 }
 357                 if(net->bssht.RT2RT_HT_Mode & RT_HT_CAP_USE_SOFTAP){
 358                         pHTInfo->IOTPeer = HT_IOT_PEER_92U_SOFTAP;
 359                 }
 360         }
 361         else if(net->broadcom_cap_exist)
 362                 pHTInfo->IOTPeer = HT_IOT_PEER_BROADCOM;
 363         else if((memcmp(net->bssid, UNKNOWN_BORADCOM, 3)==0) ||
 364                         (memcmp(net->bssid, LINKSYSWRT330_LINKSYSWRT300_BROADCOM, 3)==0)||
 365                         (memcmp(net->bssid, LINKSYSWRT350_LINKSYSWRT150_BROADCOM, 3)==0)/*||
 366                         (memcmp(net->bssid, NETGEAR834Bv2_BROADCOM, 3)==0) */)
 367                 pHTInfo->IOTPeer = HT_IOT_PEER_BROADCOM;
 368         else if((memcmp(net->bssid, BELKINF5D8233V1_RALINK, 3)==0) ||
 369                         (memcmp(net->bssid, BELKINF5D82334V3_RALINK, 3)==0) ||
 370                         (memcmp(net->bssid, PCI_RALINK, 3)==0) ||
 371                         (memcmp(net->bssid, EDIMAX_RALINK, 3)==0) ||
 372                         (memcmp(net->bssid, AIRLINK_RALINK, 3)==0) ||
 373                          net->ralink_cap_exist)
 374                 pHTInfo->IOTPeer = HT_IOT_PEER_RALINK;
 375         else if((net->atheros_cap_exist )||
 376                 (memcmp(net->bssid, DLINK_ATHEROS_1, 3) == 0)||
 377                 (memcmp(net->bssid, DLINK_ATHEROS_2, 3) == 0))
 378                 pHTInfo->IOTPeer = HT_IOT_PEER_ATHEROS;
 379         else if((memcmp(net->bssid, CISCO_BROADCOM, 3)==0)||net->cisco_cap_exist)
 380                 pHTInfo->IOTPeer = HT_IOT_PEER_CISCO;
 381         else if ((memcmp(net->bssid, LINKSYS_MARVELL_4400N, 3) == 0) ||
 382                   net->marvell_cap_exist)
 383                 pHTInfo->IOTPeer = HT_IOT_PEER_MARVELL;
 384         else
 385                 pHTInfo->IOTPeer = HT_IOT_PEER_UNKNOWN;
 386
 387         RTLLIB_DEBUG(RTLLIB_DL_IOT, "Joseph debug!! IOTPEER: %x\n", pHTInfo->IOTPeer);
 388 }
 389
 390 u8 HTIOTActIsDisableMCS14(struct rtllib_device* ieee, u8* PeerMacAddr)
 391 {
 392         u8 ret = 0;
 393 #if 0
 394 #if (HAL_CODE_BASE==RTL8192 && DEV_BUS_TYPE==USB_INTERFACE)
 395         if((memcmp(PeerMacAddr, UNKNOWN_BORADCOM, 3)==0) ||
 396                 (memcmp(PeerMacAddr, LINKSYSWRT330_LINKSYSWRT300_BROADCOM, 3)==0)
 397             )
 398         {
 399                 ret = 1;
 400         }
 401
 402
 403         if(pHTInfo->bCurrentRT2RTAggregation)
 404         {
 405                 ret = 1;
 406         }
 407 #endif
 408 #endif
 409         return ret;
 410  }
 411
 412
 413 bool HTIOTActIsDisableMCS15(struct rtllib_device* ieee)
 414 {
 415         bool retValue = false;
 416
 417 #if defined(RTL8192U)
 418         if(ieee->current_network.bssht.bdBandWidth == HT_CHANNEL_WIDTH_20_40)
 419         retValue = true;
 420         else
 421                 retValue = false;
 422 #endif
 423
 424
 425         return retValue;
 426 }
 427
 428 bool HTIOTActIsDisableMCSTwoSpatialStream(struct rtllib_device* ieee)
 429 {
 430         bool retValue = false;
 431 #ifdef RTL8192U
 432         struct rtllib_network* net = &ieee->current_network;
 433
 434         if((ieee->pHTInfo->bCurrentHTSupport == true) && (ieee->pairwise_key_type == KEY_TYPE_CCMP))
 435         {
 436                 if((memcmp(net->bssid, BELKINF5D8233V1_RALINK, 3)==0) ||
 437                                 (memcmp(net->bssid, PCI_RALINK, 3)==0) ||
 438                                 (memcmp(net->bssid, EDIMAX_RALINK, 3)==0))
 439                 {
 440                         retValue = false;
 441                 }
 442         }
 443 #endif
 444 #if defined(RTL8192SU) || defined RTL8192CE
 445         PRT_HIGH_THROUGHPUT     pHTInfo = ieee->pHTInfo;
 446         if (ieee->rtllib_ap_sec_type &&
 447                 (ieee->rtllib_ap_sec_type(ieee)&(SEC_ALG_WEP|SEC_ALG_TKIP)))
 448         {
 449                 if( (pHTInfo->IOTPeer != HT_IOT_PEER_ATHEROS) &&
 450                         (pHTInfo->IOTPeer != HT_IOT_PEER_UNKNOWN) &&
 451                         (pHTInfo->IOTPeer != HT_IOT_PEER_MARVELL) &&
 452                         (pHTInfo->IOTPeer != HT_IOT_PEER_REALTEK_92SE) &&
 453                         (pHTInfo->IOTPeer != HT_IOT_PEER_RALINK) )
 454                         retValue = true;
 455         }
 456 #elif defined(RTL8192SE)
 457         PRT_HIGH_THROUGHPUT     pHTInfo = ieee->pHTInfo;
 458         if (ieee->rtllib_ap_sec_type &&
 459                 (ieee->rtllib_ap_sec_type(ieee)&SEC_ALG_TKIP)) {
 460                         if(pHTInfo->IOTPeer == HT_IOT_PEER_RALINK){
 461                                 retValue = true;
 462                         }
 463                 }
 464 #endif
 465         return retValue;
 466 }
 467
 468 u8 HTIOTActIsDisableEDCATurbo(struct rtllib_device*     ieee, u8* PeerMacAddr)
 469 {
 470         u8      retValue = false;
 471
 472         return retValue;
 473 #if 0
 474         if((memcmp(PeerMacAddr, UNKNOWN_BORADCOM, 3)==0)||
 475                 (memcmp(PeerMacAddr, LINKSYSWRT330_LINKSYSWRT300_BROADCOM, 3)==0)||
 476                 (memcmp(PeerMacAddr, LINKSYSWRT350_LINKSYSWRT150_BROADCOM, 3)==0))
 477
 478         {
 479                 retValue = 1;
 480         }
 481
 482         return retValue;
 483 #endif
 484 }
 485
 486
 487 bool HTIOTActIsEnableBETxOPLimit(struct rtllib_device* ieee)
 488 {
 489         bool    retValue = false;
 490
 491 #if defined RTL8192SU
 492         if(ieee->mode == IEEE_G)
 493                 retValue = true;
 494 #elif defined RTL8192CE
 495         if(ieee->mode == IEEE_G ||
 496                 (ieee->rtllib_ap_sec_type(ieee)&(SEC_ALG_WEP|SEC_ALG_TKIP)))
 497                 retValue = true;
 498 #endif
 499
 500         return retValue;
 501 }
 502
 503
 504 u8 HTIOTActIsMgntUseCCK6M(struct rtllib_device* ieee,struct rtllib_network *network)
 505 {
 506         u8      retValue = 0;
 507
 508
 509 #if (defined RTL8192U || defined RTL8192E || defined RTL8190P)
 510         {
 511         if(ieee->pHTInfo->IOTPeer == HT_IOT_PEER_BROADCOM)
 512         {
 513                 retValue = 1;
 514         }
 515         }
 516 #endif
 517
 518         return retValue;
 519 }
 520
 521 u8
 522 HTIOTActWAIOTBroadcom(struct rtllib_device* ieee)
 523 {
 524         PRT_HIGH_THROUGHPUT     pHTInfo = ieee->pHTInfo;
 525         u8              retValue = false;
 526         u8              boundary=59;
 527
 528         pHTInfo->bWAIotBroadcom = false;
 529         if(ieee->pHTInfo->IOTPeer == HT_IOT_PEER_BROADCOM)
 530         {
 531                 if(ieee->current_network.bssht.bdBandWidth == HT_CHANNEL_WIDTH_20_40)
 532                 {
 533                         if(!(pHTInfo->bCurBW40MHz))
 534                         {
 535                                 if(ieee->current_network.mode != WIRELESS_MODE_B)
 536                                 {
 537                                         pHTInfo->bWAIotBroadcom = true;
 538
 539                                         if(ieee->b_customer_lenovo_id == true)
 540                                                 boundary = 30;
 541
 542                                         if( ieee->current_network.RSSI >= boundary)
 543                                                 retValue = true;
 544                                 }
 545                         }else{
 546                                 ;
 547                         }
 548                 }
 549         }
 550         return retValue;
 551 }
 552
 553 u8 HTIOTActIsForcedCTS2Self(struct rtllib_device *ieee, struct rtllib_network *network)
 554 {
 555         u8      retValue = 0;
 556 #if (defined RTL8192SE || defined RTL8192SU || defined RTL8192CE)
 557         if((ieee->pHTInfo->IOTPeer == HT_IOT_PEER_MARVELL) ||(ieee->pHTInfo->IOTPeer == HT_IOT_PEER_ATHEROS) )
 558 #else
 559         if(ieee->pHTInfo->IOTPeer == HT_IOT_PEER_MARVELL)
 560 #endif
 561         {
 562                 retValue = 1;
 563         }
 564
 565         return retValue;
 566 }
 567
 568 u8 HTIOTActIsForcedRTSCTS(struct rtllib_device *ieee, struct rtllib_network *network)
 569 {
 570         u8      retValue = 0;
 571 #if defined(RTL8192SE) || defined(RTL8192SU)
 572         if(ieee->pHTInfo->bCurrentHTSupport)
 573         {
 574                 if((ieee->pHTInfo->IOTPeer != HT_IOT_PEER_REALTEK)&&
 575                    (ieee->pHTInfo->IOTPeer != HT_IOT_PEER_REALTEK_92SE))
 576         {
 577                         if((ieee->pHTInfo->IOTAction & HT_IOT_ACT_TX_NO_AGGREGATION) == 0)
 578                                 retValue = 1;
 579                 }
 580         }
 581 #endif
 582         return retValue;
 583 }
 584
 585 u8
 586 HTIOTActIsForcedAMSDU8K(struct rtllib_device *ieee, struct rtllib_network *network)
 587 {
 588         u8 retValue = 0;
 589
 590         return retValue;
 591 }
 592
 593 u8 HTIOTActIsCCDFsync(struct rtllib_device *ieee)
 594 {
 595         u8      retValue = 0;
 596 #if (defined RTL8190P || defined RTL8192E || defined RTL8192U  ||defined RTL8192SE)
 597         if(ieee->pHTInfo->IOTPeer == HT_IOT_PEER_BROADCOM)
 598         {
 599                 retValue = 1;
 600         }
 601 #endif
 602         return retValue;
 603 }
 604
 605 u8
 606 HTIOCActRejcectADDBARequest(struct rtllib_network *network)
 607 {
 608         u8      retValue = 0;
 609 #if (defined RTL8192SE || defined RTL8192SU || defined RTL8192CE)
 610         {
 611
 612
 613         }
 614 #endif
 615
 616         return retValue;
 617
 618 }
 619
 620 u8
 621   HTIOTActIsEDCABiasRx(struct rtllib_device* ieee,struct rtllib_network *network)
 622 {
 623         u8      retValue = 0;
 624 #ifdef RTL8192SU
 625         PRT_HIGH_THROUGHPUT     pHTInfo = ieee->pHTInfo;
 626         {
 627                 if(pHTInfo->IOTPeer==HT_IOT_PEER_ATHEROS ||
 628                    pHTInfo->IOTPeer==HT_IOT_PEER_BROADCOM ||
 629                    pHTInfo->IOTPeer==HT_IOT_PEER_RALINK)
 630                         return 1;
 631
 632         }
 633 #elif defined RTL8192CE
 634         PRT_HIGH_THROUGHPUT     pHTInfo = ieee->pHTInfo;
 635         {
 636                 if(pHTInfo->IOTPeer==HT_IOT_PEER_ATHEROS ||
 637                    pHTInfo->IOTPeer==HT_IOT_PEER_RALINK)
 638                         return 1;
 639
 640         }
 641 #elif defined RTL8192SE
 642         PRT_HIGH_THROUGHPUT     pHTInfo = ieee->pHTInfo;
 643         {
 644             if(ieee->rtllib_ap_sec_type != NULL)
 645                 if(ieee->rtllib_ap_sec_type(ieee) == SEC_ALG_CCMP)
 646                     if(pHTInfo->IOTPeer==HT_IOT_PEER_RALINK){
 647                         return 1;
 648                     }
 649
 650         }
 651 #endif
 652         return retValue;
 653 }
 654
 655 u8
 656 HTIOTActDisableShortGI(struct rtllib_device* ieee,struct rtllib_network *network)
 657 {
 658         u8      retValue = 0;
 659         PRT_HIGH_THROUGHPUT     pHTInfo = ieee->pHTInfo;
 660
 661         if(pHTInfo->IOTPeer==HT_IOT_PEER_RALINK)
 662         {
 663                         retValue = 1;
 664         }
 665
 666         return retValue;
 667 }
 668
 669 u8
 670 HTIOTActDisableHighPower(struct rtllib_device* ieee,struct rtllib_network *network)
 671 {
 672         u8      retValue = 0;
 673 #if (defined RTL8192SE || defined RTL8192SU || defined RTL8192CE)
 674         PRT_HIGH_THROUGHPUT     pHTInfo = ieee->pHTInfo;
 675 #endif
 676
 677 #ifdef RTL8192SU
 678         if(pHTInfo->IOTPeer==HT_IOT_PEER_RALINK ||
 679                 pHTInfo->IOTPeer==HT_IOT_PEER_REALTEK ||
 680                 pHTInfo->IOTPeer==HT_IOT_PEER_REALTEK_92SE)
 681         {
 682                         retValue = 1;
 683         }
 684 #elif defined RTL8192SE || defined RTL8192CE
 685         if(pHTInfo->IOTPeer==HT_IOT_PEER_RALINK ||
 686                 pHTInfo->IOTPeer==HT_IOT_PEER_REALTEK )
 687         {
 688                         retValue = 1;
 689         }
 690 #endif
 691         return retValue;
 692 }
 693
 694 void
 695 HTIOTActDetermineRaFunc(struct rtllib_device* ieee,     bool    bPeerRx2ss)
 696 {
 697         PRT_HIGH_THROUGHPUT     pHTInfo = ieee->pHTInfo;
 698         pHTInfo->IOTRaFunc &= HT_IOT_RAFUNC_DISABLE_ALL;
 699
 700         if(pHTInfo->IOTPeer == HT_IOT_PEER_RALINK && !bPeerRx2ss)
 701                 pHTInfo->IOTRaFunc |= HT_IOT_RAFUNC_PEER_1R;
 702
 703         if(pHTInfo->IOTAction & HT_IOT_ACT_AMSDU_ENABLE)
 704                 pHTInfo->IOTRaFunc |= HT_IOT_RAFUNC_TX_AMSDU;
 705
 706 }
 707
 708
 709 u8
 710 HTIOTActIsDisableTx40MHz(struct rtllib_device* ieee,struct rtllib_network *network)
 711 {
 712         u8      retValue = 0;
 713
 714 #if (defined RTL8192SU || defined RTL8192SE || defined RTL8192CE)
 715         PRT_HIGH_THROUGHPUT     pHTInfo = ieee->pHTInfo;
 716         if(     (KEY_TYPE_WEP104 == ieee->pairwise_key_type) ||
 717                 (KEY_TYPE_WEP40 == ieee->pairwise_key_type) ||
 718                 (KEY_TYPE_WEP104 == ieee->group_key_type) ||
 719                 (KEY_TYPE_WEP40 == ieee->group_key_type) ||
 720                 (KEY_TYPE_TKIP == ieee->pairwise_key_type) )
 721         {
 722                 if((pHTInfo->IOTPeer==HT_IOT_PEER_REALTEK) && (network->bssht.bdSupportHT))
 723                         retValue = 1;
 724         }
 725 #endif
 726
 727         return retValue;
 728 }
 729
 730 u8
 731 HTIOTActIsTxNoAggregation(struct rtllib_device* ieee,struct rtllib_network *network)
 732 {
 733         u8 retValue = 0;
 734
 735 #if (defined RTL8192SU || defined RTL8192SE || defined RTL8192CE)
 736         PRT_HIGH_THROUGHPUT     pHTInfo = ieee->pHTInfo;
 737         if(     (KEY_TYPE_WEP104 == ieee->pairwise_key_type) ||
 738                 (KEY_TYPE_WEP40 == ieee->pairwise_key_type) ||
 739                 (KEY_TYPE_WEP104 == ieee->group_key_type) ||
 740                 (KEY_TYPE_WEP40 == ieee->group_key_type) ||
 741                 (KEY_TYPE_TKIP == ieee->pairwise_key_type) )
 742         {
 743                 if(pHTInfo->IOTPeer==HT_IOT_PEER_REALTEK)
 744                         retValue = 1;
 745         }
 746 #endif
 747
 748         return retValue;
 749 }
 750
 751
 752 u8
 753 HTIOTActIsDisableTx2SS(struct rtllib_device* ieee,struct rtllib_network *network)
 754 {
 755         u8      retValue = 0;
 756
 757 #if (defined RTL8192SU || defined RTL8192SE || defined RTL8192CE)
 758         PRT_HIGH_THROUGHPUT     pHTInfo = ieee->pHTInfo;
 759         if(     (KEY_TYPE_WEP104 == ieee->pairwise_key_type) ||
 760                 (KEY_TYPE_WEP40 == ieee->pairwise_key_type) ||
 761                 (KEY_TYPE_WEP104 == ieee->group_key_type) ||
 762                 (KEY_TYPE_WEP40 == ieee->group_key_type) ||
 763                 (KEY_TYPE_TKIP == ieee->pairwise_key_type) )
 764         {
 765                 if((pHTInfo->IOTPeer==HT_IOT_PEER_REALTEK) && (network->bssht.bdSupportHT))
 766                         retValue = 1;
 767         }
 768 #endif
 769
 770         return retValue;
 771 }
 772
 773
 774 bool HTIOCActIsDisableCckRate(struct rtllib_device* ieee,struct rtllib_network *network)
 775 {
 776         bool    retValue = false;
 777 #if defined(RTL8192SU)
 778         PRT_HIGH_THROUGHPUT     pHTInfo = ieee->pHTInfo;
 779         if(pHTInfo->IOTPeer == HT_IOT_PEER_BROADCOM)
 780         {
 781                 if((memcmp(network->bssid, NETGEAR_BROADCOM, 3)==0)
 782                         && (network->bssht.bdBandWidth == HT_CHANNEL_WIDTH_20_40))
 783                         return true;
 784         }
 785 #endif
 786         return retValue;
 787 }
 788
 789
 790 bool HTIOCActAllowPeerAggOnePacket(struct rtllib_device* ieee,struct rtllib_network *network)
 791 {
 792         bool    retValue = false;
 793 #if defined(RTL8192SE) || defined(RTL8192SU)
 794         PRT_HIGH_THROUGHPUT     pHTInfo = ieee->pHTInfo;
 795         {
 796                 if(ieee->VersionID<2)
 797                 if(pHTInfo->IOTPeer == HT_IOT_PEER_MARVELL)
 798                         return true;
 799
 800         }
 801 #endif
 802         return retValue;
 803 }
 804
 805 bool
 806 HTIOTActIsNullDataPowerSaving(struct rtllib_device* ieee,struct rtllib_network *network)
 807 {
 808         bool    retValue = false;
 809 #if defined(RTL8192SE) || defined(RTL8192SU)
 810         PRT_HIGH_THROUGHPUT     pHTInfo = ieee->pHTInfo;
 811         {
 812                 if(pHTInfo->IOTPeer == HT_IOT_PEER_BROADCOM)
 813                         return true;
 814
 815         }
 816 #endif
 817         return retValue;
 818 }
 819
 820 void HTResetIOTSetting(
 821         PRT_HIGH_THROUGHPUT             pHTInfo
 822 )
 823 {
 824         pHTInfo->IOTAction = 0;
 825         pHTInfo->IOTPeer = HT_IOT_PEER_UNKNOWN;
 826         pHTInfo->IOTRaFunc = 0;
 827 }
 828
 829
 830 #ifdef _RTL8192_EXT_PATCH_
 831 void HTConstructCapabilityElement(struct rtllib_device* ieee, u8* posHTCap, u8* len, u8 IsEncrypt, u8 bIsBcn)
 832 #else
 833 void HTConstructCapabilityElement(struct rtllib_device* ieee, u8* posHTCap, u8* len, u8 IsEncrypt)
 834 #endif
 835 {
 836         PRT_HIGH_THROUGHPUT     pHT = ieee->pHTInfo;
 837         PHT_CAPABILITY_ELE      pCapELE = NULL;
 838
 839         if ((posHTCap == NULL) || (pHT == NULL))
 840         {
 841                 RTLLIB_DEBUG(RTLLIB_DL_ERR, "posHTCap or pHTInfo can't be null in HTConstructCapabilityElement()\n");
 842                 return;
 843         }
 844         memset(posHTCap, 0, *len);
 845         if(pHT->ePeerHTSpecVer == HT_SPEC_VER_EWC)
 846         {
 847                 u8      EWC11NHTCap[] = {0x00, 0x90, 0x4c, 0x33};
 848                 memcpy(posHTCap, EWC11NHTCap, sizeof(EWC11NHTCap));
 849                 pCapELE = (PHT_CAPABILITY_ELE)&(posHTCap[4]);
 850         }else
 851         {
 852                 pCapELE = (PHT_CAPABILITY_ELE)posHTCap;
 853         }
 854
 855         pCapELE->AdvCoding              = 0;
 856         if(ieee->GetHalfNmodeSupportByAPsHandler(ieee->dev))
 857         {
 858                 pCapELE->ChlWidth = 0;
 859         }
 860         else
 861         {
 862 #ifdef _RTL8192_EXT_PATCH_
 863                 if(bIsBcn)
 864                         pCapELE->ChlWidth = (pHT->bCurBW40MHz?1:0);
 865                 else
 866 #endif
 867                         pCapELE->ChlWidth = (pHT->bRegBW40MHz?1:0);
 868         }
 869
 870         pCapELE->MimoPwrSave            = pHT->SelfMimoPs;
 871         pCapELE->GreenField             = 0;
 872         pCapELE->ShortGI20Mhz           = 1;
 873         pCapELE->ShortGI40Mhz           = 1;
 874         pCapELE->TxSTBC                 = 1;
 875 #ifdef Rtl8192SE
 876         pCapELE->TxSTBC                 = 0;
 877 #endif
 878         pCapELE->RxSTBC                 = 0;
 879         pCapELE->DelayBA                = 0;
 880         pCapELE->MaxAMSDUSize   = (MAX_RECEIVE_BUFFER_SIZE>=7935)?1:0;
 881         pCapELE->DssCCk                 = ((pHT->bRegBW40MHz)?(pHT->bRegSuppCCK?1:0):0);
 882         pCapELE->PSMP                   = 0;
 883         pCapELE->LSigTxopProtect        = 0;
 884
 885
 886         RTLLIB_DEBUG(RTLLIB_DL_HT, "TX HT cap/info ele BW=%d MaxAMSDUSize:%d DssCCk:%d\n", pCapELE->ChlWidth, pCapELE->MaxAMSDUSize, pCapELE->DssCCk);
 887
 888         if( IsEncrypt)
 889         {
 890                 pCapELE->MPDUDensity    = 7;
 891                 pCapELE->MaxRxAMPDUFactor       = 2;
 892         }
 893         else
 894         {
 895                 pCapELE->MaxRxAMPDUFactor       = 3;
 896                 pCapELE->MPDUDensity    = 0;
 897         }
 898
 899         memcpy(pCapELE->MCS, ieee->Regdot11HTOperationalRateSet, 16);
 900         if(pHT->IOTAction & HT_IOT_ACT_DISABLE_MCS15)
 901                 pCapELE->MCS[1] &= 0x7f;
 902
 903         if(pHT->IOTAction & HT_IOT_ACT_DISABLE_MCS14)
 904                 pCapELE->MCS[1] &= 0xbf;
 905
 906         if(pHT->IOTAction & HT_IOT_ACT_DISABLE_ALL_2SS)
 907                 pCapELE->MCS[1] &= 0x00;
 908
 909         if(ieee->GetHalfNmodeSupportByAPsHandler(ieee->dev))
 910         {
 911                 int i;
 912                 for(i = 1; i< 16; i++)
 913                         pCapELE->MCS[i] = 0;
 914         }
 915
 916         memset(&pCapELE->ExtHTCapInfo, 0, 2);
 917
 918
 919         memset(pCapELE->TxBFCap, 0, 4);
 920
 921         pCapELE->ASCap = 0;
 922         if(pHT->ePeerHTSpecVer == HT_SPEC_VER_EWC)
 923                 *len = 30 + 2;
 924         else
 925                 *len = 26 + 2;
 926
 927
 928
 929
 930         return;
 931
 932 }
 933 void HTConstructInfoElement(struct rtllib_device* ieee, u8* posHTInfo, u8* len, u8 IsEncrypt)
 934 {
 935         PRT_HIGH_THROUGHPUT     pHT = ieee->pHTInfo;
 936         PHT_INFORMATION_ELE             pHTInfoEle = (PHT_INFORMATION_ELE)posHTInfo;
 937         if ((posHTInfo == NULL) || (pHTInfoEle == NULL))
 938         {
 939                 RTLLIB_DEBUG(RTLLIB_DL_ERR, "posHTInfo or pHTInfoEle can't be null in HTConstructInfoElement()\n");
 940                 return;
 941         }
 942
 943         memset(posHTInfo, 0, *len);
 944 #ifdef _RTL8192_EXT_PATCH_
 945         if ((ieee->iw_mode == IW_MODE_ADHOC) || (ieee->iw_mode == IW_MODE_MASTER) ||(ieee->iw_mode == IW_MODE_MESH) )
 946 #else
 947         if ( (ieee->iw_mode == IW_MODE_ADHOC) || (ieee->iw_mode == IW_MODE_MASTER))
 948 #endif
 949         {
 950                 pHTInfoEle->ControlChl                  = ieee->current_network.channel;
 951 #ifdef _RTL8192_EXT_PATCH_
 952                 if((!ieee->only_mesh) && (ieee->iw_mode == IW_MODE_MESH) && (ieee->state == RTLLIB_LINKED))
 953                         pHTInfoEle->ExtChlOffset                        = ((pHT->bRegBW40MHz == false)?HT_EXTCHNL_OFFSET_NO_EXT:
 954                                                                                                 ieee->APExtChlOffset);
 955                 else if(ieee->iw_mode == IW_MODE_MESH)
 956                         pHTInfoEle->ExtChlOffset                        = ((pHT->bRegBW40MHz == false)?HT_EXTCHNL_OFFSET_NO_EXT:
 957                                                                                         (ieee->current_mesh_network.channel<=6)?
 958                                                                                                 HT_EXTCHNL_OFFSET_UPPER:HT_EXTCHNL_OFFSET_LOWER);
 959                 else
 960 #endif
 961                         pHTInfoEle->ExtChlOffset                        = ((pHT->bRegBW40MHz == false)?HT_EXTCHNL_OFFSET_NO_EXT:
 962                                                                                         (ieee->current_network.channel<=6)?
 963                                                                                                 HT_EXTCHNL_OFFSET_UPPER:HT_EXTCHNL_OFFSET_LOWER);
 964                 pHTInfoEle->RecommemdedTxWidth  = pHT->bRegBW40MHz;
 965                 pHTInfoEle->RIFS                                        = 0;
 966                 pHTInfoEle->PSMPAccessOnly              = 0;
 967                 pHTInfoEle->SrvIntGranularity           = 0;
 968                 pHTInfoEle->OptMode                             = pHT->CurrentOpMode;
 969                 pHTInfoEle->NonGFDevPresent             = 0;
 970                 pHTInfoEle->DualBeacon                  = 0;
 971                 pHTInfoEle->SecondaryBeacon             = 0;
 972                 pHTInfoEle->LSigTxopProtectFull         = 0;
 973                 pHTInfoEle->PcoActive                           = 0;
 974                 pHTInfoEle->PcoPhase                            = 0;
 975
 976                 memset(pHTInfoEle->BasicMSC, 0, 16);
 977
 978
 979                 *len = 22 + 2;
 980
 981         }
 982         else
 983         {
 984                 *len = 0;
 985         }
 986         return;
 987 }
 988
 989 void HTConstructRT2RTAggElement(struct rtllib_device* ieee, u8* posRT2RTAgg, u8* len)
 990 {
 991         if (posRT2RTAgg == NULL) {
 992                 RTLLIB_DEBUG(RTLLIB_DL_ERR, "posRT2RTAgg can't be null in HTConstructRT2RTAggElement()\n");
 993                 return;
 994         }
 995         memset(posRT2RTAgg, 0, *len);
 996         *posRT2RTAgg++ = 0x00;
 997         *posRT2RTAgg++ = 0xe0;
 998         *posRT2RTAgg++ = 0x4c;
 999         *posRT2RTAgg++ = 0x02;
1000         *posRT2RTAgg++ = 0x01;
1001
1002 #ifdef RTL8192CE
1003         *posRT2RTAgg = 0x70;
1004 #else
1005         *posRT2RTAgg = 0x10;
1006 #endif
1007
1008         if(ieee->bSupportRemoteWakeUp) {
1009                 *posRT2RTAgg |= RT_HT_CAP_USE_WOW;
1010         }
1011
1012         *len = 6 + 2;
1013
1014         return;
1015
1016 #ifdef TODO
1017         posRT2RTAgg->Length = 6;
1018 #endif
1019
1020
1021
1022
1023 }
1024
1025 u8 HT_PickMCSRate(struct rtllib_device* ieee, u8* pOperateMCS)
1026 {
1027         u8                                      i;
1028         if (pOperateMCS == NULL)
1029         {
1030                 RTLLIB_DEBUG(RTLLIB_DL_ERR, "pOperateMCS can't be null in HT_PickMCSRate()\n");
1031                 return false;
1032         }
1033
1034         switch(ieee->mode)
1035         {
1036         case IEEE_A:
1037         case IEEE_B:
1038         case IEEE_G:
1039
1040                         for(i=0;i<=15;i++){
1041                                 pOperateMCS[i] = 0;
1042                         }
1043                         break;
1044
1045         case IEEE_N_24G:
1046         case IEEE_N_5G:
1047
1048                         pOperateMCS[0] &=RATE_ADPT_1SS_MASK;
1049                         pOperateMCS[1] &=RATE_ADPT_2SS_MASK;
1050                         pOperateMCS[3] &=RATE_ADPT_MCS32_MASK;
1051                         break;
1052
1053         default:
1054
1055                         break;
1056
1057         }
1058
1059         return true;
1060 }
1061
1062 u8 HTGetHighestMCSRate(struct rtllib_device* ieee, u8* pMCSRateSet, u8* pMCSFilter)
1063 {
1064         u8              i, j;
1065         u8              bitMap;
1066         u8              mcsRate = 0;
1067         u8              availableMcsRate[16];
1068         if (pMCSRateSet == NULL || pMCSFilter == NULL)
1069         {
1070                 RTLLIB_DEBUG(RTLLIB_DL_ERR, "pMCSRateSet or pMCSFilter can't be null in HTGetHighestMCSRate()\n");
1071                 return false;
1072         }
1073         for(i=0; i<16; i++)
1074                 availableMcsRate[i] = pMCSRateSet[i] & pMCSFilter[i];
1075
1076         for(i = 0; i < 16; i++)
1077         {
1078                 if(availableMcsRate[i] != 0)
1079                         break;
1080         }
1081         if(i == 16)
1082                 return false;
1083
1084         for(i = 0; i < 16; i++)
1085         {
1086                 if(availableMcsRate[i] != 0)
1087                 {
1088                         bitMap = availableMcsRate[i];
1089                         for(j = 0; j < 8; j++)
1090                         {
1091                                 if((bitMap%2) != 0)
1092                                 {
1093                                         if(HTMcsToDataRate(ieee, (8*i+j)) > HTMcsToDataRate(ieee, mcsRate))
1094                                                 mcsRate = (8*i+j);
1095                                 }
1096                                 bitMap = bitMap>>1;
1097                         }
1098                 }
1099         }
1100         return (mcsRate|0x80);
1101 }
1102
1103 u8 HTFilterMCSRate( struct rtllib_device* ieee, u8* pSupportMCS, u8* pOperateMCS)
1104 {
1105
1106         u8 i=0;
1107
1108         for(i=0;i<=15;i++){
1109                 pOperateMCS[i] = ieee->Regdot11TxHTOperationalRateSet[i]&pSupportMCS[i];
1110         }
1111
1112
1113
1114         HT_PickMCSRate(ieee, pOperateMCS);
1115
1116         if(ieee->GetHalfNmodeSupportByAPsHandler(ieee->dev))
1117                 pOperateMCS[1] = 0;
1118
1119         for(i=2; i<=15; i++)
1120                 pOperateMCS[i] = 0;
1121
1122         return true;
1123 }
1124 void HTSetConnectBwMode(struct rtllib_device* ieee, HT_CHANNEL_WIDTH    Bandwidth, HT_EXTCHNL_OFFSET    Offset);
1125 void HTOnAssocRsp(struct rtllib_device *ieee)
1126 {
1127         PRT_HIGH_THROUGHPUT     pHTInfo = ieee->pHTInfo;
1128         PHT_CAPABILITY_ELE              pPeerHTCap = NULL;
1129         PHT_INFORMATION_ELE             pPeerHTInfo = NULL;
1130         u16     nMaxAMSDUSize = 0;
1131         u8*     pMcsFilter = NULL;
1132
1133         static u8                               EWC11NHTCap[] = {0x00, 0x90, 0x4c, 0x33};
1134         static u8                               EWC11NHTInfo[] = {0x00, 0x90, 0x4c, 0x34};
1135
1136         if( pHTInfo->bCurrentHTSupport == false )
1137         {
1138                 RTLLIB_DEBUG(RTLLIB_DL_ERR, "<=== HTOnAssocRsp(): HT_DISABLE\n");
1139                 return;
1140         }
1141         RTLLIB_DEBUG(RTLLIB_DL_HT, "===> HTOnAssocRsp_wq(): HT_ENABLE\n");
1142
1143         if(!memcmp(pHTInfo->PeerHTCapBuf,EWC11NHTCap, sizeof(EWC11NHTCap)))
1144                 pPeerHTCap = (PHT_CAPABILITY_ELE)(&pHTInfo->PeerHTCapBuf[4]);
1145         else
1146                 pPeerHTCap = (PHT_CAPABILITY_ELE)(pHTInfo->PeerHTCapBuf);
1147
1148         if(!memcmp(pHTInfo->PeerHTInfoBuf, EWC11NHTInfo, sizeof(EWC11NHTInfo)))
1149                 pPeerHTInfo = (PHT_INFORMATION_ELE)(&pHTInfo->PeerHTInfoBuf[4]);
1150         else
1151                 pPeerHTInfo = (PHT_INFORMATION_ELE)(pHTInfo->PeerHTInfoBuf);
1152
1153 #ifdef _RTL8192_EXT_PATCH_
1154         ieee->APExtChlOffset = (HT_EXTCHNL_OFFSET)(pPeerHTInfo->ExtChlOffset);
1155 #endif
1156         RTLLIB_DEBUG_DATA(RTLLIB_DL_DATA|RTLLIB_DL_HT, pPeerHTCap, sizeof(HT_CAPABILITY_ELE));
1157         HTSetConnectBwMode(ieee, (HT_CHANNEL_WIDTH)(pPeerHTCap->ChlWidth), (HT_EXTCHNL_OFFSET)(pPeerHTInfo->ExtChlOffset));
1158 #if defined RTL8192SE || defined RTL8192SU || defined RTL8192CE
1159         if(pHTInfo->bCurBW40MHz == true)
1160 #endif
1161                 pHTInfo->bCurTxBW40MHz = ((pPeerHTInfo->RecommemdedTxWidth == 1)?true:false);
1162
1163         pHTInfo->bCurShortGI20MHz=
1164                 ((pHTInfo->bRegShortGI20MHz)?((pPeerHTCap->ShortGI20Mhz==1)?true:false):false);
1165         pHTInfo->bCurShortGI40MHz=
1166                 ((pHTInfo->bRegShortGI40MHz)?((pPeerHTCap->ShortGI40Mhz==1)?true:false):false);
1167
1168         pHTInfo->bCurSuppCCK =
1169                 ((pHTInfo->bRegSuppCCK)?((pPeerHTCap->DssCCk==1)?true:false):false);
1170
1171
1172         pHTInfo->bCurrent_AMSDU_Support = pHTInfo->bAMSDU_Support;
1173
1174         nMaxAMSDUSize = (pPeerHTCap->MaxAMSDUSize==0)?3839:7935;
1175
1176         if(pHTInfo->nAMSDU_MaxSize > nMaxAMSDUSize )
1177                 pHTInfo->nCurrent_AMSDU_MaxSize = nMaxAMSDUSize;
1178         else
1179                 pHTInfo->nCurrent_AMSDU_MaxSize = pHTInfo->nAMSDU_MaxSize;
1180
1181         pHTInfo->bCurrentAMPDUEnable = pHTInfo->bAMPDUEnable;
1182         if (ieee->rtllib_ap_sec_type &&
1183            (ieee->rtllib_ap_sec_type(ieee)&(SEC_ALG_WEP|SEC_ALG_TKIP))){
1184                 if( (pHTInfo->IOTPeer== HT_IOT_PEER_ATHEROS) ||
1185                                 (pHTInfo->IOTPeer == HT_IOT_PEER_UNKNOWN) )
1186                         pHTInfo->bCurrentAMPDUEnable = false;
1187         }
1188
1189         if(!pHTInfo->bRegRT2RTAggregation)
1190         {
1191                 if(pHTInfo->AMPDU_Factor > pPeerHTCap->MaxRxAMPDUFactor)
1192                         pHTInfo->CurrentAMPDUFactor = pPeerHTCap->MaxRxAMPDUFactor;
1193                 else
1194                         pHTInfo->CurrentAMPDUFactor = pHTInfo->AMPDU_Factor;
1195
1196         } else {
1197 #if 0
1198                 osTmp= PacketGetElement( asocpdu, EID_Vendor, OUI_SUB_REALTEK_AGG, OUI_SUBTYPE_DONT_CARE);
1199                 if(osTmp.Length >= 5)
1200 #endif
1201                 if (ieee->current_network.bssht.bdRT2RTAggregation)
1202                 {
1203                         if( ieee->pairwise_key_type != KEY_TYPE_NA)
1204                                 pHTInfo->CurrentAMPDUFactor = pPeerHTCap->MaxRxAMPDUFactor;
1205                         else
1206                                 pHTInfo->CurrentAMPDUFactor = HT_AGG_SIZE_64K;
1207                 }else
1208                 {
1209                         if(pPeerHTCap->MaxRxAMPDUFactor < HT_AGG_SIZE_32K)
1210                                 pHTInfo->CurrentAMPDUFactor = pPeerHTCap->MaxRxAMPDUFactor;
1211                         else
1212                                 pHTInfo->CurrentAMPDUFactor = HT_AGG_SIZE_32K;
1213                 }
1214         }
1215
1216 #if 0
1217         if(pHTInfo->MPDU_Density > pPeerHTCap->MPDUDensity)
1218                 pHTInfo->CurrentMPDUDensity = pHTInfo->MPDU_Density;
1219         else
1220                 pHTInfo->CurrentMPDUDensity = pPeerHTCap->MPDUDensity;
1221         if(ieee->pairwise_key_type != KEY_TYPE_NA )
1222                 pHTInfo->CurrentMPDUDensity     = 7;
1223 #else
1224         if(pHTInfo->MPDU_Density > pPeerHTCap->MPDUDensity)
1225                 pHTInfo->CurrentMPDUDensity = pHTInfo->MPDU_Density;
1226         else
1227                 pHTInfo->CurrentMPDUDensity = pPeerHTCap->MPDUDensity;
1228 #endif
1229 #if (defined RTL8192SE || defined RTL8192SU || defined RTL8192CE)
1230         if(ieee->SetHwRegHandler != NULL) {
1231             ieee->SetHwRegHandler( ieee->dev, HW_VAR_SHORTGI_DENSITY,  (u8*)(&ieee->MaxMssDensity));
1232             ieee->SetHwRegHandler(ieee->dev, HW_VAR_AMPDU_FACTOR, &pHTInfo->CurrentAMPDUFactor);
1233             ieee->SetHwRegHandler(ieee->dev, HW_VAR_AMPDU_MIN_SPACE, &pHTInfo->CurrentMPDUDensity);
1234         }
1235 #elif defined RTL8192CE
1236         if(ieee->SetHwRegHandler != NULL) {
1237             ieee->SetHwRegHandler(ieee->dev, HW_VAR_AMPDU_FACTOR, &pHTInfo->CurrentAMPDUFactor);
1238             ieee->SetHwRegHandler(ieee->dev, HW_VAR_AMPDU_MIN_SPACE, &pHTInfo->CurrentMPDUDensity);
1239         }
1240 #endif
1241 #ifndef RTL8190P
1242         if(pHTInfo->IOTAction & HT_IOT_ACT_TX_USE_AMSDU_8K)
1243 #else
1244         if( 0 )
1245 #endif
1246         {
1247                 pHTInfo->bCurrentAMPDUEnable = false;
1248                 pHTInfo->ForcedAMSDUMode = HT_AGG_FORCE_ENABLE;
1249                 pHTInfo->ForcedAMSDUMaxSize = 7935;
1250         }
1251         pHTInfo->bCurRxReorderEnable = pHTInfo->bRegRxReorderEnable;
1252
1253
1254         if(pPeerHTCap->MCS[0] == 0)
1255                 pPeerHTCap->MCS[0] = 0xff;
1256
1257         HTIOTActDetermineRaFunc(ieee, ((pPeerHTCap->MCS[1])!=0));
1258
1259         HTFilterMCSRate(ieee, pPeerHTCap->MCS, ieee->dot11HTOperationalRateSet);
1260
1261         pHTInfo->PeerMimoPs = pPeerHTCap->MimoPwrSave;
1262         if(pHTInfo->PeerMimoPs == MIMO_PS_STATIC)
1263                 pMcsFilter = MCS_FILTER_1SS;
1264         else
1265                 pMcsFilter = MCS_FILTER_ALL;
1266         ieee->HTHighestOperaRate = HTGetHighestMCSRate(ieee, ieee->dot11HTOperationalRateSet, pMcsFilter);
1267         ieee->HTCurrentOperaRate = ieee->HTHighestOperaRate;
1268
1269         pHTInfo->CurrentOpMode = pPeerHTInfo->OptMode;
1270
1271 }
1272
1273 void HTSetConnectBwModeCallback(struct rtllib_device* ieee);
1274 void HTInitializeHTInfo(struct rtllib_device* ieee)
1275 {
1276         PRT_HIGH_THROUGHPUT pHTInfo = ieee->pHTInfo;
1277
1278         RTLLIB_DEBUG(RTLLIB_DL_HT, "===========>%s()\n", __FUNCTION__);
1279         pHTInfo->bCurrentHTSupport = false;
1280
1281         pHTInfo->bCurBW40MHz = false;
1282         pHTInfo->bCurTxBW40MHz = false;
1283
1284         pHTInfo->bCurShortGI20MHz = false;
1285         pHTInfo->bCurShortGI40MHz = false;
1286         pHTInfo->bForcedShortGI = false;
1287
1288         pHTInfo->bCurSuppCCK = true;
1289
1290         pHTInfo->bCurrent_AMSDU_Support = false;
1291         pHTInfo->nCurrent_AMSDU_MaxSize = pHTInfo->nAMSDU_MaxSize;
1292 #ifdef _RTL8192_EXT_PATCH_
1293         pHTInfo->bCurrent_Mesh_AMSDU_Support = true;
1294 #endif
1295         pHTInfo->CurrentMPDUDensity = pHTInfo->MPDU_Density;
1296         pHTInfo->CurrentAMPDUFactor = pHTInfo->AMPDU_Factor;
1297
1298         memset((void*)(&(pHTInfo->SelfHTCap)), 0, sizeof(pHTInfo->SelfHTCap));
1299         memset((void*)(&(pHTInfo->SelfHTInfo)), 0, sizeof(pHTInfo->SelfHTInfo));
1300         memset((void*)(&(pHTInfo->PeerHTCapBuf)), 0, sizeof(pHTInfo->PeerHTCapBuf));
1301         memset((void*)(&(pHTInfo->PeerHTInfoBuf)), 0, sizeof(pHTInfo->PeerHTInfoBuf));
1302
1303         pHTInfo->bSwBwInProgress = false;
1304         pHTInfo->ChnlOp = CHNLOP_NONE;
1305
1306         pHTInfo->ePeerHTSpecVer = HT_SPEC_VER_IEEE;
1307
1308         pHTInfo->bCurrentRT2RTAggregation = false;
1309         pHTInfo->bCurrentRT2RTLongSlotTime = false;
1310         pHTInfo->RT2RT_HT_Mode = (RT_HT_CAPBILITY)0;
1311
1312         pHTInfo->IOTPeer = 0;
1313         pHTInfo->IOTAction = 0;
1314         pHTInfo->IOTRaFunc = 0;
1315
1316         {
1317                 u8* RegHTSuppRateSets = &(ieee->RegHTSuppRateSet[0]);
1318                 RegHTSuppRateSets[0] = 0xFF;
1319                 RegHTSuppRateSets[1] = 0xFF;
1320                 RegHTSuppRateSets[4] = 0x01;
1321         }
1322 }
1323 void HTInitializeBssDesc(PBSS_HT pBssHT)
1324 {
1325
1326         pBssHT->bdSupportHT = false;
1327         memset(pBssHT->bdHTCapBuf, 0, sizeof(pBssHT->bdHTCapBuf));
1328         pBssHT->bdHTCapLen = 0;
1329         memset(pBssHT->bdHTInfoBuf, 0, sizeof(pBssHT->bdHTInfoBuf));
1330         pBssHT->bdHTInfoLen = 0;
1331
1332         pBssHT->bdHTSpecVer= HT_SPEC_VER_IEEE;
1333
1334         pBssHT->bdRT2RTAggregation = false;
1335         pBssHT->bdRT2RTLongSlotTime = false;
1336         pBssHT->RT2RT_HT_Mode = (RT_HT_CAPBILITY)0;
1337 }
1338
1339 void HTResetSelfAndSavePeerSetting(struct rtllib_device* ieee,  struct rtllib_network * pNetwork)
1340 {
1341         PRT_HIGH_THROUGHPUT             pHTInfo = ieee->pHTInfo;
1342         u8      bIOTAction = 0;
1343
1344         RTLLIB_DEBUG(RTLLIB_DL_HT, "==============>%s()\n", __FUNCTION__);
1345         /*unmark bEnableHT flag here is the same reason why unmarked in function rtllib_softmac_new_net. WB 2008.09.10*/
1346         if (pNetwork->bssht.bdSupportHT)
1347         {
1348                 pHTInfo->bCurrentHTSupport = true;
1349                 pHTInfo->ePeerHTSpecVer = pNetwork->bssht.bdHTSpecVer;
1350
1351                 if(pNetwork->bssht.bdHTCapLen > 0 &&    pNetwork->bssht.bdHTCapLen <= sizeof(pHTInfo->PeerHTCapBuf))
1352                         memcpy(pHTInfo->PeerHTCapBuf, pNetwork->bssht.bdHTCapBuf, pNetwork->bssht.bdHTCapLen);
1353
1354                 if(pNetwork->bssht.bdHTInfoLen > 0 && pNetwork->bssht.bdHTInfoLen <= sizeof(pHTInfo->PeerHTInfoBuf))
1355                         memcpy(pHTInfo->PeerHTInfoBuf, pNetwork->bssht.bdHTInfoBuf, pNetwork->bssht.bdHTInfoLen);
1356
1357                 if(pHTInfo->bRegRT2RTAggregation)
1358                 {
1359                         pHTInfo->bCurrentRT2RTAggregation = pNetwork->bssht.bdRT2RTAggregation;
1360                         pHTInfo->bCurrentRT2RTLongSlotTime = pNetwork->bssht.bdRT2RTLongSlotTime;
1361                         pHTInfo->RT2RT_HT_Mode = pNetwork->bssht.RT2RT_HT_Mode;
1362                 }
1363                 else
1364                 {
1365                         pHTInfo->bCurrentRT2RTAggregation = false;
1366                         pHTInfo->bCurrentRT2RTLongSlotTime = false;
1367                         pHTInfo->RT2RT_HT_Mode = (RT_HT_CAPBILITY)0;
1368                 }
1369
1370                 HTIOTPeerDetermine(ieee);
1371
1372                 pHTInfo->IOTAction = 0;
1373                 bIOTAction = HTIOTActIsDisableMCS14(ieee, pNetwork->bssid);
1374                 if(bIOTAction)
1375                         pHTInfo->IOTAction |= HT_IOT_ACT_DISABLE_MCS14;
1376
1377                 bIOTAction = HTIOTActIsDisableMCS15(ieee);
1378                 if(bIOTAction)
1379                         pHTInfo->IOTAction |= HT_IOT_ACT_DISABLE_MCS15;
1380
1381                 bIOTAction = HTIOTActIsDisableMCSTwoSpatialStream(ieee);
1382                 if(bIOTAction)
1383                         pHTInfo->IOTAction |= HT_IOT_ACT_DISABLE_ALL_2SS;
1384
1385
1386                 bIOTAction = HTIOTActIsDisableEDCATurbo(ieee, pNetwork->bssid);
1387                 if(bIOTAction)
1388                         pHTInfo->IOTAction |= HT_IOT_ACT_DISABLE_EDCA_TURBO;
1389
1390 #if defined(RTL8190P) || defined(RTL8192E) || defined(RTL8192U)
1391                 bIOTAction = HTIOTActIsMgntUseCCK6M(ieee,pNetwork);
1392                 if(bIOTAction)
1393                         pHTInfo->IOTAction |= HT_IOT_ACT_MGNT_USE_CCK_6M;
1394 #elif defined(RTL8192SE) || defined(RTL8192SU) || defined RTL8192CE
1395                 bIOTAction = HTIOTActWAIOTBroadcom(ieee);
1396                 if(bIOTAction)
1397                 {
1398                         pHTInfo->IOTAction |= HT_IOT_ACT_WA_IOT_Broadcom;
1399                 }
1400 #endif
1401                 bIOTAction = HTIOTActIsCCDFsync(ieee);
1402                 if(bIOTAction)
1403                         pHTInfo->IOTAction |= HT_IOT_ACT_CDD_FSYNC;
1404 #if defined(RTL8192SU) || defined(RTL8192SE) || defined RTL8192CE
1405                 bIOTAction = HTIOTActIsForcedCTS2Self(ieee,pNetwork);
1406                 if(bIOTAction)
1407                         pHTInfo->IOTAction |= HT_IOT_ACT_FORCED_CTS2SELF;
1408
1409
1410                 bIOTAction = HTIOTActIsEnableBETxOPLimit(ieee);
1411                 if(bIOTAction)
1412                         pHTInfo->IOTAction |= HT_IOT_ACT_FORCED_ENABLE_BE_TXOP;
1413
1414 #if defined(RTL8192SU)
1415                 bIOTAction = HTIOCActRejcectADDBARequest(pNetwork);
1416                 if(bIOTAction)
1417                         pHTInfo->IOTAction |= HT_IOT_ACT_REJECT_ADDBA_REQ;
1418 #endif
1419
1420                 bIOTAction = HTIOCActAllowPeerAggOnePacket(ieee, pNetwork);
1421                 if(bIOTAction)
1422                         pHTInfo->IOTAction |= HT_IOT_ACT_ALLOW_PEER_AGG_ONE_PKT;
1423
1424                 bIOTAction = HTIOTActIsEDCABiasRx(ieee, pNetwork);
1425                 if(bIOTAction)
1426                         pHTInfo->IOTAction |= HT_IOT_ACT_EDCA_BIAS_ON_RX;
1427
1428 #if defined(RTL8192SU)
1429                 bIOTAction = HTIOCActIsDisableCckRate(ieee, pNetwork);
1430                 if(bIOTAction)
1431                         pHTInfo->IOTAction |= HT_IOT_ACT_DISABLE_CCK_RATE;
1432 #endif
1433                 bIOTAction = HTIOTActDisableShortGI(ieee, pNetwork);
1434                 if(bIOTAction)
1435                         pHTInfo->IOTAction |= HT_IOT_ACT_DISABLE_SHORT_GI;
1436
1437                 bIOTAction = HTIOTActDisableHighPower(ieee, pNetwork);
1438                 if(bIOTAction)
1439                         pHTInfo->IOTAction |= HT_IOT_ACT_DISABLE_HIGH_POWER;
1440
1441
1442                 bIOTAction = HTIOTActIsForcedAMSDU8K(ieee, pNetwork);
1443                 if(bIOTAction)
1444                         pHTInfo->IOTAction |= HT_IOT_ACT_TX_USE_AMSDU_8K;
1445
1446 #if defined(RTL8192SU)
1447                 bIOTAction = HTIOTActIsTxNoAggregation(ieee, pNetwork);
1448                 if(bIOTAction)
1449                         pHTInfo->IOTAction |= HT_IOT_ACT_TX_NO_AGGREGATION;
1450
1451                 bIOTAction = HTIOTActIsDisableTx40MHz(ieee, pNetwork);
1452                 if(bIOTAction)
1453                         pHTInfo->IOTAction |= HT_IOT_ACT_DISABLE_TX_40_MHZ;
1454
1455                 bIOTAction = HTIOTActIsDisableTx2SS(ieee, pNetwork);
1456                 if(bIOTAction)
1457                         pHTInfo->IOTAction |= HT_IOT_ACT_DISABLE_TX_2SS;
1458 #endif
1459
1460                 bIOTAction = HTIOTActIsForcedRTSCTS(ieee, pNetwork);
1461                 if(bIOTAction)
1462                         pHTInfo->IOTAction |= HT_IOT_ACT_FORCED_RTS;
1463
1464                 bIOTAction = HTIOTActIsNullDataPowerSaving(ieee, pNetwork);
1465                 if(bIOTAction)
1466                         pHTInfo->IOTAction |= HT_IOT_ACT_NULL_DATA_POWER_SAVING;
1467 #endif
1468         }
1469         else
1470         {
1471                 pHTInfo->bCurrentHTSupport = false;
1472                 pHTInfo->bCurrentRT2RTAggregation = false;
1473                 pHTInfo->bCurrentRT2RTLongSlotTime = false;
1474                 pHTInfo->RT2RT_HT_Mode = (RT_HT_CAPBILITY)0;
1475
1476                 pHTInfo->IOTAction = 0;
1477                 pHTInfo->IOTRaFunc = 0;
1478         }
1479
1480 }
1481
1482 void HTUpdateSelfAndPeerSetting(struct rtllib_device* ieee,     struct rtllib_network * pNetwork)
1483 {
1484         PRT_HIGH_THROUGHPUT     pHTInfo = ieee->pHTInfo;
1485         PHT_INFORMATION_ELE             pPeerHTInfo = (PHT_INFORMATION_ELE)pNetwork->bssht.bdHTInfoBuf;
1486
1487         if(pHTInfo->bCurrentHTSupport)
1488         {
1489                 if(pNetwork->bssht.bdHTInfoLen != 0)
1490                         pHTInfo->CurrentOpMode = pPeerHTInfo->OptMode;
1491
1492         }
1493 }
1494
1495 void HTUseDefaultSetting(struct rtllib_device* ieee)
1496 {
1497         PRT_HIGH_THROUGHPUT pHTInfo = ieee->pHTInfo;
1498
1499         if(pHTInfo->bEnableHT)
1500         {
1501                 pHTInfo->bCurrentHTSupport = true;
1502                 pHTInfo->bCurSuppCCK = pHTInfo->bRegSuppCCK;
1503
1504                 pHTInfo->bCurBW40MHz = pHTInfo->bRegBW40MHz;
1505
1506                 pHTInfo->bCurShortGI20MHz= pHTInfo->bRegShortGI20MHz;
1507
1508                 pHTInfo->bCurShortGI40MHz= pHTInfo->bRegShortGI40MHz;
1509 #ifdef _RTL8192_EXT_PATCH_
1510                 ieee->current_mesh_network.qos_data.supported = 1;
1511                 ieee->current_mesh_network.qos_data.active = ieee->current_mesh_network.qos_data.supported;
1512 #endif
1513
1514 #ifdef ENABLE_AMSDU
1515                 if(ieee->iw_mode == IW_MODE_ADHOC)
1516                 {
1517                         ieee->current_network.qos_data.supported = 1;
1518                         ieee->current_network.qos_data.active = ieee->current_network.qos_data.supported;
1519                         pHTInfo->bCurrent_AMSDU_Support = 1;
1520                 }
1521 #ifdef _RTL8192_EXT_PATCH_
1522                 else if(ieee->iw_mode == IW_MODE_MESH)
1523                 {
1524                         pHTInfo->bCurrent_Mesh_AMSDU_Support = 1;
1525                         pHTInfo->bCurrent_AMSDU_Support = pHTInfo->bAMSDU_Support;
1526                 }
1527 #endif
1528                 else
1529                         pHTInfo->bCurrent_AMSDU_Support = pHTInfo->bAMSDU_Support;
1530 #else
1531                 pHTInfo->bCurrent_AMSDU_Support = pHTInfo->bAMSDU_Support;
1532 #endif
1533                 pHTInfo->nCurrent_AMSDU_MaxSize = pHTInfo->nAMSDU_MaxSize;
1534
1535 #ifdef ENABLE_AMSDU
1536                 if(ieee->iw_mode == IW_MODE_ADHOC)
1537                         pHTInfo->bCurrentAMPDUEnable = 0;
1538 #ifdef _RTL8192_EXT_PATCH_
1539                 else if(ieee->iw_mode == IW_MODE_MESH)
1540                 {
1541                         pHTInfo->bCurrentMeshAMPDUEnable = 0;
1542                         pHTInfo->bCurrentAMPDUEnable = pHTInfo->bAMPDUEnable;
1543                 }
1544 #endif
1545                 else
1546                         pHTInfo->bCurrentAMPDUEnable = pHTInfo->bAMPDUEnable;
1547 #else
1548                 pHTInfo->bCurrentAMPDUEnable = pHTInfo->bAMPDUEnable;
1549 #endif
1550                 pHTInfo->CurrentAMPDUFactor = pHTInfo->AMPDU_Factor;
1551
1552                 pHTInfo->CurrentMPDUDensity = pHTInfo->CurrentMPDUDensity;
1553
1554
1555                 HTFilterMCSRate(ieee, ieee->Regdot11TxHTOperationalRateSet, ieee->dot11HTOperationalRateSet);
1556 #ifdef TODO
1557                 Adapter->HalFunc.InitHalRATRTableHandler( Adapter, &pMgntInfo->dot11OperationalRateSet, pMgntInfo->dot11HTOperationalRateSet);
1558 #endif
1559                 ieee->HTHighestOperaRate = HTGetHighestMCSRate(ieee, ieee->dot11HTOperationalRateSet, MCS_FILTER_ALL);
1560                 ieee->HTCurrentOperaRate = ieee->HTHighestOperaRate;
1561
1562 #if (defined RTL8192SE || defined RTL8192SU || defined RTL8192CE)
1563                 if(ieee->SetHwRegHandler != NULL) {
1564                         ieee->SetHwRegHandler( ieee->dev, HW_VAR_SHORTGI_DENSITY,  (u8*)(&ieee->MaxMssDensity));
1565                         ieee->SetHwRegHandler(ieee->dev, HW_VAR_AMPDU_FACTOR, &pHTInfo->CurrentAMPDUFactor);
1566                         ieee->SetHwRegHandler(ieee->dev, HW_VAR_AMPDU_MIN_SPACE, &pHTInfo->CurrentMPDUDensity);
1567                 }
1568 #endif
1569
1570         }
1571         else
1572         {
1573                 pHTInfo->bCurrentHTSupport = false;
1574         }
1575         return;
1576 }
1577 u8 HTCCheck(struct rtllib_device* ieee, u8*     pFrame)
1578 {
1579         if(ieee->pHTInfo->bCurrentHTSupport)
1580         {
1581                 if( (IsQoSDataFrame(pFrame) && Frame_Order(pFrame)) == 1)
1582                 {
1583                         RTLLIB_DEBUG(RTLLIB_DL_HT, "HT CONTROL FILED EXIST!!\n");
1584                         return true;
1585                 }
1586         }
1587         return false;
1588 }
1589
1590 void HTSetConnectBwMode(struct rtllib_device* ieee, HT_CHANNEL_WIDTH    Bandwidth, HT_EXTCHNL_OFFSET    Offset)
1591 {
1592         PRT_HIGH_THROUGHPUT pHTInfo = ieee->pHTInfo;
1593
1594         if(pHTInfo->bRegBW40MHz == false)
1595                 return;
1596
1597         if(ieee->GetHalfNmodeSupportByAPsHandler(ieee->dev))
1598                 Bandwidth=HT_CHANNEL_WIDTH_20;
1599
1600
1601         if(pHTInfo->bSwBwInProgress) {
1602                 return;
1603         }
1604         if(Bandwidth==HT_CHANNEL_WIDTH_20_40)
1605          {
1606                 if(ieee->current_network.channel<2 && Offset==HT_EXTCHNL_OFFSET_LOWER)
1607                         Offset = HT_EXTCHNL_OFFSET_NO_EXT;
1608                 if(Offset==HT_EXTCHNL_OFFSET_UPPER || Offset==HT_EXTCHNL_OFFSET_LOWER) {
1609                         pHTInfo->bCurBW40MHz = true;
1610                         pHTInfo->CurSTAExtChnlOffset = Offset;
1611                 } else {
1612                         pHTInfo->bCurBW40MHz = false;
1613                         pHTInfo->CurSTAExtChnlOffset = HT_EXTCHNL_OFFSET_NO_EXT;
1614                 }
1615         } else {
1616                 pHTInfo->bCurBW40MHz = false;
1617                 pHTInfo->CurSTAExtChnlOffset = HT_EXTCHNL_OFFSET_NO_EXT;
1618         }
1619
1620         printk("%s():pHTInfo->bCurBW40MHz:%x\n", __func__, pHTInfo->bCurBW40MHz);
1621
1622         pHTInfo->bSwBwInProgress = true;
1623
1624         HTSetConnectBwModeCallback(ieee);
1625
1626 }
1627
1628 void HTSetConnectBwModeCallback(struct rtllib_device* ieee)
1629 {
1630         PRT_HIGH_THROUGHPUT pHTInfo = ieee->pHTInfo;
1631
1632         RTLLIB_DEBUG(RTLLIB_DL_HT, "======>%s()\n", __FUNCTION__);
1633         if(pHTInfo->bCurBW40MHz)
1634         {
1635                 if(pHTInfo->CurSTAExtChnlOffset==HT_EXTCHNL_OFFSET_UPPER)
1636                         ieee->set_chan(ieee->dev, ieee->current_network.channel+2);
1637                 else if(pHTInfo->CurSTAExtChnlOffset==HT_EXTCHNL_OFFSET_LOWER)
1638                         ieee->set_chan(ieee->dev, ieee->current_network.channel-2);
1639                 else
1640                         ieee->set_chan(ieee->dev, ieee->current_network.channel);
1641
1642                 ieee->SetBWModeHandler(ieee->dev, HT_CHANNEL_WIDTH_20_40, pHTInfo->CurSTAExtChnlOffset);
1643         } else {
1644                 ieee->set_chan(ieee->dev, ieee->current_network.channel);
1645                 ieee->SetBWModeHandler(ieee->dev, HT_CHANNEL_WIDTH_20, HT_EXTCHNL_OFFSET_NO_EXT);
1646         }
1647
1648         pHTInfo->bSwBwInProgress = false;
1649 }
1650
1651 #ifndef BUILT_IN_RTLLIB
1652 EXPORT_SYMBOL_RSL(HTUpdateSelfAndPeerSetting);
1653 EXPORT_SYMBOL_RSL(HTFilterMCSRate);
1654 EXPORT_SYMBOL_RSL(HTGetHighestMCSRate);
1655 EXPORT_SYMBOL_RSL(MCS_FILTER_ALL);
1656 EXPORT_SYMBOL_RSL(MCS_FILTER_1SS);
1657 #ifdef _RTL8192_EXT_PATCH_
1658 EXPORT_SYMBOL_RSL(HTSetConnectBwMode);
1659 EXPORT_SYMBOL_RSL(HTConstructCapabilityElement);
1660 EXPORT_SYMBOL_RSL(HTConstructRT2RTAggElement);
1661 EXPORT_SYMBOL_RSL(HTUseDefaultSetting);
1662 EXPORT_SYMBOL_RSL(HTConstructInfoElement);
1663 #endif
1664 #endif