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