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