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