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