drivers/staging/vt6656/rxtx.c

   1 /*
   2  * Copyright (c) 1996, 2003 VIA Networking Technologies, Inc.
   3  * All rights reserved.
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License along
  16  * with this program; if not, write to the Free Software Foundation, Inc.,
  17  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * File: rxtx.c
  20  *
  21  * Purpose: handle WMAC/802.3/802.11 rx & tx functions
  22  *
  23  * Author: Lyndon Chen
  24  *
  25  * Date: May 20, 2003
  26  *
  27  * Functions:
  28  *      s_vGenerateTxParameter - Generate tx dma required parameter.
  29  *      s_vGenerateMACHeader - Translate 802.3 to 802.11 header
  30  *      csBeacon_xmit - beacon tx function
  31  *      csMgmt_xmit - management tx function
  32  *      s_uGetDataDuration - get tx data required duration
  33  *      s_uFillDataHead- fulfill tx data duration header
  34  *      s_uGetRTSCTSDuration- get rtx/cts required duration
  35  *      s_uGetRTSCTSRsvTime- get rts/cts reserved time
  36  *      s_uGetTxRsvTime- get frame reserved time
  37  *      s_vFillCTSHead- fulfill CTS ctl header
  38  *      s_vFillFragParameter- Set fragment ctl parameter.
  39  *      s_vFillRTSHead- fulfill RTS ctl header
  40  *      s_vFillTxKey- fulfill tx encrypt key
  41  *      s_vSWencryption- Software encrypt header
  42  *      vDMA0_tx_80211- tx 802.11 frame via dma0
  43  *      vGenerateFIFOHeader- Generate tx FIFO ctl header
  44  *
  45  * Revision History:
  46  *
  47  */
  48
  49 #include "device.h"
  50 #include "rxtx.h"
  51 #include "tether.h"
  52 #include "card.h"
  53 #include "bssdb.h"
  54 #include "mac.h"
  55 #include "baseband.h"
  56 #include "michael.h"
  57 #include "tkip.h"
  58 #include "tcrc.h"
  59 #include "wctl.h"
  60 #include "hostap.h"
  61 #include "rf.h"
  62 #include "datarate.h"
  63 #include "usbpipe.h"
  64 #include "iocmd.h"
  65
  66 /*---------------------  Static Definitions -------------------------*/
  67
  68 /*---------------------  Static Classes  ----------------------------*/
  69
  70 /*---------------------  Static Variables  --------------------------*/
  71 static int          msglevel                = MSG_LEVEL_INFO;
  72
  73 /*---------------------  Static Functions  --------------------------*/
  74
  75 /*---------------------  Static Definitions -------------------------*/
  76 #define CRITICAL_PACKET_LEN      256    // if packet size < 256 -> in-direct send
  77                                         //    packet size >= 256 -> direct send
  78
  79 const WORD wTimeStampOff[2][MAX_RATE] = {
  80         {384, 288, 226, 209, 54, 43, 37, 31, 28, 25, 24, 23}, // Long Preamble
  81         {384, 192, 130, 113, 54, 43, 37, 31, 28, 25, 24, 23}, // Short Preamble
  82     };
  83
  84 const WORD wFB_Opt0[2][5] = {
  85         {RATE_12M, RATE_18M, RATE_24M, RATE_36M, RATE_48M}, // fallback_rate0
  86         {RATE_12M, RATE_12M, RATE_18M, RATE_24M, RATE_36M}, // fallback_rate1
  87     };
  88 const WORD wFB_Opt1[2][5] = {
  89         {RATE_12M, RATE_18M, RATE_24M, RATE_24M, RATE_36M}, // fallback_rate0
  90         {RATE_6M , RATE_6M,  RATE_12M, RATE_12M, RATE_18M}, // fallback_rate1
  91     };
  92
  93
  94 #define RTSDUR_BB       0
  95 #define RTSDUR_BA       1
  96 #define RTSDUR_AA       2
  97 #define CTSDUR_BA       3
  98 #define RTSDUR_BA_F0    4
  99 #define RTSDUR_AA_F0    5
 100 #define RTSDUR_BA_F1    6
 101 #define RTSDUR_AA_F1    7
 102 #define CTSDUR_BA_F0    8
 103 #define CTSDUR_BA_F1    9
 104 #define DATADUR_B       10
 105 #define DATADUR_A       11
 106 #define DATADUR_A_F0    12
 107 #define DATADUR_A_F1    13
 108
 109 /*---------------------  Static Functions  --------------------------*/
 110
 111 static
 112 void
 113 s_vSaveTxPktInfo(
 114      PSDevice pDevice,
 115      BYTE byPktNum,
 116      PBYTE pbyDestAddr,
 117      WORD wPktLength,
 118      WORD wFIFOCtl
 119 );
 120
 121 static
 122 void *
 123 s_vGetFreeContext(
 124     PSDevice pDevice
 125     );
 126
 127
 128 static
 129 void
 130 s_vGenerateTxParameter(
 131      PSDevice         pDevice,
 132      BYTE             byPktType,
 133      WORD             wCurrentRate,
 134      void *pTxBufHead,
 135      void *pvRrvTime,
 136      void *pvRTS,
 137      void *pvCTS,
 138      unsigned int             cbFrameSize,
 139      BOOL             bNeedACK,
 140      unsigned int             uDMAIdx,
 141      PSEthernetHeader psEthHeader
 142     );
 143
 144
 145 static unsigned int s_uFillDataHead(
 146      PSDevice pDevice,
 147      BYTE     byPktType,
 148      WORD     wCurrentRate,
 149      void *pTxDataHead,
 150      unsigned int     cbFrameLength,
 151      unsigned int     uDMAIdx,
 152      BOOL     bNeedAck,
 153      unsigned int     uFragIdx,
 154      unsigned int     cbLastFragmentSize,
 155      unsigned int     uMACfragNum,
 156      BYTE     byFBOption
 157     );
 158
 159
 160
 161
 162 static
 163 void
 164 s_vGenerateMACHeader (
 165      PSDevice         pDevice,
 166      PBYTE            pbyBufferAddr,
 167      WORD             wDuration,
 168      PSEthernetHeader psEthHeader,
 169      BOOL             bNeedEncrypt,
 170      WORD             wFragType,
 171      unsigned int             uDMAIdx,
 172      unsigned int             uFragIdx
 173     );
 174
 175 static
 176 void
 177 s_vFillTxKey(
 178       PSDevice   pDevice,
 179       PBYTE      pbyBuf,
 180       PBYTE      pbyIVHead,
 181       PSKeyItem  pTransmitKey,
 182       PBYTE      pbyHdrBuf,
 183       WORD       wPayloadLen,
 184      PBYTE      pMICHDR
 185     );
 186
 187 static
 188 void
 189 s_vSWencryption (
 190       PSDevice         pDevice,
 191       PSKeyItem        pTransmitKey,
 192       PBYTE            pbyPayloadHead,
 193       WORD             wPayloadSize
 194     );
 195
 196 static unsigned int s_uGetTxRsvTime(
 197      PSDevice pDevice,
 198      BYTE     byPktType,
 199      unsigned int     cbFrameLength,
 200      WORD     wRate,
 201      BOOL     bNeedAck
 202     );
 203
 204
 205 static unsigned int s_uGetRTSCTSRsvTime(
 206      PSDevice pDevice,
 207      BYTE byRTSRsvType,
 208      BYTE byPktType,
 209      unsigned int cbFrameLength,
 210      WORD wCurrentRate
 211     );
 212
 213 static
 214 void
 215 s_vFillCTSHead (
 216      PSDevice pDevice,
 217      unsigned int     uDMAIdx,
 218      BYTE     byPktType,
 219      void *pvCTS,
 220      unsigned int     cbFrameLength,
 221      BOOL     bNeedAck,
 222      BOOL     bDisCRC,
 223      WORD     wCurrentRate,
 224      BYTE     byFBOption
 225     );
 226
 227 static
 228 void
 229 s_vFillRTSHead(
 230      PSDevice         pDevice,
 231      BYTE             byPktType,
 232      void *pvRTS,
 233      unsigned int             cbFrameLength,
 234      BOOL             bNeedAck,
 235      BOOL             bDisCRC,
 236      PSEthernetHeader psEthHeader,
 237      WORD             wCurrentRate,
 238      BYTE             byFBOption
 239     );
 240
 241 static unsigned int s_uGetDataDuration(
 242      PSDevice pDevice,
 243      BYTE     byDurType,
 244      unsigned int     cbFrameLength,
 245      BYTE     byPktType,
 246      WORD     wRate,
 247      BOOL     bNeedAck,
 248      unsigned int     uFragIdx,
 249      unsigned int     cbLastFragmentSize,
 250      unsigned int     uMACfragNum,
 251      BYTE     byFBOption
 252     );
 253
 254
 255 static
 256 unsigned int
 257 s_uGetRTSCTSDuration (
 258      PSDevice pDevice,
 259      BYTE byDurType,
 260      unsigned int cbFrameLength,
 261      BYTE byPktType,
 262      WORD wRate,
 263      BOOL bNeedAck,
 264      BYTE byFBOption
 265     );
 266
 267
 268 /*---------------------  Export Variables  --------------------------*/
 269
 270 static
 271 void *
 272 s_vGetFreeContext(
 273     PSDevice pDevice
 274     )
 275 {
 276     PUSB_SEND_CONTEXT   pContext = NULL;
 277     PUSB_SEND_CONTEXT   pReturnContext = NULL;
 278     unsigned int                ii;
 279
 280     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"GetFreeContext()\n");
 281
 282     for (ii = 0; ii < pDevice->cbTD; ii++) {
 283         pContext = pDevice->apTD[ii];
 284         if (pContext->bBoolInUse == FALSE) {
 285             pContext->bBoolInUse = TRUE;
 286             pReturnContext = pContext;
 287             break;
 288         }
 289     }
 290     if ( ii == pDevice->cbTD ) {
 291         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"No Free Tx Context\n");
 292     }
 293     return (void *) pReturnContext;
 294 }
 295
 296
 297 static
 298 void
 299 s_vSaveTxPktInfo(PSDevice pDevice, BYTE byPktNum, PBYTE pbyDestAddr, WORD wPktLength, WORD wFIFOCtl)
 300 {
 301     PSStatCounter           pStatistic=&(pDevice->scStatistic);
 302
 303     if (is_broadcast_ether_addr(pbyDestAddr))
 304         pStatistic->abyTxPktInfo[byPktNum].byBroadMultiUni = TX_PKT_BROAD;
 305     else if (is_multicast_ether_addr(pbyDestAddr))
 306         pStatistic->abyTxPktInfo[byPktNum].byBroadMultiUni = TX_PKT_MULTI;
 307     else
 308         pStatistic->abyTxPktInfo[byPktNum].byBroadMultiUni = TX_PKT_UNI;
 309
 310     pStatistic->abyTxPktInfo[byPktNum].wLength = wPktLength;
 311     pStatistic->abyTxPktInfo[byPktNum].wFIFOCtl = wFIFOCtl;
 312     memcpy(pStatistic->abyTxPktInfo[byPktNum].abyDestAddr,
 313            pbyDestAddr,
 314            ETH_ALEN);
 315 }
 316
 317 static
 318 void
 319 s_vFillTxKey (
 320       PSDevice   pDevice,
 321       PBYTE      pbyBuf,
 322       PBYTE      pbyIVHead,
 323       PSKeyItem  pTransmitKey,
 324       PBYTE      pbyHdrBuf,
 325       WORD       wPayloadLen,
 326      PBYTE      pMICHDR
 327     )
 328 {
 329     PDWORD          pdwIV = (PDWORD) pbyIVHead;
 330     PDWORD          pdwExtIV = (PDWORD) ((PBYTE)pbyIVHead+4);
 331     WORD            wValue;
 332     PS802_11Header  pMACHeader = (PS802_11Header)pbyHdrBuf;
 333     DWORD           dwRevIVCounter;
 334
 335
 336
 337     //Fill TXKEY
 338     if (pTransmitKey == NULL)
 339         return;
 340
 341     dwRevIVCounter = cpu_to_le32(pDevice->dwIVCounter);
 342     *pdwIV = pDevice->dwIVCounter;
 343     pDevice->byKeyIndex = pTransmitKey->dwKeyIndex & 0xf;
 344
 345     if (pTransmitKey->byCipherSuite == KEY_CTL_WEP) {
 346         if (pTransmitKey->uKeyLength == WLAN_WEP232_KEYLEN ){
 347             memcpy(pDevice->abyPRNG, (PBYTE)&(dwRevIVCounter), 3);
 348             memcpy(pDevice->abyPRNG+3, pTransmitKey->abyKey, pTransmitKey->uKeyLength);
 349         } else {
 350             memcpy(pbyBuf, (PBYTE)&(dwRevIVCounter), 3);
 351             memcpy(pbyBuf+3, pTransmitKey->abyKey, pTransmitKey->uKeyLength);
 352             if(pTransmitKey->uKeyLength == WLAN_WEP40_KEYLEN) {
 353                 memcpy(pbyBuf+8, (PBYTE)&(dwRevIVCounter), 3);
 354                 memcpy(pbyBuf+11, pTransmitKey->abyKey, pTransmitKey->uKeyLength);
 355             }
 356             memcpy(pDevice->abyPRNG, pbyBuf, 16);
 357         }
 358         // Append IV after Mac Header
 359         *pdwIV &= WEP_IV_MASK;//00000000 11111111 11111111 11111111
 360         *pdwIV |= (pDevice->byKeyIndex << 30);
 361         *pdwIV = cpu_to_le32(*pdwIV);
 362         pDevice->dwIVCounter++;
 363         if (pDevice->dwIVCounter > WEP_IV_MASK) {
 364             pDevice->dwIVCounter = 0;
 365         }
 366     } else if (pTransmitKey->byCipherSuite == KEY_CTL_TKIP) {
 367         pTransmitKey->wTSC15_0++;
 368         if (pTransmitKey->wTSC15_0 == 0) {
 369             pTransmitKey->dwTSC47_16++;
 370         }
 371         TKIPvMixKey(pTransmitKey->abyKey, pDevice->abyCurrentNetAddr,
 372                     pTransmitKey->wTSC15_0, pTransmitKey->dwTSC47_16, pDevice->abyPRNG);
 373         memcpy(pbyBuf, pDevice->abyPRNG, 16);
 374         // Make IV
 375         memcpy(pdwIV, pDevice->abyPRNG, 3);
 376
 377         *(pbyIVHead+3) = (BYTE)(((pDevice->byKeyIndex << 6) & 0xc0) | 0x20); // 0x20 is ExtIV
 378         // Append IV&ExtIV after Mac Header
 379         *pdwExtIV = cpu_to_le32(pTransmitKey->dwTSC47_16);
 380         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"vFillTxKey()---- pdwExtIV: %x\n",
 381                 *pdwExtIV);
 382
 383     } else if (pTransmitKey->byCipherSuite == KEY_CTL_CCMP) {
 384         pTransmitKey->wTSC15_0++;
 385         if (pTransmitKey->wTSC15_0 == 0) {
 386             pTransmitKey->dwTSC47_16++;
 387         }
 388         memcpy(pbyBuf, pTransmitKey->abyKey, 16);
 389
 390         // Make IV
 391         *pdwIV = 0;
 392         *(pbyIVHead+3) = (BYTE)(((pDevice->byKeyIndex << 6) & 0xc0) | 0x20); // 0x20 is ExtIV
 393         *pdwIV |= cpu_to_le16((WORD)(pTransmitKey->wTSC15_0));
 394         //Append IV&ExtIV after Mac Header
 395         *pdwExtIV = cpu_to_le32(pTransmitKey->dwTSC47_16);
 396
 397         //Fill MICHDR0
 398         *pMICHDR = 0x59;
 399         *((PBYTE)(pMICHDR+1)) = 0; // TxPriority
 400         memcpy(pMICHDR+2, &(pMACHeader->abyAddr2[0]), 6);
 401         *((PBYTE)(pMICHDR+8)) = HIBYTE(HIWORD(pTransmitKey->dwTSC47_16));
 402         *((PBYTE)(pMICHDR+9)) = LOBYTE(HIWORD(pTransmitKey->dwTSC47_16));
 403         *((PBYTE)(pMICHDR+10)) = HIBYTE(LOWORD(pTransmitKey->dwTSC47_16));
 404         *((PBYTE)(pMICHDR+11)) = LOBYTE(LOWORD(pTransmitKey->dwTSC47_16));
 405         *((PBYTE)(pMICHDR+12)) = HIBYTE(pTransmitKey->wTSC15_0);
 406         *((PBYTE)(pMICHDR+13)) = LOBYTE(pTransmitKey->wTSC15_0);
 407         *((PBYTE)(pMICHDR+14)) = HIBYTE(wPayloadLen);
 408         *((PBYTE)(pMICHDR+15)) = LOBYTE(wPayloadLen);
 409
 410         //Fill MICHDR1
 411         *((PBYTE)(pMICHDR+16)) = 0; // HLEN[15:8]
 412         if (pDevice->bLongHeader) {
 413             *((PBYTE)(pMICHDR+17)) = 28; // HLEN[7:0]
 414         } else {
 415             *((PBYTE)(pMICHDR+17)) = 22; // HLEN[7:0]
 416         }
 417         wValue = cpu_to_le16(pMACHeader->wFrameCtl & 0xC78F);
 418         memcpy(pMICHDR+18, (PBYTE)&wValue, 2); // MSKFRACTL
 419         memcpy(pMICHDR+20, &(pMACHeader->abyAddr1[0]), 6);
 420         memcpy(pMICHDR+26, &(pMACHeader->abyAddr2[0]), 6);
 421
 422         //Fill MICHDR2
 423         memcpy(pMICHDR+32, &(pMACHeader->abyAddr3[0]), 6);
 424         wValue = pMACHeader->wSeqCtl;
 425         wValue &= 0x000F;
 426         wValue = cpu_to_le16(wValue);
 427         memcpy(pMICHDR+38, (PBYTE)&wValue, 2); // MSKSEQCTL
 428         if (pDevice->bLongHeader) {
 429             memcpy(pMICHDR+40, &(pMACHeader->abyAddr4[0]), 6);
 430         }
 431     }
 432 }
 433
 434
 435 static
 436 void
 437 s_vSWencryption (
 438       PSDevice            pDevice,
 439       PSKeyItem           pTransmitKey,
 440       PBYTE               pbyPayloadHead,
 441       WORD                wPayloadSize
 442     )
 443 {
 444     unsigned int   cbICVlen = 4;
 445     DWORD  dwICV = 0xFFFFFFFFL;
 446     PDWORD pdwICV;
 447
 448     if (pTransmitKey == NULL)
 449         return;
 450
 451     if (pTransmitKey->byCipherSuite == KEY_CTL_WEP) {
 452         //=======================================================================
 453         // Append ICV after payload
 454         dwICV = CRCdwGetCrc32Ex(pbyPayloadHead, wPayloadSize, dwICV);//ICV(Payload)
 455         pdwICV = (PDWORD)(pbyPayloadHead + wPayloadSize);
 456         // finally, we must invert dwCRC to get the correct answer
 457         *pdwICV = cpu_to_le32(~dwICV);
 458         // RC4 encryption
 459         rc4_init(&pDevice->SBox, pDevice->abyPRNG, pTransmitKey->uKeyLength + 3);
 460         rc4_encrypt(&pDevice->SBox, pbyPayloadHead, pbyPayloadHead, wPayloadSize+cbICVlen);
 461         //=======================================================================
 462     } else if (pTransmitKey->byCipherSuite == KEY_CTL_TKIP) {
 463         //=======================================================================
 464         //Append ICV after payload
 465         dwICV = CRCdwGetCrc32Ex(pbyPayloadHead, wPayloadSize, dwICV);//ICV(Payload)
 466         pdwICV = (PDWORD)(pbyPayloadHead + wPayloadSize);
 467         // finally, we must invert dwCRC to get the correct answer
 468         *pdwICV = cpu_to_le32(~dwICV);
 469         // RC4 encryption
 470         rc4_init(&pDevice->SBox, pDevice->abyPRNG, TKIP_KEY_LEN);
 471         rc4_encrypt(&pDevice->SBox, pbyPayloadHead, pbyPayloadHead, wPayloadSize+cbICVlen);
 472         //=======================================================================
 473     }
 474 }
 475
 476
 477
 478
 479 /*byPktType : PK_TYPE_11A     0
 480              PK_TYPE_11B     1
 481              PK_TYPE_11GB    2
 482              PK_TYPE_11GA    3
 483 */
 484 static
 485 unsigned int
 486 s_uGetTxRsvTime (
 487      PSDevice pDevice,
 488      BYTE     byPktType,
 489      unsigned int     cbFrameLength,
 490      WORD     wRate,
 491      BOOL     bNeedAck
 492     )
 493 {
 494     unsigned int uDataTime, uAckTime;
 495
 496     uDataTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, cbFrameLength, wRate);
 497     if (byPktType == PK_TYPE_11B) {//llb,CCK mode
 498         uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, (WORD)pDevice->byTopCCKBasicRate);
 499     } else {//11g 2.4G OFDM mode & 11a 5G OFDM mode
 500         uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, (WORD)pDevice->byTopOFDMBasicRate);
 501     }
 502
 503     if (bNeedAck) {
 504         return (uDataTime + pDevice->uSIFS + uAckTime);
 505     }
 506     else {
 507         return uDataTime;
 508     }
 509 }
 510
 511 //byFreqType: 0=>5GHZ 1=>2.4GHZ
 512 static
 513 unsigned int
 514 s_uGetRTSCTSRsvTime (
 515      PSDevice pDevice,
 516      BYTE byRTSRsvType,
 517      BYTE byPktType,
 518      unsigned int cbFrameLength,
 519      WORD wCurrentRate
 520     )
 521 {
 522     unsigned int uRrvTime  , uRTSTime, uCTSTime, uAckTime, uDataTime;
 523
 524     uRrvTime = uRTSTime = uCTSTime = uAckTime = uDataTime = 0;
 525
 526
 527     uDataTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, cbFrameLength, wCurrentRate);
 528     if (byRTSRsvType == 0) { //RTSTxRrvTime_bb
 529         uRTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 20, pDevice->byTopCCKBasicRate);
 530         uCTSTime = uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopCCKBasicRate);
 531     }
 532     else if (byRTSRsvType == 1){ //RTSTxRrvTime_ba, only in 2.4GHZ
 533         uRTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 20, pDevice->byTopCCKBasicRate);
 534         uCTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopCCKBasicRate);
 535         uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate);
 536     }
 537     else if (byRTSRsvType == 2) { //RTSTxRrvTime_aa
 538         uRTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 20, pDevice->byTopOFDMBasicRate);
 539         uCTSTime = uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate);
 540     }
 541     else if (byRTSRsvType == 3) { //CTSTxRrvTime_ba, only in 2.4GHZ
 542         uCTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopCCKBasicRate);
 543         uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate);
 544         uRrvTime = uCTSTime + uAckTime + uDataTime + 2*pDevice->uSIFS;
 545         return uRrvTime;
 546     }
 547
 548     //RTSRrvTime
 549     uRrvTime = uRTSTime + uCTSTime + uAckTime + uDataTime + 3*pDevice->uSIFS;
 550     return uRrvTime;
 551 }
 552
 553 //byFreqType 0: 5GHz, 1:2.4Ghz
 554 static
 555 unsigned int
 556 s_uGetDataDuration (
 557      PSDevice pDevice,
 558      BYTE     byDurType,
 559      unsigned int     cbFrameLength,
 560      BYTE     byPktType,
 561      WORD     wRate,
 562      BOOL     bNeedAck,
 563      unsigned int     uFragIdx,
 564      unsigned int     cbLastFragmentSize,
 565      unsigned int     uMACfragNum,
 566      BYTE     byFBOption
 567     )
 568 {
 569     BOOL bLastFrag = 0;
 570     unsigned int uAckTime = 0, uNextPktTime = 0;
 571
 572     if (uFragIdx == (uMACfragNum-1)) {
 573         bLastFrag = 1;
 574     }
 575
 576     switch (byDurType) {
 577
 578     case DATADUR_B:    //DATADUR_B
 579         if (((uMACfragNum == 1)) || (bLastFrag == 1)) {//Non Frag or Last Frag
 580             if (bNeedAck) {
 581                 uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopCCKBasicRate);
 582                 return (pDevice->uSIFS + uAckTime);
 583             } else {
 584                 return 0;
 585             }
 586         }
 587         else {//First Frag or Mid Frag
 588             if (uFragIdx == (uMACfragNum-2)) {
 589                 uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbLastFragmentSize, wRate, bNeedAck);
 590             } else {
 591                 uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wRate, bNeedAck);
 592             }
 593             if (bNeedAck) {
 594                 uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopCCKBasicRate);
 595                 return (pDevice->uSIFS + uAckTime + uNextPktTime);
 596             } else {
 597                 return (pDevice->uSIFS + uNextPktTime);
 598             }
 599         }
 600         break;
 601
 602
 603     case DATADUR_A:    //DATADUR_A
 604         if (((uMACfragNum==1)) || (bLastFrag==1)) {//Non Frag or Last Frag
 605             if(bNeedAck){
 606                 uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate);
 607                 return (pDevice->uSIFS + uAckTime);
 608             } else {
 609                 return 0;
 610             }
 611         }
 612         else {//First Frag or Mid Frag
 613             if(uFragIdx == (uMACfragNum-2)){
 614                 uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbLastFragmentSize, wRate, bNeedAck);
 615             } else {
 616                 uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wRate, bNeedAck);
 617             }
 618             if(bNeedAck){
 619                 uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate);
 620                 return (pDevice->uSIFS + uAckTime + uNextPktTime);
 621             } else {
 622                 return (pDevice->uSIFS + uNextPktTime);
 623             }
 624         }
 625         break;
 626
 627     case DATADUR_A_F0:    //DATADUR_A_F0
 628             if (((uMACfragNum==1)) || (bLastFrag==1)) {//Non Frag or Last Frag
 629             if(bNeedAck){
 630                 uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate);
 631                 return (pDevice->uSIFS + uAckTime);
 632             } else {
 633                 return 0;
 634             }
 635         }
 636             else { //First Frag or Mid Frag
 637                 if (byFBOption == AUTO_FB_0) {
 638                 if (wRate < RATE_18M)
 639                     wRate = RATE_18M;
 640                 else if (wRate > RATE_54M)
 641                     wRate = RATE_54M;
 642
 643                     if(uFragIdx == (uMACfragNum-2)){
 644                     uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbLastFragmentSize, wFB_Opt0[FB_RATE0][wRate-RATE_18M], bNeedAck);
 645                 } else {
 646                     uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt0[FB_RATE0][wRate-RATE_18M], bNeedAck);
 647                 }
 648                 } else { // (byFBOption == AUTO_FB_1)
 649                 if (wRate < RATE_18M)
 650                     wRate = RATE_18M;
 651                 else if (wRate > RATE_54M)
 652                     wRate = RATE_54M;
 653
 654                     if(uFragIdx == (uMACfragNum-2)){
 655                     uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbLastFragmentSize, wFB_Opt1[FB_RATE0][wRate-RATE_18M], bNeedAck);
 656                 } else {
 657                     uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt1[FB_RATE0][wRate-RATE_18M], bNeedAck);
 658                 }
 659                 }
 660
 661                 if(bNeedAck){
 662                 uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate);
 663                 return (pDevice->uSIFS + uAckTime + uNextPktTime);
 664             } else {
 665                 return (pDevice->uSIFS + uNextPktTime);
 666             }
 667             }
 668         break;
 669
 670     case DATADUR_A_F1:    //DATADUR_A_F1
 671         if (((uMACfragNum==1)) || (bLastFrag==1)) {//Non Frag or Last Frag
 672             if(bNeedAck){
 673                 uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate);
 674                 return (pDevice->uSIFS + uAckTime);
 675             } else {
 676                 return 0;
 677             }
 678         }
 679             else { //First Frag or Mid Frag
 680                 if (byFBOption == AUTO_FB_0) {
 681                 if (wRate < RATE_18M)
 682                     wRate = RATE_18M;
 683                 else if (wRate > RATE_54M)
 684                     wRate = RATE_54M;
 685
 686                     if(uFragIdx == (uMACfragNum-2)){
 687                     uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbLastFragmentSize, wFB_Opt0[FB_RATE1][wRate-RATE_18M], bNeedAck);
 688                 } else {
 689                     uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt0[FB_RATE1][wRate-RATE_18M], bNeedAck);
 690                 }
 691
 692                 } else { // (byFBOption == AUTO_FB_1)
 693                 if (wRate < RATE_18M)
 694                     wRate = RATE_18M;
 695                 else if (wRate > RATE_54M)
 696                     wRate = RATE_54M;
 697
 698                     if(uFragIdx == (uMACfragNum-2)){
 699                     uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbLastFragmentSize, wFB_Opt1[FB_RATE1][wRate-RATE_18M], bNeedAck);
 700                 } else {
 701                     uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt1[FB_RATE1][wRate-RATE_18M], bNeedAck);
 702                 }
 703                 }
 704                 if(bNeedAck){
 705                 uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate);
 706                 return (pDevice->uSIFS + uAckTime + uNextPktTime);
 707             } else {
 708                 return (pDevice->uSIFS + uNextPktTime);
 709             }
 710             }
 711         break;
 712
 713     default:
 714         break;
 715     }
 716
 717         ASSERT(FALSE);
 718         return 0;
 719 }
 720
 721
 722 //byFreqType: 0=>5GHZ 1=>2.4GHZ
 723 static
 724 unsigned int
 725 s_uGetRTSCTSDuration (
 726      PSDevice pDevice,
 727      BYTE byDurType,
 728      unsigned int cbFrameLength,
 729      BYTE byPktType,
 730      WORD wRate,
 731      BOOL bNeedAck,
 732      BYTE byFBOption
 733     )
 734 {
 735     unsigned int uCTSTime = 0, uDurTime = 0;
 736
 737
 738     switch (byDurType) {
 739
 740     case RTSDUR_BB:    //RTSDuration_bb
 741         uCTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopCCKBasicRate);
 742         uDurTime = uCTSTime + 2*pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wRate, bNeedAck);
 743         break;
 744
 745     case RTSDUR_BA:    //RTSDuration_ba
 746         uCTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopCCKBasicRate);
 747         uDurTime = uCTSTime + 2*pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wRate, bNeedAck);
 748         break;
 749
 750     case RTSDUR_AA:    //RTSDuration_aa
 751         uCTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate);
 752         uDurTime = uCTSTime + 2*pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wRate, bNeedAck);
 753         break;
 754
 755     case CTSDUR_BA:    //CTSDuration_ba
 756         uDurTime = pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wRate, bNeedAck);
 757         break;
 758
 759     case RTSDUR_BA_F0: //RTSDuration_ba_f0
 760         uCTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopCCKBasicRate);
 761         if ((byFBOption == AUTO_FB_0) && (wRate >= RATE_18M) && (wRate <=RATE_54M)) {
 762             uDurTime = uCTSTime + 2*pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt0[FB_RATE0][wRate-RATE_18M], bNeedAck);
 763         } else if ((byFBOption == AUTO_FB_1) && (wRate >= RATE_18M) && (wRate <=RATE_54M)) {
 764             uDurTime = uCTSTime + 2*pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt1[FB_RATE0][wRate-RATE_18M], bNeedAck);
 765         }
 766         break;
 767
 768     case RTSDUR_AA_F0: //RTSDuration_aa_f0
 769         uCTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate);
 770         if ((byFBOption == AUTO_FB_0) && (wRate >= RATE_18M) && (wRate <=RATE_54M)) {
 771             uDurTime = uCTSTime + 2*pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt0[FB_RATE0][wRate-RATE_18M], bNeedAck);
 772         } else if ((byFBOption == AUTO_FB_1) && (wRate >= RATE_18M) && (wRate <=RATE_54M)) {
 773             uDurTime = uCTSTime + 2*pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt1[FB_RATE0][wRate-RATE_18M], bNeedAck);
 774         }
 775         break;
 776
 777     case RTSDUR_BA_F1: //RTSDuration_ba_f1
 778         uCTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopCCKBasicRate);
 779         if ((byFBOption == AUTO_FB_0) && (wRate >= RATE_18M) && (wRate <=RATE_54M)) {
 780             uDurTime = uCTSTime + 2*pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt0[FB_RATE1][wRate-RATE_18M], bNeedAck);
 781         } else if ((byFBOption == AUTO_FB_1) && (wRate >= RATE_18M) && (wRate <=RATE_54M)) {
 782             uDurTime = uCTSTime + 2*pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt1[FB_RATE1][wRate-RATE_18M], bNeedAck);
 783         }
 784         break;
 785
 786     case RTSDUR_AA_F1: //RTSDuration_aa_f1
 787         uCTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate);
 788         if ((byFBOption == AUTO_FB_0) && (wRate >= RATE_18M) && (wRate <=RATE_54M)) {
 789             uDurTime = uCTSTime + 2*pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt0[FB_RATE1][wRate-RATE_18M], bNeedAck);
 790         } else if ((byFBOption == AUTO_FB_1) && (wRate >= RATE_18M) && (wRate <=RATE_54M)) {
 791             uDurTime = uCTSTime + 2*pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt1[FB_RATE1][wRate-RATE_18M], bNeedAck);
 792         }
 793         break;
 794
 795     case CTSDUR_BA_F0: //CTSDuration_ba_f0
 796         if ((byFBOption == AUTO_FB_0) && (wRate >= RATE_18M) && (wRate <=RATE_54M)) {
 797             uDurTime = pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt0[FB_RATE0][wRate-RATE_18M], bNeedAck);
 798         } else if ((byFBOption == AUTO_FB_1) && (wRate >= RATE_18M) && (wRate <=RATE_54M)) {
 799             uDurTime = pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt1[FB_RATE0][wRate-RATE_18M], bNeedAck);
 800         }
 801         break;
 802
 803     case CTSDUR_BA_F1: //CTSDuration_ba_f1
 804         if ((byFBOption == AUTO_FB_0) && (wRate >= RATE_18M) && (wRate <=RATE_54M)) {
 805             uDurTime = pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt0[FB_RATE1][wRate-RATE_18M], bNeedAck);
 806         } else if ((byFBOption == AUTO_FB_1) && (wRate >= RATE_18M) && (wRate <=RATE_54M)) {
 807             uDurTime = pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt1[FB_RATE1][wRate-RATE_18M], bNeedAck);
 808         }
 809         break;
 810
 811     default:
 812         break;
 813     }
 814
 815     return uDurTime;
 816
 817 }
 818
 819
 820
 821
 822 static
 823 unsigned int
 824 s_uFillDataHead (
 825      PSDevice pDevice,
 826      BYTE     byPktType,
 827      WORD     wCurrentRate,
 828      void *pTxDataHead,
 829      unsigned int     cbFrameLength,
 830      unsigned int     uDMAIdx,
 831      BOOL     bNeedAck,
 832      unsigned int     uFragIdx,
 833      unsigned int     cbLastFragmentSize,
 834      unsigned int     uMACfragNum,
 835      BYTE     byFBOption
 836     )
 837 {
 838
 839     if (pTxDataHead == NULL) {
 840         return 0;
 841     }
 842
 843     if (byPktType == PK_TYPE_11GB || byPktType == PK_TYPE_11GA) {
 844         if ((uDMAIdx == TYPE_ATIMDMA) || (uDMAIdx == TYPE_BEACONDMA)) {
 845                 PSTxDataHead_ab pBuf = (PSTxDataHead_ab) pTxDataHead;
 846             //Get SignalField,ServiceField,Length
 847             BBvCaculateParameter(pDevice, cbFrameLength, wCurrentRate, byPktType,
 848                 (PWORD)&(pBuf->wTransmitLength), (PBYTE)&(pBuf->byServiceField), (PBYTE)&(pBuf->bySignalField)
 849             );
 850             //Get Duration and TimeStampOff
 851             pBuf->wDuration = (WORD)s_uGetDataDuration(pDevice, DATADUR_A, cbFrameLength, byPktType,
 852                                                        wCurrentRate, bNeedAck, uFragIdx,
 853                                                        cbLastFragmentSize, uMACfragNum,
 854                                                        byFBOption); //1: 2.4GHz
 855             if(uDMAIdx!=TYPE_ATIMDMA) {
 856                 pBuf->wTimeStampOff = wTimeStampOff[pDevice->byPreambleType%2][wCurrentRate%MAX_RATE];
 857             }
 858             return (pBuf->wDuration);
 859         }
 860         else { // DATA & MANAGE Frame
 861             if (byFBOption == AUTO_FB_NONE) {
 862                 PSTxDataHead_g pBuf = (PSTxDataHead_g)pTxDataHead;
 863                 //Get SignalField,ServiceField,Length
 864                 BBvCaculateParameter(pDevice, cbFrameLength, wCurrentRate, byPktType,
 865                     (PWORD)&(pBuf->wTransmitLength_a), (PBYTE)&(pBuf->byServiceField_a), (PBYTE)&(pBuf->bySignalField_a)
 866                 );
 867                 BBvCaculateParameter(pDevice, cbFrameLength, pDevice->byTopCCKBasicRate, PK_TYPE_11B,
 868                     (PWORD)&(pBuf->wTransmitLength_b), (PBYTE)&(pBuf->byServiceField_b), (PBYTE)&(pBuf->bySignalField_b)
 869                 );
 870                 //Get Duration and TimeStamp
 871                 pBuf->wDuration_a = (WORD)s_uGetDataDuration(pDevice, DATADUR_A, cbFrameLength,
 872                                                              byPktType, wCurrentRate, bNeedAck, uFragIdx,
 873                                                              cbLastFragmentSize, uMACfragNum,
 874                                                              byFBOption); //1: 2.4GHz
 875                 pBuf->wDuration_b = (WORD)s_uGetDataDuration(pDevice, DATADUR_B, cbFrameLength,
 876                                                              PK_TYPE_11B, pDevice->byTopCCKBasicRate,
 877                                                              bNeedAck, uFragIdx, cbLastFragmentSize,
 878                                                              uMACfragNum, byFBOption); //1: 2.4GHz
 879
 880                 pBuf->wTimeStampOff_a = wTimeStampOff[pDevice->byPreambleType%2][wCurrentRate%MAX_RATE];
 881                 pBuf->wTimeStampOff_b = wTimeStampOff[pDevice->byPreambleType%2][pDevice->byTopCCKBasicRate%MAX_RATE];
 882                 return (pBuf->wDuration_a);
 883              } else {
 884                 // Auto Fallback
 885                 PSTxDataHead_g_FB pBuf = (PSTxDataHead_g_FB)pTxDataHead;
 886                 //Get SignalField,ServiceField,Length
 887                 BBvCaculateParameter(pDevice, cbFrameLength, wCurrentRate, byPktType,
 888                     (PWORD)&(pBuf->wTransmitLength_a), (PBYTE)&(pBuf->byServiceField_a), (PBYTE)&(pBuf->bySignalField_a)
 889                 );
 890                 BBvCaculateParameter(pDevice, cbFrameLength, pDevice->byTopCCKBasicRate, PK_TYPE_11B,
 891                     (PWORD)&(pBuf->wTransmitLength_b), (PBYTE)&(pBuf->byServiceField_b), (PBYTE)&(pBuf->bySignalField_b)
 892                 );
 893                 //Get Duration and TimeStamp
 894                 pBuf->wDuration_a = (WORD)s_uGetDataDuration(pDevice, DATADUR_A, cbFrameLength, byPktType,
 895                                              wCurrentRate, bNeedAck, uFragIdx, cbLastFragmentSize, uMACfragNum, byFBOption); //1: 2.4GHz
 896                 pBuf->wDuration_b = (WORD)s_uGetDataDuration(pDevice, DATADUR_B, cbFrameLength, PK_TYPE_11B,
 897                                              pDevice->byTopCCKBasicRate, bNeedAck, uFragIdx, cbLastFragmentSize, uMACfragNum, byFBOption); //1: 2.4GHz
 898                 pBuf->wDuration_a_f0 = (WORD)s_uGetDataDuration(pDevice, DATADUR_A_F0, cbFrameLength, byPktType,
 899                                              wCurrentRate, bNeedAck, uFragIdx, cbLastFragmentSize, uMACfragNum, byFBOption); //1: 2.4GHz
 900                 pBuf->wDuration_a_f1 = (WORD)s_uGetDataDuration(pDevice, DATADUR_A_F1, cbFrameLength, byPktType,
 901                                              wCurrentRate, bNeedAck, uFragIdx, cbLastFragmentSize, uMACfragNum, byFBOption); //1: 2.4GHz
 902                 pBuf->wTimeStampOff_a = wTimeStampOff[pDevice->byPreambleType%2][wCurrentRate%MAX_RATE];
 903                 pBuf->wTimeStampOff_b = wTimeStampOff[pDevice->byPreambleType%2][pDevice->byTopCCKBasicRate%MAX_RATE];
 904                 return (pBuf->wDuration_a);
 905             } //if (byFBOption == AUTO_FB_NONE)
 906         }
 907     }
 908     else if (byPktType == PK_TYPE_11A) {
 909         if ((byFBOption != AUTO_FB_NONE) && (uDMAIdx != TYPE_ATIMDMA) && (uDMAIdx != TYPE_BEACONDMA)) {
 910             // Auto Fallback
 911             PSTxDataHead_a_FB pBuf = (PSTxDataHead_a_FB)pTxDataHead;
 912             //Get SignalField,ServiceField,Length
 913             BBvCaculateParameter(pDevice, cbFrameLength, wCurrentRate, byPktType,
 914                 (PWORD)&(pBuf->wTransmitLength), (PBYTE)&(pBuf->byServiceField), (PBYTE)&(pBuf->bySignalField)
 915             );
 916             //Get Duration and TimeStampOff
 917             pBuf->wDuration = (WORD)s_uGetDataDuration(pDevice, DATADUR_A, cbFrameLength, byPktType,
 918                                         wCurrentRate, bNeedAck, uFragIdx, cbLastFragmentSize, uMACfragNum, byFBOption); //0: 5GHz
 919             pBuf->wDuration_f0 = (WORD)s_uGetDataDuration(pDevice, DATADUR_A_F0, cbFrameLength, byPktType,
 920                                         wCurrentRate, bNeedAck, uFragIdx, cbLastFragmentSize, uMACfragNum, byFBOption); //0: 5GHz
 921             pBuf->wDuration_f1 = (WORD)s_uGetDataDuration(pDevice, DATADUR_A_F1, cbFrameLength, byPktType,
 922                                         wCurrentRate, bNeedAck, uFragIdx, cbLastFragmentSize, uMACfragNum, byFBOption); //0: 5GHz
 923             if(uDMAIdx!=TYPE_ATIMDMA) {
 924                 pBuf->wTimeStampOff = wTimeStampOff[pDevice->byPreambleType%2][wCurrentRate%MAX_RATE];
 925             }
 926             return (pBuf->wDuration);
 927         } else {
 928             PSTxDataHead_ab pBuf = (PSTxDataHead_ab)pTxDataHead;
 929             //Get SignalField,ServiceField,Length
 930             BBvCaculateParameter(pDevice, cbFrameLength, wCurrentRate, byPktType,
 931                 (PWORD)&(pBuf->wTransmitLength), (PBYTE)&(pBuf->byServiceField), (PBYTE)&(pBuf->bySignalField)
 932             );
 933             //Get Duration and TimeStampOff
 934             pBuf->wDuration = (WORD)s_uGetDataDuration(pDevice, DATADUR_A, cbFrameLength, byPktType,
 935                                                        wCurrentRate, bNeedAck, uFragIdx,
 936                                                        cbLastFragmentSize, uMACfragNum,
 937                                                        byFBOption);
 938
 939             if(uDMAIdx!=TYPE_ATIMDMA) {
 940                 pBuf->wTimeStampOff = wTimeStampOff[pDevice->byPreambleType%2][wCurrentRate%MAX_RATE];
 941             }
 942             return (pBuf->wDuration);
 943         }
 944     }
 945     else if (byPktType == PK_TYPE_11B) {
 946             PSTxDataHead_ab pBuf = (PSTxDataHead_ab)pTxDataHead;
 947             //Get SignalField,ServiceField,Length
 948             BBvCaculateParameter(pDevice, cbFrameLength, wCurrentRate, byPktType,
 949                 (PWORD)&(pBuf->wTransmitLength), (PBYTE)&(pBuf->byServiceField), (PBYTE)&(pBuf->bySignalField)
 950             );
 951             //Get Duration and TimeStampOff
 952             pBuf->wDuration = (WORD)s_uGetDataDuration(pDevice, DATADUR_B, cbFrameLength, byPktType,
 953                                                        wCurrentRate, bNeedAck, uFragIdx,
 954                                                        cbLastFragmentSize, uMACfragNum,
 955                                                        byFBOption);
 956             if (uDMAIdx != TYPE_ATIMDMA) {
 957                 pBuf->wTimeStampOff = wTimeStampOff[pDevice->byPreambleType%2][wCurrentRate%MAX_RATE];
 958             }
 959             return (pBuf->wDuration);
 960     }
 961     return 0;
 962 }
 963
 964
 965
 966
 967 static
 968 void
 969 s_vFillRTSHead (
 970      PSDevice         pDevice,
 971      BYTE             byPktType,
 972      void *pvRTS,
 973      unsigned int             cbFrameLength,
 974      BOOL             bNeedAck,
 975      BOOL             bDisCRC,
 976      PSEthernetHeader psEthHeader,
 977      WORD             wCurrentRate,
 978      BYTE             byFBOption
 979     )
 980 {
 981     unsigned int uRTSFrameLen = 20;
 982     WORD  wLen = 0x0000;
 983
 984     if (pvRTS == NULL)
 985         return;
 986
 987     if (bDisCRC) {
 988         // When CRCDIS bit is on, H/W forgot to generate FCS for RTS frame,
 989         // in this case we need to decrease its length by 4.
 990         uRTSFrameLen -= 4;
 991     }
 992
 993     // Note: So far RTSHead dosen't appear in ATIM & Beacom DMA, so we don't need to take them into account.
 994     //       Otherwise, we need to modified codes for them.
 995     if (byPktType == PK_TYPE_11GB || byPktType == PK_TYPE_11GA) {
 996         if (byFBOption == AUTO_FB_NONE) {
 997             PSRTS_g pBuf = (PSRTS_g)pvRTS;
 998             //Get SignalField,ServiceField,Length
 999             BBvCaculateParameter(pDevice, uRTSFrameLen, pDevice->byTopCCKBasicRate, PK_TYPE_11B,
1000                 (PWORD)&(wLen), (PBYTE)&(pBuf->byServiceField_b), (PBYTE)&(pBuf->bySignalField_b)
1001             );
1002             pBuf->wTransmitLength_b = cpu_to_le16(wLen);
1003             BBvCaculateParameter(pDevice, uRTSFrameLen, pDevice->byTopOFDMBasicRate, byPktType,
1004                 (PWORD)&(wLen), (PBYTE)&(pBuf->byServiceField_a), (PBYTE)&(pBuf->bySignalField_a)
1005             );
1006             pBuf->wTransmitLength_a = cpu_to_le16(wLen);
1007             //Get Duration
1008             pBuf->wDuration_bb = cpu_to_le16((WORD)s_uGetRTSCTSDuration(pDevice, RTSDUR_BB, cbFrameLength, PK_TYPE_11B, pDevice->byTopCCKBasicRate, bNeedAck, byFBOption));    //0:RTSDuration_bb, 1:2.4G, 1:CCKData
1009             pBuf->wDuration_aa = cpu_to_le16((WORD)s_uGetRTSCTSDuration(pDevice, RTSDUR_AA, cbFrameLength, byPktType, wCurrentRate, bNeedAck, byFBOption)); //2:RTSDuration_aa, 1:2.4G, 2,3: 2.4G OFDMData
1010             pBuf->wDuration_ba = cpu_to_le16((WORD)s_uGetRTSCTSDuration(pDevice, RTSDUR_BA, cbFrameLength, byPktType, wCurrentRate, bNeedAck, byFBOption)); //1:RTSDuration_ba, 1:2.4G, 2,3:2.4G OFDM Data
1011
1012             pBuf->Data.wDurationID = pBuf->wDuration_aa;
1013             //Get RTS Frame body
1014             pBuf->Data.wFrameControl = TYPE_CTL_RTS;//0x00B4
1015
1016         if ((pDevice->eOPMode == OP_MODE_ADHOC) ||
1017             (pDevice->eOPMode == OP_MODE_AP)) {
1018                 memcpy(&(pBuf->Data.abyRA[0]),
1019                        &(psEthHeader->abyDstAddr[0]),
1020                        ETH_ALEN);
1021         }
1022             else {
1023                     memcpy(&(pBuf->Data.abyRA[0]),
1024                            &(pDevice->abyBSSID[0]),
1025                            ETH_ALEN);
1026             }
1027         if (pDevice->eOPMode == OP_MODE_AP) {
1028                 memcpy(&(pBuf->Data.abyTA[0]),
1029                        &(pDevice->abyBSSID[0]),
1030                        ETH_ALEN);
1031         }
1032             else {
1033                     memcpy(&(pBuf->Data.abyTA[0]),
1034                            &(psEthHeader->abySrcAddr[0]),
1035                            ETH_ALEN);
1036             }
1037         }
1038         else {
1039            PSRTS_g_FB pBuf = (PSRTS_g_FB)pvRTS;
1040             //Get SignalField,ServiceField,Length
1041             BBvCaculateParameter(pDevice, uRTSFrameLen, pDevice->byTopCCKBasicRate, PK_TYPE_11B,
1042                 (PWORD)&(wLen), (PBYTE)&(pBuf->byServiceField_b), (PBYTE)&(pBuf->bySignalField_b)
1043             );
1044             pBuf->wTransmitLength_b = cpu_to_le16(wLen);
1045             BBvCaculateParameter(pDevice, uRTSFrameLen, pDevice->byTopOFDMBasicRate, byPktType,
1046                 (PWORD)&(wLen), (PBYTE)&(pBuf->byServiceField_a), (PBYTE)&(pBuf->bySignalField_a)
1047             );
1048             pBuf->wTransmitLength_a = cpu_to_le16(wLen);
1049             //Get Duration
1050             pBuf->wDuration_bb = cpu_to_le16((WORD)s_uGetRTSCTSDuration(pDevice, RTSDUR_BB, cbFrameLength, PK_TYPE_11B, pDevice->byTopCCKBasicRate, bNeedAck, byFBOption));    //0:RTSDuration_bb, 1:2.4G, 1:CCKData
1051             pBuf->wDuration_aa = cpu_to_le16((WORD)s_uGetRTSCTSDuration(pDevice, RTSDUR_AA, cbFrameLength, byPktType, wCurrentRate, bNeedAck, byFBOption)); //2:RTSDuration_aa, 1:2.4G, 2,3:2.4G OFDMData
1052             pBuf->wDuration_ba = cpu_to_le16((WORD)s_uGetRTSCTSDuration(pDevice, RTSDUR_BA, cbFrameLength, byPktType, wCurrentRate, bNeedAck, byFBOption)); //1:RTSDuration_ba, 1:2.4G, 2,3:2.4G OFDMData
1053             pBuf->wRTSDuration_ba_f0 = cpu_to_le16((WORD)s_uGetRTSCTSDuration(pDevice, RTSDUR_BA_F0, cbFrameLength, byPktType, wCurrentRate, bNeedAck, byFBOption));    //4:wRTSDuration_ba_f0, 1:2.4G, 1:CCKData
1054             pBuf->wRTSDuration_aa_f0 = cpu_to_le16((WORD)s_uGetRTSCTSDuration(pDevice, RTSDUR_AA_F0, cbFrameLength, byPktType, wCurrentRate, bNeedAck, byFBOption));    //5:wRTSDuration_aa_f0, 1:2.4G, 1:CCKData
1055             pBuf->wRTSDuration_ba_f1 = cpu_to_le16((WORD)s_uGetRTSCTSDuration(pDevice, RTSDUR_BA_F1, cbFrameLength, byPktType, wCurrentRate, bNeedAck, byFBOption));    //6:wRTSDuration_ba_f1, 1:2.4G, 1:CCKData
1056             pBuf->wRTSDuration_aa_f1 = cpu_to_le16((WORD)s_uGetRTSCTSDuration(pDevice, RTSDUR_AA_F1, cbFrameLength, byPktType, wCurrentRate, bNeedAck, byFBOption));    //7:wRTSDuration_aa_f1, 1:2.4G, 1:CCKData
1057             pBuf->Data.wDurationID = pBuf->wDuration_aa;
1058             //Get RTS Frame body
1059             pBuf->Data.wFrameControl = TYPE_CTL_RTS;//0x00B4
1060
1061         if ((pDevice->eOPMode == OP_MODE_ADHOC) ||
1062             (pDevice->eOPMode == OP_MODE_AP)) {
1063                 memcpy(&(pBuf->Data.abyRA[0]),
1064                        &(psEthHeader->abyDstAddr[0]),
1065                        ETH_ALEN);
1066         }
1067             else {
1068                 memcpy(&(pBuf->Data.abyRA[0]),
1069                        &(pDevice->abyBSSID[0]),
1070                        ETH_ALEN);
1071             }
1072
1073         if (pDevice->eOPMode == OP_MODE_AP) {
1074                 memcpy(&(pBuf->Data.abyTA[0]),
1075                        &(pDevice->abyBSSID[0]),
1076                        ETH_ALEN);
1077         }
1078             else {
1079                     memcpy(&(pBuf->Data.abyTA[0]),
1080                            &(psEthHeader->abySrcAddr[0]),
1081                            ETH_ALEN);
1082             }
1083
1084         } // if (byFBOption == AUTO_FB_NONE)
1085     }
1086     else if (byPktType == PK_TYPE_11A) {
1087         if (byFBOption == AUTO_FB_NONE) {
1088             PSRTS_ab pBuf = (PSRTS_ab)pvRTS;
1089             //Get SignalField,ServiceField,Length
1090             BBvCaculateParameter(pDevice, uRTSFrameLen, pDevice->byTopOFDMBasicRate, byPktType,
1091                 (PWORD)&(wLen), (PBYTE)&(pBuf->byServiceField), (PBYTE)&(pBuf->bySignalField)
1092             );
1093             pBuf->wTransmitLength = cpu_to_le16(wLen);
1094             //Get Duration
1095             pBuf->wDuration = cpu_to_le16((WORD)s_uGetRTSCTSDuration(pDevice, RTSDUR_AA, cbFrameLength, byPktType, wCurrentRate, bNeedAck, byFBOption)); //0:RTSDuration_aa, 0:5G, 0: 5G OFDMData
1096             pBuf->Data.wDurationID = pBuf->wDuration;
1097             //Get RTS Frame body
1098             pBuf->Data.wFrameControl = TYPE_CTL_RTS;//0x00B4
1099
1100         if ((pDevice->eOPMode == OP_MODE_ADHOC) ||
1101             (pDevice->eOPMode == OP_MODE_AP)) {
1102                 memcpy(&(pBuf->Data.abyRA[0]),
1103                        &(psEthHeader->abyDstAddr[0]),
1104                        ETH_ALEN);
1105         } else {
1106                 memcpy(&(pBuf->Data.abyRA[0]),
1107                        &(pDevice->abyBSSID[0]),
1108                        ETH_ALEN);
1109         }
1110
1111         if (pDevice->eOPMode == OP_MODE_AP) {
1112                 memcpy(&(pBuf->Data.abyTA[0]),
1113                        &(pDevice->abyBSSID[0]),
1114                        ETH_ALEN);
1115         } else {
1116                 memcpy(&(pBuf->Data.abyTA[0]),
1117                        &(psEthHeader->abySrcAddr[0]),
1118                        ETH_ALEN);
1119         }
1120
1121         }
1122         else {
1123             PSRTS_a_FB pBuf = (PSRTS_a_FB)pvRTS;
1124             //Get SignalField,ServiceField,Length
1125             BBvCaculateParameter(pDevice, uRTSFrameLen, pDevice->byTopOFDMBasicRate, byPktType,
1126                 (PWORD)&(wLen), (PBYTE)&(pBuf->byServiceField), (PBYTE)&(pBuf->bySignalField)
1127             );
1128             pBuf->wTransmitLength = cpu_to_le16(wLen);
1129             //Get Duration
1130             pBuf->wDuration = cpu_to_le16((WORD)s_uGetRTSCTSDuration(pDevice, RTSDUR_AA, cbFrameLength, byPktType, wCurrentRate, bNeedAck, byFBOption)); //0:RTSDuration_aa, 0:5G, 0: 5G OFDMData
1131             pBuf->wRTSDuration_f0 = cpu_to_le16((WORD)s_uGetRTSCTSDuration(pDevice, RTSDUR_AA_F0, cbFrameLength, byPktType, wCurrentRate, bNeedAck, byFBOption)); //5:RTSDuration_aa_f0, 0:5G, 0: 5G OFDMData
1132             pBuf->wRTSDuration_f1 = cpu_to_le16((WORD)s_uGetRTSCTSDuration(pDevice, RTSDUR_AA_F1, cbFrameLength, byPktType, wCurrentRate, bNeedAck, byFBOption)); //7:RTSDuration_aa_f1, 0:5G, 0:
1133             pBuf->Data.wDurationID = pBuf->wDuration;
1134             //Get RTS Frame body
1135             pBuf->Data.wFrameControl = TYPE_CTL_RTS;//0x00B4
1136
1137         if ((pDevice->eOPMode == OP_MODE_ADHOC) ||
1138             (pDevice->eOPMode == OP_MODE_AP)) {
1139                 memcpy(&(pBuf->Data.abyRA[0]),
1140                        &(psEthHeader->abyDstAddr[0]),
1141                        ETH_ALEN);
1142         } else {
1143                 memcpy(&(pBuf->Data.abyRA[0]),
1144                        &(pDevice->abyBSSID[0]),
1145                        ETH_ALEN);
1146         }
1147         if (pDevice->eOPMode == OP_MODE_AP) {
1148                 memcpy(&(pBuf->Data.abyTA[0]),
1149                        &(pDevice->abyBSSID[0]),
1150                        ETH_ALEN);
1151         } else {
1152                 memcpy(&(pBuf->Data.abyTA[0]),
1153                        &(psEthHeader->abySrcAddr[0]),
1154                        ETH_ALEN);
1155         }
1156         }
1157     }
1158     else if (byPktType == PK_TYPE_11B) {
1159         PSRTS_ab pBuf = (PSRTS_ab)pvRTS;
1160         //Get SignalField,ServiceField,Length
1161         BBvCaculateParameter(pDevice, uRTSFrameLen, pDevice->byTopCCKBasicRate, PK_TYPE_11B,
1162             (PWORD)&(wLen), (PBYTE)&(pBuf->byServiceField), (PBYTE)&(pBuf->bySignalField)
1163         );
1164         pBuf->wTransmitLength = cpu_to_le16(wLen);
1165         //Get Duration
1166         pBuf->wDuration = cpu_to_le16((WORD)s_uGetRTSCTSDuration(pDevice, RTSDUR_BB, cbFrameLength, byPktType, wCurrentRate, bNeedAck, byFBOption)); //0:RTSDuration_bb, 1:2.4G, 1:CCKData
1167         pBuf->Data.wDurationID = pBuf->wDuration;
1168         //Get RTS Frame body
1169         pBuf->Data.wFrameControl = TYPE_CTL_RTS;//0x00B4
1170
1171         if ((pDevice->eOPMode == OP_MODE_ADHOC) ||
1172             (pDevice->eOPMode == OP_MODE_AP)) {
1173                 memcpy(&(pBuf->Data.abyRA[0]),
1174                        &(psEthHeader->abyDstAddr[0]),
1175                        ETH_ALEN);
1176         }
1177         else {
1178                 memcpy(&(pBuf->Data.abyRA[0]),
1179                        &(pDevice->abyBSSID[0]),
1180                        ETH_ALEN);
1181         }
1182
1183         if (pDevice->eOPMode == OP_MODE_AP) {
1184                 memcpy(&(pBuf->Data.abyTA[0]),
1185                        &(pDevice->abyBSSID[0]),
1186                        ETH_ALEN);
1187         } else {
1188                 memcpy(&(pBuf->Data.abyTA[0]),
1189                        &(psEthHeader->abySrcAddr[0]),
1190                        ETH_ALEN);
1191         }
1192     }
1193 }
1194
1195 static
1196 void
1197 s_vFillCTSHead (
1198      PSDevice pDevice,
1199      unsigned int     uDMAIdx,
1200      BYTE     byPktType,
1201      void *pvCTS,
1202      unsigned int     cbFrameLength,
1203      BOOL     bNeedAck,
1204      BOOL     bDisCRC,
1205      WORD     wCurrentRate,
1206      BYTE     byFBOption
1207     )
1208 {
1209     unsigned int uCTSFrameLen = 14;
1210     WORD  wLen = 0x0000;
1211
1212     if (pvCTS == NULL) {
1213         return;
1214     }
1215
1216     if (bDisCRC) {
1217         // When CRCDIS bit is on, H/W forgot to generate FCS for CTS frame,
1218         // in this case we need to decrease its length by 4.
1219         uCTSFrameLen -= 4;
1220     }
1221
1222     if (byPktType == PK_TYPE_11GB || byPktType == PK_TYPE_11GA) {
1223         if (byFBOption != AUTO_FB_NONE && uDMAIdx != TYPE_ATIMDMA && uDMAIdx != TYPE_BEACONDMA) {
1224             // Auto Fall back
1225             PSCTS_FB pBuf = (PSCTS_FB)pvCTS;
1226             //Get SignalField,ServiceField,Length
1227             BBvCaculateParameter(pDevice, uCTSFrameLen, pDevice->byTopCCKBasicRate, PK_TYPE_11B,
1228                 (PWORD)&(wLen), (PBYTE)&(pBuf->byServiceField_b), (PBYTE)&(pBuf->bySignalField_b)
1229             );
1230             pBuf->wTransmitLength_b = cpu_to_le16(wLen);
1231             pBuf->wDuration_ba = (WORD)s_uGetRTSCTSDuration(pDevice, CTSDUR_BA, cbFrameLength, byPktType, wCurrentRate, bNeedAck, byFBOption); //3:CTSDuration_ba, 1:2.4G, 2,3:2.4G OFDM Data
1232             pBuf->wDuration_ba += pDevice->wCTSDuration;
1233             pBuf->wDuration_ba = cpu_to_le16(pBuf->wDuration_ba);
1234             //Get CTSDuration_ba_f0
1235             pBuf->wCTSDuration_ba_f0 = (WORD)s_uGetRTSCTSDuration(pDevice, CTSDUR_BA_F0, cbFrameLength, byPktType, wCurrentRate, bNeedAck, byFBOption); //8:CTSDuration_ba_f0, 1:2.4G, 2,3:2.4G OFDM Data
1236             pBuf->wCTSDuration_ba_f0 += pDevice->wCTSDuration;
1237             pBuf->wCTSDuration_ba_f0 = cpu_to_le16(pBuf->wCTSDuration_ba_f0);
1238             //Get CTSDuration_ba_f1
1239             pBuf->wCTSDuration_ba_f1 = (WORD)s_uGetRTSCTSDuration(pDevice, CTSDUR_BA_F1, cbFrameLength, byPktType, wCurrentRate, bNeedAck, byFBOption); //9:CTSDuration_ba_f1, 1:2.4G, 2,3:2.4G OFDM Data
1240             pBuf->wCTSDuration_ba_f1 += pDevice->wCTSDuration;
1241             pBuf->wCTSDuration_ba_f1 = cpu_to_le16(pBuf->wCTSDuration_ba_f1);
1242             //Get CTS Frame body
1243             pBuf->Data.wDurationID = pBuf->wDuration_ba;
1244             pBuf->Data.wFrameControl = TYPE_CTL_CTS;//0x00C4
1245             pBuf->Data.wReserved = 0x0000;
1246         memcpy(&(pBuf->Data.abyRA[0]),
1247                &(pDevice->abyCurrentNetAddr[0]),
1248                ETH_ALEN);
1249         } else { //if (byFBOption != AUTO_FB_NONE && uDMAIdx != TYPE_ATIMDMA && uDMAIdx != TYPE_BEACONDMA)
1250             PSCTS pBuf = (PSCTS)pvCTS;
1251             //Get SignalField,ServiceField,Length
1252             BBvCaculateParameter(pDevice, uCTSFrameLen, pDevice->byTopCCKBasicRate, PK_TYPE_11B,
1253                 (PWORD)&(wLen), (PBYTE)&(pBuf->byServiceField_b), (PBYTE)&(pBuf->bySignalField_b)
1254             );
1255             pBuf->wTransmitLength_b = cpu_to_le16(wLen);
1256             //Get CTSDuration_ba
1257             pBuf->wDuration_ba = cpu_to_le16((WORD)s_uGetRTSCTSDuration(pDevice, CTSDUR_BA, cbFrameLength, byPktType, wCurrentRate, bNeedAck, byFBOption)); //3:CTSDuration_ba, 1:2.4G, 2,3:2.4G OFDM Data
1258             pBuf->wDuration_ba += pDevice->wCTSDuration;
1259             pBuf->wDuration_ba = cpu_to_le16(pBuf->wDuration_ba);
1260
1261             //Get CTS Frame body
1262             pBuf->Data.wDurationID = pBuf->wDuration_ba;
1263             pBuf->Data.wFrameControl = TYPE_CTL_CTS;//0x00C4
1264             pBuf->Data.wReserved = 0x0000;
1265         memcpy(&(pBuf->Data.abyRA[0]),
1266                &(pDevice->abyCurrentNetAddr[0]),
1267                ETH_ALEN);
1268         }
1269     }
1270 }
1271
1272 /*+
1273  *
1274  * Description:
1275  *      Generate FIFO control for MAC & Baseband controller
1276  *
1277  * Parameters:
1278  *  In:
1279  *      pDevice         - Pointer to adpater
1280  *      pTxDataHead     - Transmit Data Buffer
1281  *      pTxBufHead      - pTxBufHead
1282  *      pvRrvTime        - pvRrvTime
1283  *      pvRTS            - RTS Buffer
1284  *      pCTS            - CTS Buffer
1285  *      cbFrameSize     - Transmit Data Length (Hdr+Payload+FCS)
1286  *      bNeedACK        - If need ACK
1287  *      uDMAIdx         - DMA Index
1288  *  Out:
1289  *      none
1290  *
1291  * Return Value: none
1292  *
1293 -*/
1294
1295 static
1296 void
1297 s_vGenerateTxParameter (
1298      PSDevice         pDevice,
1299      BYTE             byPktType,
1300      WORD             wCurrentRate,
1301      void *pTxBufHead,
1302      void *pvRrvTime,
1303      void *pvRTS,
1304      void *pvCTS,
1305      unsigned int             cbFrameSize,
1306      BOOL             bNeedACK,
1307      unsigned int             uDMAIdx,
1308      PSEthernetHeader psEthHeader
1309     )
1310 {
1311         unsigned int cbMACHdLen = WLAN_HDR_ADDR3_LEN; /* 24 */
1312     WORD wFifoCtl;
1313     BOOL bDisCRC = FALSE;
1314     BYTE byFBOption = AUTO_FB_NONE;
1315 //    WORD wCurrentRate = pDevice->wCurrentRate;
1316
1317     //DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"s_vGenerateTxParameter...\n");
1318     PSTxBufHead pFifoHead = (PSTxBufHead)pTxBufHead;
1319     pFifoHead->wReserved = wCurrentRate;
1320     wFifoCtl = pFifoHead->wFIFOCtl;
1321
1322     if (wFifoCtl & FIFOCTL_CRCDIS) {
1323         bDisCRC = TRUE;
1324     }
1325
1326     if (wFifoCtl & FIFOCTL_AUTO_FB_0) {
1327         byFBOption = AUTO_FB_0;
1328     }
1329     else if (wFifoCtl & FIFOCTL_AUTO_FB_1) {
1330         byFBOption = AUTO_FB_1;
1331     }
1332
1333     if (pDevice->bLongHeader)
1334         cbMACHdLen = WLAN_HDR_ADDR3_LEN + 6;
1335
1336     if (byPktType == PK_TYPE_11GB || byPktType == PK_TYPE_11GA) {
1337
1338         if (pvRTS != NULL) { //RTS_need
1339             //Fill RsvTime
1340             if (pvRrvTime) {
1341                 PSRrvTime_gRTS pBuf = (PSRrvTime_gRTS)pvRrvTime;
1342                 pBuf->wRTSTxRrvTime_aa = cpu_to_le16((WORD)s_uGetRTSCTSRsvTime(pDevice, 2, byPktType, cbFrameSize, wCurrentRate));//2:RTSTxRrvTime_aa, 1:2.4GHz
1343                 pBuf->wRTSTxRrvTime_ba = cpu_to_le16((WORD)s_uGetRTSCTSRsvTime(pDevice, 1, byPktType, cbFrameSize, wCurrentRate));//1:RTSTxRrvTime_ba, 1:2.4GHz
1344                 pBuf->wRTSTxRrvTime_bb = cpu_to_le16((WORD)s_uGetRTSCTSRsvTime(pDevice, 0, byPktType, cbFrameSize, wCurrentRate));//0:RTSTxRrvTime_bb, 1:2.4GHz
1345                 pBuf->wTxRrvTime_a = cpu_to_le16((WORD) s_uGetTxRsvTime(pDevice, byPktType, cbFrameSize, wCurrentRate, bNeedACK));//2.4G OFDM
1346                 pBuf->wTxRrvTime_b = cpu_to_le16((WORD) s_uGetTxRsvTime(pDevice, PK_TYPE_11B, cbFrameSize, pDevice->byTopCCKBasicRate, bNeedACK));//1:CCK
1347             }
1348             //Fill RTS
1349             s_vFillRTSHead(pDevice, byPktType, pvRTS, cbFrameSize, bNeedACK, bDisCRC, psEthHeader, wCurrentRate, byFBOption);
1350         }
1351         else {//RTS_needless, PCF mode
1352
1353             //Fill RsvTime
1354             if (pvRrvTime) {
1355                 PSRrvTime_gCTS pBuf = (PSRrvTime_gCTS)pvRrvTime;
1356                 pBuf->wTxRrvTime_a = cpu_to_le16((WORD)s_uGetTxRsvTime(pDevice, byPktType, cbFrameSize, wCurrentRate, bNeedACK));//2.4G OFDM
1357                 pBuf->wTxRrvTime_b = cpu_to_le16((WORD)s_uGetTxRsvTime(pDevice, PK_TYPE_11B, cbFrameSize, pDevice->byTopCCKBasicRate, bNeedACK));//1:CCK
1358                 pBuf->wCTSTxRrvTime_ba = cpu_to_le16((WORD)s_uGetRTSCTSRsvTime(pDevice, 3, byPktType, cbFrameSize, wCurrentRate));//3:CTSTxRrvTime_Ba, 1:2.4GHz
1359             }
1360             //Fill CTS
1361             s_vFillCTSHead(pDevice, uDMAIdx, byPktType, pvCTS, cbFrameSize, bNeedACK, bDisCRC, wCurrentRate, byFBOption);
1362         }
1363     }
1364     else if (byPktType == PK_TYPE_11A) {
1365
1366         if (pvRTS != NULL) {//RTS_need, non PCF mode
1367             //Fill RsvTime
1368             if (pvRrvTime) {
1369                 PSRrvTime_ab pBuf = (PSRrvTime_ab)pvRrvTime;
1370                 pBuf->wRTSTxRrvTime = cpu_to_le16((WORD)s_uGetRTSCTSRsvTime(pDevice, 2, byPktType, cbFrameSize, wCurrentRate));//2:RTSTxRrvTime_aa, 0:5GHz
1371                 pBuf->wTxRrvTime = cpu_to_le16((WORD)s_uGetTxRsvTime(pDevice, byPktType, cbFrameSize, wCurrentRate, bNeedACK));//0:OFDM
1372             }
1373             //Fill RTS
1374             s_vFillRTSHead(pDevice, byPktType, pvRTS, cbFrameSize, bNeedACK, bDisCRC, psEthHeader, wCurrentRate, byFBOption);
1375         }
1376         else if (pvRTS == NULL) {//RTS_needless, non PCF mode
1377             //Fill RsvTime
1378             if (pvRrvTime) {
1379                 PSRrvTime_ab pBuf = (PSRrvTime_ab)pvRrvTime;
1380                 pBuf->wTxRrvTime = cpu_to_le16((WORD)s_uGetTxRsvTime(pDevice, PK_TYPE_11A, cbFrameSize, wCurrentRate, bNeedACK)); //0:OFDM
1381             }
1382         }
1383     }
1384     else if (byPktType == PK_TYPE_11B) {
1385
1386         if ((pvRTS != NULL)) {//RTS_need, non PCF mode
1387             //Fill RsvTime
1388             if (pvRrvTime) {
1389                 PSRrvTime_ab pBuf = (PSRrvTime_ab)pvRrvTime;
1390                 pBuf->wRTSTxRrvTime = cpu_to_le16((WORD)s_uGetRTSCTSRsvTime(pDevice, 0, byPktType, cbFrameSize, wCurrentRate));//0:RTSTxRrvTime_bb, 1:2.4GHz
1391                 pBuf->wTxRrvTime = cpu_to_le16((WORD)s_uGetTxRsvTime(pDevice, PK_TYPE_11B, cbFrameSize, wCurrentRate, bNeedACK));//1:CCK
1392             }
1393             //Fill RTS
1394             s_vFillRTSHead(pDevice, byPktType, pvRTS, cbFrameSize, bNeedACK, bDisCRC, psEthHeader, wCurrentRate, byFBOption);
1395         }
1396         else { //RTS_needless, non PCF mode
1397             //Fill RsvTime
1398             if (pvRrvTime) {
1399                 PSRrvTime_ab pBuf = (PSRrvTime_ab)pvRrvTime;
1400                 pBuf->wTxRrvTime = cpu_to_le16((WORD)s_uGetTxRsvTime(pDevice, PK_TYPE_11B, cbFrameSize, wCurrentRate, bNeedACK)); //1:CCK
1401             }
1402         }
1403     }
1404     //DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"s_vGenerateTxParameter END.\n");
1405 }
1406 /*
1407     PBYTE pbyBuffer,//point to pTxBufHead
1408     WORD  wFragType,//00:Non-Frag, 01:Start, 02:Mid, 03:Last
1409     unsigned int  cbFragmentSize,//Hdr+payoad+FCS
1410 */
1411
1412
1413 BOOL
1414 s_bPacketToWirelessUsb(
1415       PSDevice         pDevice,
1416       BYTE             byPktType,
1417       PBYTE            usbPacketBuf,
1418       BOOL             bNeedEncryption,
1419       unsigned int             uSkbPacketLen,
1420       unsigned int             uDMAIdx,
1421       PSEthernetHeader psEthHeader,
1422       PBYTE            pPacket,
1423       PSKeyItem        pTransmitKey,
1424       unsigned int             uNodeIndex,
1425       WORD             wCurrentRate,
1426      unsigned int             *pcbHeaderLen,
1427      unsigned int             *pcbTotalLen
1428     )
1429 {
1430     PSMgmtObject        pMgmt = &(pDevice->sMgmtObj);
1431     unsigned int cbFrameSize, cbFrameBodySize;
1432     PTX_BUFFER          pTxBufHead;
1433     unsigned int cb802_1_H_len;
1434     unsigned int cbIVlen = 0, cbICVlen = 0, cbMIClen = 0,
1435             cbMACHdLen = 0, cbFCSlen = 4;
1436     unsigned int cbMICHDR = 0;
1437     BOOL                bNeedACK,bRTS;
1438     PBYTE               pbyType,pbyMacHdr,pbyIVHead,pbyPayloadHead,pbyTxBufferAddr;
1439     BYTE abySNAP_RFC1042[ETH_ALEN] = {0xAA, 0xAA, 0x03, 0x00, 0x00, 0x00};
1440     BYTE abySNAP_Bridgetunnel[ETH_ALEN] = {0xAA, 0xAA, 0x03, 0x00, 0x00, 0xF8};
1441     unsigned int uDuration;
1442     unsigned int cbHeaderLength = 0, uPadding = 0;
1443     void *pvRrvTime;
1444     PSMICHDRHead        pMICHDR;
1445     void *pvRTS;
1446     void *pvCTS;
1447     void *pvTxDataHd;
1448     BYTE                byFBOption = AUTO_FB_NONE,byFragType;
1449     WORD                wTxBufSize;
1450     DWORD               dwMICKey0,dwMICKey1,dwMIC_Priority,dwCRC;
1451     PDWORD              pdwMIC_L,pdwMIC_R;
1452     BOOL                bSoftWEP = FALSE;
1453
1454
1455
1456
1457     pvRrvTime = pMICHDR = pvRTS = pvCTS = pvTxDataHd = NULL;
1458     if ((bNeedEncryption) && (pTransmitKey != NULL))  {
1459         if (((PSKeyTable) (pTransmitKey->pvKeyTable))->bSoftWEP == TRUE) {
1460             // WEP 256
1461             bSoftWEP = TRUE;
1462         }
1463     }
1464
1465     pTxBufHead = (PTX_BUFFER) usbPacketBuf;
1466     memset(pTxBufHead, 0, sizeof(TX_BUFFER));
1467
1468     // Get pkt type
1469     if (ntohs(psEthHeader->wType) > ETH_DATA_LEN) {
1470         if (pDevice->dwDiagRefCount == 0) {
1471             cb802_1_H_len = 8;
1472         } else {
1473             cb802_1_H_len = 2;
1474         }
1475     } else {
1476         cb802_1_H_len = 0;
1477     }
1478
1479     cbFrameBodySize = uSkbPacketLen - ETH_HLEN + cb802_1_H_len;
1480
1481     //Set packet type
1482     pTxBufHead->wFIFOCtl |= (WORD)(byPktType<<8);
1483
1484     if (pDevice->dwDiagRefCount != 0) {
1485         bNeedACK = FALSE;
1486         pTxBufHead->wFIFOCtl = pTxBufHead->wFIFOCtl & (~FIFOCTL_NEEDACK);
1487     } else { //if (pDevice->dwDiagRefCount != 0) {
1488         if ((pDevice->eOPMode == OP_MODE_ADHOC) ||
1489             (pDevice->eOPMode == OP_MODE_AP)) {
1490                 if (is_multicast_ether_addr(psEthHeader->abyDstAddr)) {
1491                         bNeedACK = FALSE;
1492                         pTxBufHead->wFIFOCtl =
1493                                 pTxBufHead->wFIFOCtl & (~FIFOCTL_NEEDACK);
1494                 } else {
1495                         bNeedACK = TRUE;
1496                         pTxBufHead->wFIFOCtl |= FIFOCTL_NEEDACK;
1497                 }
1498         }
1499         else {
1500             // MSDUs in Infra mode always need ACK
1501             bNeedACK = TRUE;
1502             pTxBufHead->wFIFOCtl |= FIFOCTL_NEEDACK;
1503         }
1504     } //if (pDevice->dwDiagRefCount != 0) {
1505
1506     pTxBufHead->wTimeStamp = DEFAULT_MSDU_LIFETIME_RES_64us;
1507
1508     //Set FIFOCTL_LHEAD
1509     if (pDevice->bLongHeader)
1510         pTxBufHead->wFIFOCtl |= FIFOCTL_LHEAD;
1511
1512     if (pDevice->bSoftwareGenCrcErr) {
1513         pTxBufHead->wFIFOCtl |= FIFOCTL_CRCDIS; // set tx descriptors to NO hardware CRC
1514     }
1515
1516     //Set FRAGCTL_MACHDCNT
1517     if (pDevice->bLongHeader) {
1518         cbMACHdLen = WLAN_HDR_ADDR3_LEN + 6;
1519     } else {
1520         cbMACHdLen = WLAN_HDR_ADDR3_LEN;
1521     }
1522     pTxBufHead->wFragCtl |= (WORD)(cbMACHdLen << 10);
1523
1524     //Set FIFOCTL_GrpAckPolicy
1525     if (pDevice->bGrpAckPolicy == TRUE) {//0000 0100 0000 0000
1526         pTxBufHead->wFIFOCtl |= FIFOCTL_GRPACK;
1527     }
1528
1529     //Set Auto Fallback Ctl
1530     if (wCurrentRate >= RATE_18M) {
1531         if (pDevice->byAutoFBCtrl == AUTO_FB_0) {
1532             pTxBufHead->wFIFOCtl |= FIFOCTL_AUTO_FB_0;
1533             byFBOption = AUTO_FB_0;
1534         } else if (pDevice->byAutoFBCtrl == AUTO_FB_1) {
1535             pTxBufHead->wFIFOCtl |= FIFOCTL_AUTO_FB_1;
1536             byFBOption = AUTO_FB_1;
1537         }
1538     }
1539
1540     if (bSoftWEP != TRUE) {
1541         if ((bNeedEncryption) && (pTransmitKey != NULL))  { //WEP enabled
1542             if (pTransmitKey->byCipherSuite == KEY_CTL_WEP) { //WEP40 or WEP104
1543                 pTxBufHead->wFragCtl |= FRAGCTL_LEGACY;
1544             }
1545             if (pTransmitKey->byCipherSuite == KEY_CTL_TKIP) {
1546                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Tx Set wFragCtl == FRAGCTL_TKIP\n");
1547                 pTxBufHead->wFragCtl |= FRAGCTL_TKIP;
1548             }
1549             else if (pTransmitKey->byCipherSuite == KEY_CTL_CCMP) { //CCMP
1550                 pTxBufHead->wFragCtl |= FRAGCTL_AES;
1551             }
1552         }
1553     }
1554
1555
1556     if ((bNeedEncryption) && (pTransmitKey != NULL))  {
1557         if (pTransmitKey->byCipherSuite == KEY_CTL_WEP) {
1558             cbIVlen = 4;
1559             cbICVlen = 4;
1560         }
1561         else if (pTransmitKey->byCipherSuite == KEY_CTL_TKIP) {
1562             cbIVlen = 8;//IV+ExtIV
1563             cbMIClen = 8;
1564             cbICVlen = 4;
1565         }
1566         if (pTransmitKey->byCipherSuite == KEY_CTL_CCMP) {
1567             cbIVlen = 8;//RSN Header
1568             cbICVlen = 8;//MIC
1569             cbMICHDR = sizeof(SMICHDRHead);
1570         }
1571         if (bSoftWEP == FALSE) {
1572             //MAC Header should be padding 0 to DW alignment.
1573             uPadding = 4 - (cbMACHdLen%4);
1574             uPadding %= 4;
1575         }
1576     }
1577
1578     cbFrameSize = cbMACHdLen + cbIVlen + (cbFrameBodySize + cbMIClen) + cbICVlen + cbFCSlen;
1579
1580     if ( (bNeedACK == FALSE) ||(cbFrameSize < pDevice->wRTSThreshold) ) {
1581         bRTS = FALSE;
1582     } else {
1583         bRTS = TRUE;
1584         pTxBufHead->wFIFOCtl |= (FIFOCTL_RTS | FIFOCTL_LRETRY);
1585     }
1586
1587     pbyTxBufferAddr = (PBYTE) &(pTxBufHead->adwTxKey[0]);
1588     wTxBufSize = sizeof(STxBufHead);
1589     if (byPktType == PK_TYPE_11GB || byPktType == PK_TYPE_11GA) {//802.11g packet
1590         if (byFBOption == AUTO_FB_NONE) {
1591             if (bRTS == TRUE) {//RTS_need
1592                 pvRrvTime = (PSRrvTime_gRTS) (pbyTxBufferAddr + wTxBufSize);
1593                 pMICHDR = (PSMICHDRHead) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_gRTS));
1594                 pvRTS = (PSRTS_g) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_gRTS) + cbMICHDR);
1595                 pvCTS = NULL;
1596                 pvTxDataHd = (PSTxDataHead_g) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_gRTS) + cbMICHDR + sizeof(SRTS_g));
1597                 cbHeaderLength = wTxBufSize + sizeof(SRrvTime_gRTS) + cbMICHDR + sizeof(SRTS_g) + sizeof(STxDataHead_g);
1598             }
1599             else { //RTS_needless
1600                 pvRrvTime = (PSRrvTime_gCTS) (pbyTxBufferAddr + wTxBufSize);
1601                 pMICHDR = (PSMICHDRHead) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_gCTS));
1602                 pvRTS = NULL;
1603                 pvCTS = (PSCTS) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_gCTS) + cbMICHDR);
1604                 pvTxDataHd = (PSTxDataHead_g) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_gCTS) + cbMICHDR + sizeof(SCTS));
1605                 cbHeaderLength = wTxBufSize + sizeof(SRrvTime_gCTS) + cbMICHDR + sizeof(SCTS) + sizeof(STxDataHead_g);
1606             }
1607         } else {
1608             // Auto Fall Back
1609             if (bRTS == TRUE) {//RTS_need
1610                 pvRrvTime = (PSRrvTime_gRTS) (pbyTxBufferAddr + wTxBufSize);
1611                 pMICHDR = (PSMICHDRHead) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_gRTS));
1612                 pvRTS = (PSRTS_g_FB) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_gRTS) + cbMICHDR);
1613                 pvCTS = NULL;
1614                 pvTxDataHd = (PSTxDataHead_g_FB) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_gRTS) + cbMICHDR + sizeof(SRTS_g_FB));
1615                 cbHeaderLength = wTxBufSize + sizeof(SRrvTime_gRTS) + cbMICHDR + sizeof(SRTS_g_FB) + sizeof(STxDataHead_g_FB);
1616             }
1617             else if (bRTS == FALSE) { //RTS_needless
1618                 pvRrvTime = (PSRrvTime_gCTS) (pbyTxBufferAddr + wTxBufSize);
1619                 pMICHDR = (PSMICHDRHead) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_gCTS));
1620                 pvRTS = NULL;
1621                 pvCTS = (PSCTS_FB) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_gCTS) + cbMICHDR);
1622                 pvTxDataHd = (PSTxDataHead_g_FB) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_gCTS) + cbMICHDR + sizeof(SCTS_FB));
1623                 cbHeaderLength = wTxBufSize + sizeof(SRrvTime_gCTS) + cbMICHDR + sizeof(SCTS_FB) + sizeof(STxDataHead_g_FB);
1624             }
1625         } // Auto Fall Back
1626     }
1627     else {//802.11a/b packet
1628         if (byFBOption == AUTO_FB_NONE) {
1629             if (bRTS == TRUE) {//RTS_need
1630                 pvRrvTime = (PSRrvTime_ab) (pbyTxBufferAddr + wTxBufSize);
1631                 pMICHDR = (PSMICHDRHead) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_ab));
1632                 pvRTS = (PSRTS_ab) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_ab) + cbMICHDR);
1633                 pvCTS = NULL;
1634                 pvTxDataHd = (PSTxDataHead_ab) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_ab) + cbMICHDR + sizeof(SRTS_ab));
1635                 cbHeaderLength = wTxBufSize + sizeof(PSRrvTime_ab) + cbMICHDR + sizeof(SRTS_ab) + sizeof(STxDataHead_ab);
1636             }
1637             else if (bRTS == FALSE) { //RTS_needless, no MICHDR
1638                 pvRrvTime = (PSRrvTime_ab) (pbyTxBufferAddr + wTxBufSize);
1639                 pMICHDR = (PSMICHDRHead) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_ab));
1640                 pvRTS = NULL;
1641                 pvCTS = NULL;
1642                 pvTxDataHd = (PSTxDataHead_ab) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_ab) + cbMICHDR);
1643                 cbHeaderLength = wTxBufSize + sizeof(SRrvTime_ab) + cbMICHDR + sizeof(STxDataHead_ab);
1644             }
1645         } else {
1646             // Auto Fall Back
1647             if (bRTS == TRUE) {//RTS_need
1648                 pvRrvTime = (PSRrvTime_ab) (pbyTxBufferAddr + wTxBufSize);
1649                 pMICHDR = (PSMICHDRHead) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_ab));
1650                 pvRTS = (PSRTS_a_FB) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_ab) + cbMICHDR);
1651                 pvCTS = NULL;
1652                 pvTxDataHd = (PSTxDataHead_a_FB) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_ab) + cbMICHDR + sizeof(SRTS_a_FB));
1653                 cbHeaderLength = wTxBufSize + sizeof(PSRrvTime_ab) + cbMICHDR + sizeof(SRTS_a_FB) + sizeof(STxDataHead_a_FB);
1654             }
1655             else if (bRTS == FALSE) { //RTS_needless
1656                 pvRrvTime = (PSRrvTime_ab) (pbyTxBufferAddr + wTxBufSize);
1657                 pMICHDR = (PSMICHDRHead) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_ab));
1658                 pvRTS = NULL;
1659                 pvCTS = NULL;
1660                 pvTxDataHd = (PSTxDataHead_a_FB) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_ab) + cbMICHDR);
1661                 cbHeaderLength = wTxBufSize + sizeof(SRrvTime_ab) + cbMICHDR + sizeof(STxDataHead_a_FB);
1662             }
1663         } // Auto Fall Back
1664     }
1665
1666     pbyMacHdr = (PBYTE)(pbyTxBufferAddr + cbHeaderLength);
1667     pbyIVHead = (PBYTE)(pbyMacHdr + cbMACHdLen + uPadding);
1668     pbyPayloadHead = (PBYTE)(pbyMacHdr + cbMACHdLen + uPadding + cbIVlen);
1669
1670
1671     //=========================
1672     //    No Fragmentation
1673     //=========================
1674     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"No Fragmentation...\n");
1675     byFragType = FRAGCTL_NONFRAG;
1676     //uDMAIdx = TYPE_AC0DMA;
1677     //pTxBufHead = (PSTxBufHead) &(pTxBufHead->adwTxKey[0]);
1678
1679
1680     //Fill FIFO,RrvTime,RTS,and CTS
1681     s_vGenerateTxParameter(pDevice, byPktType, wCurrentRate,
1682                            (void *)pbyTxBufferAddr, pvRrvTime, pvRTS, pvCTS,
1683                                cbFrameSize, bNeedACK, uDMAIdx, psEthHeader);
1684     //Fill DataHead
1685     uDuration = s_uFillDataHead(pDevice, byPktType, wCurrentRate, pvTxDataHd, cbFrameSize, uDMAIdx, bNeedACK,
1686                                     0, 0, 1/*uMACfragNum*/, byFBOption);
1687     // Generate TX MAC Header
1688     s_vGenerateMACHeader(pDevice, pbyMacHdr, (WORD)uDuration, psEthHeader, bNeedEncryption,
1689                            byFragType, uDMAIdx, 0);
1690
1691     if (bNeedEncryption == TRUE) {
1692         //Fill TXKEY
1693         s_vFillTxKey(pDevice, (PBYTE)(pTxBufHead->adwTxKey), pbyIVHead, pTransmitKey,
1694                          pbyMacHdr, (WORD)cbFrameBodySize, (PBYTE)pMICHDR);
1695
1696         if (pDevice->bEnableHostWEP) {
1697             pMgmt->sNodeDBTable[uNodeIndex].dwTSC47_16 = pTransmitKey->dwTSC47_16;
1698             pMgmt->sNodeDBTable[uNodeIndex].wTSC15_0 = pTransmitKey->wTSC15_0;
1699         }
1700     }
1701
1702     // 802.1H
1703     if (ntohs(psEthHeader->wType) > ETH_DATA_LEN) {
1704         if (pDevice->dwDiagRefCount == 0) {
1705                 if ((psEthHeader->wType == cpu_to_be16(ETH_P_IPX)) ||
1706                     (psEthHeader->wType == cpu_to_le16(0xF380))) {
1707                         memcpy((PBYTE) (pbyPayloadHead),
1708                                abySNAP_Bridgetunnel, 6);
1709             } else {
1710                 memcpy((PBYTE) (pbyPayloadHead), &abySNAP_RFC1042[0], 6);
1711             }
1712             pbyType = (PBYTE) (pbyPayloadHead + 6);
1713             memcpy(pbyType, &(psEthHeader->wType), sizeof(WORD));
1714         } else {
1715             memcpy((PBYTE) (pbyPayloadHead), &(psEthHeader->wType), sizeof(WORD));
1716
1717         }
1718
1719     }
1720
1721
1722     if (pPacket != NULL) {
1723         // Copy the Packet into a tx Buffer
1724         memcpy((pbyPayloadHead + cb802_1_H_len),
1725                  (pPacket + ETH_HLEN),
1726                  uSkbPacketLen - ETH_HLEN
1727                  );
1728
1729     } else {
1730         // while bRelayPacketSend psEthHeader is point to header+payload
1731         memcpy((pbyPayloadHead + cb802_1_H_len), ((PBYTE)psEthHeader) + ETH_HLEN, uSkbPacketLen - ETH_HLEN);
1732     }
1733
1734     ASSERT(uLength == cbNdisBodySize);
1735
1736     if ((bNeedEncryption == TRUE) && (pTransmitKey != NULL) && (pTransmitKey->byCipherSuite == KEY_CTL_TKIP)) {
1737
1738         ///////////////////////////////////////////////////////////////////
1739
1740         if (pDevice->sMgmtObj.eAuthenMode == WMAC_AUTH_WPANONE) {
1741             dwMICKey0 = *(PDWORD)(&pTransmitKey->abyKey[16]);
1742             dwMICKey1 = *(PDWORD)(&pTransmitKey->abyKey[20]);
1743         }
1744         else if ((pTransmitKey->dwKeyIndex & AUTHENTICATOR_KEY) != 0) {
1745             dwMICKey0 = *(PDWORD)(&pTransmitKey->abyKey[16]);
1746             dwMICKey1 = *(PDWORD)(&pTransmitKey->abyKey[20]);
1747         }
1748         else {
1749             dwMICKey0 = *(PDWORD)(&pTransmitKey->abyKey[24]);
1750             dwMICKey1 = *(PDWORD)(&pTransmitKey->abyKey[28]);
1751         }
1752         // DO Software Michael
1753         MIC_vInit(dwMICKey0, dwMICKey1);
1754         MIC_vAppend((PBYTE)&(psEthHeader->abyDstAddr[0]), 12);
1755         dwMIC_Priority = 0;
1756         MIC_vAppend((PBYTE)&dwMIC_Priority, 4);
1757         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"MIC KEY: %X, %X\n",
1758                 dwMICKey0, dwMICKey1);
1759
1760         ///////////////////////////////////////////////////////////////////
1761
1762         //DBG_PRN_GRP12(("Length:%d, %d\n", cbFrameBodySize, uFromHDtoPLDLength));
1763         //for (ii = 0; ii < cbFrameBodySize; ii++) {
1764         //    DBG_PRN_GRP12(("%02x ", *((PBYTE)((pbyPayloadHead + cb802_1_H_len) + ii))));
1765         //}
1766         //DBG_PRN_GRP12(("\n\n\n"));
1767
1768         MIC_vAppend(pbyPayloadHead, cbFrameBodySize);
1769
1770         pdwMIC_L = (PDWORD)(pbyPayloadHead + cbFrameBodySize);
1771         pdwMIC_R = (PDWORD)(pbyPayloadHead + cbFrameBodySize + 4);
1772
1773         MIC_vGetMIC(pdwMIC_L, pdwMIC_R);
1774         MIC_vUnInit();
1775
1776         if (pDevice->bTxMICFail == TRUE) {
1777             *pdwMIC_L = 0;
1778             *pdwMIC_R = 0;
1779             pDevice->bTxMICFail = FALSE;
1780         }
1781         //DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"uLength: %d, %d\n", uLength, cbFrameBodySize);
1782         //DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"cbReqCount:%d, %d, %d, %d\n", cbReqCount, cbHeaderLength, uPadding, cbIVlen);
1783         //DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"MIC:%lX, %lX\n", *pdwMIC_L, *pdwMIC_R);
1784     }
1785
1786
1787     if (bSoftWEP == TRUE) {
1788
1789         s_vSWencryption(pDevice, pTransmitKey, (pbyPayloadHead), (WORD)(cbFrameBodySize + cbMIClen));
1790
1791     } else if (  ((pDevice->eEncryptionStatus == Ndis802_11Encryption1Enabled) && (bNeedEncryption == TRUE))  ||
1792           ((pDevice->eEncryptionStatus == Ndis802_11Encryption2Enabled) && (bNeedEncryption == TRUE))   ||
1793           ((pDevice->eEncryptionStatus == Ndis802_11Encryption3Enabled) && (bNeedEncryption == TRUE))      ) {
1794         cbFrameSize -= cbICVlen;
1795     }
1796
1797     if (pDevice->bSoftwareGenCrcErr == TRUE) {
1798         unsigned int cbLen;
1799         PDWORD pdwCRC;
1800
1801         dwCRC = 0xFFFFFFFFL;
1802         cbLen = cbFrameSize - cbFCSlen;
1803         // calculate CRC, and wrtie CRC value to end of TD
1804         dwCRC = CRCdwGetCrc32Ex(pbyMacHdr, cbLen, dwCRC);
1805         pdwCRC = (PDWORD)(pbyMacHdr + cbLen);
1806         // finally, we must invert dwCRC to get the correct answer
1807         *pdwCRC = ~dwCRC;
1808         // Force Error
1809         *pdwCRC -= 1;
1810     } else {
1811         cbFrameSize -= cbFCSlen;
1812     }
1813
1814     *pcbHeaderLen = cbHeaderLength;
1815     *pcbTotalLen = cbHeaderLength + cbFrameSize ;
1816
1817
1818     //Set FragCtl in TxBufferHead
1819     pTxBufHead->wFragCtl |= (WORD)byFragType;
1820
1821
1822     return TRUE;
1823
1824 }
1825
1826
1827 /*+
1828  *
1829  * Description:
1830  *      Translate 802.3 to 802.11 header
1831  *
1832  * Parameters:
1833  *  In:
1834  *      pDevice         - Pointer to adpater
1835  *      dwTxBufferAddr  - Transmit Buffer
1836  *      pPacket         - Packet from upper layer
1837  *      cbPacketSize    - Transmit Data Length
1838  *  Out:
1839  *      pcbHeadSize         - Header size of MAC&Baseband control and 802.11 Header
1840  *      pcbAppendPayload    - size of append payload for 802.1H translation
1841  *
1842  * Return Value: none
1843  *
1844 -*/
1845
1846 void
1847 s_vGenerateMACHeader (
1848      PSDevice         pDevice,
1849      PBYTE            pbyBufferAddr,
1850      WORD             wDuration,
1851      PSEthernetHeader psEthHeader,
1852      BOOL             bNeedEncrypt,
1853      WORD             wFragType,
1854      unsigned int             uDMAIdx,
1855      unsigned int             uFragIdx
1856     )
1857 {
1858     PS802_11Header  pMACHeader = (PS802_11Header)pbyBufferAddr;
1859
1860     memset(pMACHeader, 0, (sizeof(S802_11Header)));  //- sizeof(pMACHeader->dwIV)));
1861
1862     if (uDMAIdx == TYPE_ATIMDMA) {
1863         pMACHeader->wFrameCtl = TYPE_802_11_ATIM;
1864     } else {
1865         pMACHeader->wFrameCtl = TYPE_802_11_DATA;
1866     }
1867
1868     if (pDevice->eOPMode == OP_MODE_AP) {
1869         memcpy(&(pMACHeader->abyAddr1[0]),
1870                &(psEthHeader->abyDstAddr[0]),
1871                ETH_ALEN);
1872         memcpy(&(pMACHeader->abyAddr2[0]), &(pDevice->abyBSSID[0]), ETH_ALEN);
1873         memcpy(&(pMACHeader->abyAddr3[0]),
1874                &(psEthHeader->abySrcAddr[0]),
1875                ETH_ALEN);
1876         pMACHeader->wFrameCtl |= FC_FROMDS;
1877     } else {
1878         if (pDevice->eOPMode == OP_MODE_ADHOC) {
1879                 memcpy(&(pMACHeader->abyAddr1[0]),
1880                        &(psEthHeader->abyDstAddr[0]),
1881                        ETH_ALEN);
1882                 memcpy(&(pMACHeader->abyAddr2[0]),
1883                        &(psEthHeader->abySrcAddr[0]),
1884                        ETH_ALEN);
1885                 memcpy(&(pMACHeader->abyAddr3[0]),
1886                        &(pDevice->abyBSSID[0]),
1887                        ETH_ALEN);
1888         } else {
1889                 memcpy(&(pMACHeader->abyAddr3[0]),
1890                        &(psEthHeader->abyDstAddr[0]),
1891                        ETH_ALEN);
1892                 memcpy(&(pMACHeader->abyAddr2[0]),
1893                        &(psEthHeader->abySrcAddr[0]),
1894                        ETH_ALEN);
1895                 memcpy(&(pMACHeader->abyAddr1[0]),
1896                        &(pDevice->abyBSSID[0]),
1897                        ETH_ALEN);
1898             pMACHeader->wFrameCtl |= FC_TODS;
1899         }
1900     }
1901
1902     if (bNeedEncrypt)
1903         pMACHeader->wFrameCtl |= cpu_to_le16((WORD)WLAN_SET_FC_ISWEP(1));
1904
1905     pMACHeader->wDurationID = cpu_to_le16(wDuration);
1906
1907     if (pDevice->bLongHeader) {
1908         PWLAN_80211HDR_A4 pMACA4Header  = (PWLAN_80211HDR_A4) pbyBufferAddr;
1909         pMACHeader->wFrameCtl |= (FC_TODS | FC_FROMDS);
1910         memcpy(pMACA4Header->abyAddr4, pDevice->abyBSSID, WLAN_ADDR_LEN);
1911     }
1912     pMACHeader->wSeqCtl = cpu_to_le16(pDevice->wSeqCounter << 4);
1913
1914     //Set FragNumber in Sequence Control
1915     pMACHeader->wSeqCtl |= cpu_to_le16((WORD)uFragIdx);
1916
1917     if ((wFragType == FRAGCTL_ENDFRAG) || (wFragType == FRAGCTL_NONFRAG)) {
1918         pDevice->wSeqCounter++;
1919         if (pDevice->wSeqCounter > 0x0fff)
1920             pDevice->wSeqCounter = 0;
1921     }
1922
1923     if ((wFragType == FRAGCTL_STAFRAG) || (wFragType == FRAGCTL_MIDFRAG)) { //StartFrag or MidFrag
1924         pMACHeader->wFrameCtl |= FC_MOREFRAG;
1925     }
1926 }
1927
1928
1929
1930 /*+
1931  *
1932  * Description:
1933  *      Request instructs a MAC to transmit a 802.11 management packet through
1934  *      the adapter onto the medium.
1935  *
1936  * Parameters:
1937  *  In:
1938  *      hDeviceContext  - Pointer to the adapter
1939  *      pPacket         - A pointer to a descriptor for the packet to transmit
1940  *  Out:
1941  *      none
1942  *
1943  * Return Value: CMD_STATUS_PENDING if MAC Tx resource available; otherwise FALSE
1944  *
1945 -*/
1946
1947 CMD_STATUS csMgmt_xmit(
1948       PSDevice pDevice,
1949       PSTxMgmtPacket pPacket
1950     )
1951 {
1952     BYTE            byPktType;
1953     PBYTE           pbyTxBufferAddr;
1954     void *pvRTS;
1955     PSCTS           pCTS;
1956     void *pvTxDataHd;
1957     unsigned int            uDuration;
1958     unsigned int            cbReqCount;
1959     PS802_11Header  pMACHeader;
1960     unsigned int            cbHeaderSize;
1961     unsigned int            cbFrameBodySize;
1962     BOOL            bNeedACK;
1963     BOOL            bIsPSPOLL = FALSE;
1964     PSTxBufHead     pTxBufHead;
1965     unsigned int            cbFrameSize;
1966     unsigned int            cbIVlen = 0;
1967     unsigned int            cbICVlen = 0;
1968     unsigned int            cbMIClen = 0;
1969     unsigned int            cbFCSlen = 4;
1970     unsigned int            uPadding = 0;
1971     WORD            wTxBufSize;
1972     unsigned int            cbMacHdLen;
1973     SEthernetHeader sEthHeader;
1974     void *pvRrvTime;
1975     void *pMICHDR;
1976     PSMgmtObject    pMgmt = &(pDevice->sMgmtObj);
1977     WORD            wCurrentRate = RATE_1M;
1978     PTX_BUFFER          pTX_Buffer;
1979     PUSB_SEND_CONTEXT   pContext;
1980
1981
1982
1983     pContext = (PUSB_SEND_CONTEXT)s_vGetFreeContext(pDevice);
1984
1985     if (NULL == pContext) {
1986         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"ManagementSend TX...NO CONTEXT!\n");
1987         return CMD_STATUS_RESOURCES;
1988     }
1989
1990     pTX_Buffer = (PTX_BUFFER) (&pContext->Data[0]);
1991     pbyTxBufferAddr = (PBYTE)&(pTX_Buffer->adwTxKey[0]);
1992     cbFrameBodySize = pPacket->cbPayloadLen;
1993     pTxBufHead = (PSTxBufHead) pbyTxBufferAddr;
1994     wTxBufSize = sizeof(STxBufHead);
1995     memset(pTxBufHead, 0, wTxBufSize);
1996
1997     if (pDevice->byBBType == BB_TYPE_11A) {
1998         wCurrentRate = RATE_6M;
1999         byPktType = PK_TYPE_11A;
2000     } else {
2001         wCurrentRate = RATE_1M;
2002         byPktType = PK_TYPE_11B;
2003     }
2004
2005     // SetPower will cause error power TX state for OFDM Date packet in TX buffer.
2006     // 2004.11.11 Kyle -- Using OFDM power to tx MngPkt will decrease the connection capability.
2007     //                    And cmd timer will wait data pkt TX finish before scanning so it's OK
2008     //                    to set power here.
2009     if (pMgmt->eScanState != WMAC_NO_SCANNING) {
2010         RFbSetPower(pDevice, wCurrentRate, pDevice->byCurrentCh);
2011     } else {
2012         RFbSetPower(pDevice, wCurrentRate, pMgmt->uCurrChannel);
2013     }
2014     pDevice->wCurrentRate = wCurrentRate;
2015
2016
2017     //Set packet type
2018     if (byPktType == PK_TYPE_11A) {//0000 0000 0000 0000
2019         pTxBufHead->wFIFOCtl = 0;
2020     }
2021     else if (byPktType == PK_TYPE_11B) {//0000 0001 0000 0000
2022         pTxBufHead->wFIFOCtl |= FIFOCTL_11B;
2023     }
2024     else if (byPktType == PK_TYPE_11GB) {//0000 0010 0000 0000
2025         pTxBufHead->wFIFOCtl |= FIFOCTL_11GB;
2026     }
2027     else if (byPktType == PK_TYPE_11GA) {//0000 0011 0000 0000
2028         pTxBufHead->wFIFOCtl |= FIFOCTL_11GA;
2029     }
2030
2031     pTxBufHead->wFIFOCtl |= FIFOCTL_TMOEN;
2032     pTxBufHead->wTimeStamp = cpu_to_le16(DEFAULT_MGN_LIFETIME_RES_64us);
2033
2034     if (is_multicast_ether_addr(pPacket->p80211Header->sA3.abyAddr1)) {
2035         bNeedACK = FALSE;
2036     }
2037     else {
2038         bNeedACK = TRUE;
2039         pTxBufHead->wFIFOCtl |= FIFOCTL_NEEDACK;
2040     };
2041
2042     if ((pMgmt->eCurrMode == WMAC_MODE_ESS_AP) ||
2043         (pMgmt->eCurrMode == WMAC_MODE_IBSS_STA) ) {
2044
2045         pTxBufHead->wFIFOCtl |= FIFOCTL_LRETRY;
2046         //Set Preamble type always long
2047         //pDevice->byPreambleType = PREAMBLE_LONG;
2048         // probe-response don't retry
2049         //if ((pPacket->p80211Header->sA4.wFrameCtl & TYPE_SUBTYPE_MASK) == TYPE_MGMT_PROBE_RSP) {
2050         //     bNeedACK = FALSE;
2051         //     pTxBufHead->wFIFOCtl  &= (~FIFOCTL_NEEDACK);
2052         //}
2053     }
2054
2055     pTxBufHead->wFIFOCtl |= (FIFOCTL_GENINT | FIFOCTL_ISDMA0);
2056
2057     if ((pPacket->p80211Header->sA4.wFrameCtl & TYPE_SUBTYPE_MASK) == TYPE_CTL_PSPOLL) {
2058         bIsPSPOLL = TRUE;
2059         cbMacHdLen = WLAN_HDR_ADDR2_LEN;
2060     } else {
2061         cbMacHdLen = WLAN_HDR_ADDR3_LEN;
2062     }
2063
2064     //Set FRAGCTL_MACHDCNT
2065     pTxBufHead->wFragCtl |= cpu_to_le16((WORD)(cbMacHdLen << 10));
2066
2067     // Notes:
2068     // Although spec says MMPDU can be fragmented; In most case,
2069     // no one will send a MMPDU under fragmentation. With RTS may occur.
2070     pDevice->bAES = FALSE;  //Set FRAGCTL_WEPTYP
2071
2072     if (WLAN_GET_FC_ISWEP(pPacket->p80211Header->sA4.wFrameCtl) != 0) {
2073         if (pDevice->eEncryptionStatus == Ndis802_11Encryption1Enabled) {
2074             cbIVlen = 4;
2075             cbICVlen = 4;
2076             pTxBufHead->wFragCtl |= FRAGCTL_LEGACY;
2077         }
2078         else if (pDevice->eEncryptionStatus == Ndis802_11Encryption2Enabled) {
2079             cbIVlen = 8;//IV+ExtIV
2080             cbMIClen = 8;
2081             cbICVlen = 4;
2082             pTxBufHead->wFragCtl |= FRAGCTL_TKIP;
2083             //We need to get seed here for filling TxKey entry.
2084             //TKIPvMixKey(pTransmitKey->abyKey, pDevice->abyCurrentNetAddr,
2085             //            pTransmitKey->wTSC15_0, pTransmitKey->dwTSC47_16, pDevice->abyPRNG);
2086         }
2087         else if (pDevice->eEncryptionStatus == Ndis802_11Encryption3Enabled) {
2088             cbIVlen = 8;//RSN Header
2089             cbICVlen = 8;//MIC
2090             pTxBufHead->wFragCtl |= FRAGCTL_AES;
2091             pDevice->bAES = TRUE;
2092         }
2093         //MAC Header should be padding 0 to DW alignment.
2094         uPadding = 4 - (cbMacHdLen%4);
2095         uPadding %= 4;
2096     }
2097
2098     cbFrameSize = cbMacHdLen + cbFrameBodySize + cbIVlen + cbMIClen + cbICVlen + cbFCSlen;
2099
2100     //Set FIFOCTL_GrpAckPolicy
2101     if (pDevice->bGrpAckPolicy == TRUE) {//0000 0100 0000 0000
2102         pTxBufHead->wFIFOCtl |= FIFOCTL_GRPACK;
2103     }
2104     //the rest of pTxBufHead->wFragCtl:FragTyp will be set later in s_vFillFragParameter()
2105
2106     //Set RrvTime/RTS/CTS Buffer
2107     if (byPktType == PK_TYPE_11GB || byPktType == PK_TYPE_11GA) {//802.11g packet
2108
2109         pvRrvTime = (PSRrvTime_gCTS) (pbyTxBufferAddr + wTxBufSize);
2110         pMICHDR = NULL;
2111         pvRTS = NULL;
2112         pCTS = (PSCTS) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_gCTS));
2113         pvTxDataHd = (PSTxDataHead_g) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_gCTS) + sizeof(SCTS));
2114         cbHeaderSize = wTxBufSize + sizeof(SRrvTime_gCTS) + sizeof(SCTS) + sizeof(STxDataHead_g);
2115     }
2116     else { // 802.11a/b packet
2117         pvRrvTime = (PSRrvTime_ab) (pbyTxBufferAddr + wTxBufSize);
2118         pMICHDR = NULL;
2119         pvRTS = NULL;
2120         pCTS = NULL;
2121         pvTxDataHd = (PSTxDataHead_ab) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_ab));
2122         cbHeaderSize = wTxBufSize + sizeof(SRrvTime_ab) + sizeof(STxDataHead_ab);
2123     }
2124
2125     memset((void *)(pbyTxBufferAddr + wTxBufSize), 0,
2126            (cbHeaderSize - wTxBufSize));
2127
2128     memcpy(&(sEthHeader.abyDstAddr[0]),
2129            &(pPacket->p80211Header->sA3.abyAddr1[0]),
2130            ETH_ALEN);
2131     memcpy(&(sEthHeader.abySrcAddr[0]),
2132            &(pPacket->p80211Header->sA3.abyAddr2[0]),
2133            ETH_ALEN);
2134     //=========================
2135     //    No Fragmentation
2136     //=========================
2137     pTxBufHead->wFragCtl |= (WORD)FRAGCTL_NONFRAG;
2138
2139
2140     //Fill FIFO,RrvTime,RTS,and CTS
2141     s_vGenerateTxParameter(pDevice, byPktType, wCurrentRate,  pbyTxBufferAddr, pvRrvTime, pvRTS, pCTS,
2142                            cbFrameSize, bNeedACK, TYPE_TXDMA0, &sEthHeader);
2143
2144     //Fill DataHead
2145     uDuration = s_uFillDataHead(pDevice, byPktType, wCurrentRate, pvTxDataHd, cbFrameSize, TYPE_TXDMA0, bNeedACK,
2146                                 0, 0, 1, AUTO_FB_NONE);
2147
2148     pMACHeader = (PS802_11Header) (pbyTxBufferAddr + cbHeaderSize);
2149
2150     cbReqCount = cbHeaderSize + cbMacHdLen + uPadding + cbIVlen + cbFrameBodySize;
2151
2152     if (WLAN_GET_FC_ISWEP(pPacket->p80211Header->sA4.wFrameCtl) != 0) {
2153         PBYTE           pbyIVHead;
2154         PBYTE           pbyPayloadHead;
2155         PBYTE           pbyBSSID;
2156         PSKeyItem       pTransmitKey = NULL;
2157
2158         pbyIVHead = (PBYTE)(pbyTxBufferAddr + cbHeaderSize + cbMacHdLen + uPadding);
2159         pbyPayloadHead = (PBYTE)(pbyTxBufferAddr + cbHeaderSize + cbMacHdLen + uPadding + cbIVlen);
2160         do {
2161             if ((pDevice->eOPMode == OP_MODE_INFRASTRUCTURE) &&
2162                 (pDevice->bLinkPass == TRUE)) {
2163                 pbyBSSID = pDevice->abyBSSID;
2164                 // get pairwise key
2165                 if (KeybGetTransmitKey(&(pDevice->sKey), pbyBSSID, PAIRWISE_KEY, &pTransmitKey) == FALSE) {
2166                     // get group key
2167                     if(KeybGetTransmitKey(&(pDevice->sKey), pbyBSSID, GROUP_KEY, &pTransmitKey) == TRUE) {
2168                         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Get GTK.\n");
2169                         break;
2170                     }
2171                 } else {
2172                     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Get PTK.\n");
2173                     break;
2174                 }
2175             }
2176             // get group key
2177             pbyBSSID = pDevice->abyBroadcastAddr;
2178             if(KeybGetTransmitKey(&(pDevice->sKey), pbyBSSID, GROUP_KEY, &pTransmitKey) == FALSE) {
2179                 pTransmitKey = NULL;
2180                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"KEY is NULL. OP Mode[%d]\n", pDevice->eOPMode);
2181             } else {
2182                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Get GTK.\n");
2183             }
2184         } while(FALSE);
2185         //Fill TXKEY
2186         s_vFillTxKey(pDevice, (PBYTE)(pTxBufHead->adwTxKey), pbyIVHead, pTransmitKey,
2187                      (PBYTE)pMACHeader, (WORD)cbFrameBodySize, NULL);
2188
2189         memcpy(pMACHeader, pPacket->p80211Header, cbMacHdLen);
2190         memcpy(pbyPayloadHead, ((PBYTE)(pPacket->p80211Header) + cbMacHdLen),
2191                  cbFrameBodySize);
2192     }
2193     else {
2194         // Copy the Packet into a tx Buffer
2195         memcpy(pMACHeader, pPacket->p80211Header, pPacket->cbMPDULen);
2196     }
2197
2198     pMACHeader->wSeqCtl = cpu_to_le16(pDevice->wSeqCounter << 4);
2199     pDevice->wSeqCounter++ ;
2200     if (pDevice->wSeqCounter > 0x0fff)
2201         pDevice->wSeqCounter = 0;
2202
2203     if (bIsPSPOLL) {
2204         // The MAC will automatically replace the Duration-field of MAC header by Duration-field
2205         // of  FIFO control header.
2206         // This will cause AID-field of PS-POLL packet be incorrect (Because PS-POLL's AID field is
2207         // in the same place of other packet's Duration-field).
2208         // And it will cause Cisco-AP to issue Disassociation-packet
2209         if (byPktType == PK_TYPE_11GB || byPktType == PK_TYPE_11GA) {
2210             ((PSTxDataHead_g)pvTxDataHd)->wDuration_a = cpu_to_le16(pPacket->p80211Header->sA2.wDurationID);
2211             ((PSTxDataHead_g)pvTxDataHd)->wDuration_b = cpu_to_le16(pPacket->p80211Header->sA2.wDurationID);
2212         } else {
2213             ((PSTxDataHead_ab)pvTxDataHd)->wDuration = cpu_to_le16(pPacket->p80211Header->sA2.wDurationID);
2214         }
2215     }
2216
2217
2218     pTX_Buffer->wTxByteCount = cpu_to_le16((WORD)(cbReqCount));
2219     pTX_Buffer->byPKTNO = (BYTE) (((wCurrentRate<<4) &0x00F0) | ((pDevice->wSeqCounter - 1) & 0x000F));
2220     pTX_Buffer->byType = 0x00;
2221
2222     pContext->pPacket = NULL;
2223     pContext->Type = CONTEXT_MGMT_PACKET;
2224     pContext->uBufLen = (WORD)cbReqCount + 4;  //USB header
2225
2226     if (WLAN_GET_FC_TODS(pMACHeader->wFrameCtl) == 0) {
2227         s_vSaveTxPktInfo(pDevice, (BYTE) (pTX_Buffer->byPKTNO & 0x0F), &(pMACHeader->abyAddr1[0]),(WORD)cbFrameSize,pTX_Buffer->wFIFOCtl);
2228     }
2229     else {
2230         s_vSaveTxPktInfo(pDevice, (BYTE) (pTX_Buffer->byPKTNO & 0x0F), &(pMACHeader->abyAddr3[0]),(WORD)cbFrameSize,pTX_Buffer->wFIFOCtl);
2231     }
2232
2233     PIPEnsSendBulkOut(pDevice,pContext);
2234     return CMD_STATUS_PENDING;
2235 }
2236
2237
2238 CMD_STATUS
2239 csBeacon_xmit(
2240       PSDevice pDevice,
2241       PSTxMgmtPacket pPacket
2242     )
2243 {
2244
2245     unsigned int                cbFrameSize = pPacket->cbMPDULen + WLAN_FCS_LEN;
2246     unsigned int                cbHeaderSize = 0;
2247     WORD                wTxBufSize = sizeof(STxShortBufHead);
2248     PSTxShortBufHead    pTxBufHead;
2249     PS802_11Header      pMACHeader;
2250     PSTxDataHead_ab     pTxDataHead;
2251     WORD                wCurrentRate;
2252     unsigned int                cbFrameBodySize;
2253     unsigned int                cbReqCount;
2254     PBEACON_BUFFER      pTX_Buffer;
2255     PBYTE               pbyTxBufferAddr;
2256     PUSB_SEND_CONTEXT   pContext;
2257     CMD_STATUS          status;
2258
2259
2260     pContext = (PUSB_SEND_CONTEXT)s_vGetFreeContext(pDevice);
2261     if (NULL == pContext) {
2262         status = CMD_STATUS_RESOURCES;
2263         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"ManagementSend TX...NO CONTEXT!\n");
2264         return status ;
2265     }
2266     pTX_Buffer = (PBEACON_BUFFER) (&pContext->Data[0]);
2267     pbyTxBufferAddr = (PBYTE)&(pTX_Buffer->wFIFOCtl);
2268
2269     cbFrameBodySize = pPacket->cbPayloadLen;
2270
2271     pTxBufHead = (PSTxShortBufHead) pbyTxBufferAddr;
2272     wTxBufSize = sizeof(STxShortBufHead);
2273     memset(pTxBufHead, 0, wTxBufSize);
2274
2275     if (pDevice->byBBType == BB_TYPE_11A) {
2276         wCurrentRate = RATE_6M;
2277         pTxDataHead = (PSTxDataHead_ab) (pbyTxBufferAddr + wTxBufSize);
2278         //Get SignalField,ServiceField,Length
2279         BBvCaculateParameter(pDevice, cbFrameSize, wCurrentRate, PK_TYPE_11A,
2280             (PWORD)&(pTxDataHead->wTransmitLength), (PBYTE)&(pTxDataHead->byServiceField), (PBYTE)&(pTxDataHead->bySignalField)
2281         );
2282         //Get Duration and TimeStampOff
2283         pTxDataHead->wDuration = cpu_to_le16((WORD)s_uGetDataDuration(pDevice, DATADUR_A, cbFrameSize, PK_TYPE_11A,
2284                                                           wCurrentRate, FALSE, 0, 0, 1, AUTO_FB_NONE));
2285         pTxDataHead->wTimeStampOff = wTimeStampOff[pDevice->byPreambleType%2][wCurrentRate%MAX_RATE];
2286         cbHeaderSize = wTxBufSize + sizeof(STxDataHead_ab);
2287     } else {
2288         wCurrentRate = RATE_1M;
2289         pTxBufHead->wFIFOCtl |= FIFOCTL_11B;
2290         pTxDataHead = (PSTxDataHead_ab) (pbyTxBufferAddr + wTxBufSize);
2291         //Get SignalField,ServiceField,Length
2292         BBvCaculateParameter(pDevice, cbFrameSize, wCurrentRate, PK_TYPE_11B,
2293             (PWORD)&(pTxDataHead->wTransmitLength), (PBYTE)&(pTxDataHead->byServiceField), (PBYTE)&(pTxDataHead->bySignalField)
2294         );
2295         //Get Duration and TimeStampOff
2296         pTxDataHead->wDuration = cpu_to_le16((WORD)s_uGetDataDuration(pDevice, DATADUR_B, cbFrameSize, PK_TYPE_11B,
2297                                                           wCurrentRate, FALSE, 0, 0, 1, AUTO_FB_NONE));
2298         pTxDataHead->wTimeStampOff = wTimeStampOff[pDevice->byPreambleType%2][wCurrentRate%MAX_RATE];
2299         cbHeaderSize = wTxBufSize + sizeof(STxDataHead_ab);
2300     }
2301
2302     //Generate Beacon Header
2303     pMACHeader = (PS802_11Header)(pbyTxBufferAddr + cbHeaderSize);
2304     memcpy(pMACHeader, pPacket->p80211Header, pPacket->cbMPDULen);
2305
2306     pMACHeader->wDurationID = 0;
2307     pMACHeader->wSeqCtl = cpu_to_le16(pDevice->wSeqCounter << 4);
2308     pDevice->wSeqCounter++ ;
2309     if (pDevice->wSeqCounter > 0x0fff)
2310         pDevice->wSeqCounter = 0;
2311
2312     cbReqCount = cbHeaderSize + WLAN_HDR_ADDR3_LEN + cbFrameBodySize;
2313
2314     pTX_Buffer->wTxByteCount = (WORD)cbReqCount;
2315     pTX_Buffer->byPKTNO = (BYTE) (((wCurrentRate<<4) &0x00F0) | ((pDevice->wSeqCounter - 1) & 0x000F));
2316     pTX_Buffer->byType = 0x01;
2317
2318     pContext->pPacket = NULL;
2319     pContext->Type = CONTEXT_MGMT_PACKET;
2320     pContext->uBufLen = (WORD)cbReqCount + 4;  //USB header
2321
2322     PIPEnsSendBulkOut(pDevice,pContext);
2323     return CMD_STATUS_PENDING;
2324
2325 }
2326
2327
2328
2329
2330
2331 void
2332 vDMA0_tx_80211(PSDevice  pDevice, struct sk_buff *skb) {
2333
2334     PSMgmtObject    pMgmt = &(pDevice->sMgmtObj);
2335     BYTE            byPktType;
2336     PBYTE           pbyTxBufferAddr;
2337     void *pvRTS;
2338     void *pvCTS;
2339     void *pvTxDataHd;
2340     unsigned int            uDuration;
2341     unsigned int            cbReqCount;
2342     PS802_11Header  pMACHeader;
2343     unsigned int            cbHeaderSize;
2344     unsigned int            cbFrameBodySize;
2345     BOOL            bNeedACK;
2346     BOOL            bIsPSPOLL = FALSE;
2347     PSTxBufHead     pTxBufHead;
2348     unsigned int            cbFrameSize;
2349     unsigned int            cbIVlen = 0;
2350     unsigned int            cbICVlen = 0;
2351     unsigned int            cbMIClen = 0;
2352     unsigned int            cbFCSlen = 4;
2353     unsigned int            uPadding = 0;
2354     unsigned int            cbMICHDR = 0;
2355     unsigned int            uLength = 0;
2356     DWORD           dwMICKey0, dwMICKey1;
2357     DWORD           dwMIC_Priority;
2358     PDWORD          pdwMIC_L;
2359     PDWORD          pdwMIC_R;
2360     WORD            wTxBufSize;
2361     unsigned int            cbMacHdLen;
2362     SEthernetHeader sEthHeader;
2363     void *pvRrvTime;
2364     void *pMICHDR;
2365     WORD            wCurrentRate = RATE_1M;
2366     PUWLAN_80211HDR  p80211Header;
2367     unsigned int             uNodeIndex = 0;
2368     BOOL            bNodeExist = FALSE;
2369     SKeyItem        STempKey;
2370     PSKeyItem       pTransmitKey = NULL;
2371     PBYTE           pbyIVHead;
2372     PBYTE           pbyPayloadHead;
2373     PBYTE           pbyMacHdr;
2374     unsigned int            cbExtSuppRate = 0;
2375     PTX_BUFFER          pTX_Buffer;
2376     PUSB_SEND_CONTEXT   pContext;
2377 //    PWLAN_IE        pItem;
2378
2379
2380     pvRrvTime = pMICHDR = pvRTS = pvCTS = pvTxDataHd = NULL;
2381
2382     if(skb->len <= WLAN_HDR_ADDR3_LEN) {
2383        cbFrameBodySize = 0;
2384     }
2385     else {
2386        cbFrameBodySize = skb->len - WLAN_HDR_ADDR3_LEN;
2387     }
2388     p80211Header = (PUWLAN_80211HDR)skb->data;
2389
2390     pContext = (PUSB_SEND_CONTEXT)s_vGetFreeContext(pDevice);
2391
2392     if (NULL == pContext) {
2393         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"DMA0 TX...NO CONTEXT!\n");
2394         dev_kfree_skb_irq(skb);
2395         return ;
2396     }
2397
2398     pTX_Buffer = (PTX_BUFFER)(&pContext->Data[0]);
2399     pbyTxBufferAddr = (PBYTE)(&pTX_Buffer->adwTxKey[0]);
2400     pTxBufHead = (PSTxBufHead) pbyTxBufferAddr;
2401     wTxBufSize = sizeof(STxBufHead);
2402     memset(pTxBufHead, 0, wTxBufSize);
2403
2404     if (pDevice->byBBType == BB_TYPE_11A) {
2405         wCurrentRate = RATE_6M;
2406         byPktType = PK_TYPE_11A;
2407     } else {
2408         wCurrentRate = RATE_1M;
2409         byPktType = PK_TYPE_11B;
2410     }
2411
2412     // SetPower will cause error power TX state for OFDM Date packet in TX buffer.
2413     // 2004.11.11 Kyle -- Using OFDM power to tx MngPkt will decrease the connection capability.
2414     //                    And cmd timer will wait data pkt TX finish before scanning so it's OK
2415     //                    to set power here.
2416     if (pMgmt->eScanState != WMAC_NO_SCANNING) {
2417         RFbSetPower(pDevice, wCurrentRate, pDevice->byCurrentCh);
2418     } else {
2419         RFbSetPower(pDevice, wCurrentRate, pMgmt->uCurrChannel);
2420     }
2421
2422     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"vDMA0_tx_80211: p80211Header->sA3.wFrameCtl = %x \n", p80211Header->sA3.wFrameCtl);
2423
2424     //Set packet type
2425     if (byPktType == PK_TYPE_11A) {//0000 0000 0000 0000
2426         pTxBufHead->wFIFOCtl = 0;
2427     }
2428     else if (byPktType == PK_TYPE_11B) {//0000 0001 0000 0000
2429         pTxBufHead->wFIFOCtl |= FIFOCTL_11B;
2430     }
2431     else if (byPktType == PK_TYPE_11GB) {//0000 0010 0000 0000
2432         pTxBufHead->wFIFOCtl |= FIFOCTL_11GB;
2433     }
2434     else if (byPktType == PK_TYPE_11GA) {//0000 0011 0000 0000
2435         pTxBufHead->wFIFOCtl |= FIFOCTL_11GA;
2436     }
2437
2438     pTxBufHead->wFIFOCtl |= FIFOCTL_TMOEN;
2439     pTxBufHead->wTimeStamp = cpu_to_le16(DEFAULT_MGN_LIFETIME_RES_64us);
2440
2441     if (is_multicast_ether_addr(p80211Header->sA3.abyAddr1)) {
2442         bNeedACK = FALSE;
2443         if (pDevice->bEnableHostWEP) {
2444             uNodeIndex = 0;
2445             bNodeExist = TRUE;
2446         }
2447     }
2448     else {
2449         if (pDevice->bEnableHostWEP) {
2450             if (BSSbIsSTAInNodeDB(pDevice, (PBYTE)(p80211Header->sA3.abyAddr1), &uNodeIndex))
2451                 bNodeExist = TRUE;
2452         }
2453         bNeedACK = TRUE;
2454         pTxBufHead->wFIFOCtl |= FIFOCTL_NEEDACK;
2455     };
2456
2457     if ((pMgmt->eCurrMode == WMAC_MODE_ESS_AP) ||
2458         (pMgmt->eCurrMode == WMAC_MODE_IBSS_STA) ) {
2459
2460         pTxBufHead->wFIFOCtl |= FIFOCTL_LRETRY;
2461         //Set Preamble type always long
2462         //pDevice->byPreambleType = PREAMBLE_LONG;
2463
2464         // probe-response don't retry
2465         //if ((p80211Header->sA4.wFrameCtl & TYPE_SUBTYPE_MASK) == TYPE_MGMT_PROBE_RSP) {
2466         //     bNeedACK = FALSE;
2467         //     pTxBufHead->wFIFOCtl  &= (~FIFOCTL_NEEDACK);
2468         //}
2469     }
2470
2471     pTxBufHead->wFIFOCtl |= (FIFOCTL_GENINT | FIFOCTL_ISDMA0);
2472
2473     if ((p80211Header->sA4.wFrameCtl & TYPE_SUBTYPE_MASK) == TYPE_CTL_PSPOLL) {
2474         bIsPSPOLL = TRUE;
2475         cbMacHdLen = WLAN_HDR_ADDR2_LEN;
2476     } else {
2477         cbMacHdLen = WLAN_HDR_ADDR3_LEN;
2478     }
2479
2480     // hostapd deamon ext support rate patch
2481     if (WLAN_GET_FC_FSTYPE(p80211Header->sA4.wFrameCtl) == WLAN_FSTYPE_ASSOCRESP) {
2482
2483         if (((PWLAN_IE_SUPP_RATES)pMgmt->abyCurrSuppRates)->len != 0) {
2484             cbExtSuppRate += ((PWLAN_IE_SUPP_RATES)pMgmt->abyCurrSuppRates)->len + WLAN_IEHDR_LEN;
2485          }
2486
2487         if (((PWLAN_IE_SUPP_RATES)pMgmt->abyCurrExtSuppRates)->len != 0) {
2488             cbExtSuppRate += ((PWLAN_IE_SUPP_RATES)pMgmt->abyCurrExtSuppRates)->len + WLAN_IEHDR_LEN;
2489          }
2490
2491          if (cbExtSuppRate >0) {
2492             cbFrameBodySize = WLAN_ASSOCRESP_OFF_SUPP_RATES;
2493          }
2494     }
2495
2496
2497     //Set FRAGCTL_MACHDCNT
2498     pTxBufHead->wFragCtl |= cpu_to_le16((WORD)cbMacHdLen << 10);
2499
2500     // Notes:
2501     // Although spec says MMPDU can be fragmented; In most case,
2502     // no one will send a MMPDU under fragmentation. With RTS may occur.
2503     pDevice->bAES = FALSE;  //Set FRAGCTL_WEPTYP
2504
2505
2506     if (WLAN_GET_FC_ISWEP(p80211Header->sA4.wFrameCtl) != 0) {
2507         if (pDevice->eEncryptionStatus == Ndis802_11Encryption1Enabled) {
2508             cbIVlen = 4;
2509             cbICVlen = 4;
2510             pTxBufHead->wFragCtl |= FRAGCTL_LEGACY;
2511         }
2512         else if (pDevice->eEncryptionStatus == Ndis802_11Encryption2Enabled) {
2513             cbIVlen = 8;//IV+ExtIV
2514             cbMIClen = 8;
2515             cbICVlen = 4;
2516             pTxBufHead->wFragCtl |= FRAGCTL_TKIP;
2517             //We need to get seed here for filling TxKey entry.
2518             //TKIPvMixKey(pTransmitKey->abyKey, pDevice->abyCurrentNetAddr,
2519             //            pTransmitKey->wTSC15_0, pTransmitKey->dwTSC47_16, pDevice->abyPRNG);
2520         }
2521         else if (pDevice->eEncryptionStatus == Ndis802_11Encryption3Enabled) {
2522             cbIVlen = 8;//RSN Header
2523             cbICVlen = 8;//MIC
2524             cbMICHDR = sizeof(SMICHDRHead);
2525             pTxBufHead->wFragCtl |= FRAGCTL_AES;
2526             pDevice->bAES = TRUE;
2527         }
2528         //MAC Header should be padding 0 to DW alignment.
2529         uPadding = 4 - (cbMacHdLen%4);
2530         uPadding %= 4;
2531     }
2532
2533     cbFrameSize = cbMacHdLen + cbFrameBodySize + cbIVlen + cbMIClen + cbICVlen + cbFCSlen + cbExtSuppRate;
2534
2535     //Set FIFOCTL_GrpAckPolicy
2536     if (pDevice->bGrpAckPolicy == TRUE) {//0000 0100 0000 0000
2537         pTxBufHead->wFIFOCtl |= FIFOCTL_GRPACK;
2538     }
2539     //the rest of pTxBufHead->wFragCtl:FragTyp will be set later in s_vFillFragParameter()
2540
2541
2542     if (byPktType == PK_TYPE_11GB || byPktType == PK_TYPE_11GA) {//802.11g packet
2543
2544         pvRrvTime = (PSRrvTime_gCTS) (pbyTxBufferAddr + wTxBufSize);
2545         pMICHDR = (PSMICHDRHead) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_gCTS));
2546         pvRTS = NULL;
2547         pvCTS = (PSCTS) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_gCTS) + cbMICHDR);
2548         pvTxDataHd = (PSTxDataHead_g) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_gCTS) + cbMICHDR + sizeof(SCTS));
2549         cbHeaderSize = wTxBufSize + sizeof(SRrvTime_gCTS) + cbMICHDR + sizeof(SCTS) + sizeof(STxDataHead_g);
2550
2551     }
2552     else {//802.11a/b packet
2553
2554         pvRrvTime = (PSRrvTime_ab) (pbyTxBufferAddr + wTxBufSize);
2555         pMICHDR = (PSMICHDRHead) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_ab));
2556         pvRTS = NULL;
2557         pvCTS = NULL;
2558         pvTxDataHd = (PSTxDataHead_ab) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_ab) + cbMICHDR);
2559         cbHeaderSize = wTxBufSize + sizeof(SRrvTime_ab) + cbMICHDR + sizeof(STxDataHead_ab);
2560     }
2561     memset((void *)(pbyTxBufferAddr + wTxBufSize), 0,
2562            (cbHeaderSize - wTxBufSize));
2563     memcpy(&(sEthHeader.abyDstAddr[0]),
2564            &(p80211Header->sA3.abyAddr1[0]),
2565            ETH_ALEN);
2566     memcpy(&(sEthHeader.abySrcAddr[0]),
2567            &(p80211Header->sA3.abyAddr2[0]),
2568            ETH_ALEN);
2569     //=========================
2570     //    No Fragmentation
2571     //=========================
2572     pTxBufHead->wFragCtl |= (WORD)FRAGCTL_NONFRAG;
2573
2574
2575     //Fill FIFO,RrvTime,RTS,and CTS
2576     s_vGenerateTxParameter(pDevice, byPktType, wCurrentRate, pbyTxBufferAddr, pvRrvTime, pvRTS, pvCTS,
2577                            cbFrameSize, bNeedACK, TYPE_TXDMA0, &sEthHeader);
2578
2579     //Fill DataHead
2580     uDuration = s_uFillDataHead(pDevice, byPktType, wCurrentRate, pvTxDataHd, cbFrameSize, TYPE_TXDMA0, bNeedACK,
2581                                 0, 0, 1, AUTO_FB_NONE);
2582
2583     pMACHeader = (PS802_11Header) (pbyTxBufferAddr + cbHeaderSize);
2584
2585     cbReqCount = cbHeaderSize + cbMacHdLen + uPadding + cbIVlen + (cbFrameBodySize + cbMIClen) + cbExtSuppRate;
2586
2587     pbyMacHdr = (PBYTE)(pbyTxBufferAddr + cbHeaderSize);
2588     pbyPayloadHead = (PBYTE)(pbyMacHdr + cbMacHdLen + uPadding + cbIVlen);
2589     pbyIVHead = (PBYTE)(pbyMacHdr + cbMacHdLen + uPadding);
2590
2591     // Copy the Packet into a tx Buffer
2592     memcpy(pbyMacHdr, skb->data, cbMacHdLen);
2593
2594     // version set to 0, patch for hostapd deamon
2595     pMACHeader->wFrameCtl &= cpu_to_le16(0xfffc);
2596     memcpy(pbyPayloadHead, (skb->data + cbMacHdLen), cbFrameBodySize);
2597
2598     // replace support rate, patch for hostapd deamon( only support 11M)
2599     if (WLAN_GET_FC_FSTYPE(p80211Header->sA4.wFrameCtl) == WLAN_FSTYPE_ASSOCRESP) {
2600         if (cbExtSuppRate != 0) {
2601             if (((PWLAN_IE_SUPP_RATES)pMgmt->abyCurrSuppRates)->len != 0)
2602                 memcpy((pbyPayloadHead + cbFrameBodySize),
2603                         pMgmt->abyCurrSuppRates,
2604                         ((PWLAN_IE_SUPP_RATES)pMgmt->abyCurrSuppRates)->len + WLAN_IEHDR_LEN
2605                        );
2606              if (((PWLAN_IE_SUPP_RATES)pMgmt->abyCurrExtSuppRates)->len != 0)
2607                 memcpy((pbyPayloadHead + cbFrameBodySize) + ((PWLAN_IE_SUPP_RATES)pMgmt->abyCurrSuppRates)->len + WLAN_IEHDR_LEN,
2608                         pMgmt->abyCurrExtSuppRates,
2609                         ((PWLAN_IE_SUPP_RATES)pMgmt->abyCurrExtSuppRates)->len + WLAN_IEHDR_LEN
2610                        );
2611          }
2612     }
2613
2614     // Set wep
2615     if (WLAN_GET_FC_ISWEP(p80211Header->sA4.wFrameCtl) != 0) {
2616
2617         if (pDevice->bEnableHostWEP) {
2618             pTransmitKey = &STempKey;
2619             pTransmitKey->byCipherSuite = pMgmt->sNodeDBTable[uNodeIndex].byCipherSuite;
2620             pTransmitKey->dwKeyIndex = pMgmt->sNodeDBTable[uNodeIndex].dwKeyIndex;
2621             pTransmitKey->uKeyLength = pMgmt->sNodeDBTable[uNodeIndex].uWepKeyLength;
2622             pTransmitKey->dwTSC47_16 = pMgmt->sNodeDBTable[uNodeIndex].dwTSC47_16;
2623             pTransmitKey->wTSC15_0 = pMgmt->sNodeDBTable[uNodeIndex].wTSC15_0;
2624             memcpy(pTransmitKey->abyKey,
2625                 &pMgmt->sNodeDBTable[uNodeIndex].abyWepKey[0],
2626                 pTransmitKey->uKeyLength
2627                 );
2628         }
2629
2630         if ((pTransmitKey != NULL) && (pTransmitKey->byCipherSuite == KEY_CTL_TKIP)) {
2631
2632             dwMICKey0 = *(PDWORD)(&pTransmitKey->abyKey[16]);
2633             dwMICKey1 = *(PDWORD)(&pTransmitKey->abyKey[20]);
2634
2635             // DO Software Michael
2636             MIC_vInit(dwMICKey0, dwMICKey1);
2637             MIC_vAppend((PBYTE)&(sEthHeader.abyDstAddr[0]), 12);
2638             dwMIC_Priority = 0;
2639             MIC_vAppend((PBYTE)&dwMIC_Priority, 4);
2640                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"DMA0_tx_8021:MIC KEY:"\
2641                         " %X, %X\n", dwMICKey0, dwMICKey1);
2642
2643             uLength = cbHeaderSize + cbMacHdLen + uPadding + cbIVlen;
2644
2645             MIC_vAppend((pbyTxBufferAddr + uLength), cbFrameBodySize);
2646
2647             pdwMIC_L = (PDWORD)(pbyTxBufferAddr + uLength + cbFrameBodySize);
2648             pdwMIC_R = (PDWORD)(pbyTxBufferAddr + uLength + cbFrameBodySize + 4);
2649
2650             MIC_vGetMIC(pdwMIC_L, pdwMIC_R);
2651             MIC_vUnInit();
2652
2653             if (pDevice->bTxMICFail == TRUE) {
2654                 *pdwMIC_L = 0;
2655                 *pdwMIC_R = 0;
2656                 pDevice->bTxMICFail = FALSE;
2657             }
2658
2659             DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"uLength: %d, %d\n", uLength, cbFrameBodySize);
2660             DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"cbReqCount:%d, %d, %d, %d\n", cbReqCount, cbHeaderSize, uPadding, cbIVlen);
2661                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"MIC:%x, %x\n",
2662                         *pdwMIC_L, *pdwMIC_R);
2663
2664         }
2665
2666         s_vFillTxKey(pDevice, (PBYTE)(pTxBufHead->adwTxKey), pbyIVHead, pTransmitKey,
2667                      pbyMacHdr, (WORD)cbFrameBodySize, (PBYTE)pMICHDR);
2668
2669         if (pDevice->bEnableHostWEP) {
2670             pMgmt->sNodeDBTable[uNodeIndex].dwTSC47_16 = pTransmitKey->dwTSC47_16;
2671             pMgmt->sNodeDBTable[uNodeIndex].wTSC15_0 = pTransmitKey->wTSC15_0;
2672         }
2673
2674         if ((pDevice->byLocalID <= REV_ID_VT3253_A1)) {
2675             s_vSWencryption(pDevice, pTransmitKey, pbyPayloadHead, (WORD)(cbFrameBodySize + cbMIClen));
2676         }
2677     }
2678
2679     pMACHeader->wSeqCtl = cpu_to_le16(pDevice->wSeqCounter << 4);
2680     pDevice->wSeqCounter++ ;
2681     if (pDevice->wSeqCounter > 0x0fff)
2682         pDevice->wSeqCounter = 0;
2683
2684
2685     if (bIsPSPOLL) {
2686         // The MAC will automatically replace the Duration-field of MAC header by Duration-field
2687         // of  FIFO control header.
2688         // This will cause AID-field of PS-POLL packet be incorrect (Because PS-POLL's AID field is
2689         // in the same place of other packet's Duration-field).
2690         // And it will cause Cisco-AP to issue Disassociation-packet
2691         if (byPktType == PK_TYPE_11GB || byPktType == PK_TYPE_11GA) {
2692             ((PSTxDataHead_g)pvTxDataHd)->wDuration_a = cpu_to_le16(p80211Header->sA2.wDurationID);
2693             ((PSTxDataHead_g)pvTxDataHd)->wDuration_b = cpu_to_le16(p80211Header->sA2.wDurationID);
2694         } else {
2695             ((PSTxDataHead_ab)pvTxDataHd)->wDuration = cpu_to_le16(p80211Header->sA2.wDurationID);
2696         }
2697     }
2698
2699     pTX_Buffer->wTxByteCount = cpu_to_le16((WORD)(cbReqCount));
2700     pTX_Buffer->byPKTNO = (BYTE) (((wCurrentRate<<4) &0x00F0) | ((pDevice->wSeqCounter - 1) & 0x000F));
2701     pTX_Buffer->byType = 0x00;
2702
2703     pContext->pPacket = skb;
2704     pContext->Type = CONTEXT_MGMT_PACKET;
2705     pContext->uBufLen = (WORD)cbReqCount + 4;  //USB header
2706
2707     if (WLAN_GET_FC_TODS(pMACHeader->wFrameCtl) == 0) {
2708         s_vSaveTxPktInfo(pDevice, (BYTE) (pTX_Buffer->byPKTNO & 0x0F), &(pMACHeader->abyAddr1[0]),(WORD)cbFrameSize,pTX_Buffer->wFIFOCtl);
2709     }
2710     else {
2711         s_vSaveTxPktInfo(pDevice, (BYTE) (pTX_Buffer->byPKTNO & 0x0F), &(pMACHeader->abyAddr3[0]),(WORD)cbFrameSize,pTX_Buffer->wFIFOCtl);
2712     }
2713     PIPEnsSendBulkOut(pDevice,pContext);
2714     return ;
2715
2716 }
2717
2718
2719
2720
2721 //TYPE_AC0DMA data tx
2722 /*
2723  * Description:
2724  *      Tx packet via AC0DMA(DMA1)
2725  *
2726  * Parameters:
2727  *  In:
2728  *      pDevice         - Pointer to the adapter
2729  *      skb             - Pointer to tx skb packet
2730  *  Out:
2731  *      void
2732  *
2733  * Return Value: NULL
2734  */
2735
2736 int nsDMA_tx_packet(PSDevice pDevice, unsigned int uDMAIdx, struct sk_buff *skb)
2737 {
2738     PSMgmtObject    pMgmt = &(pDevice->sMgmtObj);
2739     unsigned int BytesToWrite = 0, uHeaderLen = 0;
2740     unsigned int            uNodeIndex = 0;
2741     BYTE            byMask[8] = {1, 2, 4, 8, 0x10, 0x20, 0x40, 0x80};
2742     WORD            wAID;
2743     BYTE            byPktType;
2744     BOOL            bNeedEncryption = FALSE;
2745     PSKeyItem       pTransmitKey = NULL;
2746     SKeyItem        STempKey;
2747     unsigned int            ii;
2748     BOOL            bTKIP_UseGTK = FALSE;
2749     BOOL            bNeedDeAuth = FALSE;
2750     PBYTE           pbyBSSID;
2751     BOOL            bNodeExist = FALSE;
2752     PUSB_SEND_CONTEXT pContext;
2753     BOOL            fConvertedPacket;
2754     PTX_BUFFER      pTX_Buffer;
2755     unsigned int            status;
2756     WORD            wKeepRate = pDevice->wCurrentRate;
2757     struct net_device_stats* pStats = &pDevice->stats;
2758      BOOL            bTxeapol_key = FALSE;
2759
2760
2761     if (pMgmt->eCurrMode == WMAC_MODE_ESS_AP) {
2762
2763         if (pDevice->uAssocCount == 0) {
2764             dev_kfree_skb_irq(skb);
2765             return 0;
2766         }
2767
2768         if (is_multicast_ether_addr((PBYTE)(skb->data))) {
2769             uNodeIndex = 0;
2770             bNodeExist = TRUE;
2771             if (pMgmt->sNodeDBTable[0].bPSEnable) {
2772
2773                 skb_queue_tail(&(pMgmt->sNodeDBTable[0].sTxPSQueue), skb);
2774                 pMgmt->sNodeDBTable[0].wEnQueueCnt++;
2775                 // set tx map
2776                 pMgmt->abyPSTxMap[0] |= byMask[0];
2777                 return 0;
2778             }
2779             // muticast/broadcast data rate
2780
2781             if (pDevice->byBBType != BB_TYPE_11A)
2782                 pDevice->wCurrentRate = RATE_2M;
2783             else
2784                 pDevice->wCurrentRate = RATE_24M;
2785             // long preamble type
2786             pDevice->byPreambleType = PREAMBLE_SHORT;
2787
2788         }else {
2789
2790             if (BSSbIsSTAInNodeDB(pDevice, (PBYTE)(skb->data), &uNodeIndex)) {
2791
2792                 if (pMgmt->sNodeDBTable[uNodeIndex].bPSEnable) {
2793
2794                     skb_queue_tail(&pMgmt->sNodeDBTable[uNodeIndex].sTxPSQueue, skb);
2795
2796                     pMgmt->sNodeDBTable[uNodeIndex].wEnQueueCnt++;
2797                     // set tx map
2798                     wAID = pMgmt->sNodeDBTable[uNodeIndex].wAID;
2799                     pMgmt->abyPSTxMap[wAID >> 3] |=  byMask[wAID & 7];
2800                     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Set:pMgmt->abyPSTxMap[%d]= %d\n",
2801                              (wAID >> 3), pMgmt->abyPSTxMap[wAID >> 3]);
2802
2803                     return 0;
2804                 }
2805                 // AP rate decided from node
2806                 pDevice->wCurrentRate = pMgmt->sNodeDBTable[uNodeIndex].wTxDataRate;
2807                 // tx preamble decided from node
2808
2809                 if (pMgmt->sNodeDBTable[uNodeIndex].bShortPreamble) {
2810                     pDevice->byPreambleType = pDevice->byShortPreamble;
2811
2812                 }else {
2813                     pDevice->byPreambleType = PREAMBLE_LONG;
2814                 }
2815                 bNodeExist = TRUE;
2816             }
2817         }
2818
2819         if (bNodeExist == FALSE) {
2820             DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"Unknown STA not found in node DB \n");
2821             dev_kfree_skb_irq(skb);
2822             return 0;
2823         }
2824     }
2825
2826     pContext = (PUSB_SEND_CONTEXT)s_vGetFreeContext(pDevice);
2827
2828     if (pContext == NULL) {
2829         DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG" pContext == NULL\n");
2830         dev_kfree_skb_irq(skb);
2831         return STATUS_RESOURCES;
2832     }
2833
2834     memcpy(pDevice->sTxEthHeader.abyDstAddr, (PBYTE)(skb->data), ETH_HLEN);
2835
2836 //mike add:station mode check eapol-key challenge--->
2837 {
2838     BYTE  Protocol_Version;    //802.1x Authentication
2839     BYTE  Packet_Type;           //802.1x Authentication
2840     BYTE  Descriptor_type;
2841     WORD Key_info;
2842
2843     Protocol_Version = skb->data[ETH_HLEN];
2844     Packet_Type = skb->data[ETH_HLEN+1];
2845     Descriptor_type = skb->data[ETH_HLEN+1+1+2];
2846     Key_info = (skb->data[ETH_HLEN+1+1+2+1] << 8)|(skb->data[ETH_HLEN+1+1+2+2]);
2847         if (pDevice->sTxEthHeader.wType == cpu_to_be16(ETH_P_PAE)) {
2848                 /* 802.1x OR eapol-key challenge frame transfer */
2849                 if (((Protocol_Version == 1) || (Protocol_Version == 2)) &&
2850                         (Packet_Type == 3)) {
2851                         bTxeapol_key = TRUE;
2852                        if(!(Key_info & BIT3) &&  //WPA or RSN group-key challenge
2853                            (Key_info & BIT8) && (Key_info & BIT9)) {    //send 2/2 key
2854                           if(Descriptor_type==254) {
2855                                pDevice->fWPA_Authened = TRUE;
2856                              PRINT_K("WPA ");
2857                           }
2858                           else {
2859                                pDevice->fWPA_Authened = TRUE;
2860                              PRINT_K("WPA2(re-keying) ");
2861                           }
2862                           PRINT_K("Authentication completed!!\n");
2863                         }
2864                     else if((Key_info & BIT3) && (Descriptor_type==2) &&  //RSN pairse-key challenge
2865                                (Key_info & BIT8) && (Key_info & BIT9)) {
2866                           pDevice->fWPA_Authened = TRUE;
2867                             PRINT_K("WPA2 Authentication completed!!\n");
2868                      }
2869              }
2870    }
2871 }
2872 //mike add:station mode check eapol-key challenge<---
2873
2874     if (pDevice->bEncryptionEnable == TRUE) {
2875         bNeedEncryption = TRUE;
2876         // get Transmit key
2877         do {
2878             if ((pMgmt->eCurrMode == WMAC_MODE_ESS_STA) &&
2879                 (pMgmt->eCurrState == WMAC_STATE_ASSOC)) {
2880                 pbyBSSID = pDevice->abyBSSID;
2881                 // get pairwise key
2882                 if (KeybGetTransmitKey(&(pDevice->sKey), pbyBSSID, PAIRWISE_KEY, &pTransmitKey) == FALSE) {
2883                     // get group key
2884                     if(KeybGetTransmitKey(&(pDevice->sKey), pbyBSSID, GROUP_KEY, &pTransmitKey) == TRUE) {
2885                         bTKIP_UseGTK = TRUE;
2886                         DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"Get GTK.\n");
2887                         break;
2888                     }
2889                 } else {
2890                     DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"Get PTK.\n");
2891                     break;
2892                 }
2893             }else if (pMgmt->eCurrMode == WMAC_MODE_IBSS_STA) {
2894
2895                 pbyBSSID = pDevice->sTxEthHeader.abyDstAddr;  //TO_DS = 0 and FROM_DS = 0 --> 802.11 MAC Address1
2896                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"IBSS Serach Key: \n");
2897                 for (ii = 0; ii< 6; ii++)
2898                     DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"%x \n", *(pbyBSSID+ii));
2899                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"\n");
2900
2901                 // get pairwise key
2902                 if(KeybGetTransmitKey(&(pDevice->sKey), pbyBSSID, PAIRWISE_KEY, &pTransmitKey) == TRUE)
2903                     break;
2904             }
2905             // get group key
2906             pbyBSSID = pDevice->abyBroadcastAddr;
2907             if(KeybGetTransmitKey(&(pDevice->sKey), pbyBSSID, GROUP_KEY, &pTransmitKey) == FALSE) {
2908                 pTransmitKey = NULL;
2909                 if (pMgmt->eCurrMode == WMAC_MODE_IBSS_STA) {
2910                     DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"IBSS and KEY is NULL. [%d]\n", pMgmt->eCurrMode);
2911                 }
2912                 else
2913                     DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"NOT IBSS and KEY is NULL. [%d]\n", pMgmt->eCurrMode);
2914             } else {
2915                 bTKIP_UseGTK = TRUE;
2916                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"Get GTK.\n");
2917             }
2918         } while(FALSE);
2919     }
2920
2921     if (pDevice->bEnableHostWEP) {
2922         DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"acdma0: STA index %d\n", uNodeIndex);
2923         if (pDevice->bEncryptionEnable == TRUE) {
2924             pTransmitKey = &STempKey;
2925             pTransmitKey->byCipherSuite = pMgmt->sNodeDBTable[uNodeIndex].byCipherSuite;
2926             pTransmitKey->dwKeyIndex = pMgmt->sNodeDBTable[uNodeIndex].dwKeyIndex;
2927             pTransmitKey->uKeyLength = pMgmt->sNodeDBTable[uNodeIndex].uWepKeyLength;
2928             pTransmitKey->dwTSC47_16 = pMgmt->sNodeDBTable[uNodeIndex].dwTSC47_16;
2929             pTransmitKey->wTSC15_0 = pMgmt->sNodeDBTable[uNodeIndex].wTSC15_0;
2930             memcpy(pTransmitKey->abyKey,
2931                 &pMgmt->sNodeDBTable[uNodeIndex].abyWepKey[0],
2932                 pTransmitKey->uKeyLength
2933                 );
2934          }
2935     }
2936
2937     byPktType = (BYTE)pDevice->byPacketType;
2938
2939     if (pDevice->bFixRate) {
2940         if (pDevice->byBBType == BB_TYPE_11B) {
2941             if (pDevice->uConnectionRate >= RATE_11M) {
2942                 pDevice->wCurrentRate = RATE_11M;
2943             } else {
2944                 pDevice->wCurrentRate = (WORD)pDevice->uConnectionRate;
2945             }
2946         } else {
2947             if ((pDevice->byBBType == BB_TYPE_11A) &&
2948                 (pDevice->uConnectionRate <= RATE_6M)) {
2949                 pDevice->wCurrentRate = RATE_6M;
2950             } else {
2951                 if (pDevice->uConnectionRate >= RATE_54M)
2952                     pDevice->wCurrentRate = RATE_54M;
2953                 else
2954                     pDevice->wCurrentRate = (WORD)pDevice->uConnectionRate;
2955             }
2956         }
2957     }
2958     else {
2959         if (pDevice->eOPMode == OP_MODE_ADHOC) {
2960             // Adhoc Tx rate decided from node DB
2961             if (is_multicast_ether_addr(pDevice->sTxEthHeader.abyDstAddr)) {
2962                 // Multicast use highest data rate
2963                 pDevice->wCurrentRate = pMgmt->sNodeDBTable[0].wTxDataRate;
2964                 // preamble type
2965                 pDevice->byPreambleType = pDevice->byShortPreamble;
2966             }
2967             else {
2968                 if(BSSbIsSTAInNodeDB(pDevice, &(pDevice->sTxEthHeader.abyDstAddr[0]), &uNodeIndex)) {
2969                     pDevice->wCurrentRate = pMgmt->sNodeDBTable[uNodeIndex].wTxDataRate;
2970                     if (pMgmt->sNodeDBTable[uNodeIndex].bShortPreamble) {
2971                         pDevice->byPreambleType = pDevice->byShortPreamble;
2972
2973                     }
2974                     else {
2975                         pDevice->byPreambleType = PREAMBLE_LONG;
2976                     }
2977                     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Found Node Index is [%d]  Tx Data Rate:[%d]\n",uNodeIndex, pDevice->wCurrentRate);
2978                 }
2979                 else {
2980                     if (pDevice->byBBType != BB_TYPE_11A)
2981                        pDevice->wCurrentRate = RATE_2M;
2982                     else
2983                        pDevice->wCurrentRate = RATE_24M; // refer to vMgrCreateOwnIBSS()'s
2984                                                          // abyCurrExtSuppRates[]
2985                     pDevice->byPreambleType = PREAMBLE_SHORT;
2986                     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Not Found Node use highest basic Rate.....\n");
2987                 }
2988             }
2989         }
2990         if (pDevice->eOPMode == OP_MODE_INFRASTRUCTURE) {
2991             // Infra STA rate decided from AP Node, index = 0
2992             pDevice->wCurrentRate = pMgmt->sNodeDBTable[0].wTxDataRate;
2993         }
2994     }
2995
2996         if (pDevice->sTxEthHeader.wType == cpu_to_be16(ETH_P_PAE)) {
2997                 if (pDevice->byBBType != BB_TYPE_11A) {
2998                         pDevice->wCurrentRate = RATE_1M;
2999                         pDevice->byACKRate = RATE_1M;
3000                         pDevice->byTopCCKBasicRate = RATE_1M;
3001                         pDevice->byTopOFDMBasicRate = RATE_6M;
3002                 } else {
3003                         pDevice->wCurrentRate = RATE_6M;
3004                         pDevice->byACKRate = RATE_6M;
3005                         pDevice->byTopCCKBasicRate = RATE_1M;
3006                         pDevice->byTopOFDMBasicRate = RATE_6M;
3007                 }
3008         }
3009
3010     DBG_PRT(MSG_LEVEL_DEBUG,
3011             KERN_INFO "dma_tx: pDevice->wCurrentRate = %d\n",
3012             pDevice->wCurrentRate);
3013
3014     if (wKeepRate != pDevice->wCurrentRate) {
3015         bScheduleCommand((void *) pDevice, WLAN_CMD_SETPOWER, NULL);
3016     }
3017
3018     if (pDevice->wCurrentRate <= RATE_11M) {
3019         byPktType = PK_TYPE_11B;
3020     }
3021
3022     if (bNeedEncryption == TRUE) {
3023         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"ntohs Pkt Type=%04x\n", ntohs(pDevice->sTxEthHeader.wType));
3024         if ((pDevice->sTxEthHeader.wType) == cpu_to_be16(ETH_P_PAE)) {
3025                 bNeedEncryption = FALSE;
3026             DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Pkt Type=%04x\n", (pDevice->sTxEthHeader.wType));
3027             if ((pMgmt->eCurrMode == WMAC_MODE_ESS_STA) && (pMgmt->eCurrState == WMAC_STATE_ASSOC)) {
3028                 if (pTransmitKey == NULL) {
3029                     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Don't Find TX KEY\n");
3030                 }
3031                 else {
3032                     if (bTKIP_UseGTK == TRUE) {
3033                         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"error: KEY is GTK!!~~\n");
3034                     }
3035                     else {
3036                         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Find PTK [%X]\n",
3037                                 pTransmitKey->dwKeyIndex);
3038                         bNeedEncryption = TRUE;
3039                     }
3040                 }
3041             }
3042
3043             if (pDevice->byCntMeasure == 2) {
3044                 bNeedDeAuth = TRUE;
3045                 pDevice->s802_11Counter.TKIPCounterMeasuresInvoked++;
3046             }
3047
3048             if (pDevice->bEnableHostWEP) {
3049                 if ((uNodeIndex != 0) &&
3050                     (pMgmt->sNodeDBTable[uNodeIndex].dwKeyIndex & PAIRWISE_KEY)) {
3051                         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Find PTK [%X]\n",
3052                                 pTransmitKey->dwKeyIndex);
3053                     bNeedEncryption = TRUE;
3054                  }
3055              }
3056         }
3057         else {
3058
3059             if (pTransmitKey == NULL) {
3060                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"return no tx key\n");
3061                 dev_kfree_skb_irq(skb);
3062                 pStats->tx_dropped++;
3063                 return STATUS_FAILURE;
3064             }
3065         }
3066     }
3067
3068     fConvertedPacket = s_bPacketToWirelessUsb(pDevice, byPktType,
3069                         (PBYTE)(&pContext->Data[0]), bNeedEncryption,
3070                         skb->len, uDMAIdx, &pDevice->sTxEthHeader,
3071                         (PBYTE)skb->data, pTransmitKey, uNodeIndex,
3072                         pDevice->wCurrentRate,
3073                         &uHeaderLen, &BytesToWrite
3074                        );
3075
3076     if (fConvertedPacket == FALSE) {
3077         pContext->bBoolInUse = FALSE;
3078         dev_kfree_skb_irq(skb);
3079         return STATUS_FAILURE;
3080     }
3081
3082     if ( pDevice->bEnablePSMode == TRUE ) {
3083         if ( !pDevice->bPSModeTxBurst ) {
3084                 bScheduleCommand((void *) pDevice,
3085                                  WLAN_CMD_MAC_DISPOWERSAVING,
3086                                  NULL);
3087             pDevice->bPSModeTxBurst = TRUE;
3088         }
3089     }
3090
3091     pTX_Buffer = (PTX_BUFFER)&(pContext->Data[0]);
3092     pTX_Buffer->byPKTNO = (BYTE) (((pDevice->wCurrentRate<<4) &0x00F0) | ((pDevice->wSeqCounter - 1) & 0x000F));
3093     pTX_Buffer->wTxByteCount = (WORD)BytesToWrite;
3094
3095     pContext->pPacket = skb;
3096     pContext->Type = CONTEXT_DATA_PACKET;
3097     pContext->uBufLen = (WORD)BytesToWrite + 4 ; //USB header
3098
3099     s_vSaveTxPktInfo(pDevice, (BYTE) (pTX_Buffer->byPKTNO & 0x0F), &(pContext->sEthHeader.abyDstAddr[0]),(WORD) (BytesToWrite-uHeaderLen),pTX_Buffer->wFIFOCtl);
3100
3101     status = PIPEnsSendBulkOut(pDevice,pContext);
3102
3103     if (bNeedDeAuth == TRUE) {
3104         WORD wReason = WLAN_MGMT_REASON_MIC_FAILURE;
3105
3106         bScheduleCommand((void *) pDevice, WLAN_CMD_DEAUTH, (PBYTE) &wReason);
3107     }
3108
3109   if(status!=STATUS_PENDING) {
3110      pContext->bBoolInUse = FALSE;
3111     dev_kfree_skb_irq(skb);
3112     return STATUS_FAILURE;
3113   }
3114   else
3115     return 0;
3116
3117 }
3118
3119
3120
3121 /*
3122  * Description:
3123  *      Relay packet send (AC1DMA) from rx dpc.
3124  *
3125  * Parameters:
3126  *  In:
3127  *      pDevice         - Pointer to the adapter
3128  *      pPacket         - Pointer to rx packet
3129  *      cbPacketSize    - rx ethernet frame size
3130  *  Out:
3131  *      TURE, FALSE
3132  *
3133  * Return Value: Return TRUE if packet is copy to dma1; otherwise FALSE
3134  */
3135
3136
3137 BOOL
3138 bRelayPacketSend (
3139       PSDevice pDevice,
3140       PBYTE    pbySkbData,
3141       unsigned int     uDataLen,
3142       unsigned int     uNodeIndex
3143     )
3144 {
3145     PSMgmtObject    pMgmt = &(pDevice->sMgmtObj);
3146     unsigned int BytesToWrite = 0, uHeaderLen = 0;
3147     BYTE            byPktType = PK_TYPE_11B;
3148     BOOL            bNeedEncryption = FALSE;
3149     SKeyItem        STempKey;
3150     PSKeyItem       pTransmitKey = NULL;
3151     PBYTE           pbyBSSID;
3152     PUSB_SEND_CONTEXT   pContext;
3153     BYTE            byPktTyp;
3154     BOOL            fConvertedPacket;
3155     PTX_BUFFER      pTX_Buffer;
3156     unsigned int            status;
3157     WORD            wKeepRate = pDevice->wCurrentRate;
3158
3159
3160
3161     pContext = (PUSB_SEND_CONTEXT)s_vGetFreeContext(pDevice);
3162
3163     if (NULL == pContext) {
3164         return FALSE;
3165     }
3166
3167     memcpy(pDevice->sTxEthHeader.abyDstAddr, (PBYTE)pbySkbData, ETH_HLEN);
3168
3169     if (pDevice->bEncryptionEnable == TRUE) {
3170         bNeedEncryption = TRUE;
3171         // get group key
3172         pbyBSSID = pDevice->abyBroadcastAddr;
3173         if(KeybGetTransmitKey(&(pDevice->sKey), pbyBSSID, GROUP_KEY, &pTransmitKey) == FALSE) {
3174             pTransmitKey = NULL;
3175             DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"KEY is NULL. [%d]\n", pMgmt->eCurrMode);
3176         } else {
3177             DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"Get GTK.\n");
3178         }
3179     }
3180
3181     if (pDevice->bEnableHostWEP) {
3182         if (uNodeIndex < MAX_NODE_NUM + 1) {
3183             pTransmitKey = &STempKey;
3184             pTransmitKey->byCipherSuite = pMgmt->sNodeDBTable[uNodeIndex].byCipherSuite;
3185             pTransmitKey->dwKeyIndex = pMgmt->sNodeDBTable[uNodeIndex].dwKeyIndex;
3186             pTransmitKey->uKeyLength = pMgmt->sNodeDBTable[uNodeIndex].uWepKeyLength;
3187             pTransmitKey->dwTSC47_16 = pMgmt->sNodeDBTable[uNodeIndex].dwTSC47_16;
3188             pTransmitKey->wTSC15_0 = pMgmt->sNodeDBTable[uNodeIndex].wTSC15_0;
3189             memcpy(pTransmitKey->abyKey,
3190                     &pMgmt->sNodeDBTable[uNodeIndex].abyWepKey[0],
3191                     pTransmitKey->uKeyLength
3192                   );
3193         }
3194     }
3195
3196     if ( bNeedEncryption && (pTransmitKey == NULL) ) {
3197         pContext->bBoolInUse = FALSE;
3198         return FALSE;
3199     }
3200
3201     byPktTyp = (BYTE)pDevice->byPacketType;
3202
3203     if (pDevice->bFixRate) {
3204         if (pDevice->byBBType == BB_TYPE_11B) {
3205             if (pDevice->uConnectionRate >= RATE_11M) {
3206                 pDevice->wCurrentRate = RATE_11M;
3207             } else {
3208                 pDevice->wCurrentRate = (WORD)pDevice->uConnectionRate;
3209             }
3210         } else {
3211             if ((pDevice->byBBType == BB_TYPE_11A) &&
3212                 (pDevice->uConnectionRate <= RATE_6M)) {
3213                 pDevice->wCurrentRate = RATE_6M;
3214             } else {
3215                 if (pDevice->uConnectionRate >= RATE_54M)
3216                     pDevice->wCurrentRate = RATE_54M;
3217                 else
3218                     pDevice->wCurrentRate = (WORD)pDevice->uConnectionRate;
3219             }
3220         }
3221     }
3222     else {
3223         pDevice->wCurrentRate = pMgmt->sNodeDBTable[uNodeIndex].wTxDataRate;
3224     }
3225
3226     if (wKeepRate != pDevice->wCurrentRate) {
3227         bScheduleCommand((void *) pDevice, WLAN_CMD_SETPOWER, NULL);
3228     }
3229
3230     if (pDevice->wCurrentRate <= RATE_11M)
3231         byPktType = PK_TYPE_11B;
3232
3233     BytesToWrite = uDataLen + ETH_FCS_LEN;
3234
3235     // Convert the packet to an usb frame and copy into our buffer
3236     // and send the irp.
3237
3238     fConvertedPacket = s_bPacketToWirelessUsb(pDevice, byPktType,
3239                          (PBYTE)(&pContext->Data[0]), bNeedEncryption,
3240                          uDataLen, TYPE_AC0DMA, &pDevice->sTxEthHeader,
3241                          pbySkbData, pTransmitKey, uNodeIndex,
3242                          pDevice->wCurrentRate,
3243                          &uHeaderLen, &BytesToWrite
3244                         );
3245
3246     if (fConvertedPacket == FALSE) {
3247         pContext->bBoolInUse = FALSE;
3248         return FALSE;
3249     }
3250
3251     pTX_Buffer = (PTX_BUFFER)&(pContext->Data[0]);
3252     pTX_Buffer->byPKTNO = (BYTE) (((pDevice->wCurrentRate<<4) &0x00F0) | ((pDevice->wSeqCounter - 1) & 0x000F));
3253     pTX_Buffer->wTxByteCount = (WORD)BytesToWrite;
3254
3255     pContext->pPacket = NULL;
3256     pContext->Type = CONTEXT_DATA_PACKET;
3257     pContext->uBufLen = (WORD)BytesToWrite + 4 ; //USB header
3258
3259     s_vSaveTxPktInfo(pDevice, (BYTE) (pTX_Buffer->byPKTNO & 0x0F), &(pContext->sEthHeader.abyDstAddr[0]),(WORD) (BytesToWrite-uHeaderLen),pTX_Buffer->wFIFOCtl);
3260
3261     status = PIPEnsSendBulkOut(pDevice,pContext);
3262
3263     return TRUE;
3264 }
3265