git.oblomov.eu Git - linux-2.6/blob - drivers/staging/rt2870/sta/rtmp_data.c

   1 /*
   2  *************************************************************************
   3  * Ralink Tech Inc.
   4  * 5F., No.36, Taiyuan St., Jhubei City,
   5  * Hsinchu County 302,
   6  * Taiwan, R.O.C.
   7  *
   8  * (c) Copyright 2002-2007, Ralink Technology, Inc.
   9  *
  10  * This program is free software; you can redistribute it and/or modify  *
  11  * it under the terms of the GNU General Public License as published by  *
  12  * the Free Software Foundation; either version 2 of the License, or     *
  13  * (at your option) any later version.                                   *
  14  *                                                                       *
  15  * This program is distributed in the hope that it will be useful,       *
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  18  * GNU General Public License for more details.                          *
  19  *                                                                       *
  20  * You should have received a copy of the GNU General Public License     *
  21  * along with this program; if not, write to the                         *
  22  * Free Software Foundation, Inc.,                                       *
  23  * 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
  24  *                                                                       *
  25  *************************************************************************
  26
  27         Module Name:
  28         rtmp_data.c
  29
  30         Abstract:
  31         Data path subroutines
  32
  33         Revision History:
  34         Who             When                    What
  35         --------        ----------              ----------------------------------------------
  36         John                  Aug/17/04         major modification for RT2561/2661
  37         Jan Lee       Mar/17/06         major modification for RT2860 New Ring Design
  38 */
  39 #include "../rt_config.h"
  40
  41
  42 VOID STARxEAPOLFrameIndicate(
  43         IN      PRTMP_ADAPTER   pAd,
  44         IN      MAC_TABLE_ENTRY *pEntry,
  45         IN      RX_BLK                  *pRxBlk,
  46         IN      UCHAR                   FromWhichBSSID)
  47 {
  48         PRT28XX_RXD_STRUC       pRxD = &(pRxBlk->RxD);
  49         PRXWI_STRUC             pRxWI = pRxBlk->pRxWI;
  50         UCHAR                   *pTmpBuf;
  51
  52 #ifdef WPA_SUPPLICANT_SUPPORT
  53         if (pAd->StaCfg.WpaSupplicantUP)
  54         {
  55                 // All EAPoL frames have to pass to upper layer (ex. WPA_SUPPLICANT daemon)
  56                 // TBD : process fragmented EAPol frames
  57                 {
  58                         // In 802.1x mode, if the received frame is EAP-SUCCESS packet, turn on the PortSecured variable
  59                         if ( pAd->StaCfg.IEEE8021X == TRUE &&
  60                                  (EAP_CODE_SUCCESS == WpaCheckEapCode(pAd, pRxBlk->pData, pRxBlk->DataSize, LENGTH_802_1_H)))
  61                         {
  62                                 PUCHAR  Key;
  63                                 UCHAR   CipherAlg;
  64                                 int     idx = 0;
  65
  66                                 DBGPRINT_RAW(RT_DEBUG_TRACE, ("Receive EAP-SUCCESS Packet\n"));
  67                                 //pAd->StaCfg.PortSecured = WPA_802_1X_PORT_SECURED;
  68                                 STA_PORT_SECURED(pAd);
  69
  70                 if (pAd->StaCfg.IEEE8021x_required_keys == FALSE)
  71                 {
  72                     idx = pAd->StaCfg.DesireSharedKeyId;
  73                     CipherAlg = pAd->StaCfg.DesireSharedKey[idx].CipherAlg;
  74                                         Key = pAd->StaCfg.DesireSharedKey[idx].Key;
  75
  76                     if (pAd->StaCfg.DesireSharedKey[idx].KeyLen > 0)
  77                                 {
  78 #ifdef RT2870
  79                                                 union
  80                                                 {
  81                                                         char buf[sizeof(NDIS_802_11_WEP)+MAX_LEN_OF_KEY- 1];
  82                                                         NDIS_802_11_WEP keyinfo;
  83                                                 }  WepKey;
  84                                                 int len;
  85
  86
  87                                                 NdisZeroMemory(&WepKey, sizeof(WepKey));
  88                                                 len =pAd->StaCfg.DesireSharedKey[idx].KeyLen;
  89
  90                                                 NdisMoveMemory(WepKey.keyinfo.KeyMaterial,
  91                                                         pAd->StaCfg.DesireSharedKey[idx].Key,
  92                                                         pAd->StaCfg.DesireSharedKey[idx].KeyLen);
  93
  94                                                 WepKey.keyinfo.KeyIndex = 0x80000000 + idx;
  95                                                 WepKey.keyinfo.KeyLength = len;
  96                                                 pAd->SharedKey[BSS0][idx].KeyLen =(UCHAR) (len <= 5 ? 5 : 13);
  97
  98                                                 pAd->IndicateMediaState = NdisMediaStateConnected;
  99                                                 pAd->ExtraInfo = GENERAL_LINK_UP;
 100                                                 // need to enqueue cmd to thread
 101                                                 RTUSBEnqueueCmdFromNdis(pAd, OID_802_11_ADD_WEP, TRUE, &WepKey, sizeof(WepKey.keyinfo) + len - 1);
 102 #endif // RT2870 //
 103                                                 // For Preventing ShardKey Table is cleared by remove key procedure.
 104                                         pAd->SharedKey[BSS0][idx].CipherAlg = CipherAlg;
 105                                                 pAd->SharedKey[BSS0][idx].KeyLen = pAd->StaCfg.DesireSharedKey[idx].KeyLen;
 106                                                 NdisMoveMemory(pAd->SharedKey[BSS0][idx].Key,
 107                                                                            pAd->StaCfg.DesireSharedKey[idx].Key,
 108                                                                            pAd->StaCfg.DesireSharedKey[idx].KeyLen);
 109                                 }
 110                                 }
 111                         }
 112
 113                         Indicate_Legacy_Packet(pAd, pRxBlk, FromWhichBSSID);
 114                         return;
 115                 }
 116         }
 117         else
 118 #endif // WPA_SUPPLICANT_SUPPORT //
 119         {
 120                 // Special DATA frame that has to pass to MLME
 121                 //       1. Cisco Aironet frames for CCX2. We need pass it to MLME for special process
 122                 //       2. EAPOL handshaking frames when driver supplicant enabled, pass to MLME for special process
 123                 {
 124                         pTmpBuf = pRxBlk->pData - LENGTH_802_11;
 125                         NdisMoveMemory(pTmpBuf, pRxBlk->pHeader, LENGTH_802_11);
 126                         REPORT_MGMT_FRAME_TO_MLME(pAd, pRxWI->WirelessCliID, pTmpBuf, pRxBlk->DataSize + LENGTH_802_11, pRxWI->RSSI0, pRxWI->RSSI1, pRxWI->RSSI2, pRxD->PlcpSignal);
 127                         DBGPRINT_RAW(RT_DEBUG_TRACE, ("!!! report EAPOL/AIRONET DATA to MLME (len=%d) !!!\n", pRxBlk->DataSize));
 128                 }
 129         }
 130
 131         RELEASE_NDIS_PACKET(pAd, pRxBlk->pRxPacket, NDIS_STATUS_FAILURE);
 132         return;
 133
 134 }
 135
 136 VOID STARxDataFrameAnnounce(
 137         IN      PRTMP_ADAPTER   pAd,
 138         IN      MAC_TABLE_ENTRY *pEntry,
 139         IN      RX_BLK                  *pRxBlk,
 140         IN      UCHAR                   FromWhichBSSID)
 141 {
 142
 143         // non-EAP frame
 144         if (!RTMPCheckWPAframe(pAd, pEntry, pRxBlk->pData, pRxBlk->DataSize, FromWhichBSSID))
 145         {
 146                 {
 147                         // drop all non-EAP DATA frame before
 148                         // this client's Port-Access-Control is secured
 149                         if (pRxBlk->pHeader->FC.Wep)
 150                         {
 151                                 // unsupported cipher suite
 152                                 if (pAd->StaCfg.WepStatus == Ndis802_11EncryptionDisabled)
 153                                 {
 154                                         // release packet
 155                                         RELEASE_NDIS_PACKET(pAd, pRxBlk->pRxPacket, NDIS_STATUS_FAILURE);
 156                                         return;
 157                                 }
 158                         }
 159                         else
 160                         {
 161                                 // encryption in-use but receive a non-EAPOL clear text frame, drop it
 162                                 if ((pAd->StaCfg.WepStatus != Ndis802_11EncryptionDisabled) &&
 163                                         (pAd->StaCfg.PortSecured == WPA_802_1X_PORT_NOT_SECURED))
 164                                 {
 165                                         // release packet
 166                                         RELEASE_NDIS_PACKET(pAd, pRxBlk->pRxPacket, NDIS_STATUS_FAILURE);
 167                                         return;
 168                                 }
 169                         }
 170                 }
 171                 RX_BLK_CLEAR_FLAG(pRxBlk, fRX_EAP);
 172                 if (!RX_BLK_TEST_FLAG(pRxBlk, fRX_ARALINK))
 173                 {
 174                         // Normal legacy, AMPDU or AMSDU
 175                         CmmRxnonRalinkFrameIndicate(pAd, pRxBlk, FromWhichBSSID);
 176
 177                 }
 178                 else
 179                 {
 180                         // ARALINK
 181                         CmmRxRalinkFrameIndicate(pAd, pEntry, pRxBlk, FromWhichBSSID);
 182                 }
 183 #ifdef QOS_DLS_SUPPORT
 184                 RX_BLK_CLEAR_FLAG(pRxBlk, fRX_DLS);
 185 #endif // QOS_DLS_SUPPORT //
 186         }
 187         else
 188         {
 189                 RX_BLK_SET_FLAG(pRxBlk, fRX_EAP);
 190 #ifdef DOT11_N_SUPPORT
 191                 if (RX_BLK_TEST_FLAG(pRxBlk, fRX_AMPDU) && (pAd->CommonCfg.bDisableReordering == 0))
 192                 {
 193                         Indicate_AMPDU_Packet(pAd, pRxBlk, FromWhichBSSID);
 194                 }
 195                 else
 196 #endif // DOT11_N_SUPPORT //
 197                 {
 198                         // Determin the destination of the EAP frame
 199                         //  to WPA state machine or upper layer
 200                         STARxEAPOLFrameIndicate(pAd, pEntry, pRxBlk, FromWhichBSSID);
 201                 }
 202         }
 203 }
 204
 205
 206 // For TKIP frame, calculate the MIC value
 207 BOOLEAN STACheckTkipMICValue(
 208         IN      PRTMP_ADAPTER   pAd,
 209         IN      MAC_TABLE_ENTRY *pEntry,
 210         IN      RX_BLK                  *pRxBlk)
 211 {
 212         PHEADER_802_11  pHeader = pRxBlk->pHeader;
 213         UCHAR                   *pData = pRxBlk->pData;
 214         USHORT                  DataSize = pRxBlk->DataSize;
 215         UCHAR                   UserPriority = pRxBlk->UserPriority;
 216         PCIPHER_KEY             pWpaKey;
 217         UCHAR                   *pDA, *pSA;
 218
 219         pWpaKey = &pAd->SharedKey[BSS0][pRxBlk->pRxWI->KeyIndex];
 220
 221         pDA = pHeader->Addr1;
 222         if (RX_BLK_TEST_FLAG(pRxBlk, fRX_INFRA))
 223         {
 224                 pSA = pHeader->Addr3;
 225         }
 226         else
 227         {
 228                 pSA = pHeader->Addr2;
 229         }
 230
 231         if (RTMPTkipCompareMICValue(pAd,
 232                                                                 pData,
 233                                                                 pDA,
 234                                                                 pSA,
 235                                                                 pWpaKey->RxMic,
 236                                                                 UserPriority,
 237                                                                 DataSize) == FALSE)
 238         {
 239                 DBGPRINT_RAW(RT_DEBUG_ERROR,("Rx MIC Value error 2\n"));
 240
 241 #ifdef WPA_SUPPLICANT_SUPPORT
 242                 if (pAd->StaCfg.WpaSupplicantUP)
 243                 {
 244                         WpaSendMicFailureToWpaSupplicant(pAd, (pWpaKey->Type == PAIRWISEKEY) ? TRUE : FALSE);
 245                 }
 246                 else
 247 #endif // WPA_SUPPLICANT_SUPPORT //
 248                 {
 249                         RTMPReportMicError(pAd, pWpaKey);
 250                 }
 251
 252                 // release packet
 253                 RELEASE_NDIS_PACKET(pAd, pRxBlk->pRxPacket, NDIS_STATUS_FAILURE);
 254                 return FALSE;
 255         }
 256
 257         return TRUE;
 258 }
 259
 260
 261 //
 262 // All Rx routines use RX_BLK structure to hande rx events
 263 // It is very important to build pRxBlk attributes
 264 //  1. pHeader pointer to 802.11 Header
 265 //  2. pData pointer to payload including LLC (just skip Header)
 266 //  3. set payload size including LLC to DataSize
 267 //  4. set some flags with RX_BLK_SET_FLAG()
 268 //
 269 VOID STAHandleRxDataFrame(
 270         IN      PRTMP_ADAPTER   pAd,
 271         IN      RX_BLK                  *pRxBlk)
 272 {
 273         PRT28XX_RXD_STRUC                               pRxD = &(pRxBlk->RxD);
 274         PRXWI_STRUC                                             pRxWI = pRxBlk->pRxWI;
 275         PHEADER_802_11                                  pHeader = pRxBlk->pHeader;
 276         PNDIS_PACKET                                    pRxPacket = pRxBlk->pRxPacket;
 277         BOOLEAN                                                 bFragment = FALSE;
 278         MAC_TABLE_ENTRY                         *pEntry = NULL;
 279         UCHAR                                                   FromWhichBSSID = BSS0;
 280         UCHAR                           UserPriority = 0;
 281
 282         {
 283                 // before LINK UP, all DATA frames are rejected
 284                 if (!OPSTATUS_TEST_FLAG(pAd, fOP_STATUS_MEDIA_STATE_CONNECTED))
 285                 {
 286                         // release packet
 287                         RELEASE_NDIS_PACKET(pAd, pRxPacket, NDIS_STATUS_FAILURE);
 288                         return;
 289                 }
 290
 291 #ifdef QOS_DLS_SUPPORT
 292                 //if ((pHeader->FC.FrDs == 0) && (pHeader->FC.ToDs == 0))
 293                 if (RTMPRcvFrameDLSCheck(pAd, pHeader, pRxWI->MPDUtotalByteCount, pRxD))
 294                 {
 295                         return;
 296                 }
 297 #endif // QOS_DLS_SUPPORT //
 298
 299                 // Drop not my BSS frames
 300                 if (pRxD->MyBss == 0)
 301                 {
 302                         {
 303                                 // release packet
 304                                 RELEASE_NDIS_PACKET(pAd, pRxPacket, NDIS_STATUS_FAILURE);
 305                                 return;
 306                         }
 307                 }
 308
 309                 pAd->RalinkCounters.RxCountSinceLastNULL++;
 310                 if (pAd->CommonCfg.bAPSDCapable && pAd->CommonCfg.APEdcaParm.bAPSDCapable && (pHeader->FC.SubType & 0x08))
 311                 {
 312                         UCHAR *pData;
 313                         DBGPRINT(RT_DEBUG_TRACE,("bAPSDCapable\n"));
 314
 315                         // Qos bit 4
 316                         pData = (PUCHAR)pHeader + LENGTH_802_11;
 317                         if ((*pData >> 4) & 0x01)
 318                         {
 319                                 DBGPRINT(RT_DEBUG_TRACE,("RxDone- Rcv EOSP frame, driver may fall into sleep\n"));
 320                                 pAd->CommonCfg.bInServicePeriod = FALSE;
 321
 322                                 // Force driver to fall into sleep mode when rcv EOSP frame
 323                                 if (!OPSTATUS_TEST_FLAG(pAd, fOP_STATUS_DOZE))
 324                                 {
 325                                         USHORT  TbttNumToNextWakeUp;
 326                                         USHORT  NextDtim = pAd->StaCfg.DtimPeriod;
 327                                         ULONG   Now;
 328
 329                                         NdisGetSystemUpTime(&Now);
 330                                         NextDtim -= (USHORT)(Now - pAd->StaCfg.LastBeaconRxTime)/pAd->CommonCfg.BeaconPeriod;
 331
 332                                         TbttNumToNextWakeUp = pAd->StaCfg.DefaultListenCount;
 333                                         if (OPSTATUS_TEST_FLAG(pAd, fOP_STATUS_RECEIVE_DTIM) && (TbttNumToNextWakeUp > NextDtim))
 334                                                 TbttNumToNextWakeUp = NextDtim;
 335
 336                                         MlmeSetPsmBit(pAd, PWR_SAVE);
 337                                         // if WMM-APSD is failed, try to disable following line
 338                                         AsicSleepThenAutoWakeup(pAd, TbttNumToNextWakeUp);
 339                                 }
 340                         }
 341
 342                         if ((pHeader->FC.MoreData) && (pAd->CommonCfg.bInServicePeriod))
 343                         {
 344                                 DBGPRINT(RT_DEBUG_TRACE,("Sending another trigger frame when More Data bit is set to 1\n"));
 345                         }
 346                 }
 347
 348                 // Drop NULL, CF-ACK(no data), CF-POLL(no data), and CF-ACK+CF-POLL(no data) data frame
 349                 if ((pHeader->FC.SubType & 0x04)) // bit 2 : no DATA
 350                 {
 351                         // release packet
 352                         RELEASE_NDIS_PACKET(pAd, pRxPacket, NDIS_STATUS_FAILURE);
 353                         return;
 354                 }
 355
 356             // Drop not my BSS frame (we can not only check the MyBss bit in RxD)
 357 #ifdef QOS_DLS_SUPPORT
 358             if (!pAd->CommonCfg.bDLSCapable)
 359             {
 360 #endif // QOS_DLS_SUPPORT //
 361                 if (INFRA_ON(pAd))
 362                 {
 363                         // Infrastructure mode, check address 2 for BSSID
 364                         if (!RTMPEqualMemory(&pHeader->Addr2, &pAd->CommonCfg.Bssid, 6))
 365                         {
 366                                 // Receive frame not my BSSID
 367                     // release packet
 368                     RELEASE_NDIS_PACKET(pAd, pRxPacket, NDIS_STATUS_FAILURE);
 369                                 return;
 370                         }
 371                 }
 372                 else    // Ad-Hoc mode or Not associated
 373                 {
 374                         // Ad-Hoc mode, check address 3 for BSSID
 375                         if (!RTMPEqualMemory(&pHeader->Addr3, &pAd->CommonCfg.Bssid, 6))
 376                         {
 377                                 // Receive frame not my BSSID
 378                     // release packet
 379                     RELEASE_NDIS_PACKET(pAd, pRxPacket, NDIS_STATUS_FAILURE);
 380                                 return;
 381                         }
 382                 }
 383 #ifdef QOS_DLS_SUPPORT
 384             }
 385 #endif // QOS_DLS_SUPPORT //
 386
 387                 //
 388                 // find pEntry
 389                 //
 390                 if (pRxWI->WirelessCliID < MAX_LEN_OF_MAC_TABLE)
 391                 {
 392                         pEntry = &pAd->MacTab.Content[pRxWI->WirelessCliID];
 393                 }
 394                 else
 395                 {
 396                         // 1. release packet if infra mode
 397                         // 2. new a pEntry if ad-hoc mode
 398                         RELEASE_NDIS_PACKET(pAd, pRxPacket, NDIS_STATUS_FAILURE);
 399                         return;
 400                 }
 401
 402                 // infra or ad-hoc
 403                 if (INFRA_ON(pAd))
 404                 {
 405                         RX_BLK_SET_FLAG(pRxBlk, fRX_INFRA);
 406 #ifdef QOS_DLS_SUPPORT
 407                         if ((pHeader->FC.FrDs == 0) && (pHeader->FC.ToDs == 0))
 408                                 RX_BLK_SET_FLAG(pRxBlk, fRX_DLS);
 409                         else
 410 #endif // QOS_DLS_SUPPORT //
 411                         ASSERT(pRxWI->WirelessCliID == BSSID_WCID);
 412                 }
 413
 414                 // check Atheros Client
 415                 if ((pEntry->bIAmBadAtheros == FALSE) &&  (pRxD->AMPDU == 1) && (pHeader->FC.Retry ))
 416                 {
 417                         pEntry->bIAmBadAtheros = TRUE;
 418                         pAd->CommonCfg.IOTestParm.bCurrentAtheros = TRUE;
 419                         pAd->CommonCfg.IOTestParm.bLastAtheros = TRUE;
 420                         if (!STA_AES_ON(pAd))
 421                         {
 422                                 AsicUpdateProtect(pAd, 8, ALLN_SETPROTECT, TRUE, FALSE);
 423                         }
 424                 }
 425         }
 426
 427         pRxBlk->pData = (UCHAR *)pHeader;
 428
 429         //
 430         // update RxBlk->pData, DataSize
 431         // 802.11 Header, QOS, HTC, Hw Padding
 432         //
 433
 434         // 1. skip 802.11 HEADER
 435         {
 436                 pRxBlk->pData += LENGTH_802_11;
 437                 pRxBlk->DataSize -= LENGTH_802_11;
 438         }
 439
 440         // 2. QOS
 441         if (pHeader->FC.SubType & 0x08)
 442         {
 443                 RX_BLK_SET_FLAG(pRxBlk, fRX_QOS);
 444                 UserPriority = *(pRxBlk->pData) & 0x0f;
 445                 // bit 7 in QoS Control field signals the HT A-MSDU format
 446                 if ((*pRxBlk->pData) & 0x80)
 447                 {
 448                         RX_BLK_SET_FLAG(pRxBlk, fRX_AMSDU);
 449                 }
 450
 451                 // skip QOS contorl field
 452                 pRxBlk->pData += 2;
 453                 pRxBlk->DataSize -=2;
 454         }
 455         pRxBlk->UserPriority = UserPriority;
 456
 457         // 3. Order bit: A-Ralink or HTC+
 458         if (pHeader->FC.Order)
 459         {
 460 #ifdef AGGREGATION_SUPPORT
 461                 if ((pRxWI->PHYMODE <= MODE_OFDM) && (OPSTATUS_TEST_FLAG(pAd, fOP_STATUS_AGGREGATION_INUSED)))
 462                 {
 463                         RX_BLK_SET_FLAG(pRxBlk, fRX_ARALINK);
 464                 }
 465                 else
 466 #endif
 467                 {
 468 #ifdef DOT11_N_SUPPORT
 469                         RX_BLK_SET_FLAG(pRxBlk, fRX_HTC);
 470                         // skip HTC contorl field
 471                         pRxBlk->pData += 4;
 472                         pRxBlk->DataSize -= 4;
 473 #endif // DOT11_N_SUPPORT //
 474                 }
 475         }
 476
 477         // 4. skip HW padding
 478         if (pRxD->L2PAD)
 479         {
 480                 // just move pData pointer
 481                 // because DataSize excluding HW padding
 482                 RX_BLK_SET_FLAG(pRxBlk, fRX_PAD);
 483                 pRxBlk->pData += 2;
 484         }
 485
 486 #ifdef DOT11_N_SUPPORT
 487         if (pRxD->BA)
 488         {
 489                 RX_BLK_SET_FLAG(pRxBlk, fRX_AMPDU);
 490         }
 491 #endif // DOT11_N_SUPPORT //
 492
 493
 494         //
 495         // Case I  Process Broadcast & Multicast data frame
 496         //
 497         if (pRxD->Bcast || pRxD->Mcast)
 498         {
 499                 INC_COUNTER64(pAd->WlanCounters.MulticastReceivedFrameCount);
 500
 501                 // Drop Mcast/Bcast frame with fragment bit on
 502                 if (pHeader->FC.MoreFrag)
 503                 {
 504                         // release packet
 505                         RELEASE_NDIS_PACKET(pAd, pRxPacket, NDIS_STATUS_FAILURE);
 506                         return;
 507                 }
 508
 509                 // Filter out Bcast frame which AP relayed for us
 510                 if (pHeader->FC.FrDs && MAC_ADDR_EQUAL(pHeader->Addr3, pAd->CurrentAddress))
 511                 {
 512                         // release packet
 513                         RELEASE_NDIS_PACKET(pAd, pRxPacket, NDIS_STATUS_FAILURE);
 514                         return;
 515                 }
 516
 517                 Indicate_Legacy_Packet(pAd, pRxBlk, FromWhichBSSID);
 518                 return;
 519         }
 520         else if (pRxD->U2M)
 521         {
 522                 pAd->LastRxRate = (USHORT)((pRxWI->MCS) + (pRxWI->BW <<7) + (pRxWI->ShortGI <<8)+ (pRxWI->PHYMODE <<14)) ;
 523
 524
 525 #ifdef QOS_DLS_SUPPORT
 526         if (RX_BLK_TEST_FLAG(pRxBlk, fRX_DLS))
 527                 {
 528                         MAC_TABLE_ENTRY *pDlsEntry = NULL;
 529
 530                         pDlsEntry = DlsEntryTableLookupByWcid(pAd, pRxWI->WirelessCliID, pHeader->Addr2, TRUE);
 531                                                                                                         if(pDlsEntry)
 532                         Update_Rssi_Sample(pAd, &pDlsEntry->RssiSample, pRxWI);
 533                 }
 534                 else
 535 #endif // QOS_DLS_SUPPORT //
 536                 if (ADHOC_ON(pAd))
 537                 {
 538                         pEntry = MacTableLookup(pAd, pHeader->Addr2);
 539                         if (pEntry)
 540                                 Update_Rssi_Sample(pAd, &pEntry->RssiSample, pRxWI);
 541                 }
 542
 543
 544                 Update_Rssi_Sample(pAd, &pAd->StaCfg.RssiSample, pRxWI);
 545
 546                 pAd->StaCfg.LastSNR0 = (UCHAR)(pRxWI->SNR0);
 547                 pAd->StaCfg.LastSNR1 = (UCHAR)(pRxWI->SNR1);
 548
 549                 pAd->RalinkCounters.OneSecRxOkDataCnt++;
 550
 551
 552         if (!((pHeader->Frag == 0) && (pHeader->FC.MoreFrag == 0)))
 553         {
 554                 // re-assemble the fragmented packets
 555                 // return complete frame (pRxPacket) or NULL
 556                 bFragment = TRUE;
 557                 pRxPacket = RTMPDeFragmentDataFrame(pAd, pRxBlk);
 558         }
 559
 560         if (pRxPacket)
 561         {
 562                         pEntry = &pAd->MacTab.Content[pRxWI->WirelessCliID];
 563
 564                 // process complete frame
 565                 if (bFragment && (pRxD->Decrypted) && (pEntry->WepStatus == Ndis802_11Encryption2Enabled))
 566                 {
 567                                 // Minus MIC length
 568                                 pRxBlk->DataSize -= 8;
 569
 570                         // For TKIP frame, calculate the MIC value
 571                         if (STACheckTkipMICValue(pAd, pEntry, pRxBlk) == FALSE)
 572                         {
 573                                 return;
 574                         }
 575                 }
 576
 577                 STARxDataFrameAnnounce(pAd, pEntry, pRxBlk, FromWhichBSSID);
 578                         return;
 579         }
 580         else
 581         {
 582                 // just return
 583                 // because RTMPDeFragmentDataFrame() will release rx packet,
 584                 // if packet is fragmented
 585                 return;
 586         }
 587         }
 588
 589         ASSERT(0);
 590         // release packet
 591         RELEASE_NDIS_PACKET(pAd, pRxPacket, NDIS_STATUS_FAILURE);
 592 }
 593
 594 VOID STAHandleRxMgmtFrame(
 595         IN      PRTMP_ADAPTER   pAd,
 596         IN      RX_BLK                  *pRxBlk)
 597 {
 598         PRT28XX_RXD_STRUC       pRxD = &(pRxBlk->RxD);
 599         PRXWI_STRUC             pRxWI = pRxBlk->pRxWI;
 600         PHEADER_802_11  pHeader = pRxBlk->pHeader;
 601         PNDIS_PACKET    pRxPacket = pRxBlk->pRxPacket;
 602
 603         do
 604         {
 605
 606                 // We should collect RSSI not only U2M data but also my beacon
 607                 if ((pHeader->FC.SubType == SUBTYPE_BEACON) && (MAC_ADDR_EQUAL(&pAd->CommonCfg.Bssid, &pHeader->Addr2)))
 608                 {
 609                         Update_Rssi_Sample(pAd, &pAd->StaCfg.RssiSample, pRxWI);
 610
 611                         pAd->StaCfg.LastSNR0 = (UCHAR)(pRxWI->SNR0);
 612                         pAd->StaCfg.LastSNR1 = (UCHAR)(pRxWI->SNR1);
 613                 }
 614
 615                 // First check the size, it MUST not exceed the mlme queue size
 616                 if (pRxWI->MPDUtotalByteCount > MGMT_DMA_BUFFER_SIZE)
 617                 {
 618                         DBGPRINT_ERR(("STAHandleRxMgmtFrame: frame too large, size = %d \n", pRxWI->MPDUtotalByteCount));
 619                         break;
 620                 }
 621
 622                 REPORT_MGMT_FRAME_TO_MLME(pAd, pRxWI->WirelessCliID, pHeader, pRxWI->MPDUtotalByteCount,
 623                                                                         pRxWI->RSSI0, pRxWI->RSSI1, pRxWI->RSSI2, pRxD->PlcpSignal);
 624         } while (FALSE);
 625
 626         RELEASE_NDIS_PACKET(pAd, pRxPacket, NDIS_STATUS_SUCCESS);
 627 }
 628
 629 VOID STAHandleRxControlFrame(
 630         IN      PRTMP_ADAPTER   pAd,
 631         IN      RX_BLK                  *pRxBlk)
 632 {
 633 #ifdef DOT11_N_SUPPORT
 634         PRXWI_STRUC             pRxWI = pRxBlk->pRxWI;
 635 #endif // DOT11_N_SUPPORT //
 636         PHEADER_802_11  pHeader = pRxBlk->pHeader;
 637         PNDIS_PACKET    pRxPacket = pRxBlk->pRxPacket;
 638
 639         switch (pHeader->FC.SubType)
 640         {
 641                 case SUBTYPE_BLOCK_ACK_REQ:
 642 #ifdef DOT11_N_SUPPORT
 643                         {
 644                                 CntlEnqueueForRecv(pAd, pRxWI->WirelessCliID, (pRxWI->MPDUtotalByteCount), (PFRAME_BA_REQ)pHeader);
 645                         }
 646                         break;
 647 #endif // DOT11_N_SUPPORT //
 648                 case SUBTYPE_BLOCK_ACK:
 649                 case SUBTYPE_ACK:
 650                 default:
 651                         break;
 652         }
 653
 654         RELEASE_NDIS_PACKET(pAd, pRxPacket, NDIS_STATUS_FAILURE);
 655 }
 656
 657
 658 /*
 659         ========================================================================
 660
 661         Routine Description:
 662                 Process RxDone interrupt, running in DPC level
 663
 664         Arguments:
 665                 pAd Pointer to our adapter
 666
 667         Return Value:
 668                 None
 669
 670         IRQL = DISPATCH_LEVEL
 671
 672         Note:
 673                 This routine has to maintain Rx ring read pointer.
 674                 Need to consider QOS DATA format when converting to 802.3
 675         ========================================================================
 676 */
 677 BOOLEAN STARxDoneInterruptHandle(
 678         IN      PRTMP_ADAPTER   pAd,
 679         IN      BOOLEAN                 argc)
 680 {
 681         NDIS_STATUS                     Status;
 682         UINT32                  RxProcessed, RxPending;
 683         BOOLEAN                 bReschedule = FALSE;
 684         RT28XX_RXD_STRUC        *pRxD;
 685         UCHAR                   *pData;
 686         PRXWI_STRUC             pRxWI;
 687         PNDIS_PACKET    pRxPacket;
 688         PHEADER_802_11  pHeader;
 689         RX_BLK                  RxCell;
 690
 691         RxProcessed = RxPending = 0;
 692
 693         // process whole rx ring
 694         while (1)
 695         {
 696
 697                 if (RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_RADIO_OFF |
 698                                                                 fRTMP_ADAPTER_RESET_IN_PROGRESS |
 699                                                                 fRTMP_ADAPTER_HALT_IN_PROGRESS |
 700                                                                 fRTMP_ADAPTER_NIC_NOT_EXIST) ||
 701                         !RTMP_TEST_FLAG(pAd,fRTMP_ADAPTER_START_UP))
 702                 {
 703                         break;
 704                 }
 705
 706
 707                 RxProcessed ++; // test
 708
 709                 // 1. allocate a new data packet into rx ring to replace received packet
 710                 //    then processing the received packet
 711                 // 2. the callee must take charge of release of packet
 712                 // 3. As far as driver is concerned ,
 713                 //    the rx packet must
 714                 //      a. be indicated to upper layer or
 715                 //      b. be released if it is discarded
 716                 pRxPacket = GetPacketFromRxRing(pAd, &(RxCell.RxD), &bReschedule, &RxPending);
 717                 if (pRxPacket == NULL)
 718                 {
 719                         // no more packet to process
 720                         break;
 721                 }
 722
 723                 // get rx ring descriptor
 724                 pRxD = &(RxCell.RxD);
 725                 // get rx data buffer
 726                 pData   = GET_OS_PKT_DATAPTR(pRxPacket);
 727                 pRxWI   = (PRXWI_STRUC) pData;
 728                 pHeader = (PHEADER_802_11) (pData+RXWI_SIZE) ;
 729
 730 #ifdef RT_BIG_ENDIAN
 731             RTMPFrameEndianChange(pAd, (PUCHAR)pHeader, DIR_READ, TRUE);
 732                 RTMPWIEndianChange((PUCHAR)pRxWI, TYPE_RXWI);
 733 #endif
 734
 735                 // build RxCell
 736                 RxCell.pRxWI = pRxWI;
 737                 RxCell.pHeader = pHeader;
 738                 RxCell.pRxPacket = pRxPacket;
 739                 RxCell.pData = (UCHAR *) pHeader;
 740                 RxCell.DataSize = pRxWI->MPDUtotalByteCount;
 741                 RxCell.Flags = 0;
 742
 743                 // Increase Total receive byte counter after real data received no mater any error or not
 744                 pAd->RalinkCounters.ReceivedByteCount +=  pRxWI->MPDUtotalByteCount;
 745                 pAd->RalinkCounters.RxCount ++;
 746
 747                 INC_COUNTER64(pAd->WlanCounters.ReceivedFragmentCount);
 748
 749                 if (pRxWI->MPDUtotalByteCount < 14)
 750                         Status = NDIS_STATUS_FAILURE;
 751
 752         if (MONITOR_ON(pAd))
 753                 {
 754             send_monitor_packets(pAd, &RxCell);
 755                         break;
 756                 }
 757                 /* RT2870 invokes STARxDoneInterruptHandle() in rtusb_bulk.c */
 758 #ifdef RALINK_ATE
 759                 if (ATE_ON(pAd))
 760                 {
 761                         pAd->ate.RxCntPerSec++;
 762                         ATESampleRssi(pAd, pRxWI);
 763 #ifdef RALINK_28xx_QA
 764                         if (pAd->ate.bQARxStart == TRUE)
 765                         {
 766                                 /* (*pRxD) has been swapped in GetPacketFromRxRing() */
 767                                 ATE_QA_Statistics(pAd, pRxWI, pRxD,     pHeader);
 768                         }
 769 #endif // RALINK_28xx_QA //
 770                         RELEASE_NDIS_PACKET(pAd, pRxPacket, NDIS_STATUS_SUCCESS);
 771                         continue;
 772                 }
 773 #endif // RALINK_ATE //
 774
 775                 // Check for all RxD errors
 776                 Status = RTMPCheckRxError(pAd, pHeader, pRxWI, pRxD);
 777
 778                 // Handle the received frame
 779                 if (Status == NDIS_STATUS_SUCCESS)
 780                 {
 781                         switch (pHeader->FC.Type)
 782                         {
 783                                 // CASE I, receive a DATA frame
 784                                 case BTYPE_DATA:
 785                                 {
 786                                         // process DATA frame
 787                                         STAHandleRxDataFrame(pAd, &RxCell);
 788                                 }
 789                                 break;
 790                                 // CASE II, receive a MGMT frame
 791                                 case BTYPE_MGMT:
 792                                 {
 793                                         STAHandleRxMgmtFrame(pAd, &RxCell);
 794                                 }
 795                                 break;
 796                                 // CASE III. receive a CNTL frame
 797                                 case BTYPE_CNTL:
 798                                 {
 799                                         STAHandleRxControlFrame(pAd, &RxCell);
 800                                 }
 801                                 break;
 802                                 // discard other type
 803                                 default:
 804                                         RELEASE_NDIS_PACKET(pAd, pRxPacket, NDIS_STATUS_FAILURE);
 805                                         break;
 806                         }
 807                 }
 808                 else
 809                 {
 810                         pAd->Counters8023.RxErrors++;
 811                         // discard this frame
 812                         RELEASE_NDIS_PACKET(pAd, pRxPacket, NDIS_STATUS_FAILURE);
 813                 }
 814         }
 815
 816         return bReschedule;
 817 }
 818
 819 /*
 820         ========================================================================
 821
 822         Routine Description:
 823         Arguments:
 824                 pAd     Pointer to our adapter
 825
 826         IRQL = DISPATCH_LEVEL
 827
 828         ========================================================================
 829 */
 830 VOID    RTMPHandleTwakeupInterrupt(
 831         IN PRTMP_ADAPTER pAd)
 832 {
 833         AsicForceWakeup(pAd, FALSE);
 834 }
 835
 836 /*
 837 ========================================================================
 838 Routine Description:
 839     Early checking and OS-depened parsing for Tx packet send to our STA driver.
 840
 841 Arguments:
 842     NDIS_HANDLE         MiniportAdapterContext  Pointer refer to the device handle, i.e., the pAd.
 843         PPNDIS_PACKET   ppPacketArray                   The packet array need to do transmission.
 844         UINT                    NumberOfPackets                 Number of packet in packet array.
 845
 846 Return Value:
 847         NONE
 848
 849 Note:
 850         This function do early checking and classification for send-out packet.
 851         You only can put OS-depened & STA related code in here.
 852 ========================================================================
 853 */
 854 VOID STASendPackets(
 855         IN      NDIS_HANDLE             MiniportAdapterContext,
 856         IN      PPNDIS_PACKET   ppPacketArray,
 857         IN      UINT                    NumberOfPackets)
 858 {
 859         UINT                    Index;
 860         PRTMP_ADAPTER   pAd = (PRTMP_ADAPTER) MiniportAdapterContext;
 861         PNDIS_PACKET    pPacket;
 862         BOOLEAN                 allowToSend = FALSE;
 863
 864
 865         for (Index = 0; Index < NumberOfPackets; Index++)
 866         {
 867                 pPacket = ppPacketArray[Index];
 868
 869                 do
 870                 {
 871                         if (RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_RESET_IN_PROGRESS) ||
 872                                 RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_HALT_IN_PROGRESS) ||
 873                                 RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_RADIO_OFF))
 874                         {
 875                                 // Drop send request since hardware is in reset state
 876                                         break;
 877                         }
 878                         else if (!INFRA_ON(pAd) && !ADHOC_ON(pAd))
 879                         {
 880                                 // Drop send request since there are no physical connection yet
 881                                         break;
 882                         }
 883                         else
 884                         {
 885                                 // Record that orignal packet source is from NDIS layer,so that
 886                                 // later on driver knows how to release this NDIS PACKET
 887 #ifdef QOS_DLS_SUPPORT
 888                                 MAC_TABLE_ENTRY *pEntry;
 889                                 PUCHAR pSrcBufVA = GET_OS_PKT_DATAPTR(pPacket);
 890
 891                                 pEntry = MacTableLookup(pAd, pSrcBufVA);
 892                                 if (pEntry && (pEntry->ValidAsDls == TRUE))
 893                                 {
 894                                         RTMP_SET_PACKET_WCID(pPacket, pEntry->Aid);
 895                                 }
 896                                 else
 897 #endif // QOS_DLS_SUPPORT //
 898                                 RTMP_SET_PACKET_WCID(pPacket, 0); // this field is useless when in STA mode
 899                                 RTMP_SET_PACKET_SOURCE(pPacket, PKTSRC_NDIS);
 900                                 NDIS_SET_PACKET_STATUS(pPacket, NDIS_STATUS_PENDING);
 901                                 pAd->RalinkCounters.PendingNdisPacketCount++;
 902
 903                                 allowToSend = TRUE;
 904                         }
 905                 } while(FALSE);
 906
 907                 if (allowToSend == TRUE)
 908                         STASendPacket(pAd, pPacket);
 909                 else
 910                         RELEASE_NDIS_PACKET(pAd, pPacket, NDIS_STATUS_FAILURE);
 911         }
 912
 913         // Dequeue outgoing frames from TxSwQueue[] and process it
 914         RTMPDeQueuePacket(pAd, FALSE, NUM_OF_TX_RING, MAX_TX_PROCESS);
 915
 916 }
 917
 918
 919 /*
 920 ========================================================================
 921 Routine Description:
 922         This routine is used to do packet parsing and classification for Tx packet
 923         to STA device, and it will en-queue packets to our TxSwQueue depends on AC
 924         class.
 925
 926 Arguments:
 927         pAd             Pointer to our adapter
 928         pPacket         Pointer to send packet
 929
 930 Return Value:
 931         NDIS_STATUS_SUCCESS                     If succes to queue the packet into TxSwQueue.
 932         NDIS_STATUS_FAILURE                     If failed to do en-queue.
 933
 934 Note:
 935         You only can put OS-indepened & STA related code in here.
 936 ========================================================================
 937 */
 938 NDIS_STATUS STASendPacket(
 939         IN      PRTMP_ADAPTER   pAd,
 940         IN      PNDIS_PACKET    pPacket)
 941 {
 942         PACKET_INFO     PacketInfo;
 943         PUCHAR                  pSrcBufVA;
 944         UINT                    SrcBufLen;
 945         UINT                    AllowFragSize;
 946         UCHAR                   NumberOfFrag;
 947 //      UCHAR                   RTSRequired;
 948         UCHAR                   QueIdx, UserPriority;
 949         MAC_TABLE_ENTRY *pEntry = NULL;
 950         unsigned int    IrqFlags;
 951         UCHAR                   FlgIsIP = 0;
 952         UCHAR                   Rate;
 953
 954         // Prepare packet information structure for buffer descriptor
 955         // chained within a single NDIS packet.
 956         RTMP_QueryPacketInfo(pPacket, &PacketInfo, &pSrcBufVA, &SrcBufLen);
 957
 958         if (pSrcBufVA == NULL)
 959         {
 960                 DBGPRINT(RT_DEBUG_ERROR,("STASendPacket --> pSrcBufVA == NULL !!!SrcBufLen=%x\n",SrcBufLen));
 961                 // Resourece is low, system did not allocate virtual address
 962                 // return NDIS_STATUS_FAILURE directly to upper layer
 963                 RELEASE_NDIS_PACKET(pAd, pPacket, NDIS_STATUS_FAILURE);
 964                 return NDIS_STATUS_FAILURE;
 965         }
 966
 967
 968         if (SrcBufLen < 14)
 969         {
 970                 DBGPRINT(RT_DEBUG_ERROR,("STASendPacket --> Ndis Packet buffer error !!!\n"));
 971                 RELEASE_NDIS_PACKET(pAd, pPacket, NDIS_STATUS_FAILURE);
 972                 return (NDIS_STATUS_FAILURE);
 973         }
 974
 975         // In HT rate adhoc mode, A-MPDU is often used. So need to lookup BA Table and MAC Entry.
 976         // Note multicast packets in adhoc also use BSSID_WCID index.
 977         {
 978                 if(INFRA_ON(pAd))
 979                 {
 980 #ifdef QOS_DLS_SUPPORT
 981                         USHORT  tmpWcid;
 982
 983                         tmpWcid = RTMP_GET_PACKET_WCID(pPacket);
 984                         if (VALID_WCID(tmpWcid) &&
 985                                 (pAd->MacTab.Content[tmpWcid].ValidAsDls== TRUE))
 986                         {
 987                                 pEntry = &pAd->MacTab.Content[tmpWcid];
 988                                 Rate = pAd->MacTab.Content[tmpWcid].CurrTxRate;
 989                         }
 990                         else
 991 #endif // QOS_DLS_SUPPORT //
 992                         {
 993                         pEntry = &pAd->MacTab.Content[BSSID_WCID];
 994                         RTMP_SET_PACKET_WCID(pPacket, BSSID_WCID);
 995                         Rate = pAd->CommonCfg.TxRate;
 996                 }
 997                 }
 998                 else if (ADHOC_ON(pAd))
 999                 {
1000                         if (*pSrcBufVA & 0x01)
1001                         {
1002                                 RTMP_SET_PACKET_WCID(pPacket, MCAST_WCID);
1003                                 pEntry = &pAd->MacTab.Content[MCAST_WCID];
1004                         }
1005                         else
1006                         {
1007                                 pEntry = MacTableLookup(pAd, pSrcBufVA);
1008                         }
1009                         Rate = pAd->CommonCfg.TxRate;
1010                 }
1011         }
1012
1013         if (!pEntry)
1014         {
1015                 DBGPRINT(RT_DEBUG_ERROR,("STASendPacket->Cannot find pEntry(%2x:%2x:%2x:%2x:%2x:%2x) in MacTab!\n", PRINT_MAC(pSrcBufVA)));
1016                 // Resourece is low, system did not allocate virtual address
1017                 // return NDIS_STATUS_FAILURE directly to upper layer
1018                 RELEASE_NDIS_PACKET(pAd, pPacket, NDIS_STATUS_FAILURE);
1019                 return NDIS_STATUS_FAILURE;
1020         }
1021
1022         if (ADHOC_ON(pAd)
1023                 )
1024         {
1025                 RTMP_SET_PACKET_WCID(pPacket, (UCHAR)pEntry->Aid);
1026         }
1027
1028         //
1029         // Check the Ethernet Frame type of this packet, and set the RTMP_SET_PACKET_SPECIFIC flags.
1030         //              Here we set the PACKET_SPECIFIC flags(LLC, VLAN, DHCP/ARP, EAPOL).
1031         RTMPCheckEtherType(pAd, pPacket);
1032
1033
1034
1035         //
1036         // WPA 802.1x secured port control - drop all non-802.1x frame before port secured
1037         //
1038         if (((pAd->StaCfg.AuthMode == Ndis802_11AuthModeWPA) ||
1039                  (pAd->StaCfg.AuthMode == Ndis802_11AuthModeWPAPSK) ||
1040                  (pAd->StaCfg.AuthMode == Ndis802_11AuthModeWPA2) ||
1041                  (pAd->StaCfg.AuthMode == Ndis802_11AuthModeWPA2PSK)
1042 #ifdef WPA_SUPPLICANT_SUPPORT
1043                   || (pAd->StaCfg.IEEE8021X == TRUE)
1044 #endif // WPA_SUPPLICANT_SUPPORT //
1045 #ifdef LEAP_SUPPORT
1046                   || (pAd->StaCfg.LeapAuthMode == CISCO_AuthModeLEAP)
1047 #endif // LEAP_SUPPORT //
1048                   )
1049                   && ((pAd->StaCfg.PortSecured == WPA_802_1X_PORT_NOT_SECURED) || (pAd->StaCfg.MicErrCnt >= 2))
1050                   && (RTMP_GET_PACKET_EAPOL(pPacket)== FALSE)
1051                   )
1052         {
1053                 DBGPRINT(RT_DEBUG_TRACE,("STASendPacket --> Drop packet before port secured !!!\n"));
1054                 RELEASE_NDIS_PACKET(pAd, pPacket, NDIS_STATUS_FAILURE);
1055
1056                 return (NDIS_STATUS_FAILURE);
1057         }
1058
1059
1060         // STEP 1. Decide number of fragments required to deliver this MSDU.
1061         //         The estimation here is not very accurate because difficult to
1062         //         take encryption overhead into consideration here. The result
1063         //         "NumberOfFrag" is then just used to pre-check if enough free
1064         //         TXD are available to hold this MSDU.
1065
1066
1067         if (*pSrcBufVA & 0x01)  // fragmentation not allowed on multicast & broadcast
1068                 NumberOfFrag = 1;
1069         else if (OPSTATUS_TEST_FLAG(pAd, fOP_STATUS_AGGREGATION_INUSED))
1070                 NumberOfFrag = 1;       // Aggregation overwhelms fragmentation
1071         else if (CLIENT_STATUS_TEST_FLAG(pEntry, fCLIENT_STATUS_AMSDU_INUSED))
1072                 NumberOfFrag = 1;       // Aggregation overwhelms fragmentation
1073 #ifdef DOT11_N_SUPPORT
1074         else if ((pAd->StaCfg.HTPhyMode.field.MODE == MODE_HTMIX) || (pAd->StaCfg.HTPhyMode.field.MODE == MODE_HTGREENFIELD))
1075                 NumberOfFrag = 1;       // MIMO RATE overwhelms fragmentation
1076 #endif // DOT11_N_SUPPORT //
1077         else
1078         {
1079                 // The calculated "NumberOfFrag" is a rough estimation because of various
1080                 // encryption/encapsulation overhead not taken into consideration. This number is just
1081                 // used to make sure enough free TXD are available before fragmentation takes place.
1082                 // In case the actual required number of fragments of an NDIS packet
1083                 // excceeds "NumberOfFrag"caculated here and not enough free TXD available, the
1084                 // last fragment (i.e. last MPDU) will be dropped in RTMPHardTransmit() due to out of
1085                 // resource, and the NDIS packet will be indicated NDIS_STATUS_FAILURE. This should
1086                 // rarely happen and the penalty is just like a TX RETRY fail. Affordable.
1087
1088                 AllowFragSize = (pAd->CommonCfg.FragmentThreshold) - LENGTH_802_11 - LENGTH_CRC;
1089                 NumberOfFrag = ((PacketInfo.TotalPacketLength - LENGTH_802_3 + LENGTH_802_1_H) / AllowFragSize) + 1;
1090                 // To get accurate number of fragmentation, Minus 1 if the size just match to allowable fragment size
1091                 if (((PacketInfo.TotalPacketLength - LENGTH_802_3 + LENGTH_802_1_H) % AllowFragSize) == 0)
1092                 {
1093                         NumberOfFrag--;
1094                 }
1095         }
1096
1097         // Save fragment number to Ndis packet reserved field
1098         RTMP_SET_PACKET_FRAGMENTS(pPacket, NumberOfFrag);
1099
1100
1101         // STEP 2. Check the requirement of RTS:
1102         //         If multiple fragment required, RTS is required only for the first fragment
1103         //         if the fragment size large than RTS threshold
1104         //     For RT28xx, Let ASIC send RTS/CTS
1105         RTMP_SET_PACKET_RTS(pPacket, 0);
1106         RTMP_SET_PACKET_TXRATE(pPacket, pAd->CommonCfg.TxRate);
1107
1108         //
1109         // STEP 3. Traffic classification. outcome = <UserPriority, QueIdx>
1110         //
1111         UserPriority = 0;
1112         QueIdx           = QID_AC_BE;
1113         if (OPSTATUS_TEST_FLAG(pAd, fOP_STATUS_WMM_INUSED) &&
1114                 CLIENT_STATUS_TEST_FLAG(pEntry, fCLIENT_STATUS_WMM_CAPABLE))
1115         {
1116                 USHORT Protocol;
1117                 UCHAR  LlcSnapLen = 0, Byte0, Byte1;
1118                 do
1119                 {
1120                         // get Ethernet protocol field
1121                         Protocol = (USHORT)((pSrcBufVA[12] << 8) + pSrcBufVA[13]);
1122                         if (Protocol <= 1500)
1123                         {
1124                                 // get Ethernet protocol field from LLC/SNAP
1125                                 if (Sniff2BytesFromNdisBuffer(PacketInfo.pFirstBuffer, LENGTH_802_3 + 6, &Byte0, &Byte1) != NDIS_STATUS_SUCCESS)
1126                                         break;
1127
1128                                 Protocol = (USHORT)((Byte0 << 8) + Byte1);
1129                                 LlcSnapLen = 8;
1130                         }
1131
1132                         // always AC_BE for non-IP packet
1133                         if (Protocol != 0x0800)
1134                                 break;
1135
1136                         // get IP header
1137                         if (Sniff2BytesFromNdisBuffer(PacketInfo.pFirstBuffer, LENGTH_802_3 + LlcSnapLen, &Byte0, &Byte1) != NDIS_STATUS_SUCCESS)
1138                                 break;
1139
1140                         // return AC_BE if packet is not IPv4
1141                         if ((Byte0 & 0xf0) != 0x40)
1142                                 break;
1143
1144                         FlgIsIP = 1;
1145                         UserPriority = (Byte1 & 0xe0) >> 5;
1146                         QueIdx = MapUserPriorityToAccessCategory[UserPriority];
1147
1148                         // TODO: have to check ACM bit. apply TSPEC if ACM is ON
1149                         // TODO: downgrade UP & QueIdx before passing ACM
1150                         if (pAd->CommonCfg.APEdcaParm.bACM[QueIdx])
1151                         {
1152                                 UserPriority = 0;
1153                                 QueIdx           = QID_AC_BE;
1154                         }
1155                 } while (FALSE);
1156         }
1157
1158         RTMP_SET_PACKET_UP(pPacket, UserPriority);
1159
1160
1161
1162         // Make sure SendTxWait queue resource won't be used by other threads
1163         RTMP_IRQ_LOCK(&pAd->irq_lock, IrqFlags);
1164         if (pAd->TxSwQueue[QueIdx].Number >= MAX_PACKETS_IN_QUEUE)
1165         {
1166                 RTMP_IRQ_UNLOCK(&pAd->irq_lock, IrqFlags);
1167 #ifdef BLOCK_NET_IF
1168                 StopNetIfQueue(pAd, QueIdx, pPacket);
1169 #endif // BLOCK_NET_IF //
1170                 RELEASE_NDIS_PACKET(pAd, pPacket, NDIS_STATUS_FAILURE);
1171
1172                 return NDIS_STATUS_FAILURE;
1173         }
1174         else
1175         {
1176                 InsertTailQueue(&pAd->TxSwQueue[QueIdx], PACKET_TO_QUEUE_ENTRY(pPacket));
1177         }
1178         RTMP_IRQ_UNLOCK(&pAd->irq_lock, IrqFlags);
1179
1180 #ifdef DOT11_N_SUPPORT
1181     if ((pAd->CommonCfg.BACapability.field.AutoBA == TRUE)&&
1182         IS_HT_STA(pEntry))
1183         {
1184             //PMAC_TABLE_ENTRY pMacEntry = &pAd->MacTab.Content[BSSID_WCID];
1185                 if (((pEntry->TXBAbitmap & (1<<UserPriority)) == 0) &&
1186             ((pEntry->BADeclineBitmap & (1<<UserPriority)) == 0) &&
1187             (pEntry->PortSecured == WPA_802_1X_PORT_SECURED)
1188                          // For IOT compatibility, if
1189                          // 1. It is Ralink chip or
1190                          // 2. It is OPEN or AES mode,
1191                          // then BA session can be bulit.
1192                          && ((pEntry->ValidAsCLI && pAd->MlmeAux.APRalinkIe != 0x0) ||
1193                                  (pEntry->WepStatus == Ndis802_11WEPDisabled || pEntry->WepStatus == Ndis802_11Encryption3Enabled))
1194                         )
1195                 {
1196                         BAOriSessionSetUp(pAd, pEntry, 0, 0, 10, FALSE);
1197                 }
1198         }
1199 #endif // DOT11_N_SUPPORT //
1200
1201         pAd->RalinkCounters.OneSecOsTxCount[QueIdx]++; // TODO: for debug only. to be removed
1202         return NDIS_STATUS_SUCCESS;
1203 }
1204
1205
1206 /*
1207         ========================================================================
1208
1209         Routine Description:
1210                 This subroutine will scan through releative ring descriptor to find
1211                 out avaliable free ring descriptor and compare with request size.
1212
1213         Arguments:
1214                 pAd Pointer to our adapter
1215                 QueIdx          Selected TX Ring
1216
1217         Return Value:
1218                 NDIS_STATUS_FAILURE     Not enough free descriptor
1219                 NDIS_STATUS_SUCCESS     Enough free descriptor
1220
1221         IRQL = PASSIVE_LEVEL
1222         IRQL = DISPATCH_LEVEL
1223
1224         Note:
1225
1226         ========================================================================
1227 */
1228
1229 #ifdef RT2870
1230 /*
1231         Actually, this function used to check if the TxHardware Queue still has frame need to send.
1232         If no frame need to send, go to sleep, else, still wake up.
1233 */
1234 NDIS_STATUS RTMPFreeTXDRequest(
1235         IN              PRTMP_ADAPTER   pAd,
1236         IN              UCHAR                   QueIdx,
1237         IN              UCHAR                   NumberRequired,
1238         IN              PUCHAR                  FreeNumberIs)
1239 {
1240         //ULONG         FreeNumber = 0;
1241         NDIS_STATUS     Status = NDIS_STATUS_FAILURE;
1242         unsigned long   IrqFlags;
1243         HT_TX_CONTEXT   *pHTTXContext;
1244
1245         switch (QueIdx)
1246         {
1247                 case QID_AC_BK:
1248                 case QID_AC_BE:
1249                 case QID_AC_VI:
1250                 case QID_AC_VO:
1251                 case QID_HCCA:
1252                         {
1253                                 pHTTXContext = &pAd->TxContext[QueIdx];
1254                                 RTMP_IRQ_LOCK(&pAd->TxContextQueueLock[QueIdx], IrqFlags);
1255                                 if ((pHTTXContext->CurWritePosition != pHTTXContext->ENextBulkOutPosition) ||
1256                                         (pHTTXContext->IRPPending == TRUE))
1257                                 {
1258                                         Status = NDIS_STATUS_FAILURE;
1259                                 }
1260                                 else
1261                                 {
1262                                         Status = NDIS_STATUS_SUCCESS;
1263                                 }
1264                                 RTMP_IRQ_UNLOCK(&pAd->TxContextQueueLock[QueIdx], IrqFlags);
1265                         }
1266                         break;
1267
1268                 case QID_MGMT:
1269                         if (pAd->MgmtRing.TxSwFreeIdx != MGMT_RING_SIZE)
1270                                 Status = NDIS_STATUS_FAILURE;
1271                         else
1272                                 Status = NDIS_STATUS_SUCCESS;
1273                         break;
1274
1275                 default:
1276                         DBGPRINT(RT_DEBUG_ERROR,("RTMPFreeTXDRequest::Invalid QueIdx(=%d)\n", QueIdx));
1277                         break;
1278         }
1279
1280         return (Status);
1281
1282 }
1283 #endif // RT2870 //
1284
1285
1286 VOID RTMPSendDisassociationFrame(
1287         IN      PRTMP_ADAPTER   pAd)
1288 {
1289 }
1290
1291 VOID    RTMPSendNullFrame(
1292         IN      PRTMP_ADAPTER   pAd,
1293         IN      UCHAR                   TxRate,
1294         IN      BOOLEAN                 bQosNull)
1295 {
1296         UCHAR   NullFrame[48];
1297         ULONG   Length;
1298         PHEADER_802_11  pHeader_802_11;
1299
1300
1301 #ifdef RALINK_ATE
1302         if(ATE_ON(pAd))
1303         {
1304                 return;
1305         }
1306 #endif // RALINK_ATE //
1307
1308     // WPA 802.1x secured port control
1309     if (((pAd->StaCfg.AuthMode == Ndis802_11AuthModeWPA) ||
1310          (pAd->StaCfg.AuthMode == Ndis802_11AuthModeWPAPSK) ||
1311          (pAd->StaCfg.AuthMode == Ndis802_11AuthModeWPA2) ||
1312          (pAd->StaCfg.AuthMode == Ndis802_11AuthModeWPA2PSK)
1313 #ifdef WPA_SUPPLICANT_SUPPORT
1314                           || (pAd->StaCfg.IEEE8021X == TRUE)
1315 #endif
1316         ) &&
1317        (pAd->StaCfg.PortSecured == WPA_802_1X_PORT_NOT_SECURED))
1318         {
1319                 return;
1320         }
1321
1322         NdisZeroMemory(NullFrame, 48);
1323         Length = sizeof(HEADER_802_11);
1324
1325         pHeader_802_11 = (PHEADER_802_11) NullFrame;
1326
1327         pHeader_802_11->FC.Type = BTYPE_DATA;
1328         pHeader_802_11->FC.SubType = SUBTYPE_NULL_FUNC;
1329         pHeader_802_11->FC.ToDs = 1;
1330         COPY_MAC_ADDR(pHeader_802_11->Addr1, pAd->CommonCfg.Bssid);
1331         COPY_MAC_ADDR(pHeader_802_11->Addr2, pAd->CurrentAddress);
1332         COPY_MAC_ADDR(pHeader_802_11->Addr3, pAd->CommonCfg.Bssid);
1333
1334         if (pAd->CommonCfg.bAPSDForcePowerSave)
1335         {
1336                 pHeader_802_11->FC.PwrMgmt = PWR_SAVE;
1337         }
1338         else
1339         {
1340                 pHeader_802_11->FC.PwrMgmt = (pAd->StaCfg.Psm == PWR_SAVE) ? 1: 0;
1341         }
1342         pHeader_802_11->Duration = pAd->CommonCfg.Dsifs + RTMPCalcDuration(pAd, TxRate, 14);
1343
1344         pAd->Sequence++;
1345         pHeader_802_11->Sequence = pAd->Sequence;
1346
1347         // Prepare QosNull function frame
1348         if (bQosNull)
1349         {
1350                 pHeader_802_11->FC.SubType = SUBTYPE_QOS_NULL;
1351
1352                 // copy QOS control bytes
1353                 NullFrame[Length]       =  0;
1354                 NullFrame[Length+1] =  0;
1355                 Length += 2;// if pad with 2 bytes for alignment, APSD will fail
1356         }
1357
1358         HAL_KickOutNullFrameTx(pAd, 0, NullFrame, Length);
1359
1360 }
1361
1362 // IRQL = DISPATCH_LEVEL
1363 VOID    RTMPSendRTSFrame(
1364         IN      PRTMP_ADAPTER   pAd,
1365         IN      PUCHAR                  pDA,
1366         IN      unsigned int    NextMpduSize,
1367         IN      UCHAR                   TxRate,
1368         IN      UCHAR                   RTSRate,
1369         IN      USHORT                  AckDuration,
1370         IN      UCHAR                   QueIdx,
1371         IN      UCHAR                   FrameGap)
1372 {
1373 }
1374
1375
1376
1377 // --------------------------------------------------------
1378 //  FIND ENCRYPT KEY AND DECIDE CIPHER ALGORITHM
1379 //              Find the WPA key, either Group or Pairwise Key
1380 //              LEAP + TKIP also use WPA key.
1381 // --------------------------------------------------------
1382 // Decide WEP bit and cipher suite to be used. Same cipher suite should be used for whole fragment burst
1383 // In Cisco CCX 2.0 Leap Authentication
1384 //                 WepStatus is Ndis802_11Encryption1Enabled but the key will use PairwiseKey
1385 //                 Instead of the SharedKey, SharedKey Length may be Zero.
1386 VOID STAFindCipherAlgorithm(
1387         IN      PRTMP_ADAPTER   pAd,
1388         IN      TX_BLK                  *pTxBlk)
1389 {
1390         NDIS_802_11_ENCRYPTION_STATUS   Cipher;                         // To indicate cipher used for this packet
1391         UCHAR                                                   CipherAlg = CIPHER_NONE;                // cipher alogrithm
1392         UCHAR                                                   KeyIdx = 0xff;
1393         PUCHAR                                                  pSrcBufVA;
1394         PCIPHER_KEY                                             pKey = NULL;
1395
1396         pSrcBufVA = GET_OS_PKT_DATAPTR(pTxBlk->pPacket);
1397
1398         {
1399             // Select Cipher
1400             if ((*pSrcBufVA & 0x01) && (ADHOC_ON(pAd)))
1401                 Cipher = pAd->StaCfg.GroupCipher; // Cipher for Multicast or Broadcast
1402             else
1403                 Cipher = pAd->StaCfg.PairCipher; // Cipher for Unicast
1404
1405                 if (RTMP_GET_PACKET_EAPOL(pTxBlk->pPacket))
1406                 {
1407                         ASSERT(pAd->SharedKey[BSS0][0].CipherAlg <= CIPHER_CKIP128);
1408
1409                         // 4-way handshaking frame must be clear
1410                         if (!(TX_BLK_TEST_FLAG(pTxBlk, fTX_bClearEAPFrame)) && (pAd->SharedKey[BSS0][0].CipherAlg) &&
1411                                 (pAd->SharedKey[BSS0][0].KeyLen))
1412                         {
1413                                 CipherAlg = pAd->SharedKey[BSS0][0].CipherAlg;
1414                                 KeyIdx = 0;
1415                         }
1416                 }
1417                 else if (Cipher == Ndis802_11Encryption1Enabled)
1418                 {
1419 #ifdef LEAP_SUPPORT
1420                         if (pAd->StaCfg.CkipFlag & 0x10) // Cisco CKIP KP is on
1421                         {
1422                                 if (LEAP_CCKM_ON(pAd))
1423                                 {
1424                                         if (((*pSrcBufVA & 0x01) && (ADHOC_ON(pAd))))
1425                                                 KeyIdx = 1;
1426                                         else
1427                                                 KeyIdx = 0;
1428                                 }
1429                                 else
1430                                         KeyIdx = pAd->StaCfg.DefaultKeyId;
1431                         }
1432                         else if (pAd->StaCfg.CkipFlag & 0x08) // only CKIP CMIC
1433                                 KeyIdx = pAd->StaCfg.DefaultKeyId;
1434                         else if (LEAP_CCKM_ON(pAd))
1435                         {
1436                                 if ((*pSrcBufVA & 0x01) && (ADHOC_ON(pAd)))
1437                                         KeyIdx = 1;
1438                                 else
1439                                         KeyIdx = 0;
1440                         }
1441                         else    // standard WEP64 or WEP128
1442 #endif // LEAP_SUPPORT //
1443                                 KeyIdx = pAd->StaCfg.DefaultKeyId;
1444                 }
1445                 else if ((Cipher == Ndis802_11Encryption2Enabled) ||
1446                                  (Cipher == Ndis802_11Encryption3Enabled))
1447                 {
1448                         if ((*pSrcBufVA & 0x01) && (ADHOC_ON(pAd))) // multicast
1449                                 KeyIdx = pAd->StaCfg.DefaultKeyId;
1450                         else if (pAd->SharedKey[BSS0][0].KeyLen)
1451                                 KeyIdx = 0;
1452                         else
1453                                 KeyIdx = pAd->StaCfg.DefaultKeyId;
1454                 }
1455
1456                 if (KeyIdx == 0xff)
1457                         CipherAlg = CIPHER_NONE;
1458                 else if ((Cipher == Ndis802_11EncryptionDisabled) || (pAd->SharedKey[BSS0][KeyIdx].KeyLen == 0))
1459                         CipherAlg = CIPHER_NONE;
1460 #ifdef WPA_SUPPLICANT_SUPPORT
1461             else if ( pAd->StaCfg.WpaSupplicantUP &&
1462                      (Cipher == Ndis802_11Encryption1Enabled) &&
1463                      (pAd->StaCfg.IEEE8021X == TRUE) &&
1464                      (pAd->StaCfg.PortSecured == WPA_802_1X_PORT_NOT_SECURED))
1465                 CipherAlg = CIPHER_NONE;
1466 #endif // WPA_SUPPLICANT_SUPPORT //
1467                 else
1468                 {
1469                         //Header_802_11.FC.Wep = 1;
1470                         CipherAlg = pAd->SharedKey[BSS0][KeyIdx].CipherAlg;
1471                         pKey = &pAd->SharedKey[BSS0][KeyIdx];
1472                 }
1473         }
1474
1475         pTxBlk->CipherAlg = CipherAlg;
1476         pTxBlk->pKey = pKey;
1477 }
1478
1479
1480 VOID STABuildCommon802_11Header(
1481         IN  PRTMP_ADAPTER   pAd,
1482         IN  TX_BLK          *pTxBlk)
1483 {
1484
1485         HEADER_802_11   *pHeader_802_11;
1486 #ifdef QOS_DLS_SUPPORT
1487         BOOLEAN bDLSFrame = FALSE;
1488         INT     DlsEntryIndex = 0;
1489 #endif // QOS_DLS_SUPPORT //
1490
1491         //
1492         // MAKE A COMMON 802.11 HEADER
1493         //
1494
1495         // normal wlan header size : 24 octets
1496         pTxBlk->MpduHeaderLen = sizeof(HEADER_802_11);
1497
1498         pHeader_802_11 = (HEADER_802_11 *) &pTxBlk->HeaderBuf[TXINFO_SIZE + TXWI_SIZE];
1499
1500         NdisZeroMemory(pHeader_802_11, sizeof(HEADER_802_11));
1501
1502         pHeader_802_11->FC.FrDs = 0;
1503         pHeader_802_11->FC.Type = BTYPE_DATA;
1504         pHeader_802_11->FC.SubType = ((TX_BLK_TEST_FLAG(pTxBlk, fTX_bWMM)) ? SUBTYPE_QDATA : SUBTYPE_DATA);
1505
1506 #ifdef QOS_DLS_SUPPORT
1507         if (INFRA_ON(pAd))
1508         {
1509                 // Check if the frame can be sent through DLS direct link interface
1510                 // If packet can be sent through DLS, then force aggregation disable. (Hard to determine peer STA's capability)
1511                 DlsEntryIndex = RTMPCheckDLSFrame(pAd, pTxBlk->pSrcBufHeader);
1512                 if (DlsEntryIndex >= 0)
1513                         bDLSFrame = TRUE;
1514                 else
1515                         bDLSFrame = FALSE;
1516         }
1517 #endif // QOS_DLS_SUPPORT //
1518
1519     if (pTxBlk->pMacEntry)
1520         {
1521                 if (TX_BLK_TEST_FLAG(pTxBlk, fTX_bForceNonQoS))
1522                 {
1523                         pHeader_802_11->Sequence = pTxBlk->pMacEntry->NonQosDataSeq;
1524                         pTxBlk->pMacEntry->NonQosDataSeq = (pTxBlk->pMacEntry->NonQosDataSeq+1) & MAXSEQ;
1525                 }
1526                 else
1527                 {
1528             pHeader_802_11->Sequence = pTxBlk->pMacEntry->TxSeq[pTxBlk->UserPriority];
1529             pTxBlk->pMacEntry->TxSeq[pTxBlk->UserPriority] = (pTxBlk->pMacEntry->TxSeq[pTxBlk->UserPriority]+1) & MAXSEQ;
1530         }
1531         }
1532         else
1533         {
1534                 pHeader_802_11->Sequence = pAd->Sequence;
1535                 pAd->Sequence = (pAd->Sequence+1) & MAXSEQ; // next sequence
1536         }
1537
1538         pHeader_802_11->Frag = 0;
1539
1540         pHeader_802_11->FC.MoreData = TX_BLK_TEST_FLAG(pTxBlk, fTX_bMoreData);
1541
1542         {
1543                 if (INFRA_ON(pAd))
1544                 {
1545 #ifdef QOS_DLS_SUPPORT
1546                         if (bDLSFrame)
1547                         {
1548                                 COPY_MAC_ADDR(pHeader_802_11->Addr1, pTxBlk->pSrcBufHeader);
1549                                 COPY_MAC_ADDR(pHeader_802_11->Addr2, pAd->CurrentAddress);
1550                                 COPY_MAC_ADDR(pHeader_802_11->Addr3, pAd->CommonCfg.Bssid);
1551                                 pHeader_802_11->FC.ToDs = 0;
1552                         }
1553                         else
1554 #endif // QOS_DLS_SUPPORT //
1555                         {
1556                         COPY_MAC_ADDR(pHeader_802_11->Addr1, pAd->CommonCfg.Bssid);
1557                         COPY_MAC_ADDR(pHeader_802_11->Addr2, pAd->CurrentAddress);
1558                         COPY_MAC_ADDR(pHeader_802_11->Addr3, pTxBlk->pSrcBufHeader);
1559                         pHeader_802_11->FC.ToDs = 1;
1560                 }
1561                 }
1562                 else if (ADHOC_ON(pAd))
1563                 {
1564                         COPY_MAC_ADDR(pHeader_802_11->Addr1, pTxBlk->pSrcBufHeader);
1565                         COPY_MAC_ADDR(pHeader_802_11->Addr2, pAd->CurrentAddress);
1566                         COPY_MAC_ADDR(pHeader_802_11->Addr3, pAd->CommonCfg.Bssid);
1567                         pHeader_802_11->FC.ToDs = 0;
1568                 }
1569         }
1570
1571         if (pTxBlk->CipherAlg != CIPHER_NONE)
1572                 pHeader_802_11->FC.Wep = 1;
1573
1574         // -----------------------------------------------------------------
1575         // STEP 2. MAKE A COMMON 802.11 HEADER SHARED BY ENTIRE FRAGMENT BURST. Fill sequence later.
1576         // -----------------------------------------------------------------
1577         if (pAd->CommonCfg.bAPSDForcePowerSave)
1578         pHeader_802_11->FC.PwrMgmt = PWR_SAVE;
1579         else
1580         pHeader_802_11->FC.PwrMgmt = (pAd->StaCfg.Psm == PWR_SAVE);
1581 }
1582
1583 #ifdef DOT11_N_SUPPORT
1584 VOID STABuildCache802_11Header(
1585         IN RTMP_ADAPTER         *pAd,
1586         IN TX_BLK                       *pTxBlk,
1587         IN UCHAR                        *pHeader)
1588 {
1589         MAC_TABLE_ENTRY *pMacEntry;
1590         PHEADER_802_11  pHeader80211;
1591
1592         pHeader80211 = (PHEADER_802_11)pHeader;
1593         pMacEntry = pTxBlk->pMacEntry;
1594
1595         //
1596         // Update the cached 802.11 HEADER
1597         //
1598
1599         // normal wlan header size : 24 octets
1600         pTxBlk->MpduHeaderLen = sizeof(HEADER_802_11);
1601
1602         // More Bit
1603         pHeader80211->FC.MoreData = TX_BLK_TEST_FLAG(pTxBlk, fTX_bMoreData);
1604
1605         // Sequence
1606         pHeader80211->Sequence = pMacEntry->TxSeq[pTxBlk->UserPriority];
1607     pMacEntry->TxSeq[pTxBlk->UserPriority] = (pMacEntry->TxSeq[pTxBlk->UserPriority]+1) & MAXSEQ;
1608
1609         {
1610                 // Check if the frame can be sent through DLS direct link interface
1611                 // If packet can be sent through DLS, then force aggregation disable. (Hard to determine peer STA's capability)
1612 #ifdef QOS_DLS_SUPPORT
1613                 BOOLEAN bDLSFrame = FALSE;
1614                 INT     DlsEntryIndex = 0;
1615
1616                 DlsEntryIndex = RTMPCheckDLSFrame(pAd, pTxBlk->pSrcBufHeader);
1617                 if (DlsEntryIndex >= 0)
1618                         bDLSFrame = TRUE;
1619                 else
1620                         bDLSFrame = FALSE;
1621 #endif // QOS_DLS_SUPPORT //
1622
1623                 // The addr3 of normal packet send from DS is Dest Mac address.
1624 #ifdef QOS_DLS_SUPPORT
1625                 if (bDLSFrame)
1626                 {
1627                         COPY_MAC_ADDR(pHeader80211->Addr1, pTxBlk->pSrcBufHeader);
1628                         COPY_MAC_ADDR(pHeader80211->Addr3, pAd->CommonCfg.Bssid);
1629                         pHeader80211->FC.ToDs = 0;
1630                 }
1631                 else
1632 #endif // QOS_DLS_SUPPORT //
1633                 if (ADHOC_ON(pAd))
1634                         COPY_MAC_ADDR(pHeader80211->Addr3, pAd->CommonCfg.Bssid);
1635                 else
1636                         COPY_MAC_ADDR(pHeader80211->Addr3, pTxBlk->pSrcBufHeader);
1637         }
1638
1639         // -----------------------------------------------------------------
1640         // STEP 2. MAKE A COMMON 802.11 HEADER SHARED BY ENTIRE FRAGMENT BURST. Fill sequence later.
1641         // -----------------------------------------------------------------
1642         if (pAd->CommonCfg.bAPSDForcePowerSave)
1643         pHeader80211->FC.PwrMgmt = PWR_SAVE;
1644         else
1645         pHeader80211->FC.PwrMgmt = (pAd->StaCfg.Psm == PWR_SAVE);
1646 }
1647 #endif // DOT11_N_SUPPORT //
1648
1649 static inline PUCHAR STA_Build_ARalink_Frame_Header(
1650         IN RTMP_ADAPTER *pAd,
1651         IN TX_BLK               *pTxBlk)
1652 {
1653         PUCHAR                  pHeaderBufPtr;
1654         HEADER_802_11   *pHeader_802_11;
1655         PNDIS_PACKET    pNextPacket;
1656         UINT32                  nextBufLen;
1657         PQUEUE_ENTRY    pQEntry;
1658
1659         STAFindCipherAlgorithm(pAd, pTxBlk);
1660         STABuildCommon802_11Header(pAd, pTxBlk);
1661
1662
1663         pHeaderBufPtr = &pTxBlk->HeaderBuf[TXINFO_SIZE + TXWI_SIZE];
1664         pHeader_802_11 = (HEADER_802_11 *) pHeaderBufPtr;
1665
1666         // steal "order" bit to mark "aggregation"
1667         pHeader_802_11->FC.Order = 1;
1668
1669         // skip common header
1670         pHeaderBufPtr += pTxBlk->MpduHeaderLen;
1671
1672         if (TX_BLK_TEST_FLAG(pTxBlk, fTX_bWMM))
1673         {
1674                 //
1675                 // build QOS Control bytes
1676                 //
1677                 *pHeaderBufPtr = (pTxBlk->UserPriority & 0x0F);
1678
1679                 *(pHeaderBufPtr+1) = 0;
1680                 pHeaderBufPtr +=2;
1681                 pTxBlk->MpduHeaderLen += 2;
1682         }
1683
1684         // padding at front of LLC header. LLC header should at 4-bytes aligment.
1685         pTxBlk->HdrPadLen = (ULONG)pHeaderBufPtr;
1686         pHeaderBufPtr = (PCHAR)ROUND_UP(pHeaderBufPtr, 4);
1687         pTxBlk->HdrPadLen = (ULONG)(pHeaderBufPtr - pTxBlk->HdrPadLen);
1688
1689         // For RA Aggregation,
1690         // put the 2nd MSDU length(extra 2-byte field) after QOS_CONTROL in little endian format
1691         pQEntry = pTxBlk->TxPacketList.Head;
1692         pNextPacket = QUEUE_ENTRY_TO_PKT(pQEntry);
1693         nextBufLen = GET_OS_PKT_LEN(pNextPacket);
1694         if (RTMP_GET_PACKET_VLAN(pNextPacket))
1695                 nextBufLen -= LENGTH_802_1Q;
1696
1697         *pHeaderBufPtr = (UCHAR)nextBufLen & 0xff;
1698         *(pHeaderBufPtr+1) = (UCHAR)(nextBufLen >> 8);
1699
1700         pHeaderBufPtr += 2;
1701         pTxBlk->MpduHeaderLen += 2;
1702
1703         return pHeaderBufPtr;
1704
1705 }
1706
1707 #ifdef DOT11_N_SUPPORT
1708 static inline PUCHAR STA_Build_AMSDU_Frame_Header(
1709         IN RTMP_ADAPTER *pAd,
1710         IN TX_BLK               *pTxBlk)
1711 {
1712         PUCHAR                  pHeaderBufPtr;//, pSaveBufPtr;
1713         HEADER_802_11   *pHeader_802_11;
1714
1715
1716         STAFindCipherAlgorithm(pAd, pTxBlk);
1717         STABuildCommon802_11Header(pAd, pTxBlk);
1718
1719         pHeaderBufPtr = &pTxBlk->HeaderBuf[TXINFO_SIZE + TXWI_SIZE];
1720         pHeader_802_11 = (HEADER_802_11 *) pHeaderBufPtr;
1721
1722         // skip common header
1723         pHeaderBufPtr += pTxBlk->MpduHeaderLen;
1724
1725         //
1726         // build QOS Control bytes
1727         //
1728         *pHeaderBufPtr = (pTxBlk->UserPriority & 0x0F);
1729
1730         //
1731         // A-MSDU packet
1732         //
1733         *pHeaderBufPtr |= 0x80;
1734
1735         *(pHeaderBufPtr+1) = 0;
1736         pHeaderBufPtr +=2;
1737         pTxBlk->MpduHeaderLen += 2;
1738
1739         //pSaveBufPtr = pHeaderBufPtr;
1740
1741         //
1742         // padding at front of LLC header
1743         // LLC header should locate at 4-octets aligment
1744         //
1745         // @@@ MpduHeaderLen excluding padding @@@
1746         //
1747         pTxBlk->HdrPadLen = (ULONG)pHeaderBufPtr;
1748         pHeaderBufPtr = (PCHAR) ROUND_UP(pHeaderBufPtr, 4);
1749         pTxBlk->HdrPadLen = (ULONG)(pHeaderBufPtr - pTxBlk->HdrPadLen);
1750
1751         return pHeaderBufPtr;
1752
1753 }
1754
1755
1756 VOID STA_AMPDU_Frame_Tx(
1757         IN      PRTMP_ADAPTER   pAd,
1758         IN      TX_BLK                  *pTxBlk)
1759 {
1760         HEADER_802_11   *pHeader_802_11;
1761         PUCHAR                  pHeaderBufPtr;
1762         USHORT                  FreeNumber;
1763         MAC_TABLE_ENTRY *pMacEntry;
1764         BOOLEAN                 bVLANPkt;
1765         PQUEUE_ENTRY    pQEntry;
1766
1767         ASSERT(pTxBlk);
1768
1769         while(pTxBlk->TxPacketList.Head)
1770         {
1771                 pQEntry = RemoveHeadQueue(&pTxBlk->TxPacketList);
1772                 pTxBlk->pPacket = QUEUE_ENTRY_TO_PACKET(pQEntry);
1773                 if ( RTMP_FillTxBlkInfo(pAd, pTxBlk) != TRUE)
1774                 {
1775                         RELEASE_NDIS_PACKET(pAd, pTxBlk->pPacket, NDIS_STATUS_FAILURE);
1776                         continue;
1777                 }
1778
1779                 bVLANPkt = (RTMP_GET_PACKET_VLAN(pTxBlk->pPacket) ? TRUE : FALSE);
1780
1781                 pMacEntry = pTxBlk->pMacEntry;
1782                 if (pMacEntry->isCached)
1783                 {
1784                         // NOTE: Please make sure the size of pMacEntry->CachedBuf[] is smaller than pTxBlk->HeaderBuf[]!!!!
1785                         NdisMoveMemory((PUCHAR)&pTxBlk->HeaderBuf[TXINFO_SIZE], (PUCHAR)&pMacEntry->CachedBuf[0], TXWI_SIZE + sizeof(HEADER_802_11));
1786                         pHeaderBufPtr = (PUCHAR)(&pTxBlk->HeaderBuf[TXINFO_SIZE + TXWI_SIZE]);
1787                         STABuildCache802_11Header(pAd, pTxBlk, pHeaderBufPtr);
1788                 }
1789                 else
1790                 {
1791                         STAFindCipherAlgorithm(pAd, pTxBlk);
1792                         STABuildCommon802_11Header(pAd, pTxBlk);
1793
1794                         pHeaderBufPtr = &pTxBlk->HeaderBuf[TXINFO_SIZE + TXWI_SIZE];
1795                 }
1796
1797
1798                 pHeader_802_11 = (HEADER_802_11 *) pHeaderBufPtr;
1799
1800                 // skip common header
1801                 pHeaderBufPtr += pTxBlk->MpduHeaderLen;
1802
1803                 //
1804                 // build QOS Control bytes
1805                 //
1806                 *pHeaderBufPtr = (pTxBlk->UserPriority & 0x0F);
1807                 *(pHeaderBufPtr+1) = 0;
1808                 pHeaderBufPtr +=2;
1809                 pTxBlk->MpduHeaderLen += 2;
1810
1811                 //
1812                 // build HTC+
1813                 // HTC control filed following QoS field
1814                 //
1815                 if ((pAd->CommonCfg.bRdg == TRUE) && CLIENT_STATUS_TEST_FLAG(pTxBlk->pMacEntry, fCLIENT_STATUS_RDG_CAPABLE))
1816                 {
1817                         if (pMacEntry->isCached == FALSE)
1818                         {
1819                                 // mark HTC bit
1820                                 pHeader_802_11->FC.Order = 1;
1821
1822                                 NdisZeroMemory(pHeaderBufPtr, 4);
1823                                 *(pHeaderBufPtr+3) |= 0x80;
1824                         }
1825                         pHeaderBufPtr += 4;
1826                         pTxBlk->MpduHeaderLen += 4;
1827                 }
1828
1829                 //pTxBlk->MpduHeaderLen = pHeaderBufPtr - pTxBlk->HeaderBuf - TXWI_SIZE - TXINFO_SIZE;
1830                 ASSERT(pTxBlk->MpduHeaderLen >= 24);
1831
1832                 // skip 802.3 header
1833                 pTxBlk->pSrcBufData = pTxBlk->pSrcBufHeader + LENGTH_802_3;
1834                 pTxBlk->SrcBufLen  -= LENGTH_802_3;
1835
1836                 // skip vlan tag
1837                 if (bVLANPkt)
1838                 {
1839                         pTxBlk->pSrcBufData     += LENGTH_802_1Q;
1840                         pTxBlk->SrcBufLen       -= LENGTH_802_1Q;
1841                 }
1842
1843                 //
1844                 // padding at front of LLC header
1845                 // LLC header should locate at 4-octets aligment
1846                 //
1847                 // @@@ MpduHeaderLen excluding padding @@@
1848                 //
1849                 pTxBlk->HdrPadLen = (ULONG)pHeaderBufPtr;
1850                 pHeaderBufPtr = (PCHAR) ROUND_UP(pHeaderBufPtr, 4);
1851                 pTxBlk->HdrPadLen = (ULONG)(pHeaderBufPtr - pTxBlk->HdrPadLen);
1852
1853                 {
1854
1855                         //
1856                         // Insert LLC-SNAP encapsulation - 8 octets
1857                         //
1858                         EXTRA_LLCSNAP_ENCAP_FROM_PKT_OFFSET(pTxBlk->pSrcBufData-2, pTxBlk->pExtraLlcSnapEncap);
1859                         if (pTxBlk->pExtraLlcSnapEncap)
1860                         {
1861                                 NdisMoveMemory(pHeaderBufPtr, pTxBlk->pExtraLlcSnapEncap, 6);
1862                                 pHeaderBufPtr += 6;
1863                                 // get 2 octets (TypeofLen)
1864                                 NdisMoveMemory(pHeaderBufPtr, pTxBlk->pSrcBufData-2, 2);
1865                                 pHeaderBufPtr += 2;
1866                                 pTxBlk->MpduHeaderLen += LENGTH_802_1_H;
1867                         }
1868
1869                 }
1870
1871                 if (pMacEntry->isCached)
1872                 {
1873             RTMPWriteTxWI_Cache(pAd, (PTXWI_STRUC)(&pTxBlk->HeaderBuf[TXINFO_SIZE]), pTxBlk);
1874                 }
1875                 else
1876                 {
1877                         RTMPWriteTxWI_Data(pAd, (PTXWI_STRUC)(&pTxBlk->HeaderBuf[TXINFO_SIZE]), pTxBlk);
1878
1879                         NdisZeroMemory((PUCHAR)(&pMacEntry->CachedBuf[0]), sizeof(pMacEntry->CachedBuf));
1880                         NdisMoveMemory((PUCHAR)(&pMacEntry->CachedBuf[0]), (PUCHAR)(&pTxBlk->HeaderBuf[TXINFO_SIZE]), (pHeaderBufPtr - (PUCHAR)(&pTxBlk->HeaderBuf[TXINFO_SIZE])));
1881                         pMacEntry->isCached = TRUE;
1882                 }
1883
1884                 // calculate Transmitted AMPDU count and ByteCount
1885                 {
1886                         pAd->RalinkCounters.TransmittedMPDUsInAMPDUCount.u.LowPart ++;
1887                         pAd->RalinkCounters.TransmittedOctetsInAMPDUCount.QuadPart += pTxBlk->SrcBufLen;
1888                 }
1889
1890                 //FreeNumber = GET_TXRING_FREENO(pAd, QueIdx);
1891
1892                 HAL_WriteTxResource(pAd, pTxBlk, TRUE, &FreeNumber);
1893
1894                 //
1895                 // Kick out Tx
1896                 //
1897                 HAL_KickOutTx(pAd, pTxBlk, pTxBlk->QueIdx);
1898
1899                 pAd->RalinkCounters.KickTxCount++;
1900                 pAd->RalinkCounters.OneSecTxDoneCount++;
1901         }
1902
1903 }
1904
1905
1906 VOID STA_AMSDU_Frame_Tx(
1907         IN      PRTMP_ADAPTER   pAd,
1908         IN      TX_BLK                  *pTxBlk)
1909 {
1910         PUCHAR                  pHeaderBufPtr;
1911         USHORT                  FreeNumber;
1912         USHORT                  subFramePayloadLen = 0; // AMSDU Subframe length without AMSDU-Header / Padding.
1913         USHORT                  totalMPDUSize=0;
1914         UCHAR                   *subFrameHeader;
1915         UCHAR                   padding = 0;
1916         USHORT                  FirstTx = 0, LastTxIdx = 0;
1917         BOOLEAN                 bVLANPkt;
1918         int                     frameNum = 0;
1919         PQUEUE_ENTRY    pQEntry;
1920
1921
1922         ASSERT(pTxBlk);
1923
1924         ASSERT((pTxBlk->TxPacketList.Number > 1));
1925
1926         while(pTxBlk->TxPacketList.Head)
1927         {
1928                 pQEntry = RemoveHeadQueue(&pTxBlk->TxPacketList);
1929                 pTxBlk->pPacket = QUEUE_ENTRY_TO_PACKET(pQEntry);
1930                 if (RTMP_FillTxBlkInfo(pAd, pTxBlk) != TRUE)
1931                 {
1932                         RELEASE_NDIS_PACKET(pAd, pTxBlk->pPacket, NDIS_STATUS_FAILURE);
1933                         continue;
1934                 }
1935
1936                 bVLANPkt = (RTMP_GET_PACKET_VLAN(pTxBlk->pPacket) ? TRUE : FALSE);
1937
1938                 // skip 802.3 header
1939                 pTxBlk->pSrcBufData = pTxBlk->pSrcBufHeader + LENGTH_802_3;
1940                 pTxBlk->SrcBufLen  -= LENGTH_802_3;
1941
1942                 // skip vlan tag
1943                 if (bVLANPkt)
1944                 {
1945                         pTxBlk->pSrcBufData     += LENGTH_802_1Q;
1946                         pTxBlk->SrcBufLen       -= LENGTH_802_1Q;
1947                 }
1948
1949                 if (frameNum == 0)
1950                 {
1951                         pHeaderBufPtr = STA_Build_AMSDU_Frame_Header(pAd, pTxBlk);
1952
1953                         // NOTE: TxWI->MPDUtotalByteCount will be updated after final frame was handled.
1954                         RTMPWriteTxWI_Data(pAd, (PTXWI_STRUC)(&pTxBlk->HeaderBuf[TXINFO_SIZE]), pTxBlk);
1955                 }
1956                 else
1957                 {
1958                         pHeaderBufPtr = &pTxBlk->HeaderBuf[0];
1959                         padding = ROUND_UP(LENGTH_AMSDU_SUBFRAMEHEAD + subFramePayloadLen, 4) - (LENGTH_AMSDU_SUBFRAMEHEAD + subFramePayloadLen);
1960                         NdisZeroMemory(pHeaderBufPtr, padding + LENGTH_AMSDU_SUBFRAMEHEAD);
1961                         pHeaderBufPtr += padding;
1962                         pTxBlk->MpduHeaderLen = padding;
1963                 }
1964
1965                 //
1966                 // A-MSDU subframe
1967                 //   DA(6)+SA(6)+Length(2) + LLC/SNAP Encap
1968                 //
1969                 subFrameHeader = pHeaderBufPtr;
1970                 subFramePayloadLen = pTxBlk->SrcBufLen;
1971
1972                 NdisMoveMemory(subFrameHeader, pTxBlk->pSrcBufHeader, 12);
1973
1974
1975                 pHeaderBufPtr += LENGTH_AMSDU_SUBFRAMEHEAD;
1976                 pTxBlk->MpduHeaderLen += LENGTH_AMSDU_SUBFRAMEHEAD;
1977
1978
1979                 //
1980                 // Insert LLC-SNAP encapsulation - 8 octets
1981                 //
1982                 EXTRA_LLCSNAP_ENCAP_FROM_PKT_OFFSET(pTxBlk->pSrcBufData-2, pTxBlk->pExtraLlcSnapEncap);
1983
1984                 subFramePayloadLen = pTxBlk->SrcBufLen;
1985
1986                 if (pTxBlk->pExtraLlcSnapEncap)
1987                 {
1988                         NdisMoveMemory(pHeaderBufPtr, pTxBlk->pExtraLlcSnapEncap, 6);
1989                         pHeaderBufPtr += 6;
1990                         // get 2 octets (TypeofLen)
1991                         NdisMoveMemory(pHeaderBufPtr, pTxBlk->pSrcBufData-2, 2);
1992                         pHeaderBufPtr += 2;
1993                         pTxBlk->MpduHeaderLen += LENGTH_802_1_H;
1994                         subFramePayloadLen += LENGTH_802_1_H;
1995                 }
1996
1997                 // update subFrame Length field
1998                 subFrameHeader[12] = (subFramePayloadLen & 0xFF00) >> 8;
1999                 subFrameHeader[13] = subFramePayloadLen & 0xFF;
2000
2001                 totalMPDUSize += pTxBlk->MpduHeaderLen + pTxBlk->SrcBufLen;
2002
2003                 if (frameNum ==0)
2004                         FirstTx = HAL_WriteMultiTxResource(pAd, pTxBlk, frameNum, &FreeNumber);
2005                 else
2006                         LastTxIdx = HAL_WriteMultiTxResource(pAd, pTxBlk, frameNum, &FreeNumber);
2007
2008                 frameNum++;
2009
2010                 pAd->RalinkCounters.KickTxCount++;
2011                 pAd->RalinkCounters.OneSecTxDoneCount++;
2012
2013                 // calculate Transmitted AMSDU Count and ByteCount
2014                 {
2015                         pAd->RalinkCounters.TransmittedAMSDUCount.u.LowPart ++;
2016                         pAd->RalinkCounters.TransmittedOctetsInAMSDU.QuadPart += totalMPDUSize;
2017                 }
2018
2019         }
2020
2021         HAL_FinalWriteTxResource(pAd, pTxBlk, totalMPDUSize, FirstTx);
2022         HAL_LastTxIdx(pAd, pTxBlk->QueIdx, LastTxIdx);
2023
2024         //
2025         // Kick out Tx
2026         //
2027         HAL_KickOutTx(pAd, pTxBlk, pTxBlk->QueIdx);
2028 }
2029 #endif // DOT11_N_SUPPORT //
2030
2031 VOID STA_Legacy_Frame_Tx(
2032         IN      PRTMP_ADAPTER   pAd,
2033         IN      TX_BLK                  *pTxBlk)
2034 {
2035         HEADER_802_11   *pHeader_802_11;
2036         PUCHAR                  pHeaderBufPtr;
2037         USHORT                  FreeNumber;
2038         BOOLEAN                 bVLANPkt;
2039         PQUEUE_ENTRY    pQEntry;
2040
2041         ASSERT(pTxBlk);
2042
2043
2044         pQEntry = RemoveHeadQueue(&pTxBlk->TxPacketList);
2045         pTxBlk->pPacket = QUEUE_ENTRY_TO_PACKET(pQEntry);
2046         if (RTMP_FillTxBlkInfo(pAd, pTxBlk) != TRUE)
2047         {
2048                 RELEASE_NDIS_PACKET(pAd, pTxBlk->pPacket, NDIS_STATUS_FAILURE);
2049                 return;
2050         }
2051
2052         if (pTxBlk->TxFrameType == TX_MCAST_FRAME)
2053         {
2054                 INC_COUNTER64(pAd->WlanCounters.MulticastTransmittedFrameCount);
2055         }
2056
2057         if (RTMP_GET_PACKET_RTS(pTxBlk->pPacket))
2058                 TX_BLK_SET_FLAG(pTxBlk, fTX_bRtsRequired);
2059         else
2060                 TX_BLK_CLEAR_FLAG(pTxBlk, fTX_bRtsRequired);
2061
2062         bVLANPkt = (RTMP_GET_PACKET_VLAN(pTxBlk->pPacket) ? TRUE : FALSE);
2063
2064         if (pTxBlk->TxRate < pAd->CommonCfg.MinTxRate)
2065                 pTxBlk->TxRate = pAd->CommonCfg.MinTxRate;
2066
2067         STAFindCipherAlgorithm(pAd, pTxBlk);
2068         STABuildCommon802_11Header(pAd, pTxBlk);
2069
2070
2071         // skip 802.3 header
2072         pTxBlk->pSrcBufData = pTxBlk->pSrcBufHeader + LENGTH_802_3;
2073         pTxBlk->SrcBufLen  -= LENGTH_802_3;
2074
2075         // skip vlan tag
2076         if (bVLANPkt)
2077         {
2078                 pTxBlk->pSrcBufData     += LENGTH_802_1Q;
2079                 pTxBlk->SrcBufLen       -= LENGTH_802_1Q;
2080         }
2081
2082         pHeaderBufPtr = &pTxBlk->HeaderBuf[TXINFO_SIZE + TXWI_SIZE];
2083         pHeader_802_11 = (HEADER_802_11 *) pHeaderBufPtr;
2084
2085         // skip common header
2086         pHeaderBufPtr += pTxBlk->MpduHeaderLen;
2087
2088         if (TX_BLK_TEST_FLAG(pTxBlk, fTX_bWMM))
2089         {
2090                 //
2091                 // build QOS Control bytes
2092                 //
2093                 *pHeaderBufPtr = (pTxBlk->UserPriority & 0x0F);
2094                 *(pHeaderBufPtr+1) = 0;
2095                 pHeaderBufPtr +=2;
2096                 pTxBlk->MpduHeaderLen += 2;
2097         }
2098
2099         // The remaining content of MPDU header should locate at 4-octets aligment
2100         pTxBlk->HdrPadLen = (ULONG)pHeaderBufPtr;
2101         pHeaderBufPtr = (PCHAR) ROUND_UP(pHeaderBufPtr, 4);
2102         pTxBlk->HdrPadLen = (ULONG)(pHeaderBufPtr - pTxBlk->HdrPadLen);
2103
2104         {
2105
2106                 //
2107                 // Insert LLC-SNAP encapsulation - 8 octets
2108                 //
2109                 //
2110                 // if original Ethernet frame contains no LLC/SNAP,
2111                 // then an extra LLC/SNAP encap is required
2112                 //
2113                 EXTRA_LLCSNAP_ENCAP_FROM_PKT_START(pTxBlk->pSrcBufHeader, pTxBlk->pExtraLlcSnapEncap);
2114                 if (pTxBlk->pExtraLlcSnapEncap)
2115                 {
2116                         UCHAR vlan_size;
2117
2118                         NdisMoveMemory(pHeaderBufPtr, pTxBlk->pExtraLlcSnapEncap, 6);
2119                         pHeaderBufPtr += 6;
2120                         // skip vlan tag
2121                         vlan_size =  (bVLANPkt) ? LENGTH_802_1Q : 0;
2122                         // get 2 octets (TypeofLen)
2123                         NdisMoveMemory(pHeaderBufPtr, pTxBlk->pSrcBufHeader+12+vlan_size, 2);
2124                         pHeaderBufPtr += 2;
2125                         pTxBlk->MpduHeaderLen += LENGTH_802_1_H;
2126                 }
2127
2128         }
2129
2130         //
2131         // prepare for TXWI
2132         // use Wcid as Key Index
2133         //
2134
2135         RTMPWriteTxWI_Data(pAd, (PTXWI_STRUC)(&pTxBlk->HeaderBuf[TXINFO_SIZE]), pTxBlk);
2136
2137         //FreeNumber = GET_TXRING_FREENO(pAd, QueIdx);
2138
2139         HAL_WriteTxResource(pAd, pTxBlk, TRUE, &FreeNumber);
2140
2141         pAd->RalinkCounters.KickTxCount++;
2142         pAd->RalinkCounters.OneSecTxDoneCount++;
2143
2144         //
2145         // Kick out Tx
2146         //
2147         HAL_KickOutTx(pAd, pTxBlk, pTxBlk->QueIdx);
2148 }
2149
2150
2151 VOID STA_ARalink_Frame_Tx(
2152         IN      PRTMP_ADAPTER   pAd,
2153         IN      TX_BLK                  *pTxBlk)
2154 {
2155         PUCHAR                  pHeaderBufPtr;
2156         USHORT                  FreeNumber;
2157         USHORT                  totalMPDUSize=0;
2158         USHORT                  FirstTx, LastTxIdx;
2159         int                     frameNum = 0;
2160         BOOLEAN                 bVLANPkt;
2161         PQUEUE_ENTRY    pQEntry;
2162
2163
2164         ASSERT(pTxBlk);
2165
2166         ASSERT((pTxBlk->TxPacketList.Number== 2));
2167
2168
2169         FirstTx = LastTxIdx = 0;  // Is it ok init they as 0?
2170         while(pTxBlk->TxPacketList.Head)
2171         {
2172                 pQEntry = RemoveHeadQueue(&pTxBlk->TxPacketList);
2173                 pTxBlk->pPacket = QUEUE_ENTRY_TO_PACKET(pQEntry);
2174
2175                 if (RTMP_FillTxBlkInfo(pAd, pTxBlk) != TRUE)
2176                 {
2177                         RELEASE_NDIS_PACKET(pAd, pTxBlk->pPacket, NDIS_STATUS_FAILURE);
2178                         continue;
2179                 }
2180
2181                 bVLANPkt = (RTMP_GET_PACKET_VLAN(pTxBlk->pPacket) ? TRUE : FALSE);
2182
2183                 // skip 802.3 header
2184                 pTxBlk->pSrcBufData = pTxBlk->pSrcBufHeader + LENGTH_802_3;
2185                 pTxBlk->SrcBufLen  -= LENGTH_802_3;
2186
2187                 // skip vlan tag
2188                 if (bVLANPkt)
2189                 {
2190                         pTxBlk->pSrcBufData     += LENGTH_802_1Q;
2191                         pTxBlk->SrcBufLen       -= LENGTH_802_1Q;
2192                 }
2193
2194                 if (frameNum == 0)
2195                 {       // For first frame, we need to create the 802.11 header + padding(optional) + RA-AGG-LEN + SNAP Header
2196
2197                         pHeaderBufPtr = STA_Build_ARalink_Frame_Header(pAd, pTxBlk);
2198
2199                         // It's ok write the TxWI here, because the TxWI->MPDUtotalByteCount
2200                         //      will be updated after final frame was handled.
2201                         RTMPWriteTxWI_Data(pAd, (PTXWI_STRUC)(&pTxBlk->HeaderBuf[TXINFO_SIZE]), pTxBlk);
2202
2203
2204                         //
2205                         // Insert LLC-SNAP encapsulation - 8 octets
2206                         //
2207                         EXTRA_LLCSNAP_ENCAP_FROM_PKT_OFFSET(pTxBlk->pSrcBufData-2, pTxBlk->pExtraLlcSnapEncap);
2208
2209                         if (pTxBlk->pExtraLlcSnapEncap)
2210                         {
2211                                 NdisMoveMemory(pHeaderBufPtr, pTxBlk->pExtraLlcSnapEncap, 6);
2212                                 pHeaderBufPtr += 6;
2213                                 // get 2 octets (TypeofLen)
2214                                 NdisMoveMemory(pHeaderBufPtr, pTxBlk->pSrcBufData-2, 2);
2215                                 pHeaderBufPtr += 2;
2216                                 pTxBlk->MpduHeaderLen += LENGTH_802_1_H;
2217                         }
2218                 }
2219                 else
2220                 {       // For second aggregated frame, we need create the 802.3 header to headerBuf, because PCI will copy it to SDPtr0.
2221
2222                         pHeaderBufPtr = &pTxBlk->HeaderBuf[0];
2223                         pTxBlk->MpduHeaderLen = 0;
2224
2225                         // A-Ralink sub-sequent frame header is the same as 802.3 header.
2226                         //   DA(6)+SA(6)+FrameType(2)
2227                         NdisMoveMemory(pHeaderBufPtr, pTxBlk->pSrcBufHeader, 12);
2228                         pHeaderBufPtr += 12;
2229                         // get 2 octets (TypeofLen)
2230                         NdisMoveMemory(pHeaderBufPtr, pTxBlk->pSrcBufData-2, 2);
2231                         pHeaderBufPtr += 2;
2232                         pTxBlk->MpduHeaderLen = LENGTH_ARALINK_SUBFRAMEHEAD;
2233                 }
2234
2235                 totalMPDUSize += pTxBlk->MpduHeaderLen + pTxBlk->SrcBufLen;
2236
2237                 //FreeNumber = GET_TXRING_FREENO(pAd, QueIdx);
2238                 if (frameNum ==0)
2239                         FirstTx = HAL_WriteMultiTxResource(pAd, pTxBlk, frameNum, &FreeNumber);
2240                 else
2241                         LastTxIdx = HAL_WriteMultiTxResource(pAd, pTxBlk, frameNum, &FreeNumber);
2242
2243                 frameNum++;
2244
2245                 pAd->RalinkCounters.OneSecTxAggregationCount++;
2246                 pAd->RalinkCounters.KickTxCount++;
2247                 pAd->RalinkCounters.OneSecTxDoneCount++;
2248
2249         }
2250
2251         HAL_FinalWriteTxResource(pAd, pTxBlk, totalMPDUSize, FirstTx);
2252         HAL_LastTxIdx(pAd, pTxBlk->QueIdx, LastTxIdx);
2253
2254         //
2255         // Kick out Tx
2256         //
2257         HAL_KickOutTx(pAd, pTxBlk, pTxBlk->QueIdx);
2258
2259 }
2260
2261
2262 VOID STA_Fragment_Frame_Tx(
2263         IN RTMP_ADAPTER *pAd,
2264         IN TX_BLK               *pTxBlk)
2265 {
2266         HEADER_802_11   *pHeader_802_11;
2267         PUCHAR                  pHeaderBufPtr;
2268         USHORT                  FreeNumber;
2269         UCHAR                   fragNum = 0;
2270         PACKET_INFO             PacketInfo;
2271         USHORT                  EncryptionOverhead = 0;
2272         UINT32                  FreeMpduSize, SrcRemainingBytes;
2273         USHORT                  AckDuration;
2274         UINT                    NextMpduSize;
2275         BOOLEAN                 bVLANPkt;
2276         PQUEUE_ENTRY    pQEntry;
2277
2278
2279         ASSERT(pTxBlk);
2280
2281         pQEntry = RemoveHeadQueue(&pTxBlk->TxPacketList);
2282         pTxBlk->pPacket = QUEUE_ENTRY_TO_PACKET(pQEntry);
2283         if (RTMP_FillTxBlkInfo(pAd, pTxBlk) != TRUE)
2284         {
2285                 RELEASE_NDIS_PACKET(pAd, pTxBlk->pPacket, NDIS_STATUS_FAILURE);
2286                 return;
2287         }
2288
2289         ASSERT(TX_BLK_TEST_FLAG(pTxBlk, fTX_bAllowFrag));
2290         bVLANPkt = (RTMP_GET_PACKET_VLAN(pTxBlk->pPacket) ? TRUE : FALSE);
2291
2292         STAFindCipherAlgorithm(pAd, pTxBlk);
2293         STABuildCommon802_11Header(pAd, pTxBlk);
2294
2295         if (pTxBlk->CipherAlg == CIPHER_TKIP)
2296         {
2297                 pTxBlk->pPacket = duplicate_pkt_with_TKIP_MIC(pAd, pTxBlk->pPacket);
2298                 if (pTxBlk->pPacket == NULL)
2299                         return;
2300                 RTMP_QueryPacketInfo(pTxBlk->pPacket, &PacketInfo, &pTxBlk->pSrcBufHeader, &pTxBlk->SrcBufLen);
2301         }
2302
2303         // skip 802.3 header
2304         pTxBlk->pSrcBufData = pTxBlk->pSrcBufHeader + LENGTH_802_3;
2305         pTxBlk->SrcBufLen  -= LENGTH_802_3;
2306
2307
2308         // skip vlan tag
2309         if (bVLANPkt)
2310         {
2311                 pTxBlk->pSrcBufData     += LENGTH_802_1Q;
2312                 pTxBlk->SrcBufLen       -= LENGTH_802_1Q;
2313         }
2314
2315         pHeaderBufPtr = &pTxBlk->HeaderBuf[TXINFO_SIZE + TXWI_SIZE];
2316         pHeader_802_11 = (HEADER_802_11 *)pHeaderBufPtr;
2317
2318
2319         // skip common header
2320         pHeaderBufPtr += pTxBlk->MpduHeaderLen;
2321
2322         if (TX_BLK_TEST_FLAG(pTxBlk, fTX_bWMM))
2323         {
2324                 //
2325                 // build QOS Control bytes
2326                 //
2327                 *pHeaderBufPtr = (pTxBlk->UserPriority & 0x0F);
2328
2329                 *(pHeaderBufPtr+1) = 0;
2330                 pHeaderBufPtr +=2;
2331                 pTxBlk->MpduHeaderLen += 2;
2332         }
2333
2334         //
2335         // padding at front of LLC header
2336         // LLC header should locate at 4-octets aligment
2337         //
2338         pTxBlk->HdrPadLen = (ULONG)pHeaderBufPtr;
2339         pHeaderBufPtr = (PCHAR) ROUND_UP(pHeaderBufPtr, 4);
2340         pTxBlk->HdrPadLen = (ULONG)(pHeaderBufPtr - pTxBlk->HdrPadLen);
2341
2342
2343
2344         //
2345         // Insert LLC-SNAP encapsulation - 8 octets
2346         //
2347         //
2348         // if original Ethernet frame contains no LLC/SNAP,
2349         // then an extra LLC/SNAP encap is required
2350         //
2351         EXTRA_LLCSNAP_ENCAP_FROM_PKT_START(pTxBlk->pSrcBufHeader, pTxBlk->pExtraLlcSnapEncap);
2352         if (pTxBlk->pExtraLlcSnapEncap)
2353         {
2354                 UCHAR vlan_size;
2355
2356                 NdisMoveMemory(pHeaderBufPtr, pTxBlk->pExtraLlcSnapEncap, 6);
2357                 pHeaderBufPtr += 6;
2358                 // skip vlan tag
2359                 vlan_size =  (bVLANPkt) ? LENGTH_802_1Q : 0;
2360                 // get 2 octets (TypeofLen)
2361                 NdisMoveMemory(pHeaderBufPtr, pTxBlk->pSrcBufHeader+12+vlan_size, 2);
2362                 pHeaderBufPtr += 2;
2363                 pTxBlk->MpduHeaderLen += LENGTH_802_1_H;
2364         }
2365
2366
2367         // If TKIP is used and fragmentation is required. Driver has to
2368         //      append TKIP MIC at tail of the scatter buffer
2369         //      MAC ASIC will only perform IV/EIV/ICV insertion but no TKIP MIC
2370         if (pTxBlk->CipherAlg == CIPHER_TKIP)
2371         {
2372
2373                 // NOTE: DON'T refer the skb->len directly after following copy. Becasue the length is not adjust
2374                 //                      to correct lenght, refer to pTxBlk->SrcBufLen for the packet length in following progress.
2375                 NdisMoveMemory(pTxBlk->pSrcBufData + pTxBlk->SrcBufLen, &pAd->PrivateInfo.Tx.MIC[0], 8);
2376                 //skb_put((RTPKT_TO_OSPKT(pTxBlk->pPacket))->tail, 8);
2377                 pTxBlk->SrcBufLen += 8;
2378                 pTxBlk->TotalFrameLen += 8;
2379                 pTxBlk->CipherAlg = CIPHER_TKIP_NO_MIC;
2380         }
2381
2382         //
2383         // calcuate the overhead bytes that encryption algorithm may add. This
2384         // affects the calculate of "duration" field
2385         //
2386         if ((pTxBlk->CipherAlg == CIPHER_WEP64) || (pTxBlk->CipherAlg == CIPHER_WEP128))
2387                 EncryptionOverhead = 8; //WEP: IV[4] + ICV[4];
2388         else if (pTxBlk->CipherAlg == CIPHER_TKIP_NO_MIC)
2389                 EncryptionOverhead = 12;//TKIP: IV[4] + EIV[4] + ICV[4], MIC will be added to TotalPacketLength
2390         else if (pTxBlk->CipherAlg == CIPHER_TKIP)
2391                 EncryptionOverhead = 20;//TKIP: IV[4] + EIV[4] + ICV[4] + MIC[8]
2392         else if (pTxBlk->CipherAlg == CIPHER_AES)
2393                 EncryptionOverhead = 16;        // AES: IV[4] + EIV[4] + MIC[8]
2394         else
2395                 EncryptionOverhead = 0;
2396
2397         // decide how much time an ACK/CTS frame will consume in the air
2398         AckDuration = RTMPCalcDuration(pAd, pAd->CommonCfg.ExpectedACKRate[pTxBlk->TxRate], 14);
2399
2400         // Init the total payload length of this frame.
2401         SrcRemainingBytes = pTxBlk->SrcBufLen;
2402
2403         pTxBlk->TotalFragNum = 0xff;
2404
2405         do {
2406
2407                 FreeMpduSize = pAd->CommonCfg.FragmentThreshold - LENGTH_CRC;
2408
2409                 FreeMpduSize -= pTxBlk->MpduHeaderLen;
2410
2411                 if (SrcRemainingBytes <= FreeMpduSize)
2412                 {       // this is the last or only fragment
2413
2414                         pTxBlk->SrcBufLen = SrcRemainingBytes;
2415
2416                         pHeader_802_11->FC.MoreFrag = 0;
2417                         pHeader_802_11->Duration = pAd->CommonCfg.Dsifs + AckDuration;
2418
2419                         // Indicate the lower layer that this's the last fragment.
2420                         pTxBlk->TotalFragNum = fragNum;
2421                 }
2422                 else
2423                 {       // more fragment is required
2424
2425                         pTxBlk->SrcBufLen = FreeMpduSize;
2426
2427                         NextMpduSize = min(((UINT)SrcRemainingBytes - pTxBlk->SrcBufLen), ((UINT)pAd->CommonCfg.FragmentThreshold));
2428                         pHeader_802_11->FC.MoreFrag = 1;
2429                         pHeader_802_11->Duration = (3 * pAd->CommonCfg.Dsifs) + (2 * AckDuration) + RTMPCalcDuration(pAd, pTxBlk->TxRate, NextMpduSize + EncryptionOverhead);
2430                 }
2431
2432                 if (fragNum == 0)
2433                         pTxBlk->FrameGap = IFS_HTTXOP;
2434                 else
2435                         pTxBlk->FrameGap = IFS_SIFS;
2436
2437                 RTMPWriteTxWI_Data(pAd, (PTXWI_STRUC)(&pTxBlk->HeaderBuf[TXINFO_SIZE]), pTxBlk);
2438
2439                 HAL_WriteFragTxResource(pAd, pTxBlk, fragNum, &FreeNumber);
2440
2441                 pAd->RalinkCounters.KickTxCount++;
2442                 pAd->RalinkCounters.OneSecTxDoneCount++;
2443
2444                 // Update the frame number, remaining size of the NDIS packet payload.
2445
2446                 // space for 802.11 header.
2447                 if (fragNum == 0 && pTxBlk->pExtraLlcSnapEncap)
2448                         pTxBlk->MpduHeaderLen -= LENGTH_802_1_H;
2449
2450                 fragNum++;
2451                 SrcRemainingBytes -= pTxBlk->SrcBufLen;
2452                 pTxBlk->pSrcBufData += pTxBlk->SrcBufLen;
2453
2454                 pHeader_802_11->Frag++;  // increase Frag #
2455
2456         }while(SrcRemainingBytes > 0);
2457
2458         //
2459         // Kick out Tx
2460         //
2461         HAL_KickOutTx(pAd, pTxBlk, pTxBlk->QueIdx);
2462 }
2463
2464
2465 #define RELEASE_FRAMES_OF_TXBLK(_pAd, _pTxBlk, _pQEntry, _Status)                                                                               \
2466                 while(_pTxBlk->TxPacketList.Head)                                                                                                               \
2467                 {                                                                                                                                                                               \
2468                         _pQEntry = RemoveHeadQueue(&_pTxBlk->TxPacketList);                                                                     \
2469                         RELEASE_NDIS_PACKET(_pAd, QUEUE_ENTRY_TO_PACKET(_pQEntry), _Status);    \
2470                 }
2471
2472
2473 /*
2474         ========================================================================
2475
2476         Routine Description:
2477                 Copy frame from waiting queue into relative ring buffer and set
2478         appropriate ASIC register to kick hardware encryption before really
2479         sent out to air.
2480
2481         Arguments:
2482                 pAd     Pointer to our adapter
2483                 PNDIS_PACKET    Pointer to outgoing Ndis frame
2484                 NumberOfFrag    Number of fragment required
2485
2486         Return Value:
2487                 None
2488
2489         IRQL = DISPATCH_LEVEL
2490
2491         Note:
2492
2493         ========================================================================
2494 */
2495 NDIS_STATUS STAHardTransmit(
2496         IN PRTMP_ADAPTER        pAd,
2497         IN TX_BLK                       *pTxBlk,
2498         IN      UCHAR                   QueIdx)
2499 {
2500         NDIS_PACKET             *pPacket;
2501         PQUEUE_ENTRY    pQEntry;
2502
2503         // ---------------------------------------------
2504         // STEP 0. DO SANITY CHECK AND SOME EARLY PREPARATION.
2505         // ---------------------------------------------
2506         //
2507         ASSERT(pTxBlk->TxPacketList.Number);
2508         if (pTxBlk->TxPacketList.Head == NULL)
2509         {
2510                 DBGPRINT(RT_DEBUG_ERROR, ("pTxBlk->TotalFrameNum == %ld!\n", pTxBlk->TxPacketList.Number));
2511                 return NDIS_STATUS_FAILURE;
2512         }
2513
2514         pPacket = QUEUE_ENTRY_TO_PACKET(pTxBlk->TxPacketList.Head);
2515
2516 #if 0 //def CARRIER_DETECTION_SUPPORT // Roger sync Carrier
2517                 if ((pAd->CommonCfg.CarrierDetect.Enable == TRUE) && (isCarrierDetectExist(pAd) == TRUE))
2518         {
2519                 DBGPRINT(RT_DEBUG_INFO,("STAHardTransmit --> radar detect not in normal mode !!!\n"));
2520                 RELEASE_NDIS_PACKET(pAd, pPacket, NDIS_STATUS_FAILURE);
2521                 return (NDIS_STATUS_FAILURE);
2522         }
2523 #endif // CARRIER_DETECTION_SUPPORT //
2524
2525         // ------------------------------------------------------------------
2526         // STEP 1. WAKE UP PHY
2527         //              outgoing frame always wakeup PHY to prevent frame lost and
2528         //              turn off PSM bit to improve performance
2529         // ------------------------------------------------------------------
2530         // not to change PSM bit, just send this frame out?
2531         if ((pAd->StaCfg.Psm == PWR_SAVE) && OPSTATUS_TEST_FLAG(pAd, fOP_STATUS_DOZE))
2532         {
2533             DBGPRINT_RAW(RT_DEBUG_TRACE, ("AsicForceWakeup At HardTx\n"));
2534                 AsicForceWakeup(pAd, TRUE);
2535         }
2536
2537         // It should not change PSM bit, when APSD turn on.
2538         if ((!(pAd->CommonCfg.bAPSDCapable && pAd->CommonCfg.APEdcaParm.bAPSDCapable) && (pAd->CommonCfg.bAPSDForcePowerSave == FALSE))
2539                 || (RTMP_GET_PACKET_EAPOL(pTxBlk->pPacket))
2540                 || (RTMP_GET_PACKET_WAI(pTxBlk->pPacket)))
2541         {
2542                 if ((pAd->StaCfg.Psm == PWR_SAVE) &&
2543             (pAd->StaCfg.WindowsPowerMode == Ndis802_11PowerModeFast_PSP))
2544                         MlmeSetPsmBit(pAd, PWR_ACTIVE);
2545         }
2546
2547         switch (pTxBlk->TxFrameType)
2548         {
2549 #ifdef DOT11_N_SUPPORT
2550                 case TX_AMPDU_FRAME:
2551                                 STA_AMPDU_Frame_Tx(pAd, pTxBlk);
2552                         break;
2553                 case TX_AMSDU_FRAME:
2554                                 STA_AMSDU_Frame_Tx(pAd, pTxBlk);
2555                         break;
2556 #endif // DOT11_N_SUPPORT //
2557                 case TX_LEGACY_FRAME:
2558                                 STA_Legacy_Frame_Tx(pAd, pTxBlk);
2559                         break;
2560                 case TX_MCAST_FRAME:
2561                                 STA_Legacy_Frame_Tx(pAd, pTxBlk);
2562                         break;
2563                 case TX_RALINK_FRAME:
2564                                 STA_ARalink_Frame_Tx(pAd, pTxBlk);
2565                         break;
2566                 case TX_FRAG_FRAME:
2567                                 STA_Fragment_Frame_Tx(pAd, pTxBlk);
2568                         break;
2569                 default:
2570                         {
2571                                 // It should not happened!
2572                                 DBGPRINT(RT_DEBUG_ERROR, ("Send a pacekt was not classified!! It should not happen!\n"));
2573                                 while(pTxBlk->TxPacketList.Number)
2574                                 {
2575                                         pQEntry = RemoveHeadQueue(&pTxBlk->TxPacketList);
2576                                         pPacket = QUEUE_ENTRY_TO_PACKET(pQEntry);
2577                                         if (pPacket)
2578                                                 RELEASE_NDIS_PACKET(pAd, pPacket, NDIS_STATUS_FAILURE);
2579                                 }
2580                         }
2581                         break;
2582         }
2583
2584         return (NDIS_STATUS_SUCCESS);
2585
2586 }
2587
2588 ULONG  HashBytesPolynomial(UCHAR *value, unsigned int len)
2589 {
2590    unsigned char *word = value;
2591    unsigned int ret = 0;
2592    unsigned int i;
2593
2594    for(i=0; i < len; i++)
2595    {
2596           int mod = i % 32;
2597           ret ^=(unsigned int) (word[i]) << mod;
2598           ret ^=(unsigned int) (word[i]) >> (32 - mod);
2599    }
2600    return ret;
2601 }
2602
2603 VOID Sta_Announce_or_Forward_802_3_Packet(
2604         IN      PRTMP_ADAPTER   pAd,
2605         IN      PNDIS_PACKET    pPacket,
2606         IN      UCHAR                   FromWhichBSSID)
2607 {
2608         if (TRUE
2609                 )
2610         {
2611                 announce_802_3_packet(pAd, pPacket);
2612         }
2613         else
2614         {
2615                 // release packet
2616                 RELEASE_NDIS_PACKET(pAd, pPacket, NDIS_STATUS_FAILURE);
2617         }
2618 }
2619