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