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