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