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